From c49ce14e89c3ae5a9717570d160e608ea1ef3270 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 4 Nov 2024 18:13:59 +0100
Subject: [PATCH 01/23] Small fixes and pre-requisite changes.

---
 .../common/types/ElementSignature.java        | 33 +++++++++++++++++++
 .../service/codegen/DescriptorClassCode.java  | 22 +++++++++++++
 .../codegen/GenerateServiceDescriptor.java    | 12 +++----
 .../service/inject/api/LookupSupport.java     | 12 +++++++
 .../codegen/EventEmitterObserverProvider.java |  2 +-
 .../service/inject/InjectConfigBlueprint.java | 11 +++++++
 6 files changed, 85 insertions(+), 7 deletions(-)

diff --git a/common/types/src/main/java/io/helidon/common/types/ElementSignature.java b/common/types/src/main/java/io/helidon/common/types/ElementSignature.java
index a167313516d..6e045d1c970 100644
--- a/common/types/src/main/java/io/helidon/common/types/ElementSignature.java
+++ b/common/types/src/main/java/io/helidon/common/types/ElementSignature.java
@@ -45,6 +45,39 @@ public sealed interface ElementSignature permits ElementSignatures.FieldSignatur
                                                  ElementSignatures.MethodSignature,
                                                  ElementSignatures.ParameterSignature,
                                                  ElementSignatures.NoSignature {
+    /**
+     * A field signature.
+     *
+     * @param type type of the field
+     * @param name name of the field
+     * @return a new field signature
+     */
+    static ElementSignature createField(TypeName type, String name) {
+        return ElementSignatures.createField(type, name);
+    }
+
+    /**
+     * A constructor signature.
+     *
+     * @param parameters list of types of parameters
+     * @return a new constructor signature
+     */
+    static ElementSignature createConstructor(List<TypeName> parameters) {
+        return ElementSignatures.createConstructor(parameters);
+    }
+
+    /**
+     * A method signature.
+     *
+     * @param returnType return type of the method
+     * @param name name of the method
+     * @param parameters parameter types of the method
+     * @return a new method signature
+     */
+    static ElementSignature createMethod(TypeName returnType, String name, List<TypeName> parameters) {
+        return ElementSignatures.createMethod(returnType, name, parameters);
+    }
+
     /**
      * Type of the element. Resolves as follows:
      * <ul>
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
index 8c340ce7f04..c9a464af0cc 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
@@ -25,6 +25,28 @@
  * New service descriptor metadata with its class code.
  */
 public interface DescriptorClassCode {
+    /**
+     * Create a new instance.
+     *
+     * @param classCode        class code that contains necessary information for the generated class.
+     * @param registryType     type of registry that generates the descriptor (core, inject)
+     * @param weight           weight of the service this descriptor describes
+     * @param contracts        contracts of the service (i.e. {@code MyContract})
+     * @param factoryContracts factory contracts of this service (i.e. {@code Supplier<MyContract>})
+     * @return a new class code of service descriptor
+     */
+    static DescriptorClassCode create(ClassCode classCode,
+                                      String registryType,
+                                      double weight,
+                                      Set<ResolvedType> contracts,
+                                      Set<ResolvedType> factoryContracts) {
+        return new DescriptorClassCodeImpl(classCode,
+                                           registryType,
+                                           weight,
+                                           contracts,
+                                           factoryContracts);
+    }
+
     /**
      * New source code information.
      *
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java b/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
index 651ef707ffd..3fcc867a56d 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
@@ -47,7 +47,7 @@
 /**
  * Generates a service descriptor.
  */
-class GenerateServiceDescriptor {
+public class GenerateServiceDescriptor {
     static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
             .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
             .build();
@@ -89,11 +89,11 @@ private GenerateServiceDescriptor(TypeName generator,
      * @param service      service to create a descriptor for
      * @return class model builder of the service descriptor
      */
-    static ClassModel.Builder generate(TypeName generator,
-                                       RegistryCodegenContext ctx,
-                                       RegistryRoundContext roundContext,
-                                       Collection<TypeInfo> allServices,
-                                       TypeInfo service) {
+    public static ClassModel.Builder generate(TypeName generator,
+                                              RegistryCodegenContext ctx,
+                                              RegistryRoundContext roundContext,
+                                              Collection<TypeInfo> allServices,
+                                              TypeInfo service) {
         return new GenerateServiceDescriptor(generator,
                                              ctx,
                                              roundContext,
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
index 6f49a8ade71..6dad1fc703e 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
+++ b/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
@@ -110,6 +110,18 @@ static void addContract(Lookup.BuilderBase<?, ?> builder, Class<?> contract) {
             builder.addContract(ResolvedType.create(contract));
         }
 
+        /**
+         * The managed services advertised types (i.e., typically its interfaces).
+         *
+         * @param builder  builder instance
+         * @param contract contract the service implements
+         * @see Lookup#contracts()
+         */
+        @Prototype.BuilderMethod
+        static void addContract(Lookup.BuilderBase<?, ?> builder, TypeName contract) {
+            builder.addContract(ResolvedType.create(contract));
+        }
+
         /**
          * The managed service implementation type.
          *
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
index 50ebda400ac..e4c01742ad6 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
@@ -184,7 +184,7 @@ private void addMergeQualifiers(ClassModel.Builder classModel) {
                     .addContentLine("}")
                     .addContent("var qualifierSet = new ")
                     .addContent(HashSet.class)
-                    .addContentLine("(QUALIFIERS);")
+                    .addContentLine("<>(QUALIFIERS);")
                     .addContent("qualifierSet.addAll(")
                     .addContent(Set.class)
                     .addContentLine(".of(qualifiers));")
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
index e021bb27c4d..3a0287053e0 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
@@ -85,4 +85,15 @@ interface InjectConfigBlueprint extends ServiceRegistryConfig {
     @Option.Configured
     @Option.DefaultBoolean(true)
     boolean useBinding();
+
+    /**
+     * Maximal run level to handle when starting from the generated main class
+     * ({@link InjectionMain}). This setting is ignored when starting registry using
+     * other means, as run levels are not handled by default.
+     *
+     * @return maximal run level to lookup during application startup when using generated main class
+     */
+    @Option.Configured
+    @Option.DefaultDouble(Double.MAX_VALUE)
+    double maxRunLevel();
 }

From 43301ef48e01d16d77f9e9a78652db16760ac901 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 4 Nov 2024 18:14:37 +0100
Subject: [PATCH 02/23] Support for injection Main class

---
 .../helidon/service/inject/api/Injection.java |  20 ++
 .../codegen/ApplicationMainGenerator.java     | 260 ++++++++++++++++++
 .../inject/codegen/InjectCodegenTypes.java    |  57 ++++
 .../service/inject/codegen/InjectOptions.java |  28 ++
 .../inject/codegen/InjectionExtension.java    | 103 +++++++
 .../codegen/InjectionExtensionProvider.java   |   3 +-
 service/inject/inject/pom.xml                 |   8 +
 .../service/inject/InjectStartupProvider.java |  97 +++++++
 .../helidon/service/inject/InjectionMain.java | 255 +++++++++++++++++
 .../inject/src/main/java/module-info.java     |   5 +
 10 files changed, 835 insertions(+), 1 deletion(-)
 create mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
 create mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
 create mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java

diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
index d26291c3f97..5a643e45993 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
+++ b/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
@@ -311,6 +311,26 @@ private Injection() {
         Class<? extends Annotation> value() default Singleton.class;
     }
 
+    /**
+     * Marks a custom main class (should be declared as {@code abstract}).
+     * This is a required annotation to make sure the generated main class extends the user's main class.
+     * Note that the custom main class MUST extend the {@code io.helidon.service.inject.InjectionMain} to customize
+     * startup sequence.
+     * The name {@code ApplicationMain} is reserved by service registry, and cannot be used for your custom main class;
+     * the generated name can be modified through {@code Maven} plugin configuration and annotation processor configuration.
+     * <p>
+     * The generated main class adds registration of all available services to injection config,
+     * and disables service discovery to prevent any and all reflection done by service registry itself.
+     * <p>
+     * To have correct startup of your application, use the {@code ApplicationMain} as your application entry point
+     * (such as a {@code mainClass} configured in {@code pom.xml} when using Maven and Helidon application parents).
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.TYPE)
+    public @interface Main {
+    }
+
     /**
      * Provides an ability to create more than one service instance from a single service definition.
      * This is useful when the cardinality can only be determined at runtime.
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
new file mode 100644
index 00000000000..4ba8d39126e
--- /dev/null
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.codegen;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenUtil;
+import io.helidon.codegen.ElementInfoPredicates;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.codegen.classmodel.Method;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.Annotations;
+import io.helidon.common.types.ElementSignature;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+import io.helidon.common.types.TypedElementInfo;
+
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.DOUBLE_ARRAY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG_BUILDER;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.STRING_ARRAY;
+import static java.util.function.Predicate.not;
+
+/**
+ * Utility for {@value #CLASS_NAME} class generation.
+ */
+public final class ApplicationMainGenerator {
+    /**
+     * Default class name of the generated main class.
+     */
+    public static final String CLASS_NAME = "ApplicationMain";
+    /**
+     * Signature of the {@code serviceDescriptors} method (this method is abstract in InjectionMain).
+     */
+    private static final ElementSignature METHOD_SERVICE_DESCRIPTORS = ElementSignature.createMethod(
+            TypeNames.PRIMITIVE_VOID,
+            "serviceDescriptors",
+            List.of(INJECT_CONFIG_BUILDER));
+    /**
+     * Signature of the {@code discoverServices} method.
+     */
+    private static final ElementSignature METHOD_DISCOVER_SERVICES = ElementSignature.createMethod(
+            TypeNames.PRIMITIVE_BOOLEAN,
+            "discoverServices",
+            List.of());
+    /**
+     * Signature of the {@code runLevels} method.
+     */
+    private static final ElementSignature METHOD_RUN_LEVELS = ElementSignature.createMethod(
+            DOUBLE_ARRAY,
+            "runLevels",
+            List.of(INJECT_CONFIG, INJECT_REGISTRY));
+
+    private ApplicationMainGenerator() {
+    }
+
+    /**
+     * Generate the common parts of the type.
+     *
+     * <ul>
+     *     <li>Class declaration with javadoc, @Generated, and copyright, with name {@value #CLASS_NAME}</li>
+     *     <li>Protected constructor with javadoc</li>
+     *     <li>{@code public static void main} method with javadoc</li>
+     * </ul>
+     *
+     * @param generator                 generator type name
+     * @param declaredSignatures        signatures declared on custom main class (if any)
+     * @param superType                 super type of the generated class
+     * @param generatedType             the type to generate
+     * @param discoverServices          whether to discover services (false when all services are manually registered to the
+     *                                  builder)
+     * @param addRunLevels              whether to add run levels from discovered services
+     * @param serviceDescriptorsHandler handler of the service descriptor method
+     * @param runLevelHandler           handler of the run level method
+     * @return class model builder
+     */
+    @SuppressWarnings("checkstyle:ParameterNumber") // all parameters are mandatory
+    public static ClassModel.Builder generate(TypeName generator,
+                                              Set<ElementSignature> declaredSignatures,
+                                              TypeName superType,
+                                              TypeName generatedType,
+                                              boolean discoverServices,
+                                              boolean addRunLevels,
+                                              CodeGeneratorHandler serviceDescriptorsHandler,
+                                              CodeGeneratorHandler runLevelHandler) {
+        ClassModel.Builder classModel = ClassModel.builder()
+                .type(generatedType)
+                .accessModifier(AccessModifier.PUBLIC)
+                .copyright(CodegenUtil.copyright(generator,
+                                                 generator,
+                                                 generatedType))
+                .addAnnotation(CodegenUtil.generatedAnnotation(generator,
+                                                               generatedType,
+                                                               generatedType,
+                                                               "1",
+                                                               ""))
+                .superType(superType)
+                .addDescriptionLine("Main class generated for Helidon Inject Application.")
+                .isFinal(true);
+
+        classModel.addConstructor(ctr -> ctr
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE));
+
+        classModel.addMethod(main -> main
+                .accessModifier(AccessModifier.PUBLIC)
+                .isStatic(true)
+                .returnType(TypeNames.PRIMITIVE_VOID)
+                .description("Start the application.")
+                .name("main")
+                .addParameter(args -> args
+                        .type(STRING_ARRAY)
+                        .description("Command line arguments.")
+                        .name("args"))
+                .update(it -> mainMethodBody(generatedType, it)));
+
+        if (!declaredSignatures.contains(METHOD_SERVICE_DESCRIPTORS)) {
+            // only create this method if it is not created by the user
+            classModel.addMethod(methodModel -> methodModel
+                    .name("serviceDescriptors")
+                    .addAnnotation(Annotations.OVERRIDE)
+                    .accessModifier(AccessModifier.PROTECTED)
+                    .returnType(TypeNames.PRIMITIVE_VOID)
+                    .addParameter(config -> config
+                            .type(INJECT_CONFIG_BUILDER)
+                            .name("config"))
+                    .update(it -> serviceDescriptorsHandler.handle(classModel, it, "config")));
+        }
+
+        if (discoverServices && !declaredSignatures.contains(METHOD_DISCOVER_SERVICES)) {
+            classModel.addMethod(discoverServicesMethod -> discoverServicesMethod
+                    .name("discoverServices")
+                    .addAnnotation(Annotations.OVERRIDE)
+                    .accessModifier(AccessModifier.PROTECTED)
+                    .returnType(TypeNames.PRIMITIVE_BOOLEAN)
+                    .addContentLine("return true;"));
+        }
+
+        if (addRunLevels && !declaredSignatures.contains(METHOD_RUN_LEVELS)) {
+            classModel.addMethod(runLevels -> runLevels
+                    .name("runLevels")
+                    .addAnnotation(Annotations.OVERRIDE)
+                    .accessModifier(AccessModifier.PUBLIC)
+                    .returnType(DOUBLE_ARRAY)
+                    .addParameter(config -> config
+                            .type(INJECT_CONFIG)
+                            .name("config"))
+                    .addParameter(registry -> registry
+                            .type(INJECT_REGISTRY)
+                            .name("registry"))
+                    .addContentLine("return new double[] {")
+                    .update(it -> runLevelHandler.handle(classModel, it, "config"))
+                    .addContentLine("};"));
+        }
+
+        return classModel;
+    }
+
+    /**
+     * Provides all relevant signatures that may override methods from {@code InjectionMain}.
+     *
+     * @param customMain type to analyze
+     * @return set of method signatures that are non-private, non-static
+     */
+    public static Set<ElementSignature> declaredSignatures(TypeInfo customMain) {
+        return customMain.elementInfo()
+                .stream()
+                .filter(ElementInfoPredicates::isMethod)
+                .filter(not(ElementInfoPredicates::isStatic))
+                .filter(not(ElementInfoPredicates::isPrivate))
+                .map(TypedElementInfo::signature)
+                .collect(Collectors.toUnmodifiableSet());
+    }
+
+    /**
+     * Validate a type, to make sure it is a valid custom main class.
+     *
+     * @param customMain type to validate
+     */
+    public static void validate(TypeInfo customMain) {
+        Optional<TypeInfo> superType = customMain.superTypeInfo();
+        if (superType.isEmpty()) {
+            throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
+                                               + customMain.typeName().fqName() + " does not extend any class",
+                                       customMain.originatingElementValue());
+        }
+        if (!superType.get().typeName().equals(INJECT_MAIN)) {
+            throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
+                                               + customMain.typeName().fqName() + " extends " + superType.get().typeName(),
+                                       customMain.originatingElementValue());
+        }
+        if (customMain.accessModifier() == AccessModifier.PRIVATE) {
+            throw new CodegenException("Custom main class must be accessible (non-private) class, but "
+                                               + customMain.typeName().fqName() + " is private.",
+                                       customMain.originatingElementValue());
+        }
+        if (customMain.elementInfo()
+                .stream()
+                .filter(ElementInfoPredicates::isMethod)
+                .filter(ElementInfoPredicates::isStatic)
+                .filter(not(ElementInfoPredicates::isPrivate))
+                .filter(ElementInfoPredicates.elementName("main"))
+                .anyMatch(ElementInfoPredicates.hasParams(TypeName.create(String[].class)))) {
+            throw new CodegenException("Custom main class must not declare a static main(String[]) method, as it is code "
+                                               + "generated into the ApplicationMain class, but "
+                                               + customMain.typeName().fqName() + " declares it.",
+                                       customMain.originatingElementValue());
+        }
+        if (customMain.elementInfo()
+                .stream()
+                .filter(ElementInfoPredicates::isConstructor)
+                .filter(not(ElementInfoPredicates::isPrivate))
+                .noneMatch(ElementInfoPredicates.hasParams())) {
+            throw new CodegenException("Custom main class must have an accessible no-argument constructor, but "
+                                               + customMain.typeName().fqName() + " does not.",
+                                       customMain.originatingElementValue());
+        }
+    }
+
+    private static void mainMethodBody(TypeName type, Method.Builder method) {
+        method.addContent("new ")
+                .addContent(type)
+                .addContentLine("().start(args);");
+    }
+
+    /**
+     * Handler to generated method serviceDescriptors in {@value #CLASS_NAME} class.
+     */
+    @FunctionalInterface
+    public interface CodeGeneratorHandler {
+        /**
+         * Handle the class model (to allow adding constants and helper methods), and method model (to add the body).
+         *
+         * @param classModel      class model of the generated main
+         * @param methodModel     method model of the serviceDescriptors method
+         * @param configParamName name of the parameter of {@code InjectConfig.Builder}
+         */
+        void handle(ClassModel.Builder classModel, Method.Builder methodModel, String configParamName);
+    }
+}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
index 765b6e9521b..2737c061821 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
@@ -17,6 +17,7 @@
 package io.helidon.service.inject.codegen;
 
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
 
 /**
  * Types for code generation from Helidon Service Inject API and Helidon Service Inject.
@@ -63,6 +64,10 @@ public class InjectCodegenTypes {
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.RunLevel}.
      */
     public static final TypeName INJECTION_RUN_LEVEL = TypeName.create("io.helidon.service.inject.api.Injection.RunLevel");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Main}.
+     */
+    public static final TypeName INJECTION_MAIN = TypeName.create("io.helidon.service.inject.api.Injection.Main");
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectionPointFactory}.
      */
@@ -120,6 +125,42 @@ public class InjectCodegenTypes {
      */
     public static final TypeName INJECT_SERVICE_DESCRIPTOR =
             TypeName.create("io.helidon.service.inject.api.InjectServiceDescriptor");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig.Builder}.
+     */
+    public static final TypeName INJECT_CONFIG_BUILDER =
+            TypeName.create("io.helidon.service.inject.InjectConfig.Builder");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig}.
+     */
+    public static final TypeName INJECT_CONFIG =
+            TypeName.create("io.helidon.service.inject.InjectConfig");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectRegistry}.
+     */
+    public static final TypeName INJECT_REGISTRY =
+            TypeName.create("io.helidon.service.inject.api.InjectRegistry");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectRegistryManager}.
+     */
+    public static final TypeName INJECT_REGISTRY_MANAGER =
+            TypeName.create("io.helidon.service.inject.InjectRegistryManager");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionMain}.
+     */
+    public static final TypeName INJECT_MAIN =
+            TypeName.create("io.helidon.service.inject.InjectionMain");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.Binding}.
+     */
+    public static final TypeName INJECT_BINDING =
+            TypeName.create("io.helidon.service.inject.Binding");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionPlanBinder}.
+     */
+    public static final TypeName INJECT_PLAN_BINDER =
+            TypeName.create("io.helidon.service.inject.InjectionPlanBinder");
+
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InvocationException}.
      */
@@ -210,6 +251,22 @@ public class InjectCodegenTypes {
     public static final TypeName INJECT_G_EVENT_OBSERVER_REGISTRATION =
             TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.EventObserverRegistration");
 
+    /**
+     * {@link io.helidon.common.types.TypeName} for String array.
+     */
+    public static final TypeName STRING_ARRAY = TypeName.builder()
+            .from(TypeNames.STRING)
+            .array(true)
+            .build();
+    /**
+     * {@link io.helidon.common.types.TypeName} for primitive double array.
+     */
+    public static final TypeName DOUBLE_ARRAY = TypeName.builder()
+            .from(TypeNames.PRIMITIVE_DOUBLE)
+            .array(true)
+            .build();
+
+
     private InjectCodegenTypes() {
     }
 }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
index 66e8e72db63..41cf8b1ddfc 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
@@ -17,6 +17,7 @@
 package io.helidon.service.inject.codegen;
 
 import java.util.Set;
+import java.util.function.Function;
 
 import io.helidon.codegen.Option;
 import io.helidon.common.GenericType;
@@ -48,6 +49,33 @@ public final class InjectOptions {
                              TypeName::create,
                              new GenericType<Set<TypeName>>() { });
 
+    /**
+     * Name of the generated Main class for Injection. Defaults to
+     * {@value ApplicationMainGenerator#CLASS_NAME}.
+     * The same property must be provided to the maven plugin, to correctly update the generated class.
+     * To configure package name, use {@link io.helidon.codegen.CodegenOptions#CODEGEN_PACKAGE} option.
+     */
+    public static final Option<String> APPLICATION_MAIN_CLASS_NAME =
+            Option.create("helidon.inject.application.main.class.name",
+                          "Name of the generated Main class for Helidon Injection.",
+                          ApplicationMainGenerator.CLASS_NAME,
+                          Function.identity(),
+                          GenericType.STRING);
+
+    /**
+     * Whether to generate main class for Helidon Injection.
+     * Defaults to false. In case a custom main class is present (annotated with Injection.Main), this option is ignored.
+     * <p>
+     * As main class only makes sense for the end application, this is set to {@code false} by default, so we do not generate
+     * main classes for library modules.
+     */
+    public static final Option<Boolean> APPLICATION_MAIN_GENERATE =
+            Option.create("helidon.inject.application.main.generate",
+                          "Whether to generate Main class for Helidon Injection.",
+                          false,
+                          Boolean::parseBoolean,
+                          GenericType.create(Boolean.class));
+
     private InjectOptions() {
     }
 }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
index 2cef3307b2a..5a752210337 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
@@ -34,6 +34,7 @@
 import io.helidon.codegen.CodegenOptions;
 import io.helidon.codegen.CodegenUtil;
 import io.helidon.codegen.ElementInfoPredicates;
+import io.helidon.codegen.ModuleInfo;
 import io.helidon.codegen.classmodel.ClassModel;
 import io.helidon.codegen.classmodel.ContentBuilder;
 import io.helidon.codegen.classmodel.Field;
@@ -70,6 +71,7 @@
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_DESCRIBE;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_INJECT;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_MAIN;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_NAMED;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_INSTANCE;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_LOOKUP;
@@ -79,6 +81,7 @@
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_IP_SUPPORT;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_SCOPE_HANDLER_DESCRIPTOR;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_INSTANCE;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_DELEGATE;
 import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
@@ -117,6 +120,9 @@ class InjectionExtension implements RegistryCodegenExtension {
     private final Set<TypeName> scopeMetaAnnotations;
     private final List<InjectCodegenObserver> observers;
 
+    private volatile boolean mainClassGenerated;
+    private volatile String packageName;
+
     InjectionExtension(RegistryCodegenContext codegenContext) {
         this.ctx = codegenContext;
 
@@ -131,6 +137,9 @@ class InjectionExtension implements RegistryCodegenExtension {
                 .stream()
                 .map(it -> it.create(codegenContext))
                 .toList();
+        this.packageName = CodegenOptions.CODEGEN_PACKAGE.findValue(options)
+                .orElse(null);
+        this.mainClassGenerated = !options.enabled(InjectOptions.APPLICATION_MAIN_GENERATE);
     }
 
     static void annotationsField(ClassModel.Builder classModel, TypeInfo service) {
@@ -180,7 +189,29 @@ static List<ParamDefinition> declareCtrParamsAndGetThem(Method.Builder method, L
 
     @Override
     public void process(RegistryRoundContext roundContext) {
+        if (this.packageName == null) {
+            // first try from module
+            this.packageName = ctx.module()
+                    .flatMap(ModuleInfo::firstUnqualifiedExport)
+                    .orElse(null);
+            // then use the first from source code
+            if (packageName == null) {
+                packageName = roundContext.types()
+                        .stream()
+                        .map(TypeInfo::typeName)
+                        .map(TypeName::packageName)
+                        .findFirst()
+                        .orElse(null);
+            }
+        }
+
+        Collection<TypeInfo> mainClasses = roundContext.annotatedTypes(INJECTION_MAIN);
+        if (!mainClasses.isEmpty()) {
+            generateMain(roundContext, mainClasses);
+        }
+
         List<TypeInfo> descriptorsRequired = new ArrayList<>(roundContext.types());
+        mainClasses.forEach(descriptorsRequired::remove);
 
         for (TypeInfo typeInfo : descriptorsRequired) {
             if (typeInfo.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)) {
@@ -196,6 +227,13 @@ public void process(RegistryRoundContext roundContext) {
         notifyObservers(roundContext, descriptorsRequired);
     }
 
+    @Override
+    public void processingOver() {
+        if (!mainClassGenerated) {
+            generateMain();
+        }
+    }
+
     private static void addAnnotationValue(ContentBuilder<?> contentBuilder, Object objectValue) {
         switch (objectValue) {
         case String value -> contentBuilder.addContent("\"" + value + "\"");
@@ -389,6 +427,71 @@ private void generateScopeDescriptor(RegistryRoundContext roundContext, TypeInfo
                                    serviceDescriptor.typeInfo().originatingElementValue());
     }
 
+    private void generateMain() {
+        if (packageName == null) {
+            throw new CodegenException("Cannot determine package name for the generated main class. "
+                                               + "Please use option " + CodegenOptions.CODEGEN_PACKAGE.name()
+                                               + " to specify it");
+        }
+        // generate main class if it doe not exist
+        String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
+        TypeName generatedType = TypeName.builder()
+                .packageName(packageName)
+                .className(className)
+                .build();
+
+        ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
+                                                                               Set.of(),
+                                                                               INJECT_MAIN,
+                                                                               generatedType,
+                                                                               false,
+                                                                               false,
+                                                                               (a, b, c) -> {
+                                                                             },
+                                                                               (a, b, c) -> {
+                                                                             });
+        ctx.filer()
+                .writeSourceFile(applicationMain.build(), GENERATOR);
+    }
+
+    private void generateMain(RegistryRoundContext roundCtx, Collection<TypeInfo> customMainClasses) {
+        TypeInfo customMain = customMainClasses.iterator().next();
+
+        if (customMainClasses.size() != 1) {
+            String names = customMainClasses.stream()
+                    .map(TypeInfo::typeName)
+                    .map(TypeName::fqName)
+                    .collect(Collectors.joining(", "));
+            throw new CodegenException("There can only be one class annotated with " + INJECTION_MAIN.fqName() + ", "
+                                               + "but discovered more than one: " + names,
+                                       customMain.originatingElementValue());
+        }
+
+        // we always generate the main class, even when there is no Maven plugin
+        mainClassGenerated = true;
+        String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
+        TypeName generatedType = TypeName.builder()
+                .packageName(customMain.typeName().packageName())
+                .className(className)
+                .build();
+        ApplicationMainGenerator.validate(customMain);
+        var declaredSignatures = ApplicationMainGenerator.declaredSignatures(customMain);
+
+        ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
+                                                                               declaredSignatures,
+                                                                               customMain.typeName(),
+                                                                               generatedType,
+                                                                               true,
+                                                                               false,
+                                                                               (a, b, c) -> {
+                                                                             },
+                                                                               (a, b, c) -> {
+                                                                             });
+        roundCtx.addGeneratedType(generatedType,
+                                  applicationMain,
+                                  GENERATOR);
+    }
+
     // we are generating source code, that requires multiple lines
     // I would rather keep this method readable, then to put multiple statements in a single line
     @SuppressWarnings("checkstyle:MethodLength")
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
index e34e787efaf..fa8b4979485 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
@@ -71,7 +71,8 @@ public Set<Option<?>> supportedOptions() {
     public Set<TypeName> supportedAnnotations() {
         return Set.of(InjectCodegenTypes.INJECTION_INJECT,
                       InjectCodegenTypes.INJECTION_DESCRIBE,
-                      InjectCodegenTypes.INJECTION_PER_INSTANCE);
+                      InjectCodegenTypes.INJECTION_PER_INSTANCE,
+                      InjectCodegenTypes.INJECTION_MAIN);
     }
 
     @Override
diff --git a/service/inject/inject/pom.xml b/service/inject/inject/pom.xml
index 59f65966e6b..fab2a878377 100644
--- a/service/inject/inject/pom.xml
+++ b/service/inject/inject/pom.xml
@@ -39,6 +39,10 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>io.helidon</groupId>
+            <artifactId>helidon</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common</artifactId>
@@ -55,6 +59,10 @@
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common-types</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.logging</groupId>
+            <artifactId>helidon-logging-common</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.builder</groupId>
             <artifactId>helidon-builder-api</artifactId>
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
new file mode 100644
index 00000000000..09c383a5db2
--- /dev/null
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject;
+
+import java.lang.System.Logger.Level;
+
+import io.helidon.Main;
+import io.helidon.common.Weight;
+import io.helidon.common.Weighted;
+import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.spi.HelidonShutdownHandler;
+import io.helidon.spi.HelidonStartupProvider;
+
+/**
+ * {@link java.util.ServiceLoader} implementation of a Helidon startup provider for Helidon Service Inject based
+ * applications.
+ */
+@Weight(Weighted.DEFAULT_WEIGHT) // explicit default weight, this should be the "default" startup class
+public class InjectStartupProvider extends InjectionMain implements HelidonStartupProvider {
+    /**
+     * Default constructor required by {@link java.util.ServiceLoader}.
+     *
+     * @deprecated please do not use directly
+     */
+    @Deprecated
+    public InjectStartupProvider() {
+    }
+
+    /**
+     * Register a shutdown handler.
+     * The handler is registered, and never de-registered. This method should only be used by main classes of applications.
+     * If a custom shutdown is desired, please use
+     * {@link io.helidon.Main#addShutdownHandler(io.helidon.spi.HelidonShutdownHandler)} directly.
+     *
+     * @param registryManager registry manager
+     */
+    public static void registerShutdownHandler(ServiceRegistryManager registryManager) {
+        System.Logger logger = System.getLogger(InjectStartupProvider.class.getName());
+        Main.addShutdownHandler(new InjectShutdownHandler(logger, registryManager));
+    }
+
+    @Override
+    public void start(String[] arguments) {
+        super.start(arguments);
+    }
+
+    @Override
+    protected void serviceDescriptors(InjectConfig.Builder configBuilder) {
+    }
+
+    @Override
+    protected boolean discoverServices() {
+        return true;
+    }
+
+    // higher than default, so we stop server as a service, not through shutdown
+    @Weight(Weighted.DEFAULT_WEIGHT + 10)
+    private static final class InjectShutdownHandler implements HelidonShutdownHandler {
+        private final System.Logger logger;
+        private final ServiceRegistryManager registryManager;
+
+        private InjectShutdownHandler(System.Logger logger, ServiceRegistryManager registryManager) {
+            this.logger = logger;
+            this.registryManager = registryManager;
+        }
+
+        @Override
+        public void shutdown() {
+            try {
+                registryManager.shutdown();
+            } catch (Exception e) {
+                logger.log(Level.ERROR,
+                           "Failed to shutdown Helidon Inject registry",
+                           e);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "Helidon Inject shutdown handler";
+        }
+    }
+}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
new file mode 100644
index 00000000000..ac153fe9516
--- /dev/null
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject;
+
+import java.lang.System.Logger.Level;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import io.helidon.common.config.Config;
+import io.helidon.common.config.GlobalConfig;
+import io.helidon.common.types.TypeName;
+import io.helidon.logging.common.LogConfig;
+import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Injection;
+import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.GlobalServiceRegistry;
+import io.helidon.service.registry.ServiceDescriptor;
+import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
+
+/**
+ * Common ancestor for generated main classes.
+ * <p>
+ * The following methods are code generated to the {@code ApplicationMain} class by the Maven plugin.
+ * If you do not want the generated code to be used, simply implement those methods in your custom Main class,
+ * and they will NOT be generated.
+ * When not using Maven plugin, the generated class will have no-op implementations nad service discovery will be enabled.
+ * <ul>
+ *     <li>{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} - registers all service descriptors
+ *      in the current application; to customize the config builder, you can use
+ *      {@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} and
+ *      {@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} methods</li>
+ *     <li>{@link #discoverServices()} - set to {@code false} when using Maven plugin, to avoid all reflection</li>
+ * </ul>
+ */
+public abstract class InjectionMain {
+    /*
+    A change in this class requires change in ApplicationMainGenerator!
+     */
+
+    private static final System.Logger LOGGER = System.getLogger(InjectionMain.class.getName());
+
+    static {
+        LogConfig.initClass();
+    }
+
+    /**
+     * Default constructor with no side effects.
+     */
+    protected InjectionMain() {
+        LogConfig.configureRuntime();
+    }
+
+    /**
+     * Create a service descriptor for a Java {@link java.util.ServiceLoader} based service.
+     *
+     * @param providerInterface provider interface of the service
+     * @param implType          provider implementation
+     * @param instanceSupplier  supplier of a new instance of the service implementation (to allow avoiding reflection)
+     * @param weight            weight assigned to the service
+     * @param <T>               type of the service implementation
+     * @return a new service descriptor of the service
+     */
+    protected static <T> ServiceDescriptor<?> serviceLoader(TypeName providerInterface,
+                                                            Class<T> implType,
+                                                            Supplier<T> instanceSupplier,
+                                                            double weight) {
+        return ServiceLoader__ServiceDescriptor.create(providerInterface, implType, instanceSupplier, weight);
+    }
+
+    /**
+     * Method that handles the startup sequence of an application.
+     * This method is expected to be code generated.
+     * <p>
+     * The following sequence is implemented:
+     * <ol>
+     *     <li>{@link #configBuilder(String[])} to prepare the configuration builder from
+     *              {@link io.helidon.common.config.Config}</li>
+     *     <li>{@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder</li>
+     *     <li>{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} for code generated setup</li>
+     *     <li>{@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder</li>
+     *     <li>{@link #init(InjectConfig)} to initialize the service registry</li>
+     * </ol>
+     *
+     * @param arguments command line arguments
+     */
+    protected void start(String[] arguments) {
+        var config = configBuilder(arguments);
+        beforeServiceDescriptors(config);
+        serviceDescriptors(config);
+        afterServiceDescriptors(config);
+        var registry = init(config.build());
+        afterInit(registry);
+    }
+
+    /**
+     * Method that registers all service descriptors.
+     * This method is expected to be code generated.
+     *
+     * @param configBuilder in progress config builder
+     */
+    protected abstract void serviceDescriptors(InjectConfig.Builder configBuilder);
+
+    /**
+     * Create a config builder from command line arguments.
+     * This method will create default configuration (but not register it as a global config, so we still use the registry
+     * to create a config instance), configure the {@link io.helidon.service.inject.InjectConfig.Builder} from it,
+     * then disable discovery of services.
+     *
+     * @param arguments command line arguments
+     * @return a new config builder
+     */
+    protected InjectConfig.Builder configBuilder(String[] arguments) {
+        Config config;
+        if (GlobalConfig.configured()) {
+            config = GlobalConfig.config();
+        } else {
+            config = Config.create();
+        }
+
+        return InjectConfig.builder()
+                .config(config.get("registry"))
+                .discoverServices(discoverServices())
+                .discoverServicesFromServiceLoader(discoverServices());
+    }
+
+    /**
+     * Whether to discover services from classpath and from service loader.
+     * Defaults to {@code false}, should be overridden when
+     * {@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)}
+     * does not configure all services.
+     *
+     * @return whether to discover services
+     */
+    protected boolean discoverServices() {
+        return false;
+    }
+
+    /**
+     * Called before service descriptors are configured in the generated main class.
+     * This method is invoked from generated {@link #start(String[])}.
+     *
+     * @param configBuilder in-progress config builder
+     */
+    protected void beforeServiceDescriptors(InjectConfig.Builder configBuilder) {
+    }
+
+    /**
+     * Called after service descriptors are configured in the generated main class, before the registry is initialized.
+     * This method is invoked from generated {@link #start(String[])}
+     *
+     * @param configBuilder in-progress config builder
+     */
+    protected void afterServiceDescriptors(InjectConfig.Builder configBuilder) {
+    }
+
+    /**
+     * Initialize the service registry, register it for shutdown during process shutdown, and lookup all
+     * startup services.
+     *
+     * @param config configuration of the Inject service registry
+     * @return the inject registry created within this method
+     */
+    protected InjectRegistry init(InjectConfig config) {
+        InjectRegistryManager manager = InjectRegistryManager.create(config);
+        InjectRegistry registry = manager.registry();
+        InjectStartupProvider.registerShutdownHandler(manager);
+
+        GlobalServiceRegistry.registry(registry);
+
+        double maxRunLevel = maxRunLevel(config, registry);
+        for (double runLevel : runLevels(config, registry)) {
+            if (runLevel <= maxRunLevel) {
+                List<Object> all = registry.all(Lookup.builder()
+                                                        .addScope(Injection.Singleton.TYPE)
+                                                        .runLevel(runLevel)
+                                                        .build());
+                if (LOGGER.isLoggable(Level.TRACE)) {
+                    LOGGER.log(Level.DEBUG, "Starting services in run level: " + runLevel + ": ");
+                    for (Object o : all) {
+                        LOGGER.log(Level.DEBUG, "\t" + o);
+                    }
+                } else if (LOGGER.isLoggable(Level.DEBUG)) {
+                    LOGGER.log(Level.TRACE, "Starting services in run level: " + runLevel);
+                }
+            }
+        }
+
+        return registry;
+    }
+
+    /**
+     * Maximal run level to initialize.
+     * The default startup sequence will go through each
+     * {@link #runLevels(InjectConfig, io.helidon.service.inject.api.InjectRegistry) run level} up to (and including) the value
+     * returned by this method.
+     *
+     * @param config injection config
+     * @param registry registry instance
+     * @return maximal run level to initialize
+     */
+    protected double maxRunLevel(InjectConfig config,
+                                 InjectRegistry registry) {
+        return config.maxRunLevel();
+    }
+
+    /**
+     * Run levels that should be initialized at startup.
+     * Default implementation initializes all declared run levels (services with explicit
+     * {@link io.helidon.service.inject.api.Injection.RunLevel} annotation).
+     *
+     * @param config injection config
+     * @param registry registry instance
+     * @return array of doubles that represent run levels to initialize, will be used in the order provided here
+     */
+    protected double[] runLevels(InjectConfig config,
+                                 InjectRegistry registry) {
+        // child classes will have this method code generated at build time
+        List<Double> runLevelList = registry.lookupServices(Lookup.EMPTY)
+                .stream()
+                .map(InjectServiceInfo::runLevel)
+                .flatMap(Optional::stream)
+                .distinct()
+                .sorted()
+                .toList();
+        double[] result = new double[runLevelList.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = runLevelList.get(i);
+        }
+        return result;
+    }
+
+    /**
+     * Allows to query the registry after the service is started.
+     *
+     * @param registry inject service registry
+     */
+    protected void afterInit(InjectRegistry registry) {
+    }
+}
diff --git a/service/inject/inject/src/main/java/module-info.java b/service/inject/inject/src/main/java/module-info.java
index f3b6ee0cf16..26bc2a3d01a 100644
--- a/service/inject/inject/src/main/java/module-info.java
+++ b/service/inject/inject/src/main/java/module-info.java
@@ -28,6 +28,8 @@
 module io.helidon.service.inject {
     requires static io.helidon.common.features.api;
 
+    requires io.helidon;
+    requires io.helidon.logging.common;
     requires io.helidon.metrics.api;
     requires io.helidon.service.metadata;
 
@@ -42,4 +44,7 @@
 
     provides io.helidon.service.registry.spi.ServiceRegistryManagerProvider
             with io.helidon.service.inject.InjectRegistryManagerProvider;
+
+    provides io.helidon.spi.HelidonStartupProvider
+            with io.helidon.service.inject.InjectStartupProvider;
 }
\ No newline at end of file

From c19243178b315f513193439b2b6acfac1870c57f Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 4 Nov 2024 18:14:55 +0100
Subject: [PATCH 03/23] Maven plugin for Helidon Service Inject

---
 all/pom.xml                                   |   4 +
 bom/pom.xml                                   |   5 +
 service/inject/README.md                      |  24 +
 service/inject/maven-plugin/README.md         |  67 ++
 .../maven-plugin/etc/spotbugs/exclude.xml     |  41 ++
 service/inject/maven-plugin/pom.xml           | 203 ++++++
 .../maven/plugin/ApplicationValidator.java    | 121 ++++
 .../inject/maven/plugin/BindingGenerator.java | 584 ++++++++++++++++++
 .../maven/plugin/CodegenAbstractMojo.java     | 186 ++++++
 .../plugin/CreateApplicationAbstractMojo.java | 492 +++++++++++++++
 .../maven/plugin/CreateApplicationMojo.java   |  96 +++
 .../plugin/CreateTestApplicationMojo.java     | 114 ++++
 .../inject/maven/plugin/MainClassCreator.java | 289 +++++++++
 .../maven/plugin/MavenCodegenContext.java     |  94 +++
 .../inject/maven/plugin/MavenFiler.java       | 155 +++++
 .../maven/plugin/MavenFilerResource.java      |  64 ++
 .../maven/plugin/MavenFilerTextResource.java  |  67 ++
 .../inject/maven/plugin/MavenLogger.java      | 129 ++++
 .../inject/maven/plugin/MavenOptions.java     |  86 +++
 .../maven/plugin/MavenRoundContext.java       | 107 ++++
 .../inject/maven/plugin/WrappedServices.java  | 143 +++++
 .../inject/maven/plugin/package-info.java     |  26 +
 .../src/main/java/module-info.java            |  41 ++
 service/inject/pom.xml                        |   1 +
 service/pom.xml                               |   1 +
 25 files changed, 3140 insertions(+)
 create mode 100644 service/inject/maven-plugin/README.md
 create mode 100644 service/inject/maven-plugin/etc/spotbugs/exclude.xml
 create mode 100644 service/inject/maven-plugin/pom.xml
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java
 create mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java
 create mode 100644 service/inject/maven-plugin/src/main/java/module-info.java

diff --git a/all/pom.xml b/all/pom.xml
index a4d6e458d54..c37fc609d7e 100644
--- a/all/pom.xml
+++ b/all/pom.xml
@@ -1140,6 +1140,10 @@
             <groupId>io.helidon.service.inject</groupId>
             <artifactId>helidon-service-inject</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-maven-plugin</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.metadata</groupId>
             <artifactId>helidon-metadata-hson</artifactId>
diff --git a/bom/pom.xml b/bom/pom.xml
index 60d895a39ed..42775cd8560 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -1506,6 +1506,11 @@
                 <artifactId>helidon-service-inject</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+            </dependency>
 
             <!-- Metadata -->
             <dependency>
diff --git a/service/inject/README.md b/service/inject/README.md
index 7a8f87f72a3..f28d1f55c12 100644
--- a/service/inject/README.md
+++ b/service/inject/README.md
@@ -13,6 +13,7 @@ Helidon Inject includes:
 - [Aspect Oriented Programming (interceptors)](#interceptors)
 - [Events](events)
 - [Programmatic Lookup](#programmatic-lookup)
+- [Startup](#startup)
 - [Other](#other)
 - [Glossary](#glossary)
 
@@ -361,6 +362,29 @@ Lookup parameter options:
 - `TypeName` - the same, but using Helidon abstraction of type names (may have type arguments)
 - `Lookup` - a full search criteria for a registry lookup
 
+# Startup
+
+The following options are available to start a service registry (and the application):
+
+1. Use API to create an `io.helidon.service.inject.InjectRegistryManager`
+2. Use the Helidon startup class `io.helidon.Main`, which will use the injection main class through service loader
+3. Use a generated main class, by default named `ApplicationMain` in the main package of the application (supports customization)
+
+## Generated Main Class
+
+To generate a main class, the Helidon Service Inject Maven plugin must be configured.
+This is expected to be configured only for an application (i.e. not for library modules) - this is the reason we do not generate it automatically.
+
+The generated main class will contain full, reflection less configuration of the service registry. It registers all services directly through API, and disables service discovery from classpath.
+
+The Main class can also be customized; to do this:
+1. Create a custom class (let's call it `CustomMain` as an example)
+2. The class must extends the injection main class (`public abstract class CustomMain extends InjectionMain`)
+3. The class must be annotated with `@Injection.Main`, so it is discovered by annotation processor
+4. Implement any desired methods; the generated class will only implement `serviceDescriptors(InjectConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
+
+For details on how to configure your build, see [Maven Plugin](../maven-plugin/README.md).
+
 # Other
 
 ## API types quick reference
diff --git a/service/inject/maven-plugin/README.md b/service/inject/maven-plugin/README.md
new file mode 100644
index 00000000000..3d3f2260cfc
--- /dev/null
+++ b/service/inject/maven-plugin/README.md
@@ -0,0 +1,67 @@
+Maven Plugin
+---
+
+The Helidon Service Maven Plugin provides the following goals:
+
+1. Create application artifacts (`create-application`, `create-test-application`)
+
+# Create application artifacts Maven goals
+
+This goal creates artifacts that are only valid for the service (assembled from libraries and its own sources).
+This goal generates:
+
+1. Application Binding - a mapping of services to injection points (to bypass runtime lookups) - generates class `Injection__Binding`
+2. Application Main - a generated main class that registers all services (to bypass service discovery) - generates class `ApplicationMain`
+
+Usage of this plugin goal is not required, yet it is recommended for final application module, it will add
+- binding for injection points, to avoid runtime lookups
+- explicit registration of all services into `InjectConfig`, to avoid resource lookup and reflection at runtime
+- overall speedup of bootstrapping, as all the required tasks to start a service registry are code generated
+
+This goal should not be used for library modules (i.e. modules that do not have a Main class that bootstraps registry).
+
+## Usage
+
+Goal names:
+
+- `create-application` - for production sources
+- `create-test-application` - for test sources (only creates binding, main class not relevant)
+
+Configuration options:
+
+| Name               | Property                                        | Default                | Description                                                                     |
+|--------------------|-------------------------------------------------|------------------------|---------------------------------------------------------------------------------|
+| `packageName`      | `helidon.codegen.package-name`                  | Inferred from module   | Package to put the generated classes in                                         |
+| `moduleName`       | `helidon.codegen.module-name`                   | Inferred from module   | Name of the JPMS module                                                         |
+| `validate`         | `helidon.inject.application.validate`           | `true`                 | Whether to validate application                                                 |
+| `createMain`       | `helidon.inject.application.main.generate`      | `true`                 | Whether to create application Main class                                        |
+| `mainClassName`    | `helidon.inject.application.main.class.name`    | `ApplicationMain`      | Name of the generated Main class                                                |
+| `createBinding`    | `helidon.inject.application.binding.generate`   | `true`                 | Whether to create application binding                                           |
+| `bindingClassName` | `helidon.inject.application.binding.class.name` | `Application__Binding` | Name of the generated binding class, for test, it is `TestApplication__Binding` |
+| `failOnError`      | `helidon.inject.fail-on-error`                  | `true`                 | Whether to fail when the plugin encounters an error                             |
+| `failOnWarning`    | `helidon.inject.fail-on-warning`                | `false`                | Whether to fail when the plugin encounters a warning                            |
+| `compilerArgs`     |                                                 |                        | Arguments of the Java compiler (both classes are compiled by the plugin)        | 
+
+Configuration example in `pom.xml`:
+
+```xml
+
+<plugin>
+    <groupId>io.helidon.service</groupId>
+    <artifactId>helidon-service-maven-plugin</artifactId>
+    <executions>
+        <execution>
+            <id>create-application</id>
+            <goals>
+                <goal>create-application</goal>
+            </goals>
+        </execution>
+    </executions>
+    <configuration>
+        <packageName>com.example.mypackage</packageName>
+        <bindingClassName>MyInjection__Binding</bindingClassName>
+        <mainClassName>MyApplicationMain</mainClassName>
+        <validate>false</validate>
+    </configuration>
+</plugin>
+```
diff --git a/service/inject/maven-plugin/etc/spotbugs/exclude.xml b/service/inject/maven-plugin/etc/spotbugs/exclude.xml
new file mode 100644
index 00000000000..e672fbdf494
--- /dev/null
+++ b/service/inject/maven-plugin/etc/spotbugs/exclude.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<FindBugsFilter
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="https://github.com/spotbugs/filter/3.0.0"
+        xsi:schemaLocation="https://github.com/spotbugs/filter/3.0.0 https://raw.githubusercontent.com/spotbugs/spotbugs/3.1.0/spotbugs/etc/findbugsfilter.xsd">
+
+    <Match>
+        <!-- Path comes from config or code -->
+        <Class name="io.helidon.service.inject.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Bug pattern="PATH_TRAVERSAL_IN"/>
+    </Match>
+    <Match>
+        <!-- Classpath is constructed from maven classpath -->
+        <Class name="io.helidon.service.inject.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Bug pattern="DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED"/>
+    </Match>
+
+    <Match>
+        <!-- Path comes from config or code -->
+        <Class name="io.helidon.service.inject.maven.plugin.CreateTestApplicationMojo"/>
+        <Bug pattern="PATH_TRAVERSAL_IN"/>
+    </Match>
+</FindBugsFilter>
diff --git a/service/inject/maven-plugin/pom.xml b/service/inject/maven-plugin/pom.xml
new file mode 100644
index 00000000000..8a8ccd063ac
--- /dev/null
+++ b/service/inject/maven-plugin/pom.xml
@@ -0,0 +1,203 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>io.helidon.service.inject</groupId>
+        <artifactId>helidon-service-inject-project</artifactId>
+        <version>4.2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>helidon-service-inject-maven-plugin</artifactId>
+    <name>Helidon Service Maven Plugin</name>
+    <packaging>maven-plugin</packaging>
+
+    <properties>
+        <version.plexus.classworlds>2.7.0</version.plexus.classworlds>
+        <version.plexus.utils>3.3.0</version.plexus.utils>
+        <version.plugin.api>3.9.3</version.plugin.api>
+        <version.plugin.annotations>3.9.0</version.plugin.annotations>
+        <version.plugin.plugin>3.9.0</version.plugin.plugin>
+        <version.plugin.project>2.2.1</version.plugin.project>
+
+        <spotbugs.exclude>etc/spotbugs/exclude.xml</spotbugs.exclude>
+    </properties>
+
+    <reporting>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-plugin-plugin</artifactId>
+                <reportSets>
+                    <reportSet>
+                        <reports>
+                            <report>report</report>
+                        </reports>
+                    </reportSet>
+                </reportSets>
+            </plugin>
+        </plugins>
+    </reporting>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-artifact</artifactId>
+            <version>${version.plugin.api}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-model</artifactId>
+            <version>${version.plugin.api}</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- normal dependencies -->
+        <dependency>
+            <groupId>io.helidon.common</groupId>
+            <artifactId>helidon-common</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.common</groupId>
+            <artifactId>helidon-common-types</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.codegen</groupId>
+            <artifactId>helidon-codegen-class-model</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-codegen</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-codegen</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-metadata</artifactId>
+        </dependency>
+        <dependency>
+            <!--
+            we cannot use helidon-service-inject as the SPI is required on classpath of application,
+            and this introduces conflicts; API is small and does not introduce SPI
+            that is used from within it, so we can share it
+            -->
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.codegen</groupId>
+            <artifactId>helidon-codegen</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.codegen</groupId>
+            <artifactId>helidon-codegen-scan</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.codegen</groupId>
+            <artifactId>helidon-codegen-compiler</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.github.classgraph</groupId>
+            <artifactId>classgraph</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-plugin-api</artifactId>
+            <version>${version.plugin.api}</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.codehaus.plexus</groupId>
+                    <artifactId>plexus-classworlds</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.codehaus.plexus</groupId>
+                    <artifactId>plexus-utils</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.plugin-tools</groupId>
+            <artifactId>maven-plugin-annotations</artifactId>
+            <version>${version.plugin.annotations}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-project</artifactId>
+            <version>${version.plugin.project}</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.maven</groupId>
+                    <artifactId>maven-model</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.codehaus.plexus</groupId>
+                    <artifactId>plexus-utils</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.maven</groupId>
+                    <artifactId>maven-artifact</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-plugin-plugin</artifactId>
+                    <version>${version.plugin.plugin}</version>
+                    <configuration>
+                        <mojoDependencies>
+                            <!-- we need this since 19ea is not really supported -->
+                            <!--                            <mojoDependency></mojoDependency>-->
+                        </mojoDependencies>
+                        <requiredMavenVersion>[3.6.1,)</requiredMavenVersion>
+                        <requiredJavaVersion>[${version.java}.0,)</requiredJavaVersion>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <compilerArgument>-proc:none</compilerArgument>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
new file mode 100644
index 00000000000..6a54a8941b7
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.lang.System.Logger.Level;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenLogger;
+import io.helidon.common.Errors;
+import io.helidon.common.types.ResolvedType;
+import io.helidon.common.types.TypeName;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Injection;
+import io.helidon.service.inject.api.Ip;
+import io.helidon.service.inject.api.Lookup;
+
+class ApplicationValidator {
+    private final MavenCodegenContext scanContext;
+    private final boolean failOnWarning;
+
+    ApplicationValidator(MavenCodegenContext scanContext, boolean failOnWarning) {
+        this.scanContext = scanContext;
+        this.failOnWarning = failOnWarning;
+    }
+
+    void validate(WrappedServices services) {
+        Errors.Collector collector = Errors.collector();
+
+        validate(services, collector);
+
+        Errors errors = collector.collect();
+        CodegenLogger logger = scanContext.logger();
+        for (Errors.ErrorMessage error : errors) {
+            Level level = switch (error.getSeverity()) {
+                case FATAL -> Level.ERROR;
+                case WARN -> Level.WARNING;
+                case HINT -> Level.INFO;
+            };
+            logger.log(level, error.getSeverity() + " " + error.getSource() + ": " + error.getMessage());
+        }
+
+        if (errors.hasFatal() || failOnWarning && errors.hasWarning()) {
+            throw new CodegenException("Application validation failed, see log output for details.");
+        }
+    }
+
+    private void validate(WrappedServices services, Errors.Collector collector) {
+        // check all singletons, that they only contain injection points that are singletons, or have a supplier
+        List<InjectServiceInfo> requestScopedServices = services.all(Lookup.builder()
+                                                                             .addScope(Injection.PerRequest.TYPE)
+                                                                             .build());
+        Set<ResolvedType> requestScopedContracts = new HashSet<>();
+        Map<ResolvedType, Set<TypeName>> requestScopedByContracts = new HashMap<>();
+
+        for (InjectServiceInfo requestScoped : requestScopedServices) {
+            TypeName serviceType = requestScoped.serviceType();
+            Set<ResolvedType> contracts = requestScoped.contracts();
+
+            ResolvedType resolvedServiceType = ResolvedType.create(serviceType);
+            requestScopedContracts.add(resolvedServiceType);
+            requestScopedByContracts.computeIfAbsent(resolvedServiceType, k -> new HashSet<>())
+                    .add(serviceType);
+
+            requestScopedContracts.addAll(contracts);
+            for (ResolvedType contract : contracts) {
+                requestScopedByContracts.computeIfAbsent(contract, k -> new HashSet<>())
+                        .add(serviceType);
+            }
+        }
+
+        List<InjectServiceInfo> singletons = services.all(Lookup.builder()
+                                                                  .addScope(Injection.Singleton.TYPE)
+                                                                  .build());
+
+        boolean requestScopeHinted = false;
+
+        for (InjectServiceInfo singleton : singletons) {
+            for (Ip dependency : singleton.dependencies()) {
+                ResolvedType contract = ResolvedType.create(dependency.contract());
+                if (requestScopedContracts.contains(contract)) {
+                    // this is an injection of request scope service into a singleton
+                    if (dependency.typeName().isSupplier()) {
+                        // this is correct
+                        if (!requestScopeHinted) {
+                            collector.hint(
+                                    "Injection of request scoped service into a singleton (as a supplier). This is correct, "
+                                            + "please "
+                                            + "make sure you have appropriate request scope library on your module path.");
+                            requestScopeHinted = true;
+                        }
+                    } else {
+                        // this does not have to be an error, if the user decides the whole application has a request
+                        // scope active and they implement their own request scope initialization
+                        collector.warn("Injection of request scoped service into a singleton without a supplier. "
+                                               + " Singleton: " + singleton.serviceType() + ", request scoped service(s): "
+                                               + requestScopedByContracts.get(contract));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
new file mode 100644
index 00000000000..fea87bd0624
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenUtil;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.codegen.classmodel.ContentBuilder;
+import io.helidon.codegen.classmodel.Method;
+import io.helidon.codegen.compiler.Compiler;
+import io.helidon.codegen.compiler.CompilerOptions;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.Annotations;
+import io.helidon.common.types.ElementKind;
+import io.helidon.common.types.ResolvedType;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.service.codegen.DescriptorClassCode;
+import io.helidon.service.codegen.GenerateServiceDescriptor;
+import io.helidon.service.codegen.HelidonMetaInfServices;
+import io.helidon.service.codegen.RegistryCodegenContext;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Interception;
+import io.helidon.service.inject.api.Ip;
+import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.metadata.DescriptorMetadata;
+import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
+
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_CONTRACT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_POINT_FACTORY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_BINDING;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_PLAN_BINDER;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_INSTANCE;
+
+/**
+ * The default implementation for {@link BindingGenerator}.
+ */
+class BindingGenerator {
+    private static final TypeName GENERATOR = TypeName.create(BindingGenerator.class);
+
+    private final MavenCodegenContext ctx;
+    private final boolean failOnError;
+
+    BindingGenerator(MavenCodegenContext scanContext, boolean failOnError) {
+        this.ctx = scanContext;
+        this.failOnError = failOnError;
+    }
+
+    /**
+     * Generates the source and class file for {@code io.helidon.inject.Binding} using the current classpath.
+     *
+     * @param injectionServices injection services to use
+     * @param serviceTypes      types to process
+     * @param typeName          generated binding type name
+     * @param moduleName        name of the module of this maven module
+     * @param compilerOptions   compilation options
+     */
+    void createBinding(WrappedServices injectionServices,
+                       Set<TypeName> serviceTypes,
+                       TypeName typeName,
+                       String moduleName,
+                       CompilerOptions compilerOptions) {
+        Objects.requireNonNull(injectionServices);
+        Objects.requireNonNull(serviceTypes);
+
+        try {
+            codegen(injectionServices, serviceTypes, typeName, moduleName, compilerOptions);
+        } catch (CodegenException ce) {
+            handleError(ce);
+        } catch (Throwable te) {
+            handleError(new CodegenException("Failed to code generate binding class", te));
+        }
+    }
+
+    void codegen(WrappedServices injectionServices,
+                 Set<TypeName> serviceTypes,
+                 TypeName typeName,
+                 String moduleName,
+                 CompilerOptions compilerOptions) {
+        ClassModel.Builder classModel = ClassModel.builder()
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
+                .copyright(CodegenUtil.copyright(GENERATOR,
+                                                 GENERATOR,
+                                                 typeName))
+                .description("Generated Binding to provide explicit bindings for known services.")
+                .type(typeName)
+                .addAnnotation(CodegenUtil.generatedAnnotation(GENERATOR,
+                                                               GENERATOR,
+                                                               typeName,
+                                                               "1",
+                                                               ""))
+                .addInterface(INJECT_BINDING);
+
+        // deprecated default constructor - binding should always be service loaded
+        classModel.addConstructor(ctr -> ctr
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE));
+
+        // public String name()
+        classModel.addMethod(nameMethod -> nameMethod
+                .addAnnotation(Annotations.OVERRIDE)
+                .returnType(io.helidon.common.types.TypeNames.STRING)
+                .name("name")
+                .addContentLine("return \"" + moduleName + "\";"));
+
+        // public void configure(ServiceInjectionPlanBinder binder)
+        classModel.addMethod(configureMethod -> configureMethod
+                .addAnnotation(Annotations.OVERRIDE)
+                .name("configure")
+                // constructors of services for service loader are usually deprecated in Helidon
+                .addAnnotation(Annotation.create(SuppressWarnings.class, "deprecation"))
+                .addParameter(binderParam -> binderParam
+                        .name("binder")
+                        .type(INJECT_PLAN_BINDER))
+                .update(it -> createConfigureMethodBody(injectionServices,
+                                                        serviceTypes,
+                                                        it)));
+
+        Path generated = ctx.filer()
+                .writeSourceFile(classModel.build());
+
+        TypeInfo appTypeInfo = createAppTypeInfo(typeName);
+        RegistryCodegenContext registryCodegenContext = RegistryCodegenContext.create(ctx);
+        MavenRoundContext roundContext = new MavenRoundContext(ctx);
+        GenerateServiceDescriptor.generate(GENERATOR,
+                                           registryCodegenContext,
+                                           roundContext,
+                                           List.of(appTypeInfo),
+                                           appTypeInfo);
+
+        List<Path> toCompile = new ArrayList<>();
+        toCompile.add(generated);
+
+        HelidonMetaInfServices services = HelidonMetaInfServices.create(ctx.filer(), moduleName);
+
+        for (DescriptorClassCode descriptor : roundContext.descriptors()) {
+            Path path = ctx.filer().writeSourceFile(descriptor.classCode().classModel().build(),
+                                                    descriptor.classCode().originatingElements());
+            toCompile.add(path);
+
+            services.add(DescriptorMetadata.create(descriptor.registryType(),
+                                                   descriptor.classCode().newType(),
+                                                   descriptor.weight(),
+                                                   descriptor.contracts(),
+                                                   Set.of()));
+        }
+
+        services.write();
+        Compiler.compile(compilerOptions, toCompile.toArray(new Path[0]));
+    }
+
+    BindingPlan bindingPlan(WrappedServices services,
+                            TypeName serviceTypeName) {
+
+        Lookup lookup = toLookup(serviceTypeName);
+        InjectServiceInfo sp = services.get(lookup);
+        TypeName serviceDescriptorType = sp.descriptorType();
+
+        if (!isQualifiedInjectionTarget(sp)) {
+            return new BindingPlan(serviceDescriptorType, Set.of());
+        }
+
+        List<Ip> dependencies = sp.dependencies();
+        if (dependencies.isEmpty()) {
+            return new BindingPlan(serviceDescriptorType, Set.of());
+        }
+
+        Set<Binding> bindings = new LinkedHashSet<>();
+        for (Ip dependency : dependencies) {
+            InjectionPlan iPlan = injectionPlan(services, sp, dependency);
+            List<InjectServiceInfo> qualified = iPlan.qualifiedProviders();
+            List<InjectServiceInfo> unqualified = iPlan.unqualifiedProviders();
+            List<InjectServiceInfo> usedList;
+
+            if (qualified.isEmpty() && !unqualified.isEmpty()) {
+                usedList = unqualified;
+            } else {
+                usedList = qualified;
+            }
+
+            bindings.add(new Binding(dependency,
+                                     usedList));
+        }
+
+        return new BindingPlan(serviceDescriptorType, bindings);
+    }
+
+    private static Consumer<ContentBuilder<?>> toContentBuilder(InjectServiceInfo serviceInfo) {
+        if (serviceInfo.coreInfo() instanceof ServiceLoader__ServiceDescriptor sl) {
+            // we need to create a specific descriptor for interface and implementation
+            TypeName providerInterface = sl.providerInterface();
+            TypeName providerImpl = sl.serviceType();
+            return it -> it.addContent(sl.descriptorType())
+                    .addContent(".create(")
+                    .addContentCreate(providerInterface)
+                    .addContent(", ")
+                    .addContent(providerImpl)
+                    .addContent(".class, ")
+                    .addContent(providerImpl)
+                    .addContent("::new, ")
+                    .addContent(String.valueOf(sl.weight()))
+                    .addContent(")");
+        } else {
+            // the usual singleton instance
+            return it -> it.addContent(serviceInfo.descriptorType().fqName())
+                    .addContent(".INSTANCE");
+        }
+    }
+
+    private static Lookup toLookup(TypeName typeName) {
+        return Lookup.builder()
+                .serviceType(typeName)
+                .build();
+    }
+
+    /**
+     * Determines if the service is valid to receive injections.
+     *
+     * @param sp the service provider
+     * @return true if the service provider can receive injection
+     */
+    private static boolean isQualifiedInjectionTarget(InjectServiceInfo sp) {
+        Set<ResolvedType> contractsImplemented = sp.contracts();
+        List<Ip> dependencies = sp.dependencies();
+
+        if (contractsImplemented.contains(ResolvedType.create(INJECT_BINDING))) {
+            return false;
+        }
+        boolean hasDependencies = !dependencies.isEmpty();
+        boolean hasContract = !contractsImplemented.isEmpty();
+
+        return hasContract || hasDependencies;
+    }
+
+    private TypeInfo createAppTypeInfo(TypeName typeName) {
+        return TypeInfo.builder()
+                .kind(ElementKind.CLASS)
+                .typeName(typeName)
+                // to trigger generation of descriptor
+                .addAnnotation(Annotation.create(SERVICE_ANNOTATION_PROVIDER))
+                .addInterfaceTypeInfo(TypeInfo.builder()
+                                              .kind(ElementKind.INTERFACE)
+                                              .typeName(INJECT_BINDING)
+                                              .addAnnotation(Annotation.create(SERVICE_ANNOTATION_CONTRACT))
+                                              .build())
+                .build();
+    }
+
+    private void handleError(CodegenException ce) {
+        if (failOnError) {
+            throw ce;
+        } else {
+            ctx.logger().log(ce.toEvent(System.Logger.Level.WARNING));
+        }
+    }
+
+    private InjectionPlan injectionPlan(WrappedServices services,
+                                        InjectServiceInfo self,
+                                        Ip dependency) {
+        /*
+         very similar code is used in ServiceManager.planForIp
+         make sure this is kept in sync!
+         */
+        Lookup dependencyTo = Lookup.create(dependency);
+        Set<Qualifier> qualifiers = dependencyTo.qualifiers();
+        if (self.contracts().containsAll(dependencyTo.contracts()) && self.qualifiers().equals(qualifiers)) {
+            // criteria must have a single contract for each injection point
+            // if this service implements the contracts actually required, we must look for services with lower weight
+            // but only if we also have the same qualifiers
+            dependencyTo = Lookup.builder(dependencyTo)
+                    .weight(self.weight())
+                    .build();
+        }
+
+        /*
+        An injection point can be satisfied by:
+        1. a service that matches the type or contract, and qualifiers match
+        2. a Supplier<T> service, where T matches service type or contract, and qualifiers match
+        3. an InjectionPointProvider<T>, where T matches service type or contract, regardless of qualifiers
+        4. an InjectionResolver, where the method resolve returns an information if this type can be resolved (config driven)
+        */
+
+        List<InjectServiceInfo> qualifiedProviders = services.all(dependencyTo);
+        List<InjectServiceInfo> unqualifiedProviders;
+
+        if (qualifiedProviders.isEmpty()) {
+            unqualifiedProviders = injectionPointProvidersFor(services, dependency)
+                    .stream()
+                    .filter(it -> !it.serviceType().equals(self.serviceType()))
+                    .toList();
+        } else {
+            unqualifiedProviders = List.of();
+        }
+
+        // remove current service provider from matches
+        qualifiedProviders = qualifiedProviders.stream()
+                .filter(it -> !it.serviceType().equals(self.serviceType()))
+                .toList();
+
+        // the list now contains all providers that match the processed injection points
+        return new InjectionPlan(unqualifiedProviders, qualifiedProviders);
+    }
+
+    private List<InjectServiceInfo> injectionPointProvidersFor(WrappedServices services, Ip injectionPoint) {
+        if (injectionPoint.qualifiers().isEmpty()) {
+            return List.of();
+        }
+        Lookup criteria = Lookup.builder(Lookup.create(injectionPoint))
+                .qualifiers(Set.of()) // remove qualifier from lookup
+                .addContract(INJECTION_POINT_FACTORY) // only search for injection point providers
+                .build();
+        return services.all(criteria);
+    }
+
+    private void createConfigureMethodBody(WrappedServices services,
+                                           Set<TypeName> serviceTypes,
+                                           Method.Builder method) {
+        // find all interceptors and bind them
+        List<InjectServiceInfo> interceptors =
+                services.all(Lookup.builder()
+                                     .addContract(Interception.Interceptor.class)
+                                     .addQualifier(Qualifier.WILDCARD_NAMED)
+                                     .build());
+        method.addContent("binder.interceptors(");
+        boolean multiline = interceptors.size() > 2;
+        if (multiline) {
+            method.addContentLine("")
+                    .increaseContentPadding();
+        }
+
+        Iterator<InjectServiceInfo> interceptorIterator = interceptors.iterator();
+        while (interceptorIterator.hasNext()) {
+            method.addContent(interceptorIterator.next().descriptorType())
+                    .addContent(".INSTANCE");
+            if (interceptorIterator.hasNext()) {
+                method.addContent(",");
+                if (multiline) {
+                    method.addContentLine("");
+                } else {
+                    method.addContent(" ");
+                }
+            }
+        }
+
+        if (multiline) {
+            method.addContentLine("")
+                    .decreaseContentPadding();
+        }
+        method.addContentLine(");")
+                .addContentLine("");
+
+        // first collect required dependencies by descriptor
+        Map<TypeName, Set<Binding>> injectionPlan = new LinkedHashMap<>();
+        for (TypeName serviceType : serviceTypes) {
+            BindingPlan plan = bindingPlan(services, serviceType);
+            if (!plan.bindings.isEmpty()) {
+                injectionPlan.put(plan.descriptorType(), plan.bindings());
+            }
+        }
+
+        boolean supportNulls = false;
+        // we group all bindings by descriptor they belong to
+        injectionPlan.forEach((descriptorType, bindings) -> {
+            method.addContent("binder.bindTo(")
+                    .addContent(descriptorType.genericTypeName())
+                    .addContentLine(".INSTANCE)")
+                    .increaseContentPadding();
+
+            for (Binding binding : bindings) {
+                Consumer<ContentBuilder<?>> ipId = content -> content
+                        .addContent(binding.injectionPoint().descriptor().genericTypeName())
+                        .addContent(".")
+                        .addContent(binding.injectionPoint.descriptorConstant());
+
+                buildTimeBinding(method, binding, ipId, supportNulls);
+            }
+
+            /*
+            Commit the dependencies
+             */
+            method.addContentLine(".commit();")
+                    .decreaseContentPadding()
+                    .addContentLine("");
+        });
+    }
+
+    /*
+    Very similar code is used for runtime discovery in ServiceProvider.planForIp
+    make sure this is doing the same thing!
+    Here we code generate the calls to the binding class
+    */
+    private void buildTimeBinding(Method.Builder method,
+                                  Binding binding,
+                                  Consumer<ContentBuilder<?>> ipId,
+                                  boolean supportNulls) {
+
+        Ip injectionPoint = binding.injectionPoint();
+        List<InjectServiceInfo> discovered = binding.descriptors();
+        Iterator<Consumer<ContentBuilder<?>>> descriptors = discovered.stream()
+                .map(BindingGenerator::toContentBuilder)
+                .iterator();
+
+        TypeName ipType = injectionPoint.typeName();
+
+        // now there are a few options - optional, list, and single instance
+        if (ipType.isList()) {
+            TypeName typeOfList = ipType.typeArguments().getFirst();
+            if (typeOfList.isSupplier()) {
+                // inject List<Supplier<Contract>>
+                method.addContent(".bindListOfSuppliers(");
+            } else if (typeOfList.equals(INJECT_SERVICE_INSTANCE)) {
+                method.addContent(".bindServiceInstanceList(");
+            } else {
+                // inject List<Contract>
+                method.addContent(".bindList(");
+            }
+            method.update(ipId::accept);
+
+            if (discovered.isEmpty()) {
+                method.addContentLine(")");
+            } else {
+                method.addContent(", ")
+                        .update(it -> {
+                            while (descriptors.hasNext()) {
+                                descriptors.next().accept(it);
+                                if (descriptors.hasNext()) {
+                                    it.addContent(", ");
+                                }
+                            }
+                        })
+                        .addContentLine(")");
+            }
+        } else if (ipType.isOptional()) {
+            TypeName typeOfOptional = ipType.typeArguments().getFirst();
+            if (typeOfOptional.isSupplier()) {
+                // inject Optional<Supplier<Contract>>
+                method.addContent(".bindOptionalOfSupplier(");
+            } else if (typeOfOptional.equals(INJECT_SERVICE_INSTANCE)) {
+                // inject Optional<ServiceInstance<Contract>>
+                method.addContent(".bindOptionalOfServiceInstance(");
+            } else {
+                // inject Optional<Contract>
+                method.addContent(".bindOptional(");
+            }
+            method.update(ipId::accept);
+
+            if (discovered.isEmpty()) {
+                method.addContentLine(")");
+            } else {
+                method.addContent(", ");
+                descriptors.next().accept(method);
+                method.addContentLine(")");
+            }
+        } else if (ipType.isSupplier()) {
+            // one of the supplier options
+
+            TypeName typeOfSupplier = ipType.typeArguments().getFirst();
+            if (typeOfSupplier.isOptional()) {
+                // inject Supplier<Optional<Contract>>
+                method.addContent(".bindSupplierOfOptional(")
+                        .update(ipId::accept);
+                if (discovered.isEmpty()) {
+                    method.addContentLine(")");
+                } else {
+                    method.addContent(", ");
+                    descriptors.next().accept(method);
+                    method.addContentLine(")");
+                }
+            } else if (typeOfSupplier.isList()) {
+                // inject Supplier<List<Contract>>
+                method.addContent(".bindSupplierOfList(")
+                        .update(ipId::accept);
+                if (discovered.isEmpty()) {
+                    method.addContentLine(")");
+                } else {
+                    method.addContent(", ")
+                            .update(it -> {
+                                while (descriptors.hasNext()) {
+                                    descriptors.next().accept(it);
+                                    if (descriptors.hasNext()) {
+                                        it.addContent(", ");
+                                    }
+                                }
+                            })
+                            .addContentLine(")");
+                }
+            } else {
+                // inject Supplier<Contract>
+                method.addContent(".bindSupplier(")
+                        .update(ipId::accept);
+
+                if (discovered.isEmpty()) {
+                    // null binding is not supported at runtime
+                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
+                                                       + injectionPoint);
+                }
+                method.addContent(", ");
+                descriptors.next().accept(method);
+                method.addContentLine(")");
+            }
+        } else if (ipType.equals(INJECT_SERVICE_INSTANCE)) {
+            // inject Contract
+            if (discovered.isEmpty()) {
+                if (supportNulls) {
+                    method.addContent(".bindNull(")
+                            .update(ipId::accept)
+                            .addContentLine(")");
+                } else {
+                    // null binding is not supported at runtime
+                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
+                                                       + injectionPoint);
+                }
+            } else {
+                method.addContent(".bindServiceInstance(")
+                        .update(ipId::accept)
+                        .addContent(", ")
+                        .update(descriptors.next()::accept)
+                        .addContentLine(")");
+            }
+        } else {
+            // inject Contract
+            if (discovered.isEmpty()) {
+                if (supportNulls) {
+                    method.addContent(".bindNull(")
+                            .update(ipId::accept)
+                            .addContentLine(")");
+                } else {
+                    // null binding is not supported at runtime
+                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
+                                                       + injectionPoint);
+                }
+            } else {
+                method.addContent(".bind(")
+                        .update(ipId::accept)
+                        .addContent(", ")
+                        .update(descriptors.next()::accept)
+                        .addContentLine(")");
+            }
+        }
+    }
+
+    record InjectionPlan(List<InjectServiceInfo> unqualifiedProviders,
+                         List<InjectServiceInfo> qualifiedProviders) {
+    }
+
+    record BindingPlan(TypeName descriptorType,
+                       Set<Binding> bindings) {
+    }
+
+    /**
+     * @param injectionPoint to bind to
+     * @param descriptors    matching descriptors
+     */
+    record Binding(Ip injectionPoint,
+                   List<InjectServiceInfo> descriptors) {
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
new file mode 100644
index 00000000000..83ea6fe969e
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.helidon.codegen.CodegenOptions;
+
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+
+/**
+ * Abstract base for all codegen goals.
+ */
+abstract class CodegenAbstractMojo extends AbstractMojo {
+    /**
+     * Tag controlling whether we fail on error.
+     */
+    static final String TAG_FAIL_ON_ERROR = "helidon.inject.fail-on-error";
+
+    /**
+     * Tag controlling whether we fail on warnings.
+     */
+    static final String TAG_FAIL_ON_WARNING = "helidon.inject.fail-on-warning";
+
+    // ----------------------------------------------------------------------
+    // Configurables
+    // ----------------------------------------------------------------------
+    /**
+     * The module name to apply. If not found the module name will be inferred
+     * from {@code module-info.java} if present, or defined as {@code unnamed/package name}.
+     *
+     * @see io.helidon.codegen.CodegenOptions#TAG_CODEGEN_MODULE
+     */
+    @Parameter(property = CodegenOptions.TAG_CODEGEN_MODULE)
+    private String moduleName;
+    /**
+     * The package name to apply. If not found the package name will be inferred.
+     *
+     * @see io.helidon.codegen.CodegenOptions#TAG_CODEGEN_PACKAGE
+     */
+    @Parameter(property = CodegenOptions.TAG_CODEGEN_PACKAGE)
+    private String packageName;
+    /**
+     * Indicates whether the build will continue even if there are compilation errors.
+     */
+    @Parameter(property = TAG_FAIL_ON_ERROR, defaultValue = "true")
+    private boolean failOnError;
+    /**
+     * Indicates whether the build will continue even if there are any warnings.
+     */
+    @Parameter(property = TAG_FAIL_ON_WARNING)
+    private boolean failOnWarning;
+    /**
+     * Sets the arguments to be passed to the compiler.
+     * <p>
+     * Example:
+     * <pre>
+     * &lt;compilerArgs&gt;
+     *   &lt;arg&gt;-Xmaxerrs&lt;/arg&gt;
+     *   &lt;arg&gt;1000&lt;/arg&gt;
+     *   &lt;arg&gt;-Xlint&lt;/arg&gt;
+     *   &lt;arg&gt;-J-Duser.language=en_us&lt;/arg&gt;
+     * &lt;/compilerArgs&gt;
+     * </pre>
+     */
+    @Parameter
+    private List<String> compilerArgs;
+
+    // ----------------------------------------------------------------------
+    // Generic Configurables
+    // ----------------------------------------------------------------------
+
+    /**
+     * The current project instance. This is used for propagating generated-sources paths as
+     * compile/testCompile source roots.
+     */
+    @Parameter(defaultValue = "${project}", readonly = true, required = true)
+    private MavenProject project;
+
+    /**
+     * Default constructor.
+     */
+    CodegenAbstractMojo() {
+    }
+
+    @Override
+    public final void execute() throws MojoExecutionException, MojoFailureException {
+        try {
+            getLog().info("Started " + getClass().getSimpleName());
+            innerExecute();
+        } catch (MojoFailureException | MojoExecutionException e) {
+            if (failOnError) {
+                throw e;
+            }
+            getLog().warn("Failed to process " + getClass().getSimpleName(), e);
+        } catch (Throwable t) {
+            if (failOnError) {
+                throw new MojoExecutionException(t);
+            }
+            getLog().warn("Failed to process " + getClass().getSimpleName(), t);
+        }
+    }
+
+    /**
+     * Handle execution of this plugin. The {@link #execute()} method handles exceptions according to
+     * {@code failOnError} configuration.
+     *
+     * @throws org.apache.maven.plugin.MojoExecutionException as needed
+     * @throws org.apache.maven.plugin.MojoFailureException   as needed
+     */
+    abstract void innerExecute() throws MojoExecutionException, MojoFailureException;
+
+    /**
+     * The target package name.
+     *
+     * @return the target package name, if configured
+     */
+    Optional<String> packageNameFromMavenConfig() {
+        return Optional.ofNullable(packageName);
+    }
+
+    /**
+     * The module name of current module.
+     *
+     * @return the module name, if configured
+     */
+    Optional<String> moduleNameFromMavenConfig() {
+        return Optional.ofNullable(moduleName);
+    }
+
+    /**
+     * The Maven project.
+     *
+     * @return maven project
+     */
+    MavenProject mavenProject() {
+        return project;
+    }
+
+    /**
+     * Whether to fail on error.
+     * Handled in {@link #execute()} by default.
+     *
+     * @return if processing should fail on error
+     */
+    boolean failOnError() {
+        return failOnError;
+    }
+
+    /**
+     * Whether to fail on warning.
+     *
+     * @return if processing should fail on warning
+     */
+    boolean failOnWarning() {
+        return failOnWarning;
+    }
+
+    /**
+     * List of compiler arguments (expected to start with {@code -A}).
+     *
+     * @return compiler arguments
+     */
+    List<String> getCompilerArgs() {
+        return compilerArgs == null ? List.of() : compilerArgs;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
new file mode 100644
index 00000000000..07ea515d505
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
@@ -0,0 +1,492 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenOptions;
+import io.helidon.codegen.CodegenScope;
+import io.helidon.codegen.ModuleInfo;
+import io.helidon.codegen.ModuleInfoSourceParser;
+import io.helidon.codegen.compiler.CompilerOptions;
+import io.helidon.common.types.TypeName;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.codegen.ApplicationMainGenerator;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ScanResult;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+
+/**
+ * Abstract base for the Injection {@code maven-plugin} responsible for creating
+ * {@code Binding}, Test {@code Binding}, and application Main class.
+ */
+abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
+    /**
+     * Class name of the binding class generated by Maven plugin (for end user application).
+     */
+    protected static final String BINDING_CLASS_NAME = "Injection__Binding";
+    /**
+     * Name of the generated main class.
+     */
+    @Parameter(property = "helidon.inject.application.main.class.name",
+               defaultValue = ApplicationMainGenerator.CLASS_NAME)
+    private String mainClassName;
+    /**
+     * The -source argument for the Java compiler.
+     * Note: using the same as maven-compiler for convenience and least astonishment.
+     */
+    @Parameter(property = "maven.compiler.source",
+               defaultValue = "21")
+    private String source;
+    /**
+     * The -target argument for the Java compiler.
+     * Note: using the same as maven-compiler for convenience and least astonishment.
+     */
+    @Parameter(property = "maven.compiler.target",
+               defaultValue = "21")
+    private String target;
+    /**
+     * Whether to validate the application when creating its bindings.
+     */
+    @Parameter(property = "helidon.inject.application.validate",
+               defaultValue = "true")
+    private boolean validate;
+    /**
+     * Whether to generate binding class (provides generated injection plan for all services).
+     */
+    @Parameter(property = "helidon.inject.application.binding.generate",
+               defaultValue = "true")
+    private boolean generateBinding;
+
+    /**
+     * Default constructor.
+     */
+    CreateApplicationAbstractMojo() {
+    }
+
+    @Override
+    void innerExecute() {
+        MavenLogger mavenLogger = MavenLogger.create(getLog(), failOnWarning());
+
+        boolean hasModuleInfo = hasModuleInfo();
+        Set<Path> modulepath = hasModuleInfo ? getModulepathElements() : Set.of();
+        Set<Path> classpath = getClasspathElements();
+        ClassLoader prev = Thread.currentThread().getContextClassLoader();
+        URLClassLoader loader = createClassLoader(classpath, prev);
+        getLog().debug("Service registry classpath: " + classpath);
+
+        Optional<ModuleInfo> nonTestModuleInfo = findModuleInfo(nonTestSourceRootPaths())
+                .map(ModuleInfoSourceParser::parse);
+
+        /*
+        We may have module info both in sources and in tests
+         */
+        Optional<ModuleInfo> myModuleInfo = findModuleInfo(sourceRootPaths())
+                .map(ModuleInfoSourceParser::parse);
+        CodegenOptions codegenOptions = MavenOptions.create(toOptions());
+        CodegenScope scope = scope();
+        codegenOptions.validate(Set.of());
+
+        // package name to use (should be the same as ModuleComponent package)
+        String packageName = packageName(codegenOptions, myModuleInfo, nonTestModuleInfo);
+        // module name to use to define application name (should be the same as ModuleComponent uses for this module)
+        String moduleName = moduleName(loader, codegenOptions, myModuleInfo, packageName, scope);
+
+        try (ScanResult scan = new ClassGraph()
+                .overrideClasspath(classpath)
+                .enableAllInfo()
+                .scan()) {
+            MavenCodegenContext scanContext = MavenCodegenContext.create(codegenOptions,
+                                                                         scan,
+                                                                         scope,
+                                                                         generatedSourceDirectory(),
+                                                                         outputDirectory(),
+                                                                         mavenLogger,
+                                                                         myModuleInfo.orElse(null));
+
+            Thread.currentThread().setContextClassLoader(loader);
+
+            CompilerOptions compilerOptions = CompilerOptions.builder()
+                    .classpath(List.copyOf(classpath))
+                    .modulepath(List.copyOf(modulepath))
+                    .sourcepath(sourceRootPaths())
+                    .source(getSource())
+                    .target(getTarget())
+                    .commandLineArguments(getCompilerArgs())
+                    .outputDirectory(outputDirectory())
+                    .build();
+
+            applicationBinding(loader,
+                               mavenLogger,
+                               scanContext,
+                               compilerOptions,
+                               moduleName,
+                               packageName);
+
+            if (createMain()) {
+                createMain(loader,
+                           mavenLogger,
+                           scanContext,
+                           compilerOptions,
+                           packageName);
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(prev);
+        }
+    }
+
+    void createMain(ClassLoader loader,
+                    MavenLogger mavenLogger,
+                    MavenCodegenContext scanContext,
+                    CompilerOptions compilerOptions,
+                    String packageName) {
+        try (WrappedServices services = WrappedServices.create(loader, mavenLogger, false)) {
+            createMainClass(compilerOptions,
+                            scanContext,
+                            services,
+                            packageName);
+        } catch (CodegenException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new CodegenException("An error occurred creating the main class in " + getClass().getName(), e);
+        }
+    }
+
+    void applicationBinding(ClassLoader loader,
+                            MavenLogger mavenLogger,
+                            MavenCodegenContext scanContext,
+                            CompilerOptions compilerOptions,
+                            String moduleName,
+                            String packageName) {
+        try (WrappedServices services = WrappedServices.create(loader, mavenLogger, false)) {
+            applicationBinding(scanContext,
+                               services,
+                               compilerOptions,
+                               moduleName,
+                               packageName);
+        } catch (CodegenException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new CodegenException("An error occurred creating the binding in " + getClass().getName(), e);
+        }
+    }
+
+    void createMainClass(CompilerOptions compilerOptions,
+                         MavenCodegenContext scanContext,
+                         WrappedServices services,
+                         String packageName) {
+        TypeName generatedType = TypeName.builder()
+                .packageName(packageName)
+                .className(mainClassName)
+                .build();
+
+        MainClassCreator creator = new MainClassCreator(scanContext, failOnError());
+        creator.create(scanContext, compilerOptions, services, generatedType);
+    }
+
+    void applicationBinding(MavenCodegenContext scanContext,
+                            WrappedServices services,
+                            CompilerOptions compilerOptions,
+                            String moduleName,
+                            String packageName) {
+
+        // retrieves all the services in the registry
+        Set<TypeName> allServices = services.all()
+                .stream()
+                .map(InjectServiceInfo::serviceType)
+                .collect(Collectors.toCollection(TreeSet::new));
+
+        if (allServices.isEmpty()) {
+            warn("Binding generator found no services to process");
+            return;
+        }
+
+        getLog().debug("All services to be processed: " + allServices);
+
+        String className = bindingClassName();
+
+        if (validate) {
+            // validate the application
+            ApplicationValidator validator = new ApplicationValidator(scanContext, failOnWarning());
+            validator.validate(services);
+        }
+
+        if (generateBinding) {
+            // get the binding generator only after services are initialized (we need to ignore any existing apps)
+            BindingGenerator creator = new BindingGenerator(scanContext, failOnError());
+
+            creator.createBinding(services,
+                                  allServices,
+                                  TypeName.create(packageName + "." + className),
+                                  moduleName,
+                                  compilerOptions);
+        }
+    }
+
+    /**
+     * Where to generate sources. As this directory differs between production code and test code, it must be provided
+     * by a subclass.
+     *
+     * @return where to generate sources
+     */
+    abstract Path generatedSourceDirectory();
+
+    /**
+     * Binding class name to be generated.
+     *
+     * @return binding class name
+     */
+    abstract String bindingClassName();
+
+    /**
+     * Output directory for this {@link #scope()}.
+     *
+     * @return output directory
+     */
+    abstract Path outputDirectory();
+
+    abstract boolean createMain();
+
+    /**
+     * Source roots for this {@link #scope()}.
+     *
+     * @return source roots
+     */
+    List<Path> sourceRootPaths() {
+        return nonTestSourceRootPaths();
+    }
+
+    /**
+     * Production source roots for this project.
+     *
+     * @return source roots for production code
+     */
+    List<Path> nonTestSourceRootPaths() {
+        MavenProject project = mavenProject();
+        List<Path> result = new ArrayList<>(project.getCompileSourceRoots().size());
+        for (Object a : project.getCompileSourceRoots()) {
+            result.add(Path.of(a.toString()));
+        }
+        return result;
+    }
+
+    /**
+     * Test source roots for this project.
+     *
+     * @return source roots for test code
+     */
+    protected List<Path> testSourceRootPaths() {
+        MavenProject project = mavenProject();
+        List<Path> result = new ArrayList<>(project.getTestCompileSourceRoots().size());
+        for (Object a : project.getTestCompileSourceRoots()) {
+            result.add(Path.of(a.toString()));
+        }
+        return result;
+    }
+
+    LinkedHashSet<Path> getModulepathElements() {
+        return getSourceClasspathElements();
+    }
+
+    boolean hasModuleInfo() {
+        return sourceRootPaths()
+                .stream()
+                .anyMatch(p -> Files.exists(p.resolve(ModuleInfo.FILE_NAME)));
+    }
+
+    Optional<Path> findModuleInfo(List<Path> sourcePaths) {
+        return sourcePaths.stream()
+                .map(it -> it.resolve(ModuleInfo.FILE_NAME))
+                .filter(Files::exists)
+                .findFirst();
+    }
+
+    void warn(String msg) {
+        getLog().warn(msg);
+
+        if (failOnWarning()) {
+            throw new CodegenException(msg);
+        }
+    }
+
+    /**
+     * The scope of the code generation (production, test etc.).
+     *
+     * @return codegen scope
+     */
+    abstract CodegenScope scope();
+
+    /**
+     * Creates a new classloader.
+     *
+     * @param classPath the classpath to use
+     * @param parent    the parent loader
+     * @return the loader
+     */
+    URLClassLoader createClassLoader(Collection<Path> classPath,
+                                     ClassLoader parent) {
+        List<URL> urls = new ArrayList<>(classPath.size());
+        for (Path dependency : classPath) {
+            try {
+                urls.add(dependency.toUri().toURL());
+            } catch (MalformedURLException e) {
+                throw new CodegenException("Unable to build the classpath. Dependency cannot be converted to URL: "
+                                                   + dependency,
+                                           e);
+            }
+        }
+
+        if (parent == null) {
+            parent = Thread.currentThread().getContextClassLoader();
+        }
+        return new URLClassLoader(urls.toArray(new URL[0]), parent);
+    }
+
+    String getSource() {
+        return source;
+    }
+
+    String getTarget() {
+        return target;
+    }
+
+    LinkedHashSet<Path> getSourceClasspathElements() {
+        MavenProject project = mavenProject();
+        LinkedHashSet<Path> result = new LinkedHashSet<>(project.getCompileArtifacts().size());
+        result.add(Paths.get(project.getBuild().getOutputDirectory()));
+        for (Object a : project.getCompileArtifacts()) {
+            result.add(((Artifact) a).getFile().toPath());
+        }
+        return result;
+    }
+
+    /**
+     * Provides a convenient way to handle test scope. Returns the classpath for source files (or test sources) only.
+     */
+    LinkedHashSet<Path> getClasspathElements() {
+        return getSourceClasspathElements();
+    }
+
+    // to dot separated path
+    private static String toDotSeparated(Path relativePath) {
+        return StreamSupport.stream(relativePath.spliterator(), false)
+                .map(Path::toString)
+                .collect(Collectors.joining("."));
+    }
+
+    private String packageName(CodegenOptions codegenOptions,
+                               Optional<ModuleInfo> myModuleInfo,
+                               Optional<ModuleInfo> srcModuleInfo) {
+        return CodegenOptions.CODEGEN_PACKAGE
+                .findValue(codegenOptions)
+                .or(() -> myModuleInfo.flatMap(this::exportedPackage))
+                .or(() -> srcModuleInfo.flatMap(this::exportedPackage))
+                .or(this::firstUsedPackage)
+                .orElseThrow(() -> new CodegenException("Unable to determine package for binding class."));
+    }
+
+    private Optional<String> firstUsedPackage() {
+        // we expect at least some source code. If none found, try test source, if none found, must be configured
+        return firstUsedPackage(nonTestSourceRootPaths())
+                .or(() -> firstUsedPackage(testSourceRootPaths()));
+    }
+
+    private Optional<String> firstUsedPackage(List<Path> sourceRoots) {
+        Set<String> found = new TreeSet<>(Comparator.comparing(String::length));
+
+        for (Path sourceRoot : sourceRoots) {
+            try {
+                try (Stream<Path> pathStream = Files.walk(sourceRoot)) {
+                    pathStream
+                            .filter(it -> it.getFileName().toString().endsWith(".java"))
+                            .map(it -> packageName(sourceRoot, it))
+                            .filter(Predicate.not(String::isBlank))
+                            .forEach(found::add);
+                }
+            } catch (IOException e) {
+                getLog().debug("Failed to walk path tree for source root: " + sourceRoot.toAbsolutePath(),
+                               e);
+            }
+        }
+        return found.stream()
+                .findFirst();
+    }
+
+    private Optional<String> exportedPackage(ModuleInfo moduleInfo) {
+        Set<String> unqualifiedExports = new TreeSet<>(Comparator.comparing(String::length));
+        moduleInfo.exports()
+                .forEach((export, to) -> {
+                    if (to.isEmpty()) {
+                        unqualifiedExports.add(export);
+                    }
+                });
+        return unqualifiedExports.stream().findFirst();
+    }
+
+    private String moduleName(ClassLoader loader,
+                              CodegenOptions codegenOptions,
+                              Optional<ModuleInfo> myModuleInfo,
+                              String packageName,
+                              CodegenScope scope) {
+        return CodegenOptions.CODEGEN_MODULE
+                .findValue(codegenOptions)
+                .or(() -> myModuleInfo.map(ModuleInfo::name))
+                .orElseGet(() -> "unnamed/"
+                        + packageName
+                        + (scope.isProduction() ? "" : "/" + scope.name()));
+    }
+
+    private String packageName(Path rootPath, Path filePath) {
+        Path parent = filePath.getParent();
+        if (parent == null) {
+            return "";
+        }
+        return toDotSeparated(rootPath.relativize(parent));
+    }
+
+    private Set<String> toOptions() {
+        Set<String> options = new HashSet<>(getCompilerArgs());
+
+        moduleNameFromMavenConfig().ifPresent(it -> options.add("-A" + CodegenOptions.TAG_CODEGEN_MODULE + "=" + it));
+        packageNameFromMavenConfig().ifPresent(it -> options.add("-A" + CodegenOptions.TAG_CODEGEN_PACKAGE + "=" + it));
+
+        return options;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java
new file mode 100644
index 00000000000..a6bedc507cc
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import io.helidon.codegen.CodegenScope;
+
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.plugins.annotations.ResolutionScope;
+
+/**
+ * Maven goal to create application bindings (a mapping of services that satisfy injection points),
+ * and to create application main class (reflection-free registration of services).
+ */
+@Mojo(name = "create-application",
+      defaultPhase = LifecyclePhase.COMPILE,
+      threadSafe = true,
+      requiresDependencyResolution = ResolutionScope.COMPILE)
+public class CreateApplicationMojo extends CreateApplicationAbstractMojo {
+
+    /**
+     * Specify where to place generated source files created by annotation processing.
+     */
+    @Parameter(defaultValue = "${project.build.directory}/generated-sources/annotations")
+    private File generatedSourcesDirectory;
+
+    /**
+     * The directory for compiled classes.
+     */
+    @Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
+    private File outputDirectory;
+
+    /**
+     * Whether to generate main class. Default name is {@code ApplicationMain} in the same package as
+     * the generated application.
+     */
+    @Parameter(property = "helidon.inject.application.main.generate",
+               defaultValue = "true")
+    private boolean generateMain;
+
+    /**
+     * Name of the generated binding class.
+     */
+    @Parameter(property = "helidon.inject.application.binding.class.name",
+               defaultValue = BINDING_CLASS_NAME)
+    private String bindingClassName;
+
+    /**
+     * Default constructor.
+     */
+    public CreateApplicationMojo() {
+    }
+
+    @Override
+    protected Path generatedSourceDirectory() {
+        return generatedSourcesDirectory.toPath();
+    }
+
+    @Override
+    protected Path outputDirectory() {
+        return outputDirectory.toPath();
+    }
+
+    @Override
+    protected CodegenScope scope() {
+        return CodegenScope.PRODUCTION;
+    }
+
+    @Override
+    String bindingClassName() {
+        return bindingClassName;
+    }
+
+    @Override
+    boolean createMain() {
+        return generateMain;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java
new file mode 100644
index 00000000000..637ef1f1ea3
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import io.helidon.codegen.CodegenScope;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.plugins.annotations.ResolutionScope;
+import org.apache.maven.project.MavenProject;
+
+/**
+ * A mojo wrapper to {@link BindingGenerator} for test specific types.
+ * For test scope, we only generate binding, as main class would not be useful.
+ */
+@Mojo(name = "test-application-create", defaultPhase = LifecyclePhase.TEST_COMPILE, threadSafe = true,
+      requiresDependencyResolution = ResolutionScope.TEST)
+@SuppressWarnings("unused")
+public class CreateTestApplicationMojo extends CreateApplicationAbstractMojo {
+
+    /**
+     * Name of the generated binding class.
+     */
+    @Parameter(property = "helidon.inject.application.binding.classname",
+               defaultValue = "Test" + BINDING_CLASS_NAME)
+    private String bindingClassName;
+
+    /**
+     * Specify where to place generated source files created by annotation processing.
+     * Only applies to JDK 1.6+
+     */
+    @Parameter(defaultValue = "${project.build.directory}/generated-test-sources/test-annotations")
+    private File generatedTestSourcesDirectory;
+
+    /**
+     * The directory where compiled test classes go.
+     */
+    @Parameter(defaultValue = "${project.build.testOutputDirectory}", required = true, readonly = true)
+    private File testOutputDirectory;
+
+    /**
+     * Default constructor.
+     */
+    public CreateTestApplicationMojo() {
+    }
+
+    @Override
+    protected Path generatedSourceDirectory() {
+        return generatedTestSourcesDirectory.toPath();
+    }
+
+    @Override
+    protected Path outputDirectory() {
+        return testOutputDirectory.toPath();
+    }
+
+    @Override
+    protected List<Path> sourceRootPaths() {
+        return testSourceRootPaths();
+    }
+
+    @Override
+    protected LinkedHashSet<Path> getClasspathElements() {
+        MavenProject project = mavenProject();
+        LinkedHashSet<Path> result = new LinkedHashSet<>(project.getTestArtifacts().size());
+        result.add(new File(project.getBuild().getTestOutputDirectory()).toPath());
+        for (Object a : project.getTestArtifacts()) {
+            result.add(((Artifact) a).getFile().toPath());
+        }
+        result.addAll(super.getClasspathElements());
+        return result;
+    }
+
+    @Override
+    LinkedHashSet<Path> getModulepathElements() {
+        return getClasspathElements();
+    }
+
+    @Override
+    protected String bindingClassName() {
+        return bindingClassName;
+    }
+
+    @Override
+    protected CodegenScope scope() {
+        return new CodegenScope("test");
+    }
+
+    @Override
+    boolean createMain() {
+        return false;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
new file mode 100644
index 00000000000..027b00f67a3
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.codegen.classmodel.Method;
+import io.helidon.codegen.compiler.Compiler;
+import io.helidon.codegen.compiler.CompilerOptions;
+import io.helidon.codegen.scan.ScanContext;
+import io.helidon.codegen.scan.ScanTypeInfoFactory;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.ElementSignature;
+import io.helidon.common.types.ResolvedType;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Injection.RunLevel;
+import io.helidon.service.inject.codegen.ApplicationMainGenerator;
+import io.helidon.service.metadata.DescriptorMetadata;
+import io.helidon.service.registry.ServiceDescriptor;
+import io.helidon.service.registry.ServiceDiscovery;
+import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.ClassInfoList;
+import io.github.classgraph.ScanResult;
+
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_MAIN;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_RUN_LEVEL;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_BINDING;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
+
+class MainClassCreator {
+    private static final TypeName GENERATOR = TypeName.create(MainClassCreator.class);
+    private static final String INJECTION_MAIN_ANNOTATION = INJECTION_MAIN.packageName()
+            + "."
+            + INJECTION_MAIN.classNameWithEnclosingNames().replace('.', '$');
+
+    private final MavenCodegenContext ctx;
+    private final boolean failOnError;
+
+    MainClassCreator(MavenCodegenContext scanContext, boolean failOnError) {
+        this.ctx = scanContext;
+        this.failOnError = failOnError;
+    }
+
+    void create(MavenCodegenContext scanContext,
+                CompilerOptions compilerOptions,
+                WrappedServices services,
+                TypeName generatedType) {
+        try {
+            codegen(scanContext, compilerOptions, services, generatedType);
+        } catch (CodegenException ce) {
+            handleError(ce);
+        } catch (Throwable te) {
+            handleError(new CodegenException("Failed to code generate application main class", te));
+        }
+    }
+
+    private void codegen(ScanContext scanContext,
+                         CompilerOptions compilerOptions,
+                         WrappedServices services,
+                         TypeName generatedType) {
+        // if there is a custom main class present, we must honor it
+        Optional<TypeInfo> foundCustomMain = findCustomMain(scanContext, compilerOptions.outputDirectory());
+        Set<ElementSignature> declaredSignatures;
+        TypeName superType;
+
+        if (foundCustomMain.isPresent()) {
+            TypeInfo customMain = foundCustomMain.get();
+            ApplicationMainGenerator.validate(customMain);
+            declaredSignatures = ApplicationMainGenerator.declaredSignatures(customMain);
+            superType = customMain.typeName();
+        } else {
+            declaredSignatures = Set.of();
+            superType = INJECT_MAIN;
+        }
+
+        ClassModel classModel =
+                ApplicationMainGenerator.generate(GENERATOR,
+                                                  declaredSignatures,
+                                                  superType,
+                                                  generatedType,
+                                                  false,
+                                                  true,
+                                                  (classBuilder, methodModel, paramName) -> serviceDescriptors(classBuilder,
+                                                                                                               methodModel,
+                                                                                                               paramName,
+                                                                                                               services),
+                                                  (classBuilder, methodModel, paramName) -> runLevels(
+                                                          methodModel,
+                                                          services))
+                        .build();
+
+        Path generated = ctx.filer()
+                .writeSourceFile(classModel);
+
+        Compiler.compile(compilerOptions, generated);
+    }
+
+    private Optional<TypeInfo> findCustomMain(ScanContext scanContext, Path targetPath) {
+        // we do not want to search the whole application, just the current module. Main class MUST be in the module that
+        // uses the maven plugin
+        try (ScanResult scan = new ClassGraph()
+                .overrideClasspath(Set.of(targetPath))
+                .enableAllInfo()
+                .scan()) {
+            ClassInfoList customMainClasses = scan.getClassesWithAnnotation(INJECTION_MAIN_ANNOTATION);
+            if (customMainClasses.isEmpty()) {
+                return Optional.empty();
+            }
+            if (customMainClasses.size() > 1) {
+                String names = customMainClasses.stream()
+                        .map(ClassInfo::getName)
+                        .collect(Collectors.joining(", "));
+                throw new CodegenException("There can only be one class annotated with " + INJECTION_MAIN.fqName() + ", "
+                                                   + "but discovered more than one: " + names);
+            }
+            return ScanTypeInfoFactory.create(scanContext, customMainClasses.getFirst());
+        }
+    }
+
+    private void runLevels(Method.Builder method,
+                           WrappedServices services) {
+        Set<Double> runLevels = new TreeSet<>();
+
+        for (InjectServiceInfo serviceInfo : services.all()) {
+            if (serviceInfo.runLevel().isPresent()) {
+                runLevels.add(serviceInfo.runLevel().get());
+            }
+        }
+
+        List<Double> runLevelList = List.copyOf(runLevels);
+
+        for (int i = 0; i < runLevelList.size(); i++) {
+            double current = runLevelList.get(i);
+            if (Double.compare(RunLevel.STARTUP, current) == 0) {
+                method.addContent(INJECTION_RUN_LEVEL)
+                        .addContent(".STARTUP");
+            } else if (Double.compare(RunLevel.SERVER, current) == 0) {
+                method.addContent(INJECTION_RUN_LEVEL)
+                        .addContent(".SERVER");
+            } else if (Double.compare(RunLevel.NORMAL, current) == 0) {
+                method.addContent(INJECTION_RUN_LEVEL)
+                        .addContent(".NORMAL");
+            } else {
+                method.addContent(String.valueOf(current))
+                        .addContent("D");
+            }
+            if (i == runLevelList.size() - 1) {
+                method.addContentLine("");
+            } else {
+                method.addContentLine(",");
+            }
+        }
+    }
+
+    private void serviceDescriptors(ClassModel.Builder classModel,
+                                    Method.Builder method,
+                                    String paramName,
+                                    WrappedServices services) {
+        List<ServiceLoader__ServiceDescriptor> serviceLoaded = new ArrayList<>();
+        List<TypeName> serviceDescriptors = new ArrayList<>();
+
+        // bindings must be added directly from service discovery, as they are not part of the registry
+        addBindings(serviceDescriptors);
+
+        // for each discovered service, add it to the configuration
+        for (InjectServiceInfo serviceInfo : services.all()) {
+            if (serviceInfo.coreInfo() instanceof ServiceLoader__ServiceDescriptor sl) {
+                serviceLoaded.add(sl);
+            } else {
+                serviceDescriptors.add(serviceInfo.descriptorType());
+            }
+        }
+
+        Map<TypeName, String> providerConstants = new HashMap<>();
+        AtomicInteger constantCounter = new AtomicInteger();
+
+        serviceLoaded.stream()
+                .sorted(serviceLoaderComparator())
+                .forEach(it -> addServiceLoader(classModel, method, providerConstants, constantCounter, it));
+
+        if (!serviceLoaded.isEmpty() && !serviceDescriptors.isEmpty()) {
+            // visually separate service loaded services from service descriptors
+            method.addContentLine("");
+        }
+
+        // config.addServiceDescriptor(ImperativeFeature__ServiceDescriptor.INSTANCE);
+        serviceDescriptors.stream().sorted()
+                .forEach(it -> method.addContent(paramName)
+                        .addContent(".addServiceDescriptor(")
+                        .addContent(it)
+                        .addContentLine(".INSTANCE);"));
+    }
+
+    private void addBindings(List<TypeName> serviceDescriptors) {
+        ResolvedType binding = ResolvedType.create(INJECT_BINDING);
+
+        ServiceDiscovery.create()
+                .allMetadata()
+                .stream()
+                .filter(it -> it.contracts().contains(binding))
+                .map(DescriptorMetadata::descriptorType)
+                .forEach(serviceDescriptors::add);
+    }
+
+    private void addServiceLoader(ClassModel.Builder classModel,
+                                  Method.Builder main,
+                                  Map<TypeName, String> providerConstants,
+                                  AtomicInteger constantCounter,
+                                  ServiceLoader__ServiceDescriptor sl) {
+        // Generated code:
+        // config.addServiceDescriptor(serviceLoader(PROVIDER_1,
+        //                                           YamlConfigParser.class,
+        //                                           () -> new io.helidon.config.yaml.YamlConfigParser(),
+        //                                           90.0));
+        TypeName providerInterface = sl.providerInterface();
+        String constantName = providerConstants.computeIfAbsent(providerInterface, it -> {
+            int i = constantCounter.getAndIncrement();
+            String constant = "PROVIDER_" + i;
+            classModel.addField(field -> field
+                    .accessModifier(AccessModifier.PRIVATE)
+                    .isStatic(true)
+                    .isFinal(true)
+                    .type(TypeNames.TYPE_NAME)
+                    .name(constant)
+                    .addContentCreate(providerInterface));
+            return constant;
+        });
+
+        main.addContent("config")
+                .addContent(".addServiceDescriptor(serviceLoader(")
+                .addContent(constantName)
+                .addContentLine(",")
+                .increaseContentPadding()
+                .increaseContentPadding()
+                .increaseContentPadding()
+                .addContent(sl.serviceType()).addContentLine(".class,")
+                .addContent("() -> new ").addContent(sl.serviceType()).addContentLine("(),")
+                .addContent(String.valueOf(sl.weight()))
+                .addContentLine("));")
+                .decreaseContentPadding()
+                .decreaseContentPadding()
+                .decreaseContentPadding();
+    }
+
+    private Comparator<ServiceLoader__ServiceDescriptor> serviceLoaderComparator() {
+        return Comparator.comparing(ServiceLoader__ServiceDescriptor::providerInterface)
+                .thenComparing(ServiceDescriptor::serviceType);
+    }
+
+    private void handleError(CodegenException ce) {
+        if (failOnError) {
+            throw ce;
+        } else {
+            ctx.logger().log(ce.toEvent(System.Logger.Level.WARNING));
+        }
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java
new file mode 100644
index 00000000000..f5bffbf0b37
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import io.helidon.codegen.CodegenContext;
+import io.helidon.codegen.CodegenContextBase;
+import io.helidon.codegen.CodegenLogger;
+import io.helidon.codegen.CodegenOptions;
+import io.helidon.codegen.CodegenScope;
+import io.helidon.codegen.ModuleInfo;
+import io.helidon.codegen.scan.ScanContext;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypedElementInfo;
+
+import io.github.classgraph.ScanResult;
+
+class MavenCodegenContext extends CodegenContextBase implements CodegenContext, ScanContext {
+    private final ModuleInfo module;
+    private final MavenFiler filer;
+    private final ScanResult scanResult;
+
+    protected MavenCodegenContext(CodegenOptions options,
+                                  MavenFiler filer,
+                                  CodegenLogger logger,
+                                  CodegenScope scope,
+                                  ScanResult scanResult,
+                                  ModuleInfo module) {
+        super(options, Set.of(), filer, logger, scope);
+
+        this.module = module;
+        this.filer = filer;
+        this.scanResult = scanResult;
+    }
+
+    static MavenCodegenContext create(CodegenOptions options,
+                                      ScanResult scanResult,
+                                      CodegenScope scope,
+                                      Path generatedSourceDir,
+                                      Path outputDirectory,
+                                      MavenLogger logger,
+                                      ModuleInfo module /* may be null*/) {
+        return new MavenCodegenContext(options,
+                                       MavenFiler.create(generatedSourceDir, outputDirectory),
+                                       logger,
+                                       scope,
+                                       scanResult,
+                                       module);
+    }
+
+    @Override
+    public Optional<ModuleInfo> module() {
+        return Optional.ofNullable(module);
+    }
+
+    @Override
+    public MavenFiler filer() {
+        return filer;
+    }
+
+    @Override
+    public Optional<TypeInfo> typeInfo(TypeName typeName) {
+        return Optional.empty();
+    }
+
+    @Override
+    public Optional<TypeInfo> typeInfo(TypeName typeName, Predicate<TypedElementInfo> elementPredicate) {
+        return Optional.empty();
+    }
+
+    @Override
+    public ScanResult scanResult() {
+        return scanResult;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
new file mode 100644
index 00000000000..32b2a213ca2
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenFiler;
+import io.helidon.codegen.FilerResource;
+import io.helidon.codegen.FilerTextResource;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.common.types.TypeName;
+
+class MavenFiler implements CodegenFiler {
+    private final Path generatedSourceDir;
+    private final Path outputDirectory;
+    private boolean generatedSources;
+
+    MavenFiler(Path generatedSourceDir, Path outputDirectory) {
+        this.generatedSourceDir = generatedSourceDir;
+        this.outputDirectory = outputDirectory;
+    }
+
+    static MavenFiler create(Path generatedSourceDir, Path outputDirectory) {
+        return new MavenFiler(generatedSourceDir, outputDirectory);
+    }
+
+    @Override
+    public Path writeSourceFile(TypeName typeName, String content, Object... originatingElements) {
+        String pathToSourceFile = typeName.packageName().replace('.', '/');
+        String fileName = typeName.className() + ".java";
+        Path path = generatedSourceDir.resolve(pathToSourceFile)
+                .resolve(fileName);
+        Path parentDir = path.getParent();
+        if (parentDir != null) {
+            mkdirs(parentDir);
+        }
+
+        try (Writer writer = Files.newBufferedWriter(path,
+                                                     StandardCharsets.UTF_8,
+                                                     StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)) {
+            writer.write(content);
+            generatedSources = true;
+        } catch (IOException e) {
+            throw new CodegenException("Failed to write new source file: " + path.toAbsolutePath(), e, typeName);
+        }
+        return path;
+    }
+
+    @Override
+    public Path writeSourceFile(ClassModel classModel, Object... originatingElements) {
+        TypeName typeName = classModel.typeName();
+        String pathToSourceFile = typeName.packageName().replace('.', '/');
+        String fileName = typeName.className() + ".java";
+        Path path = generatedSourceDir.resolve(pathToSourceFile)
+                .resolve(fileName);
+        Path parentDir = path.getParent();
+        if (parentDir != null) {
+            mkdirs(parentDir);
+        }
+
+        try (Writer writer = Files.newBufferedWriter(path,
+                                                     StandardCharsets.UTF_8,
+                                                     StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)) {
+            classModel.write(writer, "    ");
+            generatedSources = true;
+        } catch (IOException e) {
+            throw new CodegenException("Failed to write new source file: " + path.toAbsolutePath(), e, typeName);
+        }
+        return path;
+    }
+
+    @Override
+    public Path writeResource(byte[] resource, String location, Object... originatingElements) {
+        Path path = outputDirectory.resolve(location);
+        Path parentDir = path.getParent();
+        if (parentDir != null) {
+            mkdirs(parentDir);
+        }
+        try (OutputStream out = Files.newOutputStream(path, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)) {
+            out.write(resource);
+        } catch (IOException e) {
+            throw new CodegenException("Failed to write new resource file: " + path.toAbsolutePath(), location);
+        }
+        return path;
+    }
+
+    @Override
+    public FilerTextResource textResource(String location, Object... originatingElements) {
+        Path resourcePath = outputDirectory.resolve(location);
+        Path parentDir = resourcePath.getParent();
+        if (parentDir != null) {
+            mkdirs(parentDir);
+        }
+        if (Files.exists(resourcePath)) {
+            try {
+                return new MavenFilerTextResource(resourcePath, Files.readAllLines(resourcePath));
+            } catch (IOException e) {
+                throw new CodegenException("Failed to read existing text resource: " + resourcePath.toAbsolutePath(), e);
+            }
+        } else {
+            return new MavenFilerTextResource(resourcePath);
+        }
+    }
+
+    @Override
+    public FilerResource resource(String location, Object... originatingElements) {
+        Path resourcePath = outputDirectory.resolve(location);
+        Path parentDir = resourcePath.getParent();
+        if (parentDir != null) {
+            mkdirs(parentDir);
+        }
+        if (Files.exists(resourcePath)) {
+            try {
+                return new MavenFilerResource(resourcePath, Files.readAllBytes(resourcePath));
+            } catch (IOException e) {
+                throw new CodegenException("Failed to read existing resource: " + resourcePath.toAbsolutePath(), e);
+            }
+        } else {
+            return new MavenFilerResource(resourcePath);
+        }
+    }
+
+    boolean generatedSources() {
+        return generatedSources;
+    }
+
+    private void mkdirs(Path path) {
+        try {
+            Files.createDirectories(path);
+        } catch (IOException e) {
+            throw new CodegenException("Failed to create directories for: " + path.toAbsolutePath());
+        }
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java
new file mode 100644
index 00000000000..284ea4ab585
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Arrays;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.FilerResource;
+
+class MavenFilerResource implements FilerResource {
+    private final Path resourcePath;
+
+    private byte[] currentBytes;
+    private boolean modified;
+
+    MavenFilerResource(Path resourcePath) {
+        this(resourcePath, new byte[0]);
+    }
+
+    MavenFilerResource(Path resourcePath, byte[] bytes) {
+        this.resourcePath = resourcePath;
+        this.currentBytes = bytes;
+    }
+
+    @Override
+    public byte[] bytes() {
+        return Arrays.copyOf(currentBytes, currentBytes.length);
+    }
+
+    @Override
+    public void bytes(byte[] newBytes) {
+        currentBytes = Arrays.copyOf(newBytes, newBytes.length);
+        modified = true;
+    }
+
+    @Override
+    public void write() {
+        if (modified) {
+            try {
+                Files.write(resourcePath, currentBytes, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE);
+            } catch (IOException e) {
+                throw new CodegenException("Failed to write resource " + resourcePath.toAbsolutePath(), e);
+            }
+        }
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java
new file mode 100644
index 00000000000..14a0cbcf7ca
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.List;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.FilerTextResource;
+
+class MavenFilerTextResource implements FilerTextResource {
+    private final Path resourcePath;
+    private final ArrayList<String> currentLines;
+
+    private boolean modified;
+
+    MavenFilerTextResource(Path resourcePath) {
+        this.resourcePath = resourcePath;
+        this.currentLines = new ArrayList<>();
+    }
+
+    MavenFilerTextResource(Path resourcePath, List<String> lines) {
+        this.resourcePath = resourcePath;
+        this.currentLines = new ArrayList<>(lines);
+    }
+
+    @Override
+    public List<String> lines() {
+        return List.copyOf(currentLines);
+    }
+
+    @Override
+    public void lines(List<String> newLines) {
+        currentLines.clear();
+        currentLines.addAll(newLines);
+        modified = true;
+    }
+
+    @Override
+    public void write() {
+        if (modified) {
+            try {
+                Files.write(resourcePath, currentLines, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE);
+            } catch (IOException e) {
+                throw new CodegenException("Failed to write resource " + resourcePath.toAbsolutePath(), e);
+            }
+        }
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java
new file mode 100644
index 00000000000..334cbb958ad
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import io.helidon.codegen.CodegenEvent;
+import io.helidon.codegen.CodegenLogger;
+import io.helidon.common.types.TypeName;
+
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.FieldInfo;
+import io.github.classgraph.MethodInfo;
+import org.apache.maven.plugin.logging.Log;
+
+class MavenLogger implements CodegenLogger {
+    private final Log log;
+    private final List<String> warnings = new CopyOnWriteArrayList<>();
+    private final List<String> errors = new CopyOnWriteArrayList<>();
+    private final Consumer<String> warningConsumer;
+
+    private MavenLogger(Log log, boolean failOnWarning) {
+        this.log = log;
+        if (failOnWarning) {
+            // keep them
+            warningConsumer = warnings::add;
+        } else {
+            // throw away
+            warningConsumer = it -> {
+            };
+        }
+    }
+
+    public static MavenLogger create(Log log, boolean failOnWarning) {
+        return new MavenLogger(log, failOnWarning);
+    }
+
+    @Override
+    public void log(CodegenEvent event) {
+        String message = toMessage(event);
+
+        switch (event.level()) {
+        case TRACE, DEBUG -> log(log::debug, log::debug, event, message);
+        case INFO -> log(log::info, log::info, event, message);
+        case WARNING -> {
+            warningConsumer.accept(message);
+            log(log::warn, log::warn, event, message);
+        }
+        case ERROR -> {
+            errors.add(message);
+            log(log::error, log::error, event, message);
+        }
+        default -> {
+        }
+        }
+    }
+
+    boolean hasErrors() {
+        return !errors.isEmpty() && !warnings.isEmpty();
+    }
+
+    List<String> messages() {
+        return Stream.concat(
+                        errors.stream()
+                                .map(it -> "error: " + it),
+                        warnings.stream()
+                                .map(it -> "warning: " + it)
+                )
+                .toList();
+    }
+
+    private void log(Consumer<String> messageLog,
+                     BiConsumer<? super String, Throwable> throwableLog,
+                     CodegenEvent event,
+                     String message) {
+        Optional<Throwable> throwable = event.throwable();
+        if (throwable.isPresent()) {
+            throwableLog.accept(message, throwable.get());
+        } else {
+            messageLog.accept(message);
+        }
+    }
+
+    private String toMessage(CodegenEvent event) {
+        List<Object> objects = event.objects();
+        if (objects.isEmpty()) {
+            return event.message();
+        }
+        return event.message() + ", originating in: " + objects.stream()
+                .map(this::toString)
+                .collect(Collectors.joining(", "));
+    }
+
+    private String toString(Object object) {
+        if (object instanceof TypeName type) {
+            return type.fqName();
+        }
+        if (object instanceof ClassInfo ci) {
+            return ci.getName();
+        }
+        if (object instanceof MethodInfo mi) {
+            return mi.getClassInfo().getName() + "#" + mi.toStringWithSimpleNames();
+        }
+        if (object instanceof FieldInfo fi) {
+            return fi.getClassInfo().getName() + "." + fi.getName();
+        }
+        return String.valueOf(object);
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java
new file mode 100644
index 00000000000..eb393e30fa0
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenOptions;
+import io.helidon.codegen.Option;
+
+class MavenOptions implements CodegenOptions {
+    private final Map<String, String> options;
+
+    private MavenOptions(Map<String, String> options) {
+        this.options = options;
+    }
+
+    static CodegenOptions create(Set<String> compilerArgs) {
+        Map<String, String> options = new HashMap<>();
+
+        compilerArgs.forEach(it -> addInjectOption(options, it));
+
+        return new MavenOptions(Map.copyOf(options));
+    }
+
+    @Override
+    public Optional<String> option(String option) {
+        return Optional.ofNullable(options.get(option)).map(String::trim);
+    }
+
+    @Override
+    public void validate(Set<Option<?>> permittedOptions) {
+        Set<String> helidonOptions = options
+                .keySet()
+                .stream()
+                .filter(it -> it.startsWith("helidon."))
+                .collect(Collectors.toSet());
+
+        // now remove all expected
+        permittedOptions.stream()
+                .map(Option::name)
+                .forEach(helidonOptions::remove);
+
+        helidonOptions.remove(CODEGEN_SCOPE.name());
+        helidonOptions.remove(CODEGEN_MODULE.name());
+        helidonOptions.remove(CODEGEN_PACKAGE.name());
+        helidonOptions.remove(INDENT_TYPE.name());
+        helidonOptions.remove(INDENT_COUNT.name());
+        helidonOptions.remove(CREATE_META_INF_SERVICES.name());
+
+        if (!helidonOptions.isEmpty()) {
+            throw new CodegenException("Unrecognized/unsupported Helidon option configured: " + helidonOptions);
+        }
+    }
+
+    private static void addInjectOption(Map<String, String> options, String option) {
+        String toProcess = option;
+        if (toProcess.startsWith("-A")) {
+            toProcess = toProcess.substring(2);
+        }
+        int eq = toProcess.indexOf('=');
+        if (eq < 0) {
+            options.put(toProcess, "true");
+            return;
+        }
+        options.put(toProcess.substring(0, eq), toProcess.substring(eq + 1));
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java
new file mode 100644
index 00000000000..23cfa7802ee
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import io.helidon.codegen.ClassCode;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.common.types.ResolvedType;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypedElementInfo;
+import io.helidon.service.codegen.DescriptorClassCode;
+import io.helidon.service.codegen.RegistryRoundContext;
+import io.helidon.service.codegen.ServiceContracts;
+
+class MavenRoundContext implements RegistryRoundContext {
+    private final List<DescriptorClassCode> descriptors = new ArrayList<>();
+    private final MavenCodegenContext ctx;
+
+    MavenRoundContext(MavenCodegenContext ctx) {
+        this.ctx = ctx;
+    }
+
+    @Override
+    public void addDescriptor(String registryType,
+                              TypeName serviceType,
+                              TypeName descriptorType,
+                              ClassModel.Builder descriptor,
+                              double weight,
+                              Set<ResolvedType> contracts,
+                              Set<ResolvedType> factoryContracts,
+                              Object... originatingElements) {
+        ClassCode cc = new ClassCode(descriptorType,
+                                     descriptor,
+                                     serviceType,
+                                     originatingElements);
+        descriptors.add(DescriptorClassCode.create(cc, registryType, weight, contracts, factoryContracts));
+    }
+
+    @Override
+    public ServiceContracts serviceContracts(TypeInfo serviceInfo) {
+        return ServiceContracts.create(ctx.options(),
+                                       this::typeInfo,
+                                       serviceInfo);
+    }
+
+    @Override
+    public Collection<TypeName> availableAnnotations() {
+        return List.of();
+    }
+
+    @Override
+    public Collection<TypeInfo> types() {
+        return List.of();
+    }
+
+    @Override
+    public Collection<TypeInfo> annotatedTypes(TypeName annotationType) {
+        return List.of();
+    }
+
+    @Override
+    public Collection<TypedElementInfo> annotatedElements(TypeName annotationType) {
+        return List.of();
+    }
+
+    @Override
+    public void addGeneratedType(TypeName type,
+                                 ClassModel.Builder newClass,
+                                 TypeName mainTrigger,
+                                 Object... originatingElements) {
+
+    }
+
+    @Override
+    public Optional<ClassModel.Builder> generatedType(TypeName type) {
+        return Optional.empty();
+    }
+
+    @Override
+    public Optional<TypeInfo> typeInfo(TypeName typeName) {
+        return ctx.typeInfo(typeName);
+    }
+
+    public List<DescriptorClassCode> descriptors() {
+        return descriptors;
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java
new file mode 100644
index 00000000000..20bebf70b01
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.inject.maven.plugin;
+
+import java.lang.System.Logger.Level;
+import java.util.List;
+
+import io.helidon.codegen.CodegenEvent;
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenLogger;
+import io.helidon.service.inject.api.Activator;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Lookup;
+
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY_MANAGER;
+
+class WrappedServices implements AutoCloseable {
+    private final ClassLoader classLoader;
+    private final CodegenLogger logger;
+    private final Class<?> injectionServicesType;
+    private final Class<?> servicesType;
+    private final Object injectionServices;
+    private final Object services;
+
+    private WrappedServices(ClassLoader classLoader,
+                            CodegenLogger logger,
+                            Class<?> injectionServicesType,
+                            Class<?> servicesType,
+                            Object injectionServices,
+                            Object services) {
+        this.classLoader = classLoader;
+        this.logger = logger;
+        this.injectionServicesType = injectionServicesType;
+        this.servicesType = servicesType;
+        this.injectionServices = injectionServices;
+        this.services = services;
+    }
+
+    static WrappedServices create(ClassLoader classLoader, CodegenLogger logger, boolean useBindings) {
+        try {
+            /*
+            Phase.GATHERING_DEPENDENCIES
+             */
+
+            Activator.Phase limitPhase = Activator.Phase.ACTIVATION_STARTING;
+
+            /*
+            InjectionConfig.builder()....build();
+             */
+            Class<?> injectConfigType = classLoader.loadClass(INJECT_CONFIG.fqName());
+            Object injectConfigBuilder = injectConfigType.getMethod("builder")
+                    .invoke(null);
+            Class<?> injectConfigBuilderType = injectConfigBuilder.getClass();
+
+            injectConfigBuilderType.getMethod("useBinding", boolean.class)
+                    .invoke(injectConfigBuilder, useBindings);
+            injectConfigBuilderType.getMethod("limitRuntimePhase", Activator.Phase.class)
+                    .invoke(injectConfigBuilder, limitPhase);
+            Object injectionConfig = injectConfigBuilderType.getMethod("build")
+                    .invoke(injectConfigBuilder);
+
+            /*
+            InjectRegistryManager registryManager = InjectRegistryManager.create(injectionConfig)
+            InjectRegistry services = injectionServices.registry();
+             */
+            Class<?> injectionServicesType = classLoader.loadClass(INJECT_REGISTRY_MANAGER.fqName());
+            Object injectionServices = injectionServicesType.getMethod("create", injectConfigType)
+                    .invoke(null, injectionConfig);
+            Class<?> servicesType = classLoader.loadClass(INJECT_REGISTRY.fqName());
+            Object services = injectionServicesType.getMethod("registry")
+                    .invoke(injectionServices);
+
+            return new WrappedServices(classLoader,
+                                       logger,
+                                       injectionServicesType,
+                                       servicesType,
+                                       injectionServices,
+                                       services);
+        } catch (ReflectiveOperationException e) {
+            throw new CodegenException(
+                    "Failed to invoke Service registry related methods in user's application class loader using reflection",
+                    e);
+        }
+    }
+
+    @Override
+    public void close() {
+        try {
+            injectionServicesType.getMethod("shutdown")
+                    .invoke(injectionServices);
+        } catch (ReflectiveOperationException e) {
+            logger.log(CodegenEvent.builder()
+                               .level(Level.WARNING)
+                               .message("Failed to shutdown services used from Maven plugin")
+                               .throwable(e)
+                               .build());
+        }
+    }
+
+    List<InjectServiceInfo> all() {
+        return all(Lookup.EMPTY);
+    }
+
+    @SuppressWarnings("unchecked")
+    List<InjectServiceInfo> all(Lookup lookup) {
+        try {
+            // retrieves all the services in the registry
+            return (List<InjectServiceInfo>) servicesType.getMethod("lookupServices", Lookup.class)
+                    .invoke(services, lookup);
+        } catch (ReflectiveOperationException e) {
+            throw new CodegenException("Failed to get providers from service registry using reflection", e);
+        }
+    }
+
+    InjectServiceInfo get(Lookup lookup) {
+        List<InjectServiceInfo> services = all(lookup);
+        if (services.size() == 1) {
+            return services.getFirst();
+        }
+        if (services.isEmpty()) {
+            throw new CodegenException("Expected that service registry contains service: " + lookup + ", yet none was found");
+        }
+
+        throw new CodegenException("Expected that service registry contains service: " + lookup
+                                           + ", yet more than one was found: " + services);
+    }
+}
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java
new file mode 100644
index 00000000000..1f616eb568e
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Maven plugin for Helidon Service Inject.
+ * <p>
+ * This plugin should be used by the application - i.e. the actual microservice that is going to be deployed and started.
+ * This plugin will not help when used on a library.
+ * <p>
+ * The plugin generates application binding (mapping of services to injection points they satisfy), and application main class
+ * to avoid lookups (binding), and reflection and resources discovery from classpath (main class).
+ */
+package io.helidon.service.inject.maven.plugin;
diff --git a/service/inject/maven-plugin/src/main/java/module-info.java b/service/inject/maven-plugin/src/main/java/module-info.java
new file mode 100644
index 00000000000..f75f6c19013
--- /dev/null
+++ b/service/inject/maven-plugin/src/main/java/module-info.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Injection maven-plugin module.
+ */
+module io.helidon.service.inject.maven.plugin {
+
+    requires io.helidon.builder.api;
+    requires io.helidon.common;
+    requires io.helidon.common.config;
+    requires io.helidon.codegen;
+    requires io.helidon.codegen.scan;
+    requires io.helidon.codegen.compiler;
+    requires io.helidon.service.codegen;
+    requires io.helidon.service.inject.codegen;
+    requires io.helidon.service.inject.api;
+
+    requires maven.artifact;
+    requires maven.model;
+    requires maven.plugin.annotations;
+    requires maven.plugin.api;
+    requires maven.project;
+    requires io.github.classgraph;
+    requires io.helidon.service.metadata;
+
+    exports io.helidon.service.inject.maven.plugin;
+}
diff --git a/service/inject/pom.xml b/service/inject/pom.xml
index a246ccb2276..1d863c4a322 100644
--- a/service/inject/pom.xml
+++ b/service/inject/pom.xml
@@ -40,5 +40,6 @@
         <module>codegen</module>
         <module>api</module>
         <module>inject</module>
+        <module>maven-plugin</module>
     </modules>
 </project>
diff --git a/service/pom.xml b/service/pom.xml
index 72de3cd13e2..dc67f7c9624 100644
--- a/service/pom.xml
+++ b/service/pom.xml
@@ -25,6 +25,7 @@
         <groupId>io.helidon</groupId>
         <artifactId>helidon-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
     </parent>
 
     <groupId>io.helidon.service</groupId>

From 24dd507842e8d5bae5e04c3b6bfa46e7236d6a46 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 4 Nov 2024 18:15:04 +0100
Subject: [PATCH 04/23] Tests to validate previous commits.

---
 .../codegen/InjectCodegenTypesTest.java       | 17 +++++
 service/tests/inject/inject/pom.xml           | 16 +++++
 .../service/tests/inject/CustomMain.java      | 68 +++++++++++++++++++
 .../service/tests/inject/MainClassTest.java   | 61 +++++++++++++++++
 service/tests/inject/lookup/pom.xml           | 16 +++++
 .../tests/inject/qualified-providers/pom.xml  | 16 +++++
 service/tests/inject/toolbox/pom.xml          | 16 +++++
 .../tests/inject/toolbox/ToolBoxTest.java     |  1 -
 8 files changed, 210 insertions(+), 1 deletion(-)
 create mode 100644 service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
 create mode 100644 service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java

diff --git a/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java b/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
index c221515bca2..5856b589df5 100644
--- a/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
+++ b/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
@@ -24,10 +24,16 @@
 import java.util.Set;
 
 import io.helidon.common.types.TypeName;
+import io.helidon.service.inject.Binding;
+import io.helidon.service.inject.InjectConfig;
+import io.helidon.service.inject.InjectRegistryManager;
+import io.helidon.service.inject.InjectionMain;
+import io.helidon.service.inject.InjectionPlanBinder;
 import io.helidon.service.inject.api.Event;
 import io.helidon.service.inject.api.EventManager;
 import io.helidon.service.inject.api.FactoryType;
 import io.helidon.service.inject.api.GeneratedInjectService;
+import io.helidon.service.inject.api.InjectRegistry;
 import io.helidon.service.inject.api.InjectServiceDescriptor;
 import io.helidon.service.inject.api.Injection;
 import io.helidon.service.inject.api.Interception;
@@ -85,6 +91,7 @@ void testTypes() {
         checkField(toCheck, checked, fields, "INJECTION_SCOPE_HANDLER", Injection.ScopeHandler.class);
         checkField(toCheck, checked, fields, "INJECTION_SERVICES_FACTORY", Injection.ServicesFactory.class);
         checkField(toCheck, checked, fields, "INJECTION_QUALIFIED_FACTORY", Injection.QualifiedFactory.class);
+        checkField(toCheck, checked, fields, "INJECTION_MAIN", Injection.Main.class);
 
         // api.Interception.*
         checkField(toCheck, checked, fields, "INTERCEPTION_INTERCEPTED", Interception.Intercepted.class);
@@ -97,6 +104,13 @@ void testTypes() {
         checkField(toCheck, checked, fields, "INJECT_INJECTION_POINT", Ip.class);
         checkField(toCheck, checked, fields, "INJECT_SERVICE_INSTANCE", ServiceInstance.class);
         checkField(toCheck, checked, fields, "INJECT_SERVICE_DESCRIPTOR", InjectServiceDescriptor.class);
+        checkField(toCheck, checked, fields, "INJECT_CONFIG", InjectConfig.class);
+        checkField(toCheck, checked, fields, "INJECT_CONFIG_BUILDER", InjectConfig.Builder.class);
+        checkField(toCheck, checked, fields, "INJECT_MAIN", InjectionMain.class);
+        checkField(toCheck, checked, fields, "INJECT_BINDING", Binding.class);
+        checkField(toCheck, checked, fields, "INJECT_REGISTRY", InjectRegistry.class);
+        checkField(toCheck, checked, fields, "INJECT_REGISTRY_MANAGER", InjectRegistryManager.class);
+        checkField(toCheck, checked, fields, "INJECT_PLAN_BINDER", InjectionPlanBinder.class);
 
         // api.* interception types
         checkField(toCheck, checked, fields, "INTERCEPT_EXCEPTION", InterceptionException.class);
@@ -132,6 +146,9 @@ void testTypes() {
         checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY",
                    GeneratedInjectService.QualifiedFactoryInterceptionWrapper.class);
 
+        checkField(toCheck, checked, fields, "STRING_ARRAY", String[].class);
+        checkField(toCheck, checked, fields, "DOUBLE_ARRAY", double[].class);
+
         assertThat("If the collection is not empty, please add appropriate checkField line to this test",
                    toCheck,
                    IsEmptyCollection.empty());
diff --git a/service/tests/inject/inject/pom.xml b/service/tests/inject/inject/pom.xml
index 3d483dca7b4..7768e2efaf7 100644
--- a/service/tests/inject/inject/pom.xml
+++ b/service/tests/inject/inject/pom.xml
@@ -137,6 +137,22 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java b/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
new file mode 100644
index 00000000000..41fff4325b6
--- /dev/null
+++ b/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.tests.inject;
+
+import io.helidon.service.inject.InjectConfig;
+import io.helidon.service.inject.InjectionMain;
+import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.inject.api.Injection;
+
+/**
+ * Example of a custom main class.
+ * This class is here to make sure this does not get broken.
+ */
+@Injection.Main
+public abstract class CustomMain extends InjectionMain {
+    /*
+    Important note:
+    DO NOT change the signature of methods in this class, as that would cause a backward incompatible change
+    for our users.
+    The subtype is code generated. Any changes in the
+    Helidon APIs would cause older generated code to stop working.
+    The only exception is major version updates, but it would still be better if this stays compatible.
+     */
+
+    @Override
+    protected void beforeServiceDescriptors(InjectConfig.Builder configBuilder) {
+        System.out.println("Before service descriptors");
+    }
+
+    @Override
+    protected void afterServiceDescriptors(InjectConfig.Builder configBuilder) {
+        System.out.println("After service descriptors");
+    }
+
+    @Override
+    protected InjectRegistry init(InjectConfig config) {
+        System.out.println("Before init method");
+        try {
+            return super.init(config);
+        } finally {
+            System.out.println("After init method");
+        }
+    }
+
+    @Override
+    protected void start(String[] arguments) {
+        super.start(arguments);
+    }
+
+    @Override
+    protected InjectConfig.Builder configBuilder(String[] arguments) {
+        return super.configBuilder(arguments);
+    }
+}
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java b/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java
new file mode 100644
index 00000000000..82cc105a13c
--- /dev/null
+++ b/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.tests.inject;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import io.helidon.service.inject.InjectConfig;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+// test that the generated main class exists and works as expected
+public class MainClassTest {
+    @Test
+    public void testMain() throws NoSuchMethodException {
+        // this class is expected to be code generated based on CustomMain @Injection.Main annotation
+        ApplicationMain appMain = new ApplicationMain();
+
+        assertThat(appMain, instanceOf(CustomMain.class));
+
+        Class<ApplicationMain> theClass = ApplicationMain.class;
+
+        assertThat("The class must be public, to be a candidate for Main class",
+                   Modifier.isPublic(theClass.getModifiers()));
+
+        // the class must have the following two methods (when not using the maven plugin):
+        // public static void main(String[] args) {}
+        // protected void serviceDescriptors(InjectConfig.Builder config) {}
+        Method mainMethod = theClass.getMethod("main", String[].class);
+        assertThat("The main method must be public", Modifier.isPublic(mainMethod.getModifiers()));
+        assertThat("The main method must be static", Modifier.isStatic(mainMethod.getModifiers()));
+        assertThat("The main method must return void", mainMethod.getReturnType(), equalTo(void.class));
+
+        Method serviceDescriptorMethod = theClass.getDeclaredMethod("serviceDescriptors", InjectConfig.Builder.class);
+        assertThat("The service descriptors method must be protected",
+                   Modifier.isProtected(serviceDescriptorMethod.getModifiers()));
+        assertThat("The service descriptors method must not be static",
+                   !Modifier.isStatic(serviceDescriptorMethod.getModifiers()));
+        assertThat("The service descriptors method must return void",
+                   serviceDescriptorMethod.getReturnType(),
+                   equalTo(void.class));
+    }
+}
diff --git a/service/tests/inject/lookup/pom.xml b/service/tests/inject/lookup/pom.xml
index 4ee6d85a335..1d1be68d387 100644
--- a/service/tests/inject/lookup/pom.xml
+++ b/service/tests/inject/lookup/pom.xml
@@ -137,6 +137,22 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 
diff --git a/service/tests/inject/qualified-providers/pom.xml b/service/tests/inject/qualified-providers/pom.xml
index 0772cf44a96..e00b45ef4c1 100644
--- a/service/tests/inject/qualified-providers/pom.xml
+++ b/service/tests/inject/qualified-providers/pom.xml
@@ -127,6 +127,22 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/service/tests/inject/toolbox/pom.xml b/service/tests/inject/toolbox/pom.xml
index 5cc2a7b0322..84c7f654273 100644
--- a/service/tests/inject/toolbox/pom.xml
+++ b/service/tests/inject/toolbox/pom.xml
@@ -141,6 +141,22 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java b/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java
index 5e9b9a6a023..974c976e4c0 100644
--- a/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java
+++ b/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java
@@ -150,7 +150,6 @@ void hierarchyOfInjections() {
      * This assumes the presence of module(s) + application(s) to handle all bindings, with effectively no lookups!
      */
     @Test
-    @Disabled("Disabled, as this required maven plugin, to be added in a later PR")
     void noServiceActivationRequiresLookupWhenApplicationIsPresent() {
         Counter counter = lookupCounter();
         long initialCount = counter.count();

From 47c482a478e3484cae9d29c1bb9c0d8c8c68f138 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 26 Nov 2024 17:18:01 +0100
Subject: [PATCH 05/23] Review fixes.

---
 service/inject/README.md                              |  2 +-
 .../helidon/service/inject/InjectStartupProvider.java |  1 +
 .../service/inject/maven/plugin/BindingGenerator.java | 11 ++++++++---
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/service/inject/README.md b/service/inject/README.md
index f28d1f55c12..304f35e63a2 100644
--- a/service/inject/README.md
+++ b/service/inject/README.md
@@ -379,7 +379,7 @@ The generated main class will contain full, reflection less configuration of the
 
 The Main class can also be customized; to do this:
 1. Create a custom class (let's call it `CustomMain` as an example)
-2. The class must extends the injection main class (`public abstract class CustomMain extends InjectionMain`)
+2. The class must extend the injection main class (`public abstract class CustomMain extends InjectionMain`)
 3. The class must be annotated with `@Injection.Main`, so it is discovered by annotation processor
 4. Implement any desired methods; the generated class will only implement `serviceDescriptors(InjectConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
 
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
index 09c383a5db2..58b13960320 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
@@ -60,6 +60,7 @@ public void start(String[] arguments) {
 
     @Override
     protected void serviceDescriptors(InjectConfig.Builder configBuilder) {
+        // service descriptors are discovered when startup provider is used - see below discoverServices() method
     }
 
     @Override
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
index fea87bd0624..93f3ea286a6 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
@@ -291,9 +291,14 @@ private InjectionPlan injectionPlan(WrappedServices services,
         Lookup dependencyTo = Lookup.create(dependency);
         Set<Qualifier> qualifiers = dependencyTo.qualifiers();
         if (self.contracts().containsAll(dependencyTo.contracts()) && self.qualifiers().equals(qualifiers)) {
-            // criteria must have a single contract for each injection point
-            // if this service implements the contracts actually required, we must look for services with lower weight
-            // but only if we also have the same qualifiers
+            /*
+            lookup must have a single contract for each injection point
+            if this service implements the contracts actually required, we must look for services with lower weight
+            but only if we also have the same qualifiers;
+            this is to ensure that if an injection point in a service injects a contract the service implements itself,
+            we do not end up in an infinite loop, but look for a service with a lower weight to satisfy that injection point
+            this allows us to "chain" a single contract through multiple services
+             */
             dependencyTo = Lookup.builder(dependencyTo)
                     .weight(self.weight())
                     .build();

From 50e06814a99497ba1fe7966447c09f0a309bd6ef Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Wed, 27 Nov 2024 11:42:30 +0100
Subject: [PATCH 06/23] Rebased on main and updated error message for record
 field injection.

---
 .../service/inject/codegen/InjectionExtension.java        | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
index 5a752210337..9ae22e16a18 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
@@ -1066,6 +1066,14 @@ private List<TypedElementInfo> fieldInjectElements(TypeInfo typeInfo) {
                 .filter(ElementInfoPredicates::isPrivate)
                 .findFirst();
         if (firstFound.isPresent()) {
+            if (typeInfo.kind() == ElementKind.RECORD) {
+                throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+                                                   + " annotation on record field(s). This is not supported. "
+                                                   + "If this is the only constructor, you can remove the Inject annotation; "
+                                                   + "if you need to inject the default constructor, kindly create an explicit"
+                                                   + " default constructor and annotate it with Inject.",
+                                           firstFound.get().originatingElementValue());
+            }
             throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
                                                + " annotation on private field(s). We cannot support private field injection.",
                                        firstFound.get().originatingElementValue());

From 3d83e4963e54573779ce1aa12f41014eded9ff81 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Wed, 27 Nov 2024 13:06:45 +0100
Subject: [PATCH 07/23] Review comments.

---
 pom.xml                                       | 46 +++++++++++++++
 service/inject/maven-plugin/README.md         | 10 +---
 service/inject/maven-plugin/pom.xml           | 59 -------------------
 .../plugin/CreateApplicationAbstractMojo.java |  2 +
 .../inject/maven/plugin/MavenFiler.java       | 23 ++------
 .../registry/CoreServiceDiscovery.java        | 13 +++-
 service/tests/inject/inject/pom.xml           |  7 +++
 7 files changed, 73 insertions(+), 87 deletions(-)

diff --git a/pom.xml b/pom.xml
index 0b57c348ff2..932b54c1595 100644
--- a/pom.xml
+++ b/pom.xml
@@ -99,6 +99,11 @@
         <version.lib.wiremock>2.26.3</version.lib.wiremock>
         <version.lib.commons-lang3>3.10</version.lib.commons-lang3>
         <version.lib.classgraph>4.8.165</version.lib.classgraph>
+        <version.lib.plexus.classworlds>2.7.0</version.lib.plexus.classworlds>
+        <version.lib.plexus.utils>3.3.0</version.lib.plexus.utils>
+        <version.lib.maven.plugin.annotations>3.9.0</version.lib.maven.plugin.annotations>
+        <version.lib.maven.plugin.api>3.9.3</version.lib.maven.plugin.api>
+        <version.lib.maven.plugin.project>2.2.1</version.lib.maven.plugin.project>
         <!--
         !Version statement! - end
         -->
@@ -127,6 +132,7 @@
         <version.plugin.jaxb>2.5.0</version.plugin.jaxb>
         <version.plugin.license>1.16</version.plugin.license>
         <version.plugin.os>1.5.0.Final</version.plugin.os>
+        <version.plugin.plugin>3.9.0</version.plugin.plugin>
         <version.plugin.project-info-reports>3.0.0</version.plugin.project-info-reports>
         <version.plugin.protobuf>0.6.1</version.plugin.protobuf>
         <version.plugin.resources>3.3.1</version.plugin.resources>
@@ -944,6 +950,15 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-plugin-plugin</artifactId>
+                <version>${version.plugin.plugin}</version>
+                <configuration>
+                    <requiredMavenVersion>[3.6.1,)</requiredMavenVersion>
+                    <requiredJavaVersion>[${version.java}.0,)</requiredJavaVersion>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 
@@ -1314,6 +1329,37 @@
                 <artifactId>jakarta.inject-tck</artifactId>
                 <version>${version.lib.jakarta.inject}</version>
             </dependency>
+            <!-- Maven plugin -->
+            <dependency>
+                <groupId>org.apache.maven</groupId>
+                <artifactId>maven-artifact</artifactId>
+                <version>${version.lib.maven.plugin.api}</version>
+                <scope>provided</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.maven</groupId>
+                <artifactId>maven-model</artifactId>
+                <version>${version.lib.maven.plugin.api}</version>
+                <scope>provided</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.maven</groupId>
+                <artifactId>maven-plugin-api</artifactId>
+                <version>${version.lib.maven.plugin.api}</version>
+                <scope>provided</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.maven.plugin-tools</groupId>
+                <artifactId>maven-plugin-annotations</artifactId>
+                <version>${version.lib.maven.plugin.annotations}</version>
+                <scope>provided</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.maven</groupId>
+                <artifactId>maven-project</artifactId>
+                <version>${version.lib.maven.plugin.project}</version>
+                <scope>provided</scope>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
diff --git a/service/inject/maven-plugin/README.md b/service/inject/maven-plugin/README.md
index 3d3f2260cfc..ca14faba7bc 100644
--- a/service/inject/maven-plugin/README.md
+++ b/service/inject/maven-plugin/README.md
@@ -47,8 +47,8 @@ Configuration example in `pom.xml`:
 ```xml
 
 <plugin>
-    <groupId>io.helidon.service</groupId>
-    <artifactId>helidon-service-maven-plugin</artifactId>
+    <groupId>io.helidon.service.inject</groupId>
+    <artifactId>helidon-service-inject-maven-plugin</artifactId>
     <executions>
         <execution>
             <id>create-application</id>
@@ -57,11 +57,5 @@ Configuration example in `pom.xml`:
             </goals>
         </execution>
     </executions>
-    <configuration>
-        <packageName>com.example.mypackage</packageName>
-        <bindingClassName>MyInjection__Binding</bindingClassName>
-        <mainClassName>MyApplicationMain</mainClassName>
-        <validate>false</validate>
-    </configuration>
 </plugin>
 ```
diff --git a/service/inject/maven-plugin/pom.xml b/service/inject/maven-plugin/pom.xml
index 8a8ccd063ac..7bd5a7de28b 100644
--- a/service/inject/maven-plugin/pom.xml
+++ b/service/inject/maven-plugin/pom.xml
@@ -32,13 +32,6 @@
     <packaging>maven-plugin</packaging>
 
     <properties>
-        <version.plexus.classworlds>2.7.0</version.plexus.classworlds>
-        <version.plexus.utils>3.3.0</version.plexus.utils>
-        <version.plugin.api>3.9.3</version.plugin.api>
-        <version.plugin.annotations>3.9.0</version.plugin.annotations>
-        <version.plugin.plugin>3.9.0</version.plugin.plugin>
-        <version.plugin.project>2.2.1</version.plugin.project>
-
         <spotbugs.exclude>etc/spotbugs/exclude.xml</spotbugs.exclude>
     </properties>
 
@@ -62,13 +55,11 @@
         <dependency>
             <groupId>org.apache.maven</groupId>
             <artifactId>maven-artifact</artifactId>
-            <version>${version.plugin.api}</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.maven</groupId>
             <artifactId>maven-model</artifactId>
-            <version>${version.plugin.api}</version>
             <scope>provided</scope>
         </dependency>
 
@@ -102,11 +93,6 @@
             <artifactId>helidon-service-metadata</artifactId>
         </dependency>
         <dependency>
-            <!--
-            we cannot use helidon-service-inject as the SPI is required on classpath of application,
-            and this introduces conflicts; API is small and does not introduce SPI
-            that is used from within it, so we can share it
-            -->
             <groupId>io.helidon.service.inject</groupId>
             <artifactId>helidon-service-inject-api</artifactId>
         </dependency>
@@ -129,66 +115,21 @@
         <dependency>
             <groupId>org.apache.maven</groupId>
             <artifactId>maven-plugin-api</artifactId>
-            <version>${version.plugin.api}</version>
             <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.codehaus.plexus</groupId>
-                    <artifactId>plexus-classworlds</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.codehaus.plexus</groupId>
-                    <artifactId>plexus-utils</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
         <dependency>
             <groupId>org.apache.maven.plugin-tools</groupId>
             <artifactId>maven-plugin-annotations</artifactId>
-            <version>${version.plugin.annotations}</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.maven</groupId>
             <artifactId>maven-project</artifactId>
-            <version>${version.plugin.project}</version>
             <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.apache.maven</groupId>
-                    <artifactId>maven-model</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.codehaus.plexus</groupId>
-                    <artifactId>plexus-utils</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.apache.maven</groupId>
-                    <artifactId>maven-artifact</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
     </dependencies>
 
     <build>
-        <pluginManagement>
-            <plugins>
-                <plugin>
-                    <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-plugin-plugin</artifactId>
-                    <version>${version.plugin.plugin}</version>
-                    <configuration>
-                        <mojoDependencies>
-                            <!-- we need this since 19ea is not really supported -->
-                            <!--                            <mojoDependency></mojoDependency>-->
-                        </mojoDependencies>
-                        <requiredMavenVersion>[3.6.1,)</requiredMavenVersion>
-                        <requiredJavaVersion>[${version.java}.0,)</requiredJavaVersion>
-                    </configuration>
-                </plugin>
-            </plugins>
-        </pluginManagement>
-
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
index 07ea515d505..dbb88b3f2e4 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
@@ -161,6 +161,8 @@ void innerExecute() {
                                packageName);
 
             if (createMain()) {
+                // we need to re-create the classloader, as we have created new classes for binding
+                loader = createClassLoader(classpath, prev);
                 createMain(loader,
                            mavenLogger,
                            scanContext,
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
index 32b2a213ca2..1de4e40a56b 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
@@ -18,6 +18,7 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.io.StringWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -69,25 +70,13 @@ public Path writeSourceFile(TypeName typeName, String content, Object... origina
 
     @Override
     public Path writeSourceFile(ClassModel classModel, Object... originatingElements) {
-        TypeName typeName = classModel.typeName();
-        String pathToSourceFile = typeName.packageName().replace('.', '/');
-        String fileName = typeName.className() + ".java";
-        Path path = generatedSourceDir.resolve(pathToSourceFile)
-                .resolve(fileName);
-        Path parentDir = path.getParent();
-        if (parentDir != null) {
-            mkdirs(parentDir);
-        }
-
-        try (Writer writer = Files.newBufferedWriter(path,
-                                                     StandardCharsets.UTF_8,
-                                                     StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)) {
-            classModel.write(writer, "    ");
-            generatedSources = true;
+        try {
+            StringWriter sw = new StringWriter();
+            classModel.write(sw);
+            return writeSourceFile(classModel.typeName(), sw.toString(), originatingElements);
         } catch (IOException e) {
-            throw new CodegenException("Failed to write new source file: " + path.toAbsolutePath(), e, typeName);
+            throw new CodegenException("Failed to write new source file: " + classModel.typeName(), e, classModel.typeName());
         }
-        return path;
     }
 
     @Override
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
index e7635d0681b..ab6e4ae7461 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
@@ -100,9 +100,16 @@ private static <T> Class<T> toClass(TypeName className) {
 
             return (Class) cl.loadClass(className.fqName());
         } catch (ClassNotFoundException e) {
-            throw new ServiceRegistryException("Resolution of type \"" + className.fqName()
-                                                       + "\" to class failed.",
-                                               e);
+            try {
+                // fall back to classloader of our class
+                return (Class) CoreServiceDiscovery.class.getClassLoader().loadClass(className.fqName());
+            } catch (ClassNotFoundException ex) {
+                var toThrow = new ServiceRegistryException("Resolution of type \"" + className.fqName()
+                                                           + "\" to class failed.",
+                                                   ex);
+                toThrow.addSuppressed(e);
+                throw toThrow;
+            }
         }
     }
 
diff --git a/service/tests/inject/inject/pom.xml b/service/tests/inject/inject/pom.xml
index 7768e2efaf7..ca0630caaa7 100644
--- a/service/tests/inject/inject/pom.xml
+++ b/service/tests/inject/inject/pom.xml
@@ -149,6 +149,13 @@
                         </goals>
                     </execution>
                 </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                </dependencies>
                 <configuration>
                     <failOnWarning>true</failOnWarning>
                 </configuration>

From 11bb3ca56978c6cfc3e455e1456f6af534c04282 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Wed, 27 Nov 2024 15:04:16 +0100
Subject: [PATCH 08/23] Maven plugin integration tests. Moved version
 management for maven plugin to project root pom, moved plugin configuration
 there as well A fix in `AptTypeInfoFactory` where a NPE was possible.

---
 .../codegen/apt/AptTypeInfoFactory.java       |   3 +-
 pom.xml                                       |  42 +++++
 service/inject/maven-plugin/pom.xml           |  16 ++
 service/tests/inject/maven-plugin/pom.xml     |  86 ++++++++++
 .../src/it/projects/test1/pom.xml             |  98 +++++++++++
 .../src/it/projects/test1/postbuild.groovy    |  29 ++++
 .../src/main/java/my/module/ServiceType.java  |  24 +++
 .../src/it/projects/test2/pom.xml             | 101 ++++++++++++
 .../src/it/projects/test2/postbuild.groovy    |  29 ++++
 .../src/main/java/my/module/ServiceType.java  |  24 +++
 .../src/it/projects/test3/pom.xml             | 100 ++++++++++++
 .../src/it/projects/test3/postbuild.groovy    |  29 ++++
 .../src/main/java/my/module/ServiceType.java  |  24 +++
 .../inject/maven-plugin/src/it/settings.xml   |  54 +++++++
 .../inject/maven/plugin/ProjectsTestIT.java   | 153 ++++++++++++++++++
 service/tests/inject/pom.xml                  |   1 +
 16 files changed, 812 insertions(+), 1 deletion(-)
 create mode 100644 service/tests/inject/maven-plugin/pom.xml
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy
 create mode 100644 service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
 create mode 100644 service/tests/inject/maven-plugin/src/it/settings.xml
 create mode 100644 service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java

diff --git a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
index b5a42510ed8..3bb8a300cea 100644
--- a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
+++ b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
@@ -697,7 +697,8 @@ private static boolean isTypeInThisModule(AptContext ctx,
         moduleName.set(null);
 
         ModuleElement module = ctx.aptEnv().getElementUtils().getModuleOf(type);
-        if (!module.isUnnamed()) {
+
+        if (module != null && !module.isUnnamed()) {
             String name = module.getQualifiedName().toString();
             if (hasValue(name)) {
                 moduleName.set(name);
diff --git a/pom.xml b/pom.xml
index 932b54c1595..d1b7a6bb06e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -104,6 +104,8 @@
         <version.lib.maven.plugin.annotations>3.9.0</version.lib.maven.plugin.annotations>
         <version.lib.maven.plugin.api>3.9.3</version.lib.maven.plugin.api>
         <version.lib.maven.plugin.project>2.2.1</version.lib.maven.plugin.project>
+        <version.lib.apiguardian.api>1.1.2</version.lib.apiguardian.api>
+        <version.lib.groovy>2.4.16</version.lib.groovy>
         <!--
         !Version statement! - end
         -->
@@ -125,6 +127,7 @@
         <version.plugin.helidon-build-tools>4.0.14</version.plugin.helidon-build-tools>
         <version.plugin.hibernate-enhance>${version.lib.hibernate}</version.plugin.hibernate-enhance>
         <version.plugin.install>3.1.2</version.plugin.install>
+        <version.plugin.invoker>3.2.2</version.plugin.invoker>
         <version.plugin.jacoco>0.8.5</version.plugin.jacoco>
         <version.plugin.jandex>3.1.2</version.plugin.jandex>
         <version.plugin.jar>3.3.0</version.plugin.jar>
@@ -859,6 +862,39 @@
                     <artifactId>maven-antrun-plugin</artifactId>
                     <version>${version.plugin.ant}</version>
                 </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-invoker-plugin</artifactId>
+                    <version>${version.plugin.invoker}</version>
+                    <configuration>
+                        <addTestClassPath>true</addTestClassPath>
+                        <settingsFile>src/it/settings.xml</settingsFile>
+                        <mergeUserSettings>true</mergeUserSettings>
+                        <localRepositoryPath>${project.build.directory}/it-repo</localRepositoryPath>
+                        <!--suppress MavenModelInspection -->
+                        <ignoreFailures>${maven.test.failure.ignore}</ignoreFailures>
+                        <showErrors>true</showErrors>
+                        <!--suppress UnresolvedMavenProperty, MavenModelInspection -->
+                        <skipInvocation>${skipTests}</skipInvocation>
+                        <!--suppress UnresolvedMavenProperty, MavenModelInspection -->
+                        <skipInstallation>${skipTests}</skipInstallation>
+                        <pomIncludes>
+                            <pomInclude>projects/*/pom.xml</pomInclude>
+                        </pomIncludes>
+                        <cloneProjectsTo>${project.build.directory}/it</cloneProjectsTo>
+                        <goals>
+                            <goal>clean</goal>
+                            <goal>install</goal>
+                        </goals>
+                    </configuration>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.codehaus.groovy</groupId>
+                            <artifactId>groovy</artifactId>
+                            <version>${version.lib.groovy}</version>
+                        </dependency>
+                    </dependencies>
+                </plugin>
             </plugins>
         </pluginManagement>
         <plugins>
@@ -1360,6 +1396,12 @@
                 <version>${version.lib.maven.plugin.project}</version>
                 <scope>provided</scope>
             </dependency>
+            <dependency>
+                <!-- dependency convergence -->
+                <groupId>org.apiguardian</groupId>
+                <artifactId>apiguardian-api</artifactId>
+                <version>${version.lib.apiguardian.api}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
diff --git a/service/inject/maven-plugin/pom.xml b/service/inject/maven-plugin/pom.xml
index 7bd5a7de28b..7e320213b06 100644
--- a/service/inject/maven-plugin/pom.xml
+++ b/service/inject/maven-plugin/pom.xml
@@ -138,6 +138,22 @@
                     <compilerArgument>-proc:none</compilerArgument>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-plugin-plugin</artifactId>
+                <configuration>
+                    <goalPrefix>helidon-inject</goalPrefix>
+                    <skipErrorNoDescriptorsFound>false</skipErrorNoDescriptorsFound>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>help-goal</id>
+                        <goals>
+                            <goal>helpmojo</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 
diff --git a/service/tests/inject/maven-plugin/pom.xml b/service/tests/inject/maven-plugin/pom.xml
new file mode 100644
index 00000000000..e4acf371362
--- /dev/null
+++ b/service/tests/inject/maven-plugin/pom.xml
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>io.helidon.service.tests.inject</groupId>
+        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <version>4.2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>helidon-service-tests-inject-maven-plugin</artifactId>
+    <name>Helidon Service Tests Inject Maven Plugin</name>
+    <description>Tests for Maven Plugin</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-all</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.build-tools.common</groupId>
+            <artifactId>helidon-build-common-test-utils</artifactId>
+            <version>${version.plugin.helidon-build-tools}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>**/*IT.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-invoker-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>install</goal>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml b/service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml
new file mode 100644
index 00000000000..0692c5a56bf
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml
@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <artifactId>test-1</artifactId>
+    <version>@project.version@</version>
+    <name>Test Inject Maven Plugin 1</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-api</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service.inject</groupId>
+                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${project.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${project.version}</version>
+                    </dependency>
+                </dependencies>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy b/service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy
new file mode 100644
index 00000000000..aaeb9dcaca5
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import io.helidon.build.common.test.utils.JUnitLauncher
+import io.helidon.service.tests.inject.maven.plugin.ProjectsTestIT
+
+//noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
+JUnitLauncher.builder()
+        .select(ProjectsTestIT.class, "test1", String.class)
+        .parameter("basedir", basedir.getAbsolutePath())
+        .reportsDir(basedir)
+        .outputFile(new File(basedir, "test.log"))
+        .suiteId("helidon-inject-maven-plugin-it-test1")
+        .suiteDisplayName("Helidon Inject Maven Plugin Integration Test 1")
+        .build()
+        .launch()
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java b/service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
new file mode 100644
index 00000000000..4244fb878cb
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package my.module;
+
+import io.helidon.service.inject.api.Injection;
+
+@Injection.Singleton
+class ServiceType {
+
+}
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml b/service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml
new file mode 100644
index 00000000000..3279da678b6
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <artifactId>test-2</artifactId>
+    <version>@project.version@</version>
+    <name>Test Inject Maven Plugin 2</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-api</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service.inject</groupId>
+                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${project.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${project.version}</version>
+                    </dependency>
+                </dependencies>
+                <configuration>
+                    <packageName>my.updated</packageName>
+                    <mainClassName>UpdatedMain</mainClassName>
+                    <bindingClassName>UpdatedBinding</bindingClassName>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy b/service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy
new file mode 100644
index 00000000000..39aa4086ed9
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import io.helidon.build.common.test.utils.JUnitLauncher
+import io.helidon.service.tests.inject.maven.plugin.ProjectsTestIT
+
+//noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
+JUnitLauncher.builder()
+        .select(ProjectsTestIT.class, "test2", String.class)
+        .parameter("basedir", basedir.getAbsolutePath())
+        .reportsDir(basedir)
+        .outputFile(new File(basedir, "test.log"))
+        .suiteId("helidon-inject-maven-plugin-it-test2")
+        .suiteDisplayName("Helidon Inject Maven Plugin Integration Test 2")
+        .build()
+        .launch()
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java b/service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
new file mode 100644
index 00000000000..4244fb878cb
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package my.module;
+
+import io.helidon.service.inject.api.Injection;
+
+@Injection.Singleton
+class ServiceType {
+
+}
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml b/service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml
new file mode 100644
index 00000000000..b81874fb86d
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <artifactId>test-3</artifactId>
+    <version>@project.version@</version>
+    <name>Test Inject Maven Plugin 3</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject-api</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service.inject</groupId>
+            <artifactId>helidon-service-inject</artifactId>
+            <version>@project.version@</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service.inject</groupId>
+                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>@project.version@</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>io.helidon.service.inject</groupId>
+                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <version>${project.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${project.version}</version>
+                    </dependency>
+                </dependencies>
+                <configuration>
+                    <generateBinding>false</generateBinding>
+                    <generateMain>false</generateMain>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy b/service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy
new file mode 100644
index 00000000000..fcf3d319c86
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import io.helidon.build.common.test.utils.JUnitLauncher
+import io.helidon.service.tests.inject.maven.plugin.ProjectsTestIT
+
+//noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
+JUnitLauncher.builder()
+        .select(ProjectsTestIT.class, "test3", String.class)
+        .parameter("basedir", basedir.getAbsolutePath())
+        .reportsDir(basedir)
+        .outputFile(new File(basedir, "test.log"))
+        .suiteId("helidon-inject-maven-plugin-it-test3")
+        .suiteDisplayName("Helidon Inject Maven Plugin Integration Test 3")
+        .build()
+        .launch()
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java b/service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
new file mode 100644
index 00000000000..4244fb878cb
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package my.module;
+
+import io.helidon.service.inject.api.Injection;
+
+@Injection.Singleton
+class ServiceType {
+
+}
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/settings.xml b/service/tests/inject/maven-plugin/src/it/settings.xml
new file mode 100644
index 00000000000..251955ad56b
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/it/settings.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2021, 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<settings>
+    <profiles>
+        <profile>
+            <id>it-repo</id>
+            <repositories>
+                <repository>
+                    <id>local.central</id>
+                    <url>@localRepositoryUrl@</url>
+                    <releases>
+                        <enabled>true</enabled>
+                    </releases>
+                    <snapshots>
+                        <checksumPolicy>ignore</checksumPolicy>
+                        <enabled>true</enabled>
+                    </snapshots>
+                </repository>
+            </repositories>
+            <pluginRepositories>
+                <pluginRepository>
+                    <id>local.central</id>
+                    <url>@localRepositoryUrl@</url>
+                    <releases>
+                        <enabled>true</enabled>
+                    </releases>
+                    <snapshots>
+                        <checksumPolicy>ignore</checksumPolicy>
+                        <enabled>true</enabled>
+                    </snapshots>
+                </pluginRepository>
+            </pluginRepositories>
+        </profile>
+    </profiles>
+    <activeProfiles>
+        <activeProfile>it-repo</activeProfile>
+    </activeProfiles>
+</settings>
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java b/service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
new file mode 100644
index 00000000000..fb46edd1e93
--- /dev/null
+++ b/service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.tests.inject.maven.plugin;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import io.helidon.build.common.test.utils.ConfigurationParameterSource;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+
+import static io.helidon.build.common.test.utils.FileMatchers.fileExists;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * Integration test that verifies the projects under {@code src/it/projects}.
+ */
+public class ProjectsTestIT {
+    @ParameterizedTest
+    @ConfigurationParameterSource("basedir")
+    @DisplayName("Test default binding and main class names")
+    void test1(String basedir) {
+        // test the first project under src/it/projects/test1 (referenced from postbuild.groovy)
+        // make sure all the required types are created
+        Path projectPath = Paths.get(basedir);
+        Path compiledClasses = projectPath.resolve("target/classes/my/module");
+        Path generatedSources = projectPath.resolve("target/generated-sources/annotations/my/module");
+
+        assertThat("Generated by the Maven plugin", generatedSources.resolve("Injection__Binding.java"), fileExists());
+        assertThat("Generated by the Maven plugin",
+                   generatedSources.resolve("Injection__Binding__ServiceDescriptor.java"),
+                   fileExists());
+        assertThat("Generated by the service inject codegen during compilation",
+                   generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationMain.java"), fileExists());
+        assertThat("Not a generated type, exists in project sources only",
+                   generatedSources.resolve("ServiceType.java"),
+                   not(fileExists()));
+
+        assertThat("Generated by the Maven plugin", compiledClasses.resolve("Injection__Binding.class"), fileExists());
+        assertThat("Generated by the Maven plugin",
+                   compiledClasses.resolve("Injection__Binding__ServiceDescriptor.class"),
+                   fileExists());
+        assertThat("Generated by the service inject codegen during compilation",
+                   compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationMain.class"), fileExists());
+        assertThat("Compiled service", compiledClasses.resolve("ServiceType.class"), fileExists());
+
+    }
+
+    @ParameterizedTest
+    @ConfigurationParameterSource("basedir")
+    @DisplayName("Test custom binding and main class names and custom package")
+    void test2(String basedir) {
+        // test the first project under src/it/projects/test1 (referenced from postbuild.groovy)
+        // make sure all the required types are created
+        Path projectPath = Paths.get(basedir);
+        Path compiledClasses = projectPath.resolve("target/classes/my/module");
+        Path compiledCustomClasses = projectPath.resolve("target/classes/my/updated");
+        Path generatedSources = projectPath.resolve("target/generated-sources/annotations/my/module");
+        Path generatedCustomSources = projectPath.resolve("target/generated-sources/annotations/my/updated");
+
+        assertThat("Generated by the Maven plugin",
+                   generatedCustomSources.resolve("UpdatedBinding.java"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin",
+                   generatedCustomSources.resolve("UpdatedBinding__ServiceDescriptor.java"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin",
+                   generatedCustomSources.resolve("UpdatedMain.java"),
+                   fileExists());
+        assertThat("Generated by the service inject codegen during compilation",
+                   generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
+                   fileExists());
+        assertThat("Not a generated type, exists in project sources only",
+                   generatedSources.resolve("ServiceType.java"),
+                   not(fileExists()));
+
+        assertThat("Generated by the Maven plugin",
+                   compiledCustomClasses.resolve("UpdatedBinding.class"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin",
+                   compiledCustomClasses.resolve("UpdatedBinding__ServiceDescriptor.class"),
+                   fileExists());
+        assertThat("Generated by the Maven plugin",
+                   compiledCustomClasses.resolve("UpdatedMain.class"),
+                   fileExists());
+        assertThat("Generated by the service inject codegen during compilation",
+                   compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
+                   fileExists());
+        assertThat("Compiled service", compiledClasses.resolve("ServiceType.class"), fileExists());
+
+    }
+
+    @ParameterizedTest
+    @ConfigurationParameterSource("basedir")
+    @DisplayName("Test binding and main class generation disabled")
+    void test3(String basedir) {
+        // test the first project under src/it/projects/test1 (referenced from postbuild.groovy)
+        // make sure all the required types are created
+        Path projectPath = Paths.get(basedir);
+        Path compiledClasses = projectPath.resolve("target/classes/my/module");
+        Path generatedSources = projectPath.resolve("target/generated-sources/annotations/my/module");
+
+        assertThat("Should not be generated by the Maven plugin",
+                   generatedSources.resolve("Injection__Binding.java"),
+                   not(fileExists()));
+        assertThat("Should nto be generated by the Maven plugin",
+                   generatedSources.resolve("Injection__Binding__ServiceDescriptor.java"),
+                   not(fileExists()));
+        assertThat("Generated by the service inject codegen during compilation",
+                   generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
+                   fileExists());
+        assertThat("Should not be generated by the Maven plugin",
+                   generatedSources.resolve("ApplicationMain.java"),
+                   not(fileExists()));
+        assertThat("Not a generated type, exists in project sources only",
+                   generatedSources.resolve("ServiceType.java"),
+                   not(fileExists()));
+
+        assertThat("Should not be generated by the Maven plugin",
+                   compiledClasses.resolve("Injection__Binding.class"),
+                   not(fileExists()));
+        assertThat("Should nto be generated by the Maven plugin",
+                   compiledClasses.resolve("Injection__Binding__ServiceDescriptor.class"),
+                   not(fileExists()));
+        assertThat("Generated by the service inject codegen during compilation",
+                   compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
+                   fileExists());
+        assertThat("Should not be generated by the Maven plugin",
+                   compiledClasses.resolve("ApplicationMain.class"),
+                   not(fileExists()));
+        assertThat("Compiled service", compiledClasses.resolve("ServiceType.class"), fileExists());
+
+    }
+}
diff --git a/service/tests/inject/pom.xml b/service/tests/inject/pom.xml
index 71b7de940a5..65a3bf6683b 100644
--- a/service/tests/inject/pom.xml
+++ b/service/tests/inject/pom.xml
@@ -46,5 +46,6 @@
         <module>stacking</module>
         <module>toolbox</module>
         <module>events</module>
+        <module>maven-plugin</module>
     </modules>
 </project>

From e766a9e2b00dc2ec1c368f79fea19566b1247763 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Thu, 28 Nov 2024 15:56:00 +0100
Subject: [PATCH 09/23] Use `release` if available for codegen compiler Switch
 hint log level to trace in maven plugin Removed bad info log, added useful
 info log to maven plugin

---
 .../compiler/CompilerOptionsBlueprint.java    |  9 +++++++
 .../io/helidon/codegen/compiler/JavaC.java    | 22 ++++++++++-----
 .../maven/plugin/ApplicationValidator.java    |  2 +-
 .../maven/plugin/CodegenAbstractMojo.java     |  1 -
 .../plugin/CreateApplicationAbstractMojo.java | 27 +++++++------------
 .../src/main/java/module-info.java            |  1 +
 6 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/codegen/compiler/src/main/java/io/helidon/codegen/compiler/CompilerOptionsBlueprint.java b/codegen/compiler/src/main/java/io/helidon/codegen/compiler/CompilerOptionsBlueprint.java
index 37c17191603..243d60fa4c9 100644
--- a/codegen/compiler/src/main/java/io/helidon/codegen/compiler/CompilerOptionsBlueprint.java
+++ b/codegen/compiler/src/main/java/io/helidon/codegen/compiler/CompilerOptionsBlueprint.java
@@ -18,6 +18,7 @@
 
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Optional;
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
@@ -77,6 +78,14 @@ interface CompilerOptionsBlueprint {
     @Option.Default("21")
     String target();
 
+    /**
+     * The compiler release.
+     * If not specified, {@link #source()} and {@link #target()} would be used.
+     *
+     * @return release for compilation
+     */
+    Optional<String> release();
+
     /**
      * Target directory to generate class files to.
      *
diff --git a/codegen/compiler/src/main/java/io/helidon/codegen/compiler/JavaC.java b/codegen/compiler/src/main/java/io/helidon/codegen/compiler/JavaC.java
index ac7f67127c8..ea116847ef9 100644
--- a/codegen/compiler/src/main/java/io/helidon/codegen/compiler/JavaC.java
+++ b/codegen/compiler/src/main/java/io/helidon/codegen/compiler/JavaC.java
@@ -44,6 +44,7 @@ class JavaC {
     private final List<String> commandLineArgs;
     private final String source;
     private final String target;
+    private final String release;
     private final Path outputDirectory;
     private final CodegenLogger logger;
 
@@ -54,6 +55,7 @@ private JavaC(CompilerOptions options) {
         this.commandLineArgs = options.commandLineArguments();
         this.source = options.source();
         this.target = options.target();
+        this.release = options.release().orElse(null);
         this.outputDirectory = options.outputDirectory();
         this.logger = options.logger();
     }
@@ -123,14 +125,20 @@ private void doCompile(Result result, Path[] sourceFilesToCompile) {
             optionList.add("--source-path");
             optionList.add(toSourcepath());
         }
-        if (source != null) {
-            optionList.add("--source");
-            optionList.add(source);
-        }
-        if (target != null) {
-            optionList.add("--target");
-            optionList.add(target);
+        if (release == null) {
+            if (source != null) {
+                optionList.add("--source");
+                optionList.add(source);
+            }
+            if (target != null) {
+                optionList.add("--target");
+                optionList.add(target);
+            }
+        } else {
+            optionList.add("--release");
+            optionList.add(release);
         }
+
         optionList.addAll(commandLineArgs);
         if (outputDirectory != null) {
             optionList.add("-d");
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
index 6a54a8941b7..e5545f21777 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
@@ -53,7 +53,7 @@ void validate(WrappedServices services) {
             Level level = switch (error.getSeverity()) {
                 case FATAL -> Level.ERROR;
                 case WARN -> Level.WARNING;
-                case HINT -> Level.INFO;
+                case HINT -> Level.TRACE;
             };
             logger.log(level, error.getSeverity() + " " + error.getSource() + ": " + error.getMessage());
         }
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
index 83ea6fe969e..2a1ac7f0f59 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
@@ -105,7 +105,6 @@ abstract class CodegenAbstractMojo extends AbstractMojo {
     @Override
     public final void execute() throws MojoExecutionException, MojoFailureException {
         try {
-            getLog().info("Started " + getClass().getSimpleName());
             innerExecute();
         } catch (MojoFailureException | MojoExecutionException e) {
             if (failOnError) {
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
index dbb88b3f2e4..144e26b9d24 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
+++ b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
@@ -74,14 +74,7 @@ abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
      */
     @Parameter(property = "maven.compiler.source",
                defaultValue = "21")
-    private String source;
-    /**
-     * The -target argument for the Java compiler.
-     * Note: using the same as maven-compiler for convenience and least astonishment.
-     */
-    @Parameter(property = "maven.compiler.target",
-               defaultValue = "21")
-    private String target;
+    private String release;
     /**
      * Whether to validate the application when creating its bindings.
      */
@@ -147,8 +140,7 @@ void innerExecute() {
                     .classpath(List.copyOf(classpath))
                     .modulepath(List.copyOf(modulepath))
                     .sourcepath(sourceRootPaths())
-                    .source(getSource())
-                    .target(getTarget())
+                    .release(javaRelease())
                     .commandLineArguments(getCompilerArgs())
                     .outputDirectory(outputDirectory())
                     .build();
@@ -219,6 +211,8 @@ void createMainClass(CompilerOptions compilerOptions,
                 .className(mainClassName)
                 .build();
 
+        getLog().info("Generating application main class: " + generatedType.fqName());
+
         MainClassCreator creator = new MainClassCreator(scanContext, failOnError());
         creator.create(scanContext, compilerOptions, services, generatedType);
     }
@@ -253,10 +247,13 @@ void applicationBinding(MavenCodegenContext scanContext,
         if (generateBinding) {
             // get the binding generator only after services are initialized (we need to ignore any existing apps)
             BindingGenerator creator = new BindingGenerator(scanContext, failOnError());
+            TypeName bindingTypeName = TypeName.create(packageName + "." + className);
+
+            getLog().info("Generating application binding: " + bindingTypeName.fqName());
 
             creator.createBinding(services,
                                   allServices,
-                                  TypeName.create(packageName + "." + className),
+                                  bindingTypeName,
                                   moduleName,
                                   compilerOptions);
         }
@@ -381,12 +378,8 @@ URLClassLoader createClassLoader(Collection<Path> classPath,
         return new URLClassLoader(urls.toArray(new URL[0]), parent);
     }
 
-    String getSource() {
-        return source;
-    }
-
-    String getTarget() {
-        return target;
+    String javaRelease() {
+        return release;
     }
 
     LinkedHashSet<Path> getSourceClasspathElements() {
diff --git a/service/inject/maven-plugin/src/main/java/module-info.java b/service/inject/maven-plugin/src/main/java/module-info.java
index f75f6c19013..2922be8f334 100644
--- a/service/inject/maven-plugin/src/main/java/module-info.java
+++ b/service/inject/maven-plugin/src/main/java/module-info.java
@@ -34,6 +34,7 @@
     requires maven.plugin.annotations;
     requires maven.plugin.api;
     requires maven.project;
+    requires java.xml;
     requires io.github.classgraph;
     requires io.helidon.service.metadata;
 

From d4a1e636c498c82c1449180259c4cd35a918483e Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 2 Dec 2024 20:28:49 +0100
Subject: [PATCH 10/23] Fix qualifiers

---
 .../io/helidon/service/inject/codegen/DescribedService.java  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java
index fec8f10385c..11c3647dc2e 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java
@@ -304,8 +304,9 @@ private static Set<Annotation> gatherQualifiers(TypeInfo serviceTypeInfo) {
         }
 
         for (Annotation annotation : serviceTypeInfo.annotations()) {
-            if (serviceTypeInfo.hasMetaAnnotation(annotation.typeName(),
-                                                  InjectCodegenTypes.INJECTION_QUALIFIER)) {
+            if (annotation.hasMetaAnnotation(InjectCodegenTypes.INJECTION_QUALIFIER)
+                    || serviceTypeInfo.hasMetaAnnotation(annotation.typeName(),
+                                                         InjectCodegenTypes.INJECTION_QUALIFIER)) {
                 qualifiers.add(annotation);
             }
         }

From d77615bf8c7bb5d611d89a2ed72d8280e52f9329 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Thu, 5 Dec 2024 17:26:58 +0100
Subject: [PATCH 11/23] Updates to registry (less dependencies, single module)

---
 all/pom.xml                                   |   16 +-
 bom/pom.xml                                   |   18 +-
 .../java/io/helidon/builder/api/Option.java   |   15 +
 .../io/helidon/builder/api/Prototype.java     |    2 +
 .../builder/codegen/BuilderCodegen.java       |  104 +-
 .../codegen/GenerateAbstractBuilder.java      |   10 +-
 .../builder/codegen/PrototypeProperty.java    |    7 +-
 .../helidon/builder/codegen/TypeContext.java  |   14 +-
 .../helidon/builder/codegen/TypeHandler.java  |   29 +
 .../builder/codegen/TypeHandlerList.java      |   32 +
 .../builder/codegen/TypeHandlerSet.java       |   37 +
 .../io/helidon/builder/codegen/Types.java     |    4 +-
 .../codegen/src/main/java/module-info.java    |    1 +
 builder/tests/builder/pom.xml                 |    4 +
 .../WithProviderRegistryBlueprint.java        |   14 +
 .../builder/src/main/java/module-info.java    |    1 +
 .../builder/test/ProviderRegistryTest.java    |   23 +-
 builder/tests/codegen/pom.xml                 |    5 +
 .../io/helidon/builder/codegen/TypesTest.java |    8 +-
 .../helidon/common/HelidonServiceLoader.java  |   13 +
 .../main/java/io/helidon/common/LruCache.java |  115 +
 .../java/io/helidon/common/LruCacheImpl.java  |  152 ++
 .../java/io/helidon/common/LruCacheTest.java  |  112 +
 .../helidon/common/configurable/LruCache.java |  175 +-
 .../io/helidon/common/types/TypeNameTest.java |   10 +-
 .../main/asciidoc/mp/guides/mp-tutorial.adoc  |    2 +-
 docs/src/main/asciidoc/mp/scheduling.adoc     |    2 +-
 inject/api/README.md                          |    4 +-
 .../inject/api/InjectionException.java        |    2 +-
 .../java/io/helidon/inject/api/Services.java  |    2 +-
 .../PriorityAndServiceTypeComparatorTest.java |    2 +-
 .../io/helidon/inject/runtime/Versions.java   |    2 +-
 .../io/helidon/inject/tools/CodeGenFiler.java |    2 +-
 .../test/resources/new-service-registry.json  |    2 +-
 service/README.md                             |  450 +++-
 service/{inject/codegen => builder}/pom.xml   |   32 +-
 .../builder/BuilderRegistrySupport.java       |  458 ++++
 .../builder/src/main/java/module-info.java    |    6 +
 service/codegen/README.md                     |   20 +-
 .../helidon/service}/codegen/Assignments.java |    7 +-
 .../service/codegen/CodegenHelper.java        |   61 +
 .../service}/codegen/DescribedElements.java   |    6 +-
 .../service}/codegen/DescribedService.java    |   59 +-
 .../service}/codegen/DescribedType.java       |    2 +-
 .../codegen/EventEmitterObserverProvider.java |   29 +-
 .../EventObserverExtensionProvider.java       |   22 +-
 .../helidon/service}/codegen/FactoryType.java |    2 +-
 .../codegen/GenerateServiceDescriptor.java    |  717 ------
 .../codegen/InterceptedTypeGenerator.java     |   15 +-
 .../service}/codegen/Interception.java        |    6 +-
 .../codegen/InterceptionStrategy.java         |    4 +-
 .../service}/codegen/InterceptionSupport.java |   28 +-
 .../codegen/MapNamedByTypeMapperProvider.java |   11 +-
 .../service}/codegen/MethodDefinition.java    |    2 +-
 .../service}/codegen/ParamDefinition.java     |    2 +-
 .../helidon/service}/codegen/Qualifiers.java  |   14 +-
 .../codegen/ServiceCodegenAnnotations.java    |    9 +
 .../service/codegen/ServiceCodegenTypes.java  |  257 +++
 .../codegen/ServiceDescriptorCodegen.java}    | 1978 ++++++++---------
 .../service/codegen/ServiceExtension.java     |   90 +-
 .../codegen/ServiceExtensionProvider.java     |   38 +-
 .../service/codegen/ServiceOptions.java       |   21 +
 .../service}/codegen/TypedElements.java       |    2 +-
 .../service}/codegen/spi/AssignmentImpl.java  |    2 +-
 .../codegen/spi/InjectAssignment.java         |    2 +-
 .../codegen/spi/InjectAssignmentProvider.java |    2 +-
 .../codegen/spi/InjectCodegenObserver.java    |    2 +-
 .../spi/InjectCodegenObserverProvider.java    |    2 +-
 .../codegen/src/main/java/module-info.java    |   10 +-
 service/inject/README.md                      |  453 ----
 service/inject/api/pom.xml                    |  114 -
 .../service/inject/api/Configuration.java     |   99 -
 .../inject/api/GeneratedInjectService.java    |  280 ---
 .../service/inject/api/InjectRegistry.java    |  135 --
 .../inject/api/InjectServiceDescriptor.java   |   58 -
 .../service/inject/api/InjectServiceInfo.java |   86 -
 .../helidon/service/inject/api/Injection.java |  547 -----
 .../service/inject/api/IpBlueprint.java       |   82 -
 .../helidon/service/inject/api/IpSupport.java |   49 -
 .../service/inject/api/package-info.java      |   28 -
 .../inject/api/src/main/java/module-info.java |   27 -
 service/inject/codegen/README.md              |   21 -
 .../codegen/ApplicationMainGenerator.java     |  260 ---
 .../inject/codegen/InjectCodegenTypes.java    |  272 ---
 .../service/inject/codegen/InjectOptions.java |   81 -
 .../codegen/InjectionExtensionProvider.java   |   87 -
 .../inject/codegen/spi/package-info.java      |   20 -
 .../codegen/src/main/java/module-info.java    |   42 -
 .../inject/inject/etc/spotbugs/exclude.xml    |   33 -
 service/inject/inject/pom.xml                 |  171 --
 .../service/inject/ConfigProvider.java        |   34 -
 .../service/inject/ConfigValueProvider.java   |  118 -
 .../helidon/service/inject/CoreWrappers.java  |  142 --
 .../service/inject/InjectConfigBlueprint.java |   99 -
 .../service/inject/InjectRegistryManager.java |  465 ----
 .../inject/InjectRegistryManagerProvider.java |   57 -
 .../inject/InjectServiceRegistryImpl.java     |  654 ------
 .../service/inject/InjectStartupProvider.java |   98 -
 .../helidon/service/inject/InjectionMain.java |  255 ---
 .../helidon/service/inject/package-info.java  |   24 -
 .../inject/src/main/java/module-info.java     |   50 -
 .../inject/maven/plugin/MainClassCreator.java |  289 ---
 service/inject/pom.xml                        |   45 -
 service/{inject => }/maven-plugin/README.md   |    4 +-
 .../maven-plugin/etc/spotbugs/exclude.xml     |    6 +-
 service/{inject => }/maven-plugin/pom.xml     |   16 +-
 .../maven/plugin/ApplicationValidator.java    |   26 +-
 .../maven/plugin/BindingGenerator.java        |  106 +-
 .../maven/plugin/CodegenAbstractMojo.java     |    6 +-
 .../plugin/CreateApplicationAbstractMojo.java |   61 +-
 .../maven/plugin/CreateApplicationMojo.java   |   17 +-
 .../plugin/CreateTestApplicationMojo.java     |    9 +-
 .../maven/plugin/MavenCodegenContext.java     |    2 +-
 .../service}/maven/plugin/MavenFiler.java     |    2 +-
 .../maven/plugin/MavenFilerResource.java      |    2 +-
 .../maven/plugin/MavenFilerTextResource.java  |    2 +-
 .../service}/maven/plugin/MavenLogger.java    |    2 +-
 .../service}/maven/plugin/MavenOptions.java   |    2 +-
 .../maven/plugin/MavenRoundContext.java       |    2 +-
 .../maven/plugin/WrappedServices.java         |   38 +-
 .../service}/maven/plugin/package-info.java   |    2 +-
 .../src/main/java/module-info.java            |   12 +-
 service/pom.xml                               |    3 +-
 service/registry/pom.xml                      |   20 +-
 .../service/registry/ActivationPhase.java     |   81 +
 .../registry}/ActivationRequestBlueprint.java |    9 +-
 .../registry}/ActivationResultBlueprint.java  |    9 +-
 .../helidon/service/registry}/Activator.java  |   75 +-
 .../helidon/service/registry}/Activators.java |  167 +-
 .../registry}/ActivatorsPerLookup.java        |   74 +-
 .../io/helidon/service/registry}/Binding.java |    5 +-
 .../helidon/service/registry}/Contracts.java  |    6 +-
 .../service/registry/CoreServiceRegistry.java |  808 ++++---
 .../registry/CoreServiceRegistryManager.java  |   73 -
 .../service/registry/DependencyBlueprint.java |   54 +
 .../registry/DependencyPlanBinder.java}       |   17 +-
 .../io/helidon/service/registry}/Event.java   |   16 +-
 .../registry}/EventDispatchException.java     |    2 +-
 .../service/registry}/EventManager.java       |    5 +-
 .../service/registry}/EventManagerImpl.java   |   17 +-
 .../registry/ExistingInstanceDescriptor.java  |    7 +-
 .../service/registry}/FactoryType.java        |    8 +-
 .../service/registry/GeneratedService.java    |  471 ++--
 .../registry/GlobalServiceRegistry.java       |   10 +-
 .../service/registry}/InjectionContext.java   |    5 +-
 .../InstanceName__ServiceDescriptor.java      |   10 +-
 .../service/registry}/Interception.java       |   14 +-
 .../InterceptionContextBlueprint.java         |    6 +-
 .../registry}/InterceptionException.java      |    6 +-
 .../registry}/InterceptionInvoker.java        |    2 +-
 .../registry}/InterceptionMetadata.java       |   12 +-
 .../registry}/InterceptionMetadataImpl.java   |   31 +-
 .../helidon/service/registry}/Invocation.java |   19 +-
 .../io/helidon/service/registry}/IpPlan.java  |    4 +-
 .../service/registry}/LookupBlueprint.java    |   22 +-
 .../service/registry}/LookupSupport.java      |   42 +-
 .../service/registry}/LookupTrace.java        |   12 +-
 .../registry}/PerRequestScopeHandler.java     |   11 +-
 .../registry}/QualifiedInstanceImpl.java      |    4 +-
 .../service/registry}/QualifierBlueprint.java |    6 +-
 .../service/registry}/QualifierSupport.java   |   38 +-
 .../helidon/service/registry}/Qualifiers.java |    6 +-
 .../service/registry/RegistryMetrics.java     |    8 +
 .../service/registry/RegistryMetricsImpl.java |   47 +
 .../io/helidon/service/registry}/Scope.java   |    2 +-
 .../registry}/ScopeNotActiveException.java    |    3 +-
 .../service/registry}/ScopedRegistry.java     |    4 +-
 .../service/registry}/ScopedRegistryImpl.java |   19 +-
 .../io/helidon/service/registry}/Scopes.java  |    8 +-
 .../io/helidon/service/registry/Service.java  |  494 +++-
 .../service/registry/ServiceDescriptor.java   |   29 +-
 .../helidon/service/registry/ServiceInfo.java |   41 +-
 .../service/registry}/ServiceInstance.java    |    8 +-
 .../ServiceLoader__ServiceDescriptor.java     |    7 +-
 .../service/registry}/ServiceManager.java     |   24 +-
 .../service/registry}/ServicePlanBinder.java  |   65 +-
 .../service/registry}/ServiceProvider.java    |   40 +-
 .../service/registry/ServiceRegistry.java     |  103 +-
 .../ServiceRegistryConfigBlueprint.java       |   62 +-
 .../registry/ServiceRegistryManager.java      |  425 +++-
 .../ServiceRegistryManagerDiscovery.java      |   46 -
 .../ServiceRegistry__ServiceDescriptor.java   |   54 -
 .../service/registry}/ServiceSupplies.java    |   15 +-
 .../io/helidon/service/registry/Services.java |  140 ++
 .../service/registry/VirtualDescriptor.java   |   25 +-
 .../spi/ServiceRegistryManagerProvider.java   |   42 -
 .../service/registry/spi/package-info.java    |   20 -
 .../registry/src/main/java/module-info.java   |    4 -
 service/tests/codegen/pom.xml                 |    9 +-
 .../codegen/src/main/java/module-info.java    |    2 -
 .../codegen/ServiceCodegenTypesTest.java      |  133 +-
 .../codegen/src/test/java/module-info.java    |    2 -
 service/tests/{inject => }/events/pom.xml     |   26 +-
 .../tests}/events/AsyncEventTypes.java        |   14 +-
 .../service/tests}/events/EventTypes.java     |   16 +-
 .../tests}/events/QualifiedEventTypes.java    |   15 +-
 .../src/main/java/module-info.java            |    4 +-
 .../service/tests}/events/EventTest.java      |   12 +-
 service/tests/inject/codegen/pom.xml          |   64 -
 .../codegen/InjectCodegenTypesTest.java       |  176 --
 .../events/src/main/java/module-info.java     |   26 -
 service/tests/inject/inject/pom.xml           |  165 --
 .../service/tests/inject/CustomMain.java      |   68 -
 .../inject/InjectRegistryConfigTest.java      |   88 -
 .../service/tests/inject/MainClassTest.java   |   61 -
 .../src/main/java/module-info.java            |   24 -
 service/tests/inject/pom.xml                  |  142 +-
 .../src/main/java/module-info.java            |   26 -
 .../scopes/src/main/java/module-info.java     |   27 -
 .../service/tests/inject/AContract.java       |    0
 .../tests/inject/AContractSupplier.java       |    4 +-
 .../service/tests/inject/ContractOfNamed.java |    0
 .../tests/inject/ContractOfQualified.java     |    0
 .../service/tests/inject/DescribeTypes.java   |    6 +-
 .../tests/inject/FactoryIsAServiceTypes.java  |    8 +-
 .../service/tests/inject/InnerTypes.java      |    3 +-
 .../tests/inject/LateBindingTypes.java        |   28 +
 .../tests/inject/LifecycleReceiver.java       |    3 +-
 .../service/tests/inject/MutableService.java  |    0
 .../service/tests/inject/MutatorA.java        |    6 +-
 .../service/tests/inject/MutatorB.java        |    6 +-
 .../service/tests/inject/MutatorC.java        |    6 +-
 .../service/tests/inject/MutatorReceiver.java |    6 +-
 .../service/tests/inject/MyContract.java      |    0
 .../service/tests/inject/MyService.java       |    4 +-
 .../service/tests/inject/MyService2.java      |    6 +-
 .../service/tests/inject/MyService3.java      |    6 +-
 .../service/tests/inject/NamedReceiver.java   |    8 +-
 .../service/tests/inject/NamedService.java    |    6 +-
 .../tests/inject/NonSingletonService.java     |    6 +-
 .../tests/inject/ParameterizedTypes.java      |   19 +-
 .../tests/inject/ProviderReceiver.java        |    6 +-
 .../tests/inject/QualifiedReceiver.java       |    6 +-
 .../tests/inject/QualifiedService.java        |    4 +-
 .../tests/inject/QualifierAnnotation.java     |    4 +-
 .../service/tests/inject/ServiceSupplier.java |    0
 .../tests/inject/ServicesFactoryTypes.java    |   24 +-
 .../tests/inject/SingletonService.java        |    4 +-
 .../tests/inject/SuppliedContract.java        |    0
 .../tests/inject/UnQualifiedService.java      |    4 +-
 .../service/tests/inject/UnnamedService.java  |    4 +-
 .../src/main/java/module-info.java            |    4 -
 .../inject/CyclicDependencyCoreTest.java      |   16 +-
 .../inject/CyclicDependencyInjectTest.java    |   24 +-
 .../service/tests/inject/DescribeTest.java    |   14 +-
 .../tests/inject/FactoryIsAServiceTest.java   |   14 +-
 .../inject/InjectRegistryConfigTest.java      |   43 +
 .../tests/inject/InjectRegistryTest.java      |    9 +-
 .../service/tests/inject/InjectionTest.java   |   10 +-
 .../service/tests/inject/LateBindingTest.java |  180 ++
 .../service/tests/inject/MutationTest.java    |    6 +-
 .../tests/inject/ParameterizedTypesTest.java  |   14 +-
 .../ServicesFactoryProvidedInstancesTest.java |   21 +-
 .../tests/inject/ServicesFactoryTest.java     |   18 +-
 .../src/test/resources/logging.properties     |    4 +-
 .../stacking/src/main/java/module-info.java   |   27 -
 .../toolbox/src/main/java/module-info.java    |   31 -
 .../tests/{inject => }/interception/pom.xml   |   26 +-
 .../interception/AbstractClassTypes.java      |   15 +-
 .../tests}/interception/Construct.java        |    4 +-
 .../interception/ConstructorInterceptor.java  |   12 +-
 .../tests}/interception/DelegatedClass.java   |    4 +-
 .../DelegatedClassServiceProvider.java        |    6 +-
 .../interception/DelegatedContract.java       |    4 +-
 .../DelegatedServiceProvider.java             |    6 +-
 .../tests}/interception/Invocation.java       |    2 +-
 .../service/tests}/interception/Modify.java   |    4 +-
 .../interception/ModifyingInterceptor.java    |   12 +-
 .../tests}/interception/OtherContract.java    |    2 +-
 .../service/tests}/interception/Repeat.java   |    4 +-
 .../interception/RepeatingInterceptor.java    |   14 +-
 .../service/tests}/interception/Return.java   |    4 +-
 .../interception/ReturningInterceptor.java    |   12 +-
 .../tests}/interception/TheOtherService.java  |    6 +-
 .../tests}/interception/TheService.java       |    6 +-
 .../src/main/java/module-info.java            |   21 +
 .../AbstractClassInterceptionTest.java        |   18 +-
 .../DelegatingInterceptionTest.java           |   17 +-
 .../tests}/interception/InterceptionTest.java |   14 +-
 .../InterfaceInterceptionTest.java            |   14 +-
 .../src/test/resources/logging.properties     |    4 +-
 service/tests/{inject => }/lookup/pom.xml     |   28 +-
 .../service}/tests/lookup/ContractCommon.java |    2 +-
 .../tests/lookup/ContractNoIpProvider.java    |    2 +-
 .../tests/lookup/ContractNoScope.java         |    2 +-
 .../lookup/ContractNoScopeNoIpProvider.java   |    2 +-
 .../tests/lookup/ContractRequestScope.java    |    2 +-
 .../ContractRequestScopeNoIpProvider.java     |    2 +-
 .../tests/lookup/ContractSingleton.java       |    2 +-
 .../lookup/ContractSingletonNoIpProvider.java |    2 +-
 .../tests/lookup/NoScopeDirectExample.java    |    6 +-
 .../NoScopeInjectionPointProviderExample.java |   18 +-
 .../NoScopeServicesProviderExample.java       |   16 +-
 .../tests/lookup/NoScopeSupplierExample.java  |    6 +-
 .../lookup/RequestScopeDirectExample.java     |    6 +-
 ...estScopeInjectionPointProviderExample.java |   18 +-
 .../RequestScopeServicesProviderExample.java  |   16 +-
 .../lookup/RequestScopeSupplierExample.java   |    6 +-
 .../tests/lookup/SingletonDirectExample.java  |    6 +-
 ...ingletonInjectionPointProviderExample.java |   18 +-
 .../SingletonServicesProviderExample.java     |   16 +-
 .../lookup/SingletonSupplierExample.java      |    6 +-
 .../lookup/src/main/java/module-info.java     |   21 +
 .../tests/lookup/AllScopesLookupTest.java     |   26 +-
 .../tests/lookup/NoScopeLookupTest.java       |   18 +-
 .../tests/lookup/RequestScopeLookupTest.java  |   32 +-
 .../tests/lookup/SingletonLookupTest.java     |   22 +-
 .../src/test/resources/logging.properties     |    4 +-
 .../tests/{inject => }/maven-plugin/pom.xml   |    8 +-
 .../src/it/projects/test1/pom.xml             |   20 +-
 .../src/it/projects/test1/postbuild.groovy    |    0
 .../src/main/java/my/module/ServiceType.java  |    4 +-
 .../src/it/projects/test2/pom.xml             |   20 +-
 .../src/it/projects/test2/postbuild.groovy    |    0
 .../src/main/java/my/module/ServiceType.java  |    4 +-
 .../src/it/projects/test3/pom.xml             |   20 +-
 .../src/it/projects/test3/postbuild.groovy    |    0
 .../src/main/java/my/module/ServiceType.java  |    4 +-
 .../maven-plugin/src/it/settings.xml          |    0
 .../inject/maven/plugin/ProjectsTestIT.java   |   21 +-
 service/tests/pom.xml                         |   11 +-
 .../{inject => }/qualified-providers/pom.xml  |   28 +-
 .../providers/FirstQualifiedProvider.java     |   14 +-
 .../qualified/providers/FirstQualifier.java   |    6 +-
 .../providers/QualifiedContract.java          |    2 +-
 .../providers/SecondQualifiedProvider.java    |   14 +-
 .../qualified/providers/SecondQualifier.java  |    6 +-
 .../qualified/providers/TheService.java       |    8 +-
 .../src/main/java/module-info.java            |   21 +
 .../providers/QualifiedProvidersTest.java     |   10 +-
 .../test/registry/CyclicDependencyTest.java   |    6 +-
 .../test/registry/RegistryConfigTest.java     |   61 -
 service/tests/{inject => }/scopes/pom.xml     |   26 +-
 .../service/tests}/scopes/CustomScope.java    |    6 +-
 .../scopes/CustomScopeDescribedContract.java  |    5 +-
 .../CustomScopeDescribedContractImpl.java     |    2 +-
 .../tests}/scopes/CustomScopeHandler.java     |   12 +-
 .../tests}/scopes/CustomScopedContract.java   |    3 +-
 .../tests}/scopes/CustomScopedProducer.java   |    6 +-
 .../tests}/scopes/RequestScopedContract.java  |    2 +-
 .../tests}/scopes/RequestScopedProducer.java  |    6 +-
 .../tests}/scopes/SingletonContract.java      |    2 +-
 .../tests}/scopes/SingletonService.java       |    8 +-
 .../scopes/src/main/java/module-info.java     |   21 +
 .../service/tests}/scopes/TestScopes.java     |   30 +-
 .../{inject => }/service-lifecycle/pom.xml    |   24 +-
 .../service}/lifecycle/AServiceContract.java  |    2 +-
 .../lifecycle/AServiceContractImpl.java       |    8 +-
 .../lifecycle/ASingletonContract.java         |    2 +-
 .../lifecycle/ASingletonContractImpl.java     |    8 +-
 .../service}/lifecycle/InjectedService.java   |    6 +-
 .../src/main/java/module-info.java}           |    7 +-
 .../ServiceLifecycleLimitPhaseTest.java       |   20 +-
 .../lifecycle/ServiceLifecycleTest.java       |   12 +-
 service/tests/{inject => }/stacking/pom.xml   |   24 +-
 .../tests}/stacking/CommonContract.java       |    2 +-
 .../tests}/stacking/CommonContractImpl.java   |   10 +-
 .../stacking/MostOuterCommonContractImpl.java |    8 +-
 .../stacking/OuterCommonContractImpl.java     |    8 +-
 .../stacking/src/main/java/module-info.java   |   21 +
 service/tests/{inject => }/toolbox/pom.xml    |   33 +-
 .../service/tests}/toolbox/AbstractBlade.java |    6 +-
 .../service/tests}/toolbox/AbstractSaw.java   |   29 +-
 .../helidon/service/tests}/toolbox/Awl.java   |    2 +-
 .../service/tests}/toolbox/Hammer.java        |    2 +-
 .../service/tests}/toolbox/Lubricant.java     |    2 +-
 .../service/tests}/toolbox/Preferred.java     |    6 +-
 .../SomeOtherLocalNonContractInterface1.java  |    2 +-
 .../service/tests}/toolbox/TableSaw.java      |   40 +-
 .../helidon/service/tests}/toolbox/Tool.java  |    2 +-
 .../service/tests}/toolbox/ToolBox.java       |    2 +-
 .../service/tests}/toolbox/Verification.java  |    2 +-
 .../service/tests}/toolbox/impl/AwlImpl.java  |   10 +-
 .../tests}/toolbox/impl/BigHammer.java        |   12 +-
 .../tests}/toolbox/impl/BladeProvider.java    |   18 +-
 .../tests}/toolbox/impl/CoarseBlade.java      |    8 +-
 .../tests}/toolbox/impl/DullBlade.java        |    8 +-
 .../tests}/toolbox/impl/FineBlade.java        |    8 +-
 .../service/tests}/toolbox/impl/HandSaw.java  |   30 +-
 .../tests}/toolbox/impl/LittleHammer.java     |   10 +-
 .../tests}/toolbox/impl/MainToolBox.java      |   23 +-
 .../tests}/toolbox/impl/Screwdriver.java      |   10 +-
 .../tests}/toolbox/impl/SledgeHammer.java     |    8 +-
 .../tests/toolbox/impl}/package-info.java     |    2 +-
 .../service/tests/toolbox}/package-info.java  |    2 +-
 .../src/main/java/module-info.java            |   10 +-
 .../service/tests}/toolbox/ToolBoxTest.java   |   71 +-
 tests/integration/packaging/inject/pom.xml    |   16 +-
 .../packaging/inject/GreetFeature.java        |    9 +-
 .../integration/packaging/inject/Main.java    |   14 +-
 .../packaging/inject/ServerStarter.java       |    7 +-
 .../inject/src/main/java/module-info.java     |    2 +-
 392 files changed, 7269 insertions(+), 10797 deletions(-)
 create mode 100644 common/common/src/main/java/io/helidon/common/LruCache.java
 create mode 100644 common/common/src/main/java/io/helidon/common/LruCacheImpl.java
 create mode 100644 common/common/src/test/java/io/helidon/common/LruCacheTest.java
 rename service/{inject/codegen => builder}/pom.xml (60%)
 create mode 100644 service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java
 create mode 100644 service/builder/src/main/java/module-info.java
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/Assignments.java (90%)
 create mode 100644 service/codegen/src/main/java/io/helidon/service/codegen/CodegenHelper.java
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/DescribedElements.java (96%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/DescribedService.java (82%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/DescribedType.java (98%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/EventEmitterObserverProvider.java (91%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/EventObserverExtensionProvider.java (91%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/FactoryType.java (97%)
 delete mode 100644 service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/InterceptedTypeGenerator.java (96%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/Interception.java (98%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/InterceptionStrategy.java (95%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/InterceptionSupport.java (96%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/MapNamedByTypeMapperProvider.java (82%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/MethodDefinition.java (97%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/ParamDefinition.java (98%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/Qualifiers.java (82%)
 create mode 100644 service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java => codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java} (84%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/TypedElements.java (99%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/spi/AssignmentImpl.java (96%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/spi/InjectAssignment.java (98%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/spi/InjectAssignmentProvider.java (95%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/spi/InjectCodegenObserver.java (97%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject => codegen/src/main/java/io/helidon/service}/codegen/spi/InjectCodegenObserverProvider.java (96%)
 delete mode 100644 service/inject/README.md
 delete mode 100644 service/inject/api/pom.xml
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/Configuration.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/GeneratedInjectService.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/InjectRegistry.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceDescriptor.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceInfo.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/IpBlueprint.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/IpSupport.java
 delete mode 100644 service/inject/api/src/main/java/io/helidon/service/inject/api/package-info.java
 delete mode 100644 service/inject/api/src/main/java/module-info.java
 delete mode 100644 service/inject/codegen/README.md
 delete mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
 delete mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
 delete mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
 delete mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
 delete mode 100644 service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/package-info.java
 delete mode 100644 service/inject/codegen/src/main/java/module-info.java
 delete mode 100644 service/inject/inject/etc/spotbugs/exclude.xml
 delete mode 100644 service/inject/inject/pom.xml
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/ConfigProvider.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/ConfigValueProvider.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/CoreWrappers.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManager.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManagerProvider.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectServiceRegistryImpl.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
 delete mode 100644 service/inject/inject/src/main/java/io/helidon/service/inject/package-info.java
 delete mode 100644 service/inject/inject/src/main/java/module-info.java
 delete mode 100644 service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
 delete mode 100644 service/inject/pom.xml
 rename service/{inject => }/maven-plugin/README.md (95%)
 rename service/{inject => }/maven-plugin/etc/spotbugs/exclude.xml (83%)
 rename service/{inject => }/maven-plugin/pom.xml (91%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/ApplicationValidator.java (87%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/BindingGenerator.java (86%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/CodegenAbstractMojo.java (96%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/CreateApplicationAbstractMojo.java (87%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/CreateApplicationMojo.java (83%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/CreateTestApplicationMojo.java (94%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenCodegenContext.java (98%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenFiler.java (99%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenFilerResource.java (97%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenFilerTextResource.java (97%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenLogger.java (98%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenOptions.java (98%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/MavenRoundContext.java (98%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/WrappedServices.java (79%)
 rename service/{inject/maven-plugin/src/main/java/io/helidon/service/inject => maven-plugin/src/main/java/io/helidon/service}/maven/plugin/package-info.java (95%)
 rename service/{inject => }/maven-plugin/src/main/java/module-info.java (75%)
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/ActivationPhase.java
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/ActivationRequestBlueprint.java (86%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/ActivationResultBlueprint.java (90%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Activator.java (50%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/Activators.java (85%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ActivatorsPerLookup.java (84%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/Binding.java (92%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/Contracts.java (91%)
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistryManager.java
 rename service/{inject/inject/src/main/java/io/helidon/service/inject/InjectionPlanBinder.java => registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java} (93%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Event.java (85%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/EventDispatchException.java (96%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/EventManager.java (94%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/EventManagerImpl.java (92%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/FactoryType.java (81%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/InjectionContext.java (92%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/InstanceName__ServiceDescriptor.java (85%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Interception.java (90%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/InterceptionContextBlueprint.java (92%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/InterceptionException.java (93%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/InterceptionInvoker.java (96%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/InterceptionMetadata.java (90%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/InterceptionMetadataImpl.java (86%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/Invocation.java (87%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/IpPlan.java (92%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/LookupBlueprint.java (91%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/LookupSupport.java (78%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/LookupTrace.java (91%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/PerRequestScopeHandler.java (89%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/QualifiedInstanceImpl.java (89%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/QualifierBlueprint.java (86%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/QualifierSupport.java (84%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Qualifiers.java (93%)
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Scope.java (96%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/ScopeNotActiveException.java (93%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/ScopedRegistry.java (95%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ScopedRegistryImpl.java (88%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/Scopes.java (86%)
 rename service/{inject/api/src/main/java/io/helidon/service/inject/api => registry/src/main/java/io/helidon/service/registry}/ServiceInstance.java (88%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ServiceManager.java (82%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ServicePlanBinder.java (70%)
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ServiceProvider.java (85%)
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManagerDiscovery.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry__ServiceDescriptor.java
 rename service/{inject/inject/src/main/java/io/helidon/service/inject => registry/src/main/java/io/helidon/service/registry}/ServiceSupplies.java (94%)
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/Services.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/spi/ServiceRegistryManagerProvider.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/spi/package-info.java
 rename service/tests/{inject => }/events/pom.xml (83%)
 rename service/tests/{inject/events/src/main/java/io/helidon/service/tests/inject => events/src/main/java/io/helidon/service/tests}/events/AsyncEventTypes.java (91%)
 rename service/tests/{inject/events/src/main/java/io/helidon/service/tests/inject => events/src/main/java/io/helidon/service/tests}/events/EventTypes.java (86%)
 rename service/tests/{inject/events/src/main/java/io/helidon/service/tests/inject => events/src/main/java/io/helidon/service/tests}/events/QualifiedEventTypes.java (89%)
 rename service/tests/{inject/service-lifecycle => events}/src/main/java/module-info.java (85%)
 rename service/tests/{inject/events/src/test/java/io/helidon/service/tests/inject => events/src/test/java/io/helidon/service/tests}/events/EventTest.java (92%)
 delete mode 100644 service/tests/inject/codegen/pom.xml
 delete mode 100644 service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
 delete mode 100644 service/tests/inject/events/src/main/java/module-info.java
 delete mode 100644 service/tests/inject/inject/pom.xml
 delete mode 100644 service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
 delete mode 100644 service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
 delete mode 100644 service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java
 delete mode 100644 service/tests/inject/interception/src/main/java/module-info.java
 delete mode 100644 service/tests/inject/qualified-providers/src/main/java/module-info.java
 delete mode 100644 service/tests/inject/scopes/src/main/java/module-info.java
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/AContract.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ContractOfNamed.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ContractOfQualified.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java (93%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java (94%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/InnerTypes.java (94%)
 create mode 100644 service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java (94%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MutableService.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MutatorA.java (91%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MutatorB.java (91%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MutatorC.java (91%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java (90%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MyContract.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MyService.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MyService2.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/MyService3.java (90%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java (83%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/NamedService.java (89%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java (90%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java (95%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java (91%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/QualifiedService.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java (93%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ServiceSupplier.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java (78%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/SingletonService.java (90%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/SuppliedContract.java (100%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java (92%)
 rename service/tests/inject/{inject => }/src/main/java/io/helidon/service/tests/inject/UnnamedService.java (91%)
 rename service/tests/inject/{inject => }/src/main/java/module-info.java (82%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java (91%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java (88%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/DescribeTest.java (82%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java (82%)
 create mode 100644 service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java (93%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/InjectionTest.java (95%)
 create mode 100644 service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/MutationTest.java (90%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java (86%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java (80%)
 rename service/tests/inject/{inject => }/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java (82%)
 rename service/tests/inject/{inject => }/src/test/resources/logging.properties (94%)
 delete mode 100644 service/tests/inject/stacking/src/main/java/module-info.java
 delete mode 100644 service/tests/inject/toolbox/src/main/java/module-info.java
 rename service/tests/{inject => }/interception/pom.xml (83%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/AbstractClassTypes.java (87%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/Construct.java (89%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/ConstructorInterceptor.java (79%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/DelegatedClass.java (91%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/DelegatedClassServiceProvider.java (87%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/DelegatedContract.java (89%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/DelegatedServiceProvider.java (91%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/Invocation.java (93%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/Modify.java (90%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/ModifyingInterceptor.java (86%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/OtherContract.java (95%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/Repeat.java (90%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/RepeatingInterceptor.java (85%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/Return.java (90%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/ReturningInterceptor.java (86%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/TheOtherService.java (93%)
 rename service/tests/{inject/interception/src/main/java/io/helidon/service/tests/inject => interception/src/main/java/io/helidon/service/tests}/interception/TheService.java (93%)
 create mode 100644 service/tests/interception/src/main/java/module-info.java
 rename service/tests/{inject/interception/src/test/java/io/helidon/service/tests/inject => interception/src/test/java/io/helidon/service/tests}/interception/AbstractClassInterceptionTest.java (76%)
 rename service/tests/{inject/interception/src/test/java/io/helidon/service/tests/inject => interception/src/test/java/io/helidon/service/tests}/interception/DelegatingInterceptionTest.java (94%)
 rename service/tests/{inject/interception/src/test/java/io/helidon/service/tests/inject => interception/src/test/java/io/helidon/service/tests}/interception/InterceptionTest.java (96%)
 rename service/tests/{inject/interception/src/test/java/io/helidon/service/tests/inject => interception/src/test/java/io/helidon/service/tests}/interception/InterfaceInterceptionTest.java (96%)
 rename service/tests/{inject => }/interception/src/test/resources/logging.properties (94%)
 rename service/tests/{inject => }/lookup/pom.xml (84%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractCommon.java (93%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractNoIpProvider.java (93%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractNoScope.java (93%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractNoScopeNoIpProvider.java (94%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractRequestScope.java (93%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractRequestScopeNoIpProvider.java (94%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractSingleton.java (93%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/ContractSingletonNoIpProvider.java (94%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/NoScopeDirectExample.java (85%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/NoScopeInjectionPointProviderExample.java (81%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/NoScopeServicesProviderExample.java (78%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/NoScopeSupplierExample.java (90%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/RequestScopeDirectExample.java (85%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/RequestScopeInjectionPointProviderExample.java (81%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/RequestScopeServicesProviderExample.java (82%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/RequestScopeSupplierExample.java (90%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/SingletonDirectExample.java (85%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/SingletonInjectionPointProviderExample.java (82%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/SingletonServicesProviderExample.java (79%)
 rename service/tests/{inject/lookup/src/main/java/io/helidon/service/inject => lookup/src/main/java/io/helidon/service}/tests/lookup/SingletonSupplierExample.java (90%)
 create mode 100644 service/tests/lookup/src/main/java/module-info.java
 rename service/tests/{inject/lookup/src/test/java/io/helidon/service/inject => lookup/src/test/java/io/helidon/service}/tests/lookup/AllScopesLookupTest.java (91%)
 rename service/tests/{inject/lookup/src/test/java/io/helidon/service/inject => lookup/src/test/java/io/helidon/service}/tests/lookup/NoScopeLookupTest.java (94%)
 rename service/tests/{inject/lookup/src/test/java/io/helidon/service/inject => lookup/src/test/java/io/helidon/service}/tests/lookup/RequestScopeLookupTest.java (92%)
 rename service/tests/{inject/lookup/src/test/java/io/helidon/service/inject => lookup/src/test/java/io/helidon/service}/tests/lookup/SingletonLookupTest.java (93%)
 rename service/tests/{inject => }/lookup/src/test/resources/logging.properties (94%)
 rename service/tests/{inject => }/maven-plugin/pom.xml (91%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test1/pom.xml (80%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test1/postbuild.groovy (100%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java (90%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test2/pom.xml (81%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test2/postbuild.groovy (100%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java (90%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test3/pom.xml (81%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test3/postbuild.groovy (100%)
 rename service/tests/{inject => }/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java (90%)
 rename service/tests/{inject => }/maven-plugin/src/it/settings.xml (100%)
 rename service/tests/{inject => }/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java (90%)
 rename service/tests/{inject => }/qualified-providers/pom.xml (83%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/FirstQualifiedProvider.java (81%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/FirstQualifier.java (87%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/QualifiedContract.java (92%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/SecondQualifiedProvider.java (83%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/SecondQualifier.java (87%)
 rename service/tests/{inject/qualified-providers/src/main/java/io/helidon/service/tests/inject => qualified-providers/src/main/java/io/helidon/service/tests}/qualified/providers/TheService.java (90%)
 create mode 100644 service/tests/qualified-providers/src/main/java/module-info.java
 rename service/tests/{inject/qualified-providers/src/test/java/io/helidon/service/tests/inject => qualified-providers/src/test/java/io/helidon/service/tests}/qualified/providers/QualifiedProvidersTest.java (83%)
 delete mode 100644 service/tests/registry/src/test/java/io/helidon/service/test/registry/RegistryConfigTest.java
 rename service/tests/{inject => }/scopes/pom.xml (78%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScope.java (90%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScopeDescribedContract.java (84%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScopeDescribedContractImpl.java (94%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScopeHandler.java (79%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScopedContract.java (94%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/CustomScopedProducer.java (91%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/RequestScopedContract.java (93%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/RequestScopedProducer.java (88%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/SingletonContract.java (93%)
 rename service/tests/{inject/scopes/src/main/java/io/helidon/service/tests/inject => scopes/src/main/java/io/helidon/service/tests}/scopes/SingletonService.java (87%)
 create mode 100644 service/tests/scopes/src/main/java/module-info.java
 rename service/tests/{inject/scopes/src/test/java/io/helidon/service/tests/inject => scopes/src/test/java/io/helidon/service/tests}/scopes/TestScopes.java (80%)
 rename service/tests/{inject => }/service-lifecycle/pom.xml (84%)
 rename service/tests/{inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject => service-lifecycle/src/main/java/io/helidon/tests/service}/lifecycle/AServiceContract.java (93%)
 rename service/tests/{inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject => service-lifecycle/src/main/java/io/helidon/tests/service}/lifecycle/AServiceContractImpl.java (89%)
 rename service/tests/{inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject => service-lifecycle/src/main/java/io/helidon/tests/service}/lifecycle/ASingletonContract.java (93%)
 rename service/tests/{inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject => service-lifecycle/src/main/java/io/helidon/tests/service}/lifecycle/ASingletonContractImpl.java (89%)
 rename service/tests/{inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject => service-lifecycle/src/main/java/io/helidon/tests/service}/lifecycle/InjectedService.java (84%)
 rename service/{inject/codegen/src/main/java/io/helidon/service/inject/codegen/package-info.java => tests/service-lifecycle/src/main/java/module-info.java} (85%)
 rename service/tests/{inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject => service-lifecycle/src/test/java/io/helidon/tests/service}/lifecycle/ServiceLifecycleLimitPhaseTest.java (88%)
 rename service/tests/{inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject => service-lifecycle/src/test/java/io/helidon/tests/service}/lifecycle/ServiceLifecycleTest.java (94%)
 rename service/tests/{inject => }/stacking/pom.xml (84%)
 rename service/tests/{inject/stacking/src/main/java/io/helidon/service/tests/inject => stacking/src/main/java/io/helidon/service/tests}/stacking/CommonContract.java (95%)
 rename service/tests/{inject/stacking/src/main/java/io/helidon/service/tests/inject => stacking/src/main/java/io/helidon/service/tests}/stacking/CommonContractImpl.java (88%)
 rename service/tests/{inject/stacking/src/main/java/io/helidon/service/tests/inject => stacking/src/main/java/io/helidon/service/tests}/stacking/MostOuterCommonContractImpl.java (86%)
 rename service/tests/{inject/stacking/src/main/java/io/helidon/service/tests/inject => stacking/src/main/java/io/helidon/service/tests}/stacking/OuterCommonContractImpl.java (86%)
 create mode 100644 service/tests/stacking/src/main/java/module-info.java
 rename service/tests/{inject => }/toolbox/pom.xml (82%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/AbstractBlade.java (86%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/AbstractSaw.java (82%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Awl.java (93%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Hammer.java (93%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Lubricant.java (93%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Preferred.java (89%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/SomeOtherLocalNonContractInterface1.java (93%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/TableSaw.java (88%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Tool.java (94%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/ToolBox.java (95%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/Verification.java (99%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/AwlImpl.java (79%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/BigHammer.java (77%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/BladeProvider.java (86%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/CoarseBlade.java (78%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/DullBlade.java (79%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/FineBlade.java (78%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/HandSaw.java (84%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/LittleHammer.java (78%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/MainToolBox.java (82%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/Screwdriver.java (76%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject => toolbox/src/main/java/io/helidon/service/tests}/toolbox/impl/SledgeHammer.java (84%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox => toolbox/src/main/java/io/helidon/service/tests/toolbox/impl}/package-info.java (92%)
 rename service/tests/{inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl => toolbox/src/main/java/io/helidon/service/tests/toolbox}/package-info.java (92%)
 rename service/tests/{inject/lookup => toolbox}/src/main/java/module-info.java (73%)
 rename service/tests/{inject/toolbox/src/test/java/io/helidon/service/tests/inject => toolbox/src/test/java/io/helidon/service/tests}/toolbox/ToolBoxTest.java (71%)

diff --git a/all/pom.xml b/all/pom.xml
index c37fc609d7e..0281de7bd2c 100644
--- a/all/pom.xml
+++ b/all/pom.xml
@@ -1129,20 +1129,12 @@
             <artifactId>helidon-service-codegen</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-codegen</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-maven-plugin</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-maven-plugin</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-builder</artifactId>
         </dependency>
         <dependency>
             <groupId>io.helidon.metadata</groupId>
diff --git a/bom/pom.xml b/bom/pom.xml
index 42775cd8560..8a52ec29605 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -1492,23 +1492,13 @@
                 <version>${helidon.version}</version>
             </dependency>
             <dependency>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-codegen</artifactId>
-                <version>${helidon.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-api</artifactId>
-                <version>${helidon.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
             <dependency>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-builder</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
 
diff --git a/builder/api/src/main/java/io/helidon/builder/api/Option.java b/builder/api/src/main/java/io/helidon/builder/api/Option.java
index 96f6143be93..e315748b874 100644
--- a/builder/api/src/main/java/io/helidon/builder/api/Option.java
+++ b/builder/api/src/main/java/io/helidon/builder/api/Option.java
@@ -152,6 +152,21 @@ private Option() {
         boolean discoverServices() default true;
     }
 
+    /**
+     * Options annotated with this annotation will use service registry to discover instances to use.
+     * This annotation cannot be combined with {@link io.helidon.builder.api.Option.Configured} - if you want
+     * providers configured from configuration, kindly use {@link io.helidon.builder.api.Option.Provider}.
+     * <p>
+     * Options annotated with this annotation will load the instances as the default value (before method {@code builder()})
+     * returns, thus you have full control over the field, be it an Optional, single value, or a List.
+     * <p>
+     * To support usage of custom service registry, a {@code builder(ServiceRegistry)} method will be generated as well.
+     */
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.CLASS)
+    public @interface RegistryService {
+    }
+
     /**
      * Allowed values for this option.
      * The allowed value is always configured as a string, and is compared to {@link java.lang.String#valueOf(Object)} of the
diff --git a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
index 7c8cccd86c0..f1efe5ad12c 100644
--- a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
+++ b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
@@ -468,6 +468,8 @@ public interface OptionDecorator<B, T> {
      * <p>
      * When using this annotation, you cannot use {@code serviceRegistry} as a custom option in your blueprint, as it will
      * be added by the annotation processor, to allow customization of the registry instance.
+     * <p>
+     * This
      */
     @Target(ElementType.TYPE)
     @Retention(RetentionPolicy.CLASS)
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
index 22e13bb88b5..c4bb405a26f 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
@@ -46,6 +46,7 @@
 import io.helidon.common.types.TypeName;
 
 import static io.helidon.builder.codegen.Types.RUNTIME_PROTOTYPE;
+import static io.helidon.builder.codegen.Types.SERVICE_REGISTRY;
 
 class BuilderCodegen implements CodegenExtension {
     private static final TypeName GENERATOR = TypeName.create(BuilderCodegen.class);
@@ -196,21 +197,106 @@ private static void addCopyBuilderMethod(ClassModel.Builder classModel,
         });
     }
 
+    private static void addRegistryBuilderMethod(ClassModel.Builder classModel,
+                                                 TypeName builderTypeName,
+                                                 List<TypeArgument> typeArguments,
+                                                 String ifaceName, List<PrototypeProperty> properties) {
+        classModel.addMethod(builder -> {
+            builder.isStatic(true)
+                    .name("builder")
+                    .description("Create a new fluent API builder to customize configuration using the provided service "
+                                         + "registry.")
+                    .addParameter(registry -> registry
+                            .type(SERVICE_REGISTRY)
+                            .name("registry")
+                    )
+                    .returnType(builderTypeName, "a new builder");
+            typeArguments.forEach(builder::addGenericArgument);
+            builder.addContent(builderTypeName.genericTypeName());
+
+            if (!typeArguments.isEmpty()) {
+                builder.addContent("<");
+                builder.addContent(typeArguments.stream()
+                                           .map(TypeArgument::className)
+                                           .collect(Collectors.joining(", ")));
+                builder.addContent(">");
+            }
+
+            builder.addContent(" builder = new ")
+                    .addContent(ifaceName)
+                    .addContent(".Builder");
+
+            if (typeArguments.isEmpty()) {
+                builder.addContentLine("();");
+            } else {
+                builder.addContentLine("<>();");
+            }
+
+            // and configure the service registry, and load all @Option.RegistryService fields
+            if (properties.stream()
+                    .anyMatch(PrototypeProperty::registryService)) {
+                builder.addContentLine("");
+                builder.addContentLine("builder.serviceRegistry(registry);");
+                // now for each option that has registry, add initialization
+                for (PrototypeProperty property : properties) {
+                    if (property.registryService()) {
+                        // depends on type - Optional, List, Direct (supplier?)
+                        TypeHandler typeHandler = property.typeHandler();
+                        typeHandler.updateBuilderFromRegistry(builder, "builder", "registry");
+                    }
+                }
+                builder.addContentLine("");
+            }
+            builder.addContentLine("return builder;");
+        });
+    }
     private static void addBuilderMethod(ClassModel.Builder classModel,
                                          TypeName builderTypeName,
                                          List<TypeArgument> typeArguments,
-                                         String ifaceName) {
+                                         String ifaceName,
+                                         List<PrototypeProperty> properties) {
         classModel.addMethod(builder -> {
             builder.isStatic(true)
                     .name("builder")
                     .description("Create a new fluent API builder to customize configuration.")
                     .returnType(builderTypeName, "a new builder");
             typeArguments.forEach(builder::addGenericArgument);
+            builder.addContent(builderTypeName.genericTypeName());
+
+            if (!typeArguments.isEmpty()) {
+                builder.addContent("<");
+                builder.addContent(typeArguments.stream()
+                                           .map(TypeArgument::className)
+                                           .collect(Collectors.joining(", ")));
+                builder.addContent(">");
+            }
+
+            builder.addContent(" builder = new ")
+                    .addContent(ifaceName)
+                    .addContent(".Builder");
+
             if (typeArguments.isEmpty()) {
-                builder.addContentLine("return new " + ifaceName + ".Builder();");
+                builder.addContentLine("();");
             } else {
-                builder.addContentLine("return new " + ifaceName + ".Builder<>();");
+                builder.addContentLine("<>();");
             }
+
+            // and configure the service registry, and load all @Option.RegistryService fields
+            if (properties.stream()
+                    .anyMatch(PrototypeProperty::registryService)) {
+                builder.addContentLine("");
+                // now for each option that has registry, add initialization
+                for (PrototypeProperty property : properties) {
+                    if (property.registryService()) {
+                        // depends on type - Optional, List, Direct (supplier?)
+                        TypeHandler typeHandler = property.typeHandler();
+                        typeHandler.updateBuilderFromServices(builder, "builder");
+                    }
+                }
+                builder.addContentLine("");
+            }
+
+            builder.addContentLine("return builder;");
         });
     }
 
@@ -398,11 +484,19 @@ private void process(RoundContext roundContext, TypeInfo blueprint) {
                 .build();
 
         // static Builder builder()
-        addBuilderMethod(classModel, builderTypeName, typeArguments, ifaceName);
+        addBuilderMethod(classModel, builderTypeName, typeArguments, ifaceName, typeContext.propertyData().properties());
 
         // static Builder builder(T instance)
         addCopyBuilderMethod(classModel, builderTypeName, prototype, typeArguments, ifaceName, typeArgumentString);
 
+        if (typeContext.typeInfo().supportsServiceRegistry()) {
+            addRegistryBuilderMethod(classModel,
+                                     builderTypeName,
+                                     typeArguments,
+                                     ifaceName,
+                                     typeContext.propertyData().properties());
+        }
+
         // static T create(Config config)
         addCreateFromConfigMethod(blueprintDef,
                                   configuredData,
@@ -438,7 +532,7 @@ private void process(RoundContext roundContext, TypeInfo blueprint) {
                                       blueprint.typeName(),
                                       blueprint.originatingElementValue());
 
-        if (typeContext.typeInfo().supportsServiceRegistry() && typeContext.propertyData().hasProvider()) {
+        if (typeContext.typeInfo().supportsServiceRegistry()) {
             for (PrototypeProperty property : typeContext.propertyData().properties()) {
                 if (property.configuredOption().provider()) {
                     this.serviceLoaderContracts.add(property.configuredOption().providerType().genericTypeName().fqName());
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
index 4da0d457c6f..dc6c215dbf3 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
@@ -222,7 +222,7 @@ private static void builderMethods(InnerClass.Builder classBuilder, TypeContext
 
         TypeName returnType = TypeName.createFromGenericDeclaration("BUILDER");
 
-        if (typeContext.propertyData().hasProvider() && typeContext.typeInfo().supportsServiceRegistry()) {
+        if (typeContext.typeInfo().supportsServiceRegistry()) {
             // generate setter for service registry
             serviceRegistrySetter(classBuilder);
         }
@@ -513,9 +513,7 @@ private static void fields(InnerClass.Builder classBuilder, TypeContext typeCont
         if (isBuilder && (typeContext.configuredData().configured() || hasConfig(typeContext.propertyData().properties()))) {
             classBuilder.addField(builder -> builder.type(Types.COMMON_CONFIG).name("config"));
         }
-        if (isBuilder
-                && typeContext.typeInfo().supportsServiceRegistry()
-                && typeContext.propertyData().hasProvider()) {
+        if (isBuilder && typeContext.typeInfo().supportsServiceRegistry()) {
             classBuilder.addField(builder -> builder.type(Types.SERVICE_REGISTRY).name("serviceRegistry"));
         }
         for (PrototypeProperty child : typeContext.propertyData().properties()) {
@@ -689,7 +687,7 @@ private static void serviceRegistryPropertyDiscovery(Method.Builder preBuildBuil
                 preBuildBuilder.addContent("this.add")
                         .addContent(capitalize(property.name()))
                         .addContent("(")
-                        .addContent(Types.GENERATED_SERVICE)
+                        .addContent(Types.REGISTRY_SUPPORT)
                         .addContentLine(".discoverServices(config,")
                         .increaseContentPadding()
                         .increaseContentPadding()
@@ -711,7 +709,7 @@ private static void serviceRegistryPropertyDiscovery(Method.Builder preBuildBuil
                         .decreaseContentPadding();
             } else {
                 preBuildBuilder
-                        .addContent(Types.GENERATED_SERVICE)
+                        .addContent(Types.REGISTRY_SUPPORT)
                         .addContentLine(".discoverService(config,")
                         .increaseContentPadding()
                         .increaseContentPadding()
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/PrototypeProperty.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/PrototypeProperty.java
index 2488dea8a4c..9e4631a24b6 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/PrototypeProperty.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/PrototypeProperty.java
@@ -39,7 +39,8 @@ record PrototypeProperty(MethodSignature signature,
                          FactoryMethods factoryMethods,
                          boolean equality, // part of equals and hash code
                          boolean toStringValue, // part of toString
-                         boolean confidential // if part of toString, do not print the actual value
+                         boolean confidential, // if part of toString, do not print the actual value,
+                         boolean registryService
 ) {
     // cannot be identifiers - such as field name or method name
     private static final Set<String> RESERVED_WORDS = Set.of(
@@ -101,6 +102,7 @@ static PrototypeProperty create(CodegenContext ctx,
         boolean equality = !redundantAnnotation.flatMap(it -> it.getValue("equality"))
                 .map(Boolean::parseBoolean)
                 .orElse(false);
+        boolean registryService = element.hasAnnotation(Types.OPTION_REGISTRY_SERVICE);
 
         return new PrototypeProperty(
                 MethodSignature.create(element),
@@ -109,7 +111,8 @@ static PrototypeProperty create(CodegenContext ctx,
                 factoryMethods,
                 equality,
                 toStringValue,
-                confidential
+                confidential,
+                registryService
         );
     }
 
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeContext.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeContext.java
index 12b74b32555..13a8614340f 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeContext.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeContext.java
@@ -203,9 +203,21 @@ static TypeContext create(CodegenContext ctx, TypeInfo blueprint) {
                 .className("Builder")
                 .build();
 
+        /*
+        Service registry is supported if it is explicitly configured && a provider exists,
+        or there is an option annotated with @Option.RegistryService
+         */
         boolean supportsServiceRegistry = blueprint.findAnnotation(Types.PROTOTYPE_SERVICE_REGISTRY)
                 .flatMap(Annotation::booleanValue)
-                .orElse(false);
+                .orElse(false)
+                && blueprint.elementInfo()
+                .stream()
+                .filter(ElementInfoPredicates::isMethod)
+                .anyMatch(ElementInfoPredicates.hasAnnotation(Types.OPTION_PROVIDER));
+        supportsServiceRegistry |= blueprint.elementInfo()
+                        .stream()
+                        .filter(ElementInfoPredicates::isMethod)
+                        .anyMatch(ElementInfoPredicates.hasAnnotation(Types.OPTION_REGISTRY_SERVICE));
 
         TypeInformation typeInformation = new TypeInformation(supportsServiceRegistry,
                                                               blueprint,
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandler.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandler.java
index c67e0d0ef6f..e8f7643acd0 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandler.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandler.java
@@ -41,6 +41,7 @@
 import io.helidon.common.types.TypedElementInfo;
 
 import static io.helidon.builder.codegen.Types.OPTION_DEFAULT;
+import static io.helidon.builder.codegen.Types.SERVICES;
 import static io.helidon.common.types.TypeNames.BOXED_BOOLEAN;
 import static io.helidon.common.types.TypeNames.BOXED_BYTE;
 import static io.helidon.common.types.TypeNames.BOXED_CHAR;
@@ -164,6 +165,34 @@ public String toString() {
         return declaredType.fqName() + " " + name;
     }
 
+    void updateBuilderFromServices(ContentBuilder<?> content, String builder) {
+        /*
+        Services.first(Type.class).ifPresent(builder::option);
+         */
+        content.addContent(SERVICES)
+                .addContent(".first(")
+                .addContent(actualType())
+                .addContent(".class).ifPresent(")
+                .addContent(builder)
+                .addContent("::")
+                .addContent(setterName())
+                .addContentLine(");");
+    }
+
+    void updateBuilderFromRegistry(ContentBuilder<?> content, String builder, String registry) {
+        /*
+        registry.first(Type.class).ifPresent(builder::option);
+         */
+        content.addContent(registry)
+                .addContent(".first(")
+                .addContent(actualType())
+                .addContent(".class).ifPresent(")
+                .addContent(builder)
+                .addContent("::")
+                .addContent(setterName())
+                .addContentLine(");");
+    }
+
     TypeName builderGetterType(boolean required, boolean hasDefault) {
         if (builderGetterOptional(required, hasDefault)) {
             if (declaredType().isOptional()) {
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerList.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerList.java
index 3f6273d9d9b..e1c3190021f 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerList.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerList.java
@@ -19,10 +19,12 @@
 import java.util.Optional;
 
 import io.helidon.codegen.CodegenUtil;
+import io.helidon.codegen.classmodel.ContentBuilder;
 import io.helidon.codegen.classmodel.Method;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypedElementInfo;
 
+import static io.helidon.builder.codegen.Types.SERVICES;
 import static io.helidon.common.types.TypeNames.LIST;
 
 class TypeHandlerList extends TypeHandlerCollection {
@@ -47,6 +49,36 @@ Method.Builder extraSetterContent(Method.Builder builder) {
         return builder.addContentLine(isMutatedField() + " = true;");
     }
 
+    @Override
+    void updateBuilderFromServices(ContentBuilder<?> content, String builder) {
+        /*
+        builder.option(Services.all(Type.class));
+         */
+        content.addContent(builder)
+                .addContent(".")
+                .addContent(setterName())
+                .addContent("(")
+                .addContent(SERVICES)
+                .addContent(".all(")
+                .addContent(actualType())
+                .addContentLine(".class));");
+    }
+
+    @Override
+    void updateBuilderFromRegistry(ContentBuilder<?> content, String builder, String registry) {
+        /*
+        builder.option(registry.all(Type.class));
+         */
+        content.addContent(builder)
+                .addContent(".")
+                .addContent(setterName())
+                .addContent("(")
+                .addContent(registry)
+                .addContent(".all(")
+                .addContent(actualType())
+                .addContentLine(".class));");
+    }
+
     private String isMutatedField() {
         return isMutatedField(name());
     }
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerSet.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerSet.java
index 20a68b5a7bf..32187796ff8 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerSet.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerSet.java
@@ -18,9 +18,12 @@
 
 import java.util.Optional;
 
+import io.helidon.codegen.classmodel.ContentBuilder;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypedElementInfo;
 
+import static io.helidon.builder.codegen.Types.LINKED_HASH_SET;
+import static io.helidon.builder.codegen.Types.SERVICES;
 import static io.helidon.common.types.TypeNames.SET;
 
 class TypeHandlerSet extends TypeHandlerCollection {
@@ -38,4 +41,38 @@ class TypeHandlerSet extends TypeHandlerCollection {
               "collect(java.util.stream.Collectors.toSet())",
               Optional.of(".map(java.util.Set::copyOf)"));
     }
+
+    @Override
+    void updateBuilderFromServices(ContentBuilder<?> content, String builder) {
+        /*
+        builder.option(new LinkedHashSet(Services.all(Type.class)));
+         */
+        content.addContent(builder)
+                .addContent(".")
+                .addContent(setterName())
+                .addContent("(new ")
+                .addContent(LINKED_HASH_SET)
+                .addContent("(")
+                .addContent(SERVICES)
+                .addContent(".all(")
+                .addContent(actualType())
+                .addContentLine(".class)));");
+    }
+
+    @Override
+    void updateBuilderFromRegistry(ContentBuilder<?> content, String builder, String registry) {
+        /*
+        builder.option(new LinkedHashSet(registry.all(Type.class)));
+         */
+        content.addContent(builder)
+                .addContent(".")
+                .addContent(setterName())
+                .addContent("(new ")
+                .addContent(LINKED_HASH_SET)
+                .addContent("(")
+                .addContent(registry)
+                .addContent(".all(")
+                .addContent(actualType())
+                .addContentLine(".class)));");
+    }
 }
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
index 2b7b56131ca..f7b05bb3701 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
@@ -36,7 +36,8 @@ final class Types {
     static final TypeName URI = TypeName.create(java.net.URI.class);
     static final TypeName SERVICE_REGISTRY = TypeName.create("io.helidon.service.registry.ServiceRegistry");
     static final TypeName GLOBAL_SERVICE_REGISTRY = TypeName.create("io.helidon.service.registry.GlobalServiceRegistry");
-    static final TypeName GENERATED_SERVICE = TypeName.create("io.helidon.service.registry.GeneratedService");
+    static final TypeName SERVICES = TypeName.create("io.helidon.service.registry.Services");
+    static final TypeName REGISTRY_SUPPORT = TypeName.create("io.helidon.service.builder.BuilderRegistrySupport");
 
     static final TypeName BUILDER_DESCRIPTION = TypeName.create("io.helidon.builder.api.Description");
 
@@ -72,6 +73,7 @@ final class Types {
     static final TypeName OPTION_PROVIDER = TypeName.create("io.helidon.builder.api.Option.Provider");
     static final TypeName OPTION_ALLOWED_VALUES = TypeName.create("io.helidon.builder.api.Option.AllowedValues");
     static final TypeName OPTION_ALLOWED_VALUE = TypeName.create("io.helidon.builder.api.Option.AllowedValue");
+    static final TypeName OPTION_REGISTRY_SERVICE = TypeName.create("io.helidon.builder.api.Option.RegistryService");
     static final TypeName OPTION_DEFAULT = TypeName.create("io.helidon.builder.api.Option.Default");
     static final TypeName OPTION_DEFAULT_INT = TypeName.create("io.helidon.builder.api.Option.DefaultInt");
     static final TypeName OPTION_DEFAULT_DOUBLE = TypeName.create("io.helidon.builder.api.Option.DefaultDouble");
diff --git a/builder/codegen/src/main/java/module-info.java b/builder/codegen/src/main/java/module-info.java
index daf59b4212a..03028027941 100644
--- a/builder/codegen/src/main/java/module-info.java
+++ b/builder/codegen/src/main/java/module-info.java
@@ -23,6 +23,7 @@
     requires io.helidon.common.types;
     requires io.helidon.codegen;
     requires io.helidon.codegen.classmodel;
+    requires java.desktop;
 
     exports io.helidon.builder.codegen;
 
diff --git a/builder/tests/builder/pom.xml b/builder/tests/builder/pom.xml
index e60957cd550..bb670f36128 100644
--- a/builder/tests/builder/pom.xml
+++ b/builder/tests/builder/pom.xml
@@ -39,6 +39,10 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-builder</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
diff --git a/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java b/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
index 37d6a35c534..48566e93919 100644
--- a/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
+++ b/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
@@ -18,9 +18,11 @@
 
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
+import io.helidon.common.mapper.MapperManager;
 
 @Prototype.Blueprint
 @Prototype.Configured
@@ -68,4 +70,16 @@ interface WithProviderRegistryBlueprint {
     @Option.Configured
     @Option.Provider(value = ProviderNoImpls.class, discoverServices = false)
     List<ProviderNoImpls.SomeService> listNoImplNotDiscover();
+
+    @Option.RegistryService
+    Optional<MapperManager> mapperManager();
+
+    @Option.RegistryService
+    MapperManager mapperManagerExplicit();
+
+    @Option.RegistryService
+    List<MapperManager> mapperManagers();
+
+    @Option.RegistryService
+    Set<MapperManager> mapperManagerSet();
 }
diff --git a/builder/tests/builder/src/main/java/module-info.java b/builder/tests/builder/src/main/java/module-info.java
index f1db16c08c2..9706e29f293 100644
--- a/builder/tests/builder/src/main/java/module-info.java
+++ b/builder/tests/builder/src/main/java/module-info.java
@@ -25,6 +25,7 @@
     requires io.helidon.common.config;
     requires io.helidon.builder.api;
     requires io.helidon.service.registry;
+    requires io.helidon.service.builder;
 
     exports io.helidon.builder.test.testsubjects;
 
diff --git a/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java b/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
index 186bb4da369..86055fb26a4 100644
--- a/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
+++ b/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
@@ -21,6 +21,7 @@
 import io.helidon.builder.test.testsubjects.SomeProvider;
 import io.helidon.builder.test.testsubjects.WithProviderRegistry;
 import io.helidon.common.Errors;
+import io.helidon.common.mapper.MapperManager;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 
@@ -48,7 +49,10 @@ void testMinimalDefined() {
         /*
         Only the property that does not discover services and does not return optional is defined in config
          */
-        WithProviderRegistry value = WithProviderRegistry.create(config.get("min-defined"));
+        WithProviderRegistry value = WithProviderRegistry.builder()
+                .config(config.get("min-defined"))
+                .mapperManagerExplicit(MapperManager.global())
+                .build();
 
         assertThat(value.oneDiscover().prop(), is("some-1"));
         assertThat(value.oneNotDiscover().prop(), is("config"));
@@ -73,7 +77,10 @@ void testAllDefined() {
         /*
         Everything is customized
          */
-        WithProviderRegistry value = WithProviderRegistry.create(config.get("all-defined"));
+        WithProviderRegistry value = WithProviderRegistry.builder()
+                .config(config.get("all-defined"))
+                .mapperManagerExplicit(MapperManager.global())
+                .build();
 
         assertThat(value.oneDiscover().prop(), is("config"));
         assertThat(value.oneNotDiscover().prop(), is("config"));
@@ -98,7 +105,10 @@ void testFail() {
         Missing the one mandatory option in config
          */
         Errors.ErrorMessagesException fail = assertThrows(Errors.ErrorMessagesException.class,
-                                                          () -> WithProviderRegistry.create(config.get("fail")));
+                                                          () -> WithProviderRegistry.builder()
+                                                                  .config(config.get("fail"))
+                                                                  .mapperManagerExplicit(MapperManager.global())
+                                                                  .build());
 
         assertThat(fail.getMessages(), hasSize(1));
         assertThat(fail.getMessage(), containsString("\"one-not-discover\" must not be null"));
@@ -110,7 +120,10 @@ void testSingleList() {
         Single value list (when not using discovery). When discovery is used, all in service loader are discovered, even
         if not configured
          */
-        WithProviderRegistry value = WithProviderRegistry.create(config.get("single-list"));
+        WithProviderRegistry value = WithProviderRegistry.builder()
+                .config(config.get("single-list"))
+                .mapperManagerExplicit(MapperManager.global())
+                .build();
 
         assertThat(value.oneNotDiscover().prop(), is("config2"));
 
@@ -130,6 +143,7 @@ void testDisabledDiscoveryOnTheCopy() {
         WithProviderRegistry value = WithProviderRegistry.builder()
                 .listDiscoverDiscoverServices(false)
                 .oneNotDiscover(someService) //This needs to be set, otherwise validation fails
+                .mapperManagerExplicit(MapperManager.global())
                 .build();
         assertThat(value.listDiscover(), is(List.of()));
 
@@ -144,6 +158,7 @@ void testDisabledDiscoveryOnTheCopiedBuilder() {
         SomeProvider.SomeService someService = new DummyService();
         WithProviderRegistry.Builder value = WithProviderRegistry.builder()
                 .listDiscoverDiscoverServices(false)
+                .mapperManagerExplicit(MapperManager.global())
                 .oneNotDiscover(someService);
 
         WithProviderRegistry copy = WithProviderRegistry.builder()
diff --git a/builder/tests/codegen/pom.xml b/builder/tests/codegen/pom.xml
index 56aae2c3df5..18d8e34e44e 100644
--- a/builder/tests/codegen/pom.xml
+++ b/builder/tests/codegen/pom.xml
@@ -48,6 +48,11 @@
             <artifactId>helidon-service-registry</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-builder</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>io.helidon.builder</groupId>
             <artifactId>helidon-builder-api</artifactId>
diff --git a/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java b/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
index a2cc8559586..5641ddd9bfb 100644
--- a/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
+++ b/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
@@ -36,9 +36,10 @@
 import io.helidon.common.Generated;
 import io.helidon.common.config.Config;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.GeneratedService;
+import io.helidon.service.builder.BuilderRegistrySupport;
 import io.helidon.service.registry.GlobalServiceRegistry;
 import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.Services;
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.collection.IsEmptyCollection;
@@ -90,7 +91,6 @@ void testTypes() {
         checkField(toCheck, checked, fields, "URI", URI.class);
         checkField(toCheck, checked, fields, "SERVICE_REGISTRY", ServiceRegistry.class);
         checkField(toCheck, checked, fields, "GLOBAL_SERVICE_REGISTRY", GlobalServiceRegistry.class);
-        checkField(toCheck, checked, fields, "GENERATED_SERVICE", GeneratedService.class);
         checkField(toCheck, checked, fields, "BUILDER_DESCRIPTION", Description.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_BLUEPRINT", Prototype.Blueprint.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_IMPLEMENT", Prototype.Implement.class);
@@ -132,6 +132,10 @@ void testTypes() {
         checkField(toCheck, checked, fields, "OPTION_DEPRECATED", Option.Deprecated.class);
         checkField(toCheck, checked, fields, "OPTION_TYPE", Option.Type.class);
         checkField(toCheck, checked, fields, "OPTION_DECORATOR", Option.Decorator.class);
+        checkField(toCheck, checked, fields, "OPTION_REGISTRY_SERVICE", Option.RegistryService.class);
+
+        checkField(toCheck, checked, fields, "REGISTRY_SUPPORT", BuilderRegistrySupport.class);
+        checkField(toCheck, checked, fields, "SERVICES", Services.class);
 
         assertThat(toCheck, IsEmptyCollection.empty());
     }
diff --git a/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java b/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
index d31e4280839..5bc557b3dfd 100644
--- a/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
+++ b/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
@@ -100,6 +100,19 @@ public static <T> Builder<T> builder(ServiceLoader<T> serviceLoader) {
         return new Builder<>(serviceLoader);
     }
 
+    /**
+     * A shortcut method to create a service loader based on the provider interface directly.
+     *
+     * @param theProviderInterface provider interface
+     * @return service loader
+     * @param <T> type of the service
+     */
+    public static <T> HelidonServiceLoader<T> create(Class<T> theProviderInterface) {
+        HelidonServiceLoader.class.getModule()
+                .addUses(theProviderInterface);
+        return create(ServiceLoader.load(theProviderInterface));
+    }
+
     /**
      * Create a weighted service loader from a Java Service loader.
      *
diff --git a/common/common/src/main/java/io/helidon/common/LruCache.java b/common/common/src/main/java/io/helidon/common/LruCache.java
new file mode 100644
index 00000000000..d1c3da6bf65
--- /dev/null
+++ b/common/common/src/main/java/io/helidon/common/LruCache.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.helidon.common;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+/**
+ * Least recently used cache.
+ * This cache has a capacity. When the capacity is reached, the oldest record is removed from the cache when a new one
+ * is added.
+ *
+ * @param <K> type of the keys of the map
+ * @param <V> type of the values of the map
+ */
+public interface LruCache<K, V> {
+    /**
+     * Default capacity of the cache: {@value}.
+     */
+    int DEFAULT_CAPACITY = 10000;
+
+    /**
+     * Create an instance with default capacity.
+     *
+     * @param <K> key type
+     * @param <V> value type
+     * @return a new cache instance
+     * @see #DEFAULT_CAPACITY
+     */
+    static <K, V> LruCache<K, V> create() {
+        return new LruCacheImpl<>(DEFAULT_CAPACITY);
+    }
+
+    /**
+     * Create an instance with custom capacity.
+     *
+     * @param capacity of the cache
+     * @param <K>      key type
+     * @param <V>      value type
+     * @return a new cache instance
+     */
+    static <K, V> LruCache<K, V> create(int capacity) {
+        return new LruCacheImpl<>(capacity);
+    }
+
+    /**
+     * Get a value from the cache.
+     *
+     * @param key key to retrieve
+     * @return value if present or empty
+     */
+    Optional<V> get(K key);
+
+    /**
+     * Remove a value from the cache.
+     *
+     * @param key key of the record to remove
+     * @return the value that was mapped to the key, or empty if none was
+     */
+    Optional<V> remove(K key);
+
+    /**
+     * Put a value to the cache.
+     *
+     * @param key   key to add
+     * @param value value to add
+     * @return value that was already mapped or empty if the value was not mapped
+     */
+    Optional<V> put(K key, V value);
+
+    /**
+     * Either return a cached value or compute it and cache it.
+     * In case this method is called in parallel for the same key, the value actually present in the map may be from
+     * any of the calls.
+     * This method always returns either the existing value from the map, or the value provided by the supplier. It
+     * never returns a result from another thread's supplier.
+     *
+     * @param key           key to check/insert value for
+     * @param valueSupplier supplier called if the value is not yet cached, or is invalid
+     * @return current value from the cache, or computed value from the supplier
+     */
+    Optional<V> computeValue(K key, Supplier<Optional<V>> valueSupplier);
+
+    /**
+     * Current size of the map.
+     *
+     * @return number of records currently cached
+     */
+    int size();
+
+    /**
+     * Capacity of this cache.
+     *
+     * @return configured capacity of this cache
+     */
+    int capacity();
+
+    /**
+     * Clear all records in the cache.
+     */
+    void clear();
+}
diff --git a/common/common/src/main/java/io/helidon/common/LruCacheImpl.java b/common/common/src/main/java/io/helidon/common/LruCacheImpl.java
new file mode 100644
index 00000000000..7b174bd2448
--- /dev/null
+++ b/common/common/src/main/java/io/helidon/common/LruCacheImpl.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.helidon.common;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Optional;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+
+/**
+ * Least recently used cache.
+ * This cache has a capacity. When the capacity is reached, the oldest record is removed from the cache when a new one
+ * is added.
+ *
+ * @param <K> type of the keys of the map
+ * @param <V> type of the values of the map
+ */
+final class LruCacheImpl<K, V> implements LruCache<K, V> {
+    private final LinkedHashMap<K, V> backingMap = new LinkedHashMap<>();
+    private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
+    private final Lock readLock = rwLock.readLock();
+    private final Lock writeLock = rwLock.writeLock();
+
+    private final int capacity;
+
+    LruCacheImpl(int capacity) {
+        this.capacity = capacity;
+    }
+
+    @Override
+    public Optional<V> get(K key) {
+        readLock.lock();
+
+        V value;
+        try {
+            value = backingMap.get(key);
+        } finally {
+            readLock.unlock();
+        }
+
+        if (null == value) {
+            return Optional.empty();
+        }
+
+        writeLock.lock();
+        try {
+            // make sure the value is the last in the map (I do ignore a race here, as it is not significant)
+            // if some other thread moved another record to the front, we just move ours before it
+
+            // TODO this hurts - we just need to move the key to the last position
+            // maybe this should be replaced with a list and a map?
+            value = backingMap.get(key);
+            if (null == value) {
+                return Optional.empty();
+            }
+            backingMap.remove(key);
+            backingMap.put(key, value);
+
+            return Optional.of(value);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public Optional<V> remove(K key) {
+
+        writeLock.lock();
+        try {
+            return Optional.ofNullable(backingMap.remove(key));
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public Optional<V> put(K key, V value) {
+        writeLock.lock();
+        try {
+            V currentValue = backingMap.remove(key);
+            if (null == currentValue) {
+                // need to free space - we did not make the map smaller
+                if (backingMap.size() >= capacity) {
+                    Iterator<V> iterator = backingMap.values().iterator();
+                    iterator.next();
+                    iterator.remove();
+                }
+            }
+
+            backingMap.put(key, value);
+            return Optional.ofNullable(currentValue);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public Optional<V> computeValue(K key, Supplier<Optional<V>> valueSupplier) {
+        // get is properly synchronized
+        Optional<V> currentValue = get(key);
+        if (currentValue.isPresent()) {
+            return currentValue;
+        }
+        Optional<V> newValue = valueSupplier.get();
+        // put is also properly synchronized - nevertheless we may replace the value more then once
+        // if called from parallel threads
+        newValue.ifPresent(theValue -> put(key, theValue));
+
+        return newValue;
+    }
+
+    @Override
+    public int size() {
+        readLock.lock();
+        try {
+            return backingMap.size();
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    @Override
+    public int capacity() {
+        return capacity;
+    }
+
+    @Override
+    public void clear() {
+        writeLock.lock();
+        try {
+            backingMap.clear();
+        } finally {
+            writeLock.unlock();
+        }
+    }
+}
diff --git a/common/common/src/test/java/io/helidon/common/LruCacheTest.java b/common/common/src/test/java/io/helidon/common/LruCacheTest.java
new file mode 100644
index 00000000000..d8fac97efa2
--- /dev/null
+++ b/common/common/src/test/java/io/helidon/common/LruCacheTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2019, 2023 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.common;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * Unit test for {@link io.helidon.common.LruCache}.
+ */
+class LruCacheTest {
+    @Test
+    void testCache() {
+        LruCache<String, String> theCache = LruCache.create();
+        String value = "cached";
+        String key = "theKey";
+        String newValue = "not-cached";
+
+        Optional<String> res = theCache.put(key, value);
+        assertThat(res, is(Optional.empty()));
+        res = theCache.get(key);
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.computeValue(key, () -> Optional.of(newValue));
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.remove(key);
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.get(key);
+        assertThat(res, is(Optional.empty()));
+    }
+
+    @Test
+    void testCacheComputeValue() {
+        LruCache<String, String> theCache = LruCache.create();
+        String value = "cached";
+        String key = "theKey";
+        String newValue = "not-cached";
+
+        Optional<String> res = theCache.computeValue(key, () -> Optional.of(value));
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.get(key);
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.computeValue(key, () -> Optional.of(newValue));
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.remove(key);
+        assertThat(res, is(Optional.of(value)));
+        res = theCache.get(key);
+        assertThat(res, is(Optional.empty()));
+    }
+
+    @Test
+    void testMaxCapacity() {
+        LruCache<Integer, Integer> theCache = LruCache.create(10);
+        for (int i = 0; i < 10; i++) {
+            theCache.put(i, i);
+        }
+        for (int i = 0; i < 10; i++) {
+            Optional<Integer> integer = theCache.get(i);
+            assertThat(integer, is(Optional.of(i)));
+        }
+        theCache.put(10, 10);
+        Optional<Integer> res = theCache.get(0);
+        assertThat(res, is(Optional.empty()));
+        res = theCache.get(10);
+        assertThat(res, is(Optional.of(10)));
+    }
+
+    @Test
+    void testLruBehavior() {
+        LruCache<Integer, Integer> theCache = LruCache.create(10);
+        for (int i = 0; i < 10; i++) {
+            // insert all
+            theCache.put(i, i);
+        }
+        for (int i = 0; i < 10; i++) {
+            // use them in ascending order
+            Optional<Integer> integer = theCache.get(i);
+            assertThat(integer, is(Optional.of(i)));
+        }
+        // now use 0
+        Optional<Integer> value = theCache.get(0);
+        assertThat(value, is(Optional.of(0)));
+
+        theCache.put(10, 10);
+
+        // 0 should be in
+        value = theCache.get(0);
+        assertThat(value, is(Optional.of(0)));
+
+        // 1 should not
+        value = theCache.get(1);
+        assertThat(value, is(Optional.empty()));
+
+    }
+}
diff --git a/common/configurable/src/main/java/io/helidon/common/configurable/LruCache.java b/common/configurable/src/main/java/io/helidon/common/configurable/LruCache.java
index d57f72f7bae..317ddd2c982 100644
--- a/common/configurable/src/main/java/io/helidon/common/configurable/LruCache.java
+++ b/common/configurable/src/main/java/io/helidon/common/configurable/LruCache.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,12 +15,7 @@
  */
 package io.helidon.common.configurable;
 
-import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.Optional;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
@@ -33,24 +28,17 @@
  *
  * @param <K> type of the keys of the map
  * @param <V> type of the values of the map
+ * @deprecated kindly use {@link io.helidon.common.LruCache}, we are removing this from the configurable module, as cache has
+ *         only a single option, and we need it from modules that do not use configuration
  */
 @RuntimeType.PrototypedBy(LruCacheConfig.class)
-public final class LruCache<K, V> implements RuntimeType.Api<LruCacheConfig<K, V>> {
-    /**
-     * Default capacity of the cache: {@value}.
-     */
-    public static final int DEFAULT_CAPACITY = 10000;
-
-    private final LinkedHashMap<K, V> backingMap = new LinkedHashMap<>();
-    private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
-    private final Lock readLock = rwLock.readLock();
-    private final Lock writeLock = rwLock.writeLock();
-
-    private final int capacity;
+@Deprecated(forRemoval = true, since = "4.2.0")
+public final class LruCache<K, V> implements io.helidon.common.LruCache<K, V>, RuntimeType.Api<LruCacheConfig<K, V>> {
     private final LruCacheConfig<K, V> config;
+    private final io.helidon.common.LruCache<K, V> delegate;
 
     private LruCache(LruCacheConfig<K, V> config) {
-        this.capacity = config.capacity();
+        this.delegate = io.helidon.common.LruCache.create(config.capacity());
         this.config = config;
     }
 
@@ -81,9 +69,9 @@ public static <K, V> LruCache<K, V> create() {
      * Create an instance with custom configuration.
      *
      * @param config configuration of LRU cache
+     * @param <K>    key type
+     * @param <V>    value type
      * @return a new cache instance
-     * @param <K> key type
-     * @param <V> value type
      */
     public static <K, V> LruCache<K, V> create(LruCacheConfig<K, V> config) {
         return new LruCache<>(config);
@@ -93,9 +81,9 @@ public static <K, V> LruCache<K, V> create(LruCacheConfig<K, V> config) {
      * Create an instance with custom configuration.
      *
      * @param consumer of custom configuration builder
+     * @param <K>      key type
+     * @param <V>      value type
      * @return a new cache instance
-     * @param <K> key type
-     * @param <V> value type
      */
     public static <K, V> LruCache<K, V> create(Consumer<LruCacheConfig.Builder<K, V>> consumer) {
         LruCacheConfig.Builder<K, V> builder = LruCacheConfig.builder();
@@ -108,151 +96,38 @@ public LruCacheConfig<K, V> prototype() {
         return config;
     }
 
-    /**
-     * Get a value from the cache.
-     *
-     * @param key key to retrieve
-     * @return value if present or empty
-     */
+    @Override
     public Optional<V> get(K key) {
-        readLock.lock();
-
-        V value;
-        try {
-            value = backingMap.get(key);
-        } finally {
-            readLock.unlock();
-        }
-
-        if (null == value) {
-            return Optional.empty();
-        }
-
-        writeLock.lock();
-        try {
-            // make sure the value is the last in the map (I do ignore a race here, as it is not significant)
-            // if some other thread moved another record to the front, we just move ours before it
-
-            // TODO this hurts - we just need to move the key to the last position
-            // maybe this should be replaced with a list and a map?
-            value = backingMap.get(key);
-            if (null == value) {
-                return Optional.empty();
-            }
-            backingMap.remove(key);
-            backingMap.put(key, value);
-
-            return Optional.of(value);
-        } finally {
-            writeLock.unlock();
-        }
+        return delegate.get(key);
     }
 
-    /**
-     * Remove a value from the cache.
-     *
-     * @param key key of the record to remove
-     * @return the value that was mapped to the key, or empty if none was
-     */
+    @Override
     public Optional<V> remove(K key) {
-
-        writeLock.lock();
-        try {
-            return Optional.ofNullable(backingMap.remove(key));
-        } finally {
-            writeLock.unlock();
-        }
+        return delegate.remove(key);
     }
 
-    /**
-     * Put a value to the cache.
-     *
-     * @param key   key to add
-     * @param value value to add
-     * @return value that was already mapped or empty if the value was not mapped
-     */
+    @Override
     public Optional<V> put(K key, V value) {
-        writeLock.lock();
-        try {
-            V currentValue = backingMap.remove(key);
-            if (null == currentValue) {
-                // need to free space - we did not make the map smaller
-                if (backingMap.size() >= capacity) {
-                    Iterator<V> iterator = backingMap.values().iterator();
-                    iterator.next();
-                    iterator.remove();
-                }
-            }
-
-            backingMap.put(key, value);
-            return Optional.ofNullable(currentValue);
-        } finally {
-            writeLock.unlock();
-        }
+        return delegate.put(key, value);
     }
 
-    /**
-     * Either return a cached value or compute it and cache it.
-     * In case this method is called in parallel for the same key, the value actually present in the map may be from
-     * any of the calls.
-     * This method always returns either the existing value from the map, or the value provided by the supplier. It
-     * never returns a result from another thread's supplier.
-     *
-     * @param key           key to check/insert value for
-     * @param valueSupplier supplier called if the value is not yet cached, or is invalid
-     * @return current value from the cache, or computed value from the supplier
-     */
+    @Override
     public Optional<V> computeValue(K key, Supplier<Optional<V>> valueSupplier) {
-        // get is properly synchronized
-        Optional<V> currentValue = get(key);
-        if (currentValue.isPresent()) {
-            return currentValue;
-        }
-        Optional<V> newValue = valueSupplier.get();
-        // put is also properly synchronized - nevertheless we may replace the value more then once
-        // if called from parallel threads
-        newValue.ifPresent(theValue -> put(key, theValue));
-
-        return newValue;
+        return delegate.computeValue(key, valueSupplier);
     }
 
-    /**
-     * Current size of the map.
-     *
-     * @return number of records currently cached
-     */
+    @Override
     public int size() {
-        readLock.lock();
-        try {
-            return backingMap.size();
-        } finally {
-            readLock.unlock();
-        }
+        return delegate.size();
     }
 
-    /**
-     * Capacity of this cache.
-     *
-     * @return configured capacity of this cache
-     */
+    @Override
     public int capacity() {
-        return capacity;
+        return delegate.capacity();
     }
 
-    /**
-     * Clear all records in the cache.
-     */
+    @Override
     public void clear() {
-        writeLock.lock();
-        try {
-            backingMap.clear();
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    // for unit testing
-    V directGet(K key) {
-        return backingMap.get(key);
+        delegate.clear();
     }
 }
diff --git a/common/types/src/test/java/io/helidon/common/types/TypeNameTest.java b/common/types/src/test/java/io/helidon/common/types/TypeNameTest.java
index 0f09f8bbe47..d79d2df914e 100644
--- a/common/types/src/test/java/io/helidon/common/types/TypeNameTest.java
+++ b/common/types/src/test/java/io/helidon/common/types/TypeNameTest.java
@@ -65,21 +65,21 @@ void testNested() {
     @Test
     void testGenericInnerType() {
         String resolved =
-                "io.helidon.service.inject.api.Injection.ScopeHandler<io.helidon.examples.inject.CustomScopeExample.MyScope>";
+                "io.helidon.service.registry.Service.ScopeHandler<io.helidon.examples.inject.CustomScopeExample.MyScope>";
 
         TypeName typeName = TypeName.builder()
-                .packageName("io.helidon.service.inject.api")
+                .packageName("io.helidon.service.registry")
                 .className("ScopeHandler")
-                .addEnclosingName("Injection")
+                .addEnclosingName("Service")
                 .addTypeArgument(TypeName.create("io.helidon.examples.inject.CustomScopeExample.MyScope"))
                 .build();
 
         assertThat(typeName.resolvedName(), is(resolved));
-        assertThat(typeName.fqName(), is("io.helidon.service.inject.api.Injection.ScopeHandler"));
+        assertThat(typeName.fqName(), is("io.helidon.service.registry.Service.ScopeHandler"));
 
         ResolvedType rt = ResolvedType.create(typeName);
         assertThat(rt.type().resolvedName(), is(resolved));
-        assertThat(rt.type().fqName(), is("io.helidon.service.inject.api.Injection.ScopeHandler"));
+        assertThat(rt.type().fqName(), is("io.helidon.service.registry.Service.ScopeHandler"));
     }
 
     @Test
diff --git a/docs/src/main/asciidoc/mp/guides/mp-tutorial.adoc b/docs/src/main/asciidoc/mp/guides/mp-tutorial.adoc
index e0b50df56fe..9f7671d911d 100644
--- a/docs/src/main/asciidoc/mp/guides/mp-tutorial.adoc
+++ b/docs/src/main/asciidoc/mp/guides/mp-tutorial.adoc
@@ -669,7 +669,7 @@ include::{sourcedir}/mp/guides/MpTutorialSnippets.java[tag=snippet_8, indent=0]
  link:{microprofile-health-spec-url}##_protocol_and_wireformat[MicroProfile Health Protocol and Wireformat] document.
 <2> This class also has the `ApplicationScoped` annotation, as seen previously.
 <3> The `GreetingProvider` is injected using Context and Dependency
- Injection.  This example will use the greeting to determine whether
+ Service.  This example will use the greeting to determine whether
  the application is healthy, this is a contrived example for demonstration
  purposes.
 <4> Health checks must implement the `HealthCheck` functional interface, which
diff --git a/docs/src/main/asciidoc/mp/scheduling.adoc b/docs/src/main/asciidoc/mp/scheduling.adoc
index a39486c5455..9507bc0c76c 100644
--- a/docs/src/main/asciidoc/mp/scheduling.adoc
+++ b/docs/src/main/asciidoc/mp/scheduling.adoc
@@ -148,7 +148,7 @@ include::{sourcedir}/mp/SchedulingSnippets.java[tag=snippet_6, indent=0]
 include::{sourcedir}/mp/SchedulingSnippets.java[tag=snippet_7, indent=0]
 ----
 
-=== Scheduled Metadata Injection.
+=== Scheduled Metadata Service.
 
 [source,java]
 .Example with invocation metadata
diff --git a/inject/api/README.md b/inject/api/README.md
index 9faed5242be..f11f1623d12 100644
--- a/inject/api/README.md
+++ b/inject/api/README.md
@@ -1,6 +1,6 @@
 This module contains all the API and SPI types that are applicable to a Helidon Injection based application.
 
-The API can logically be broken up into two categories - declarative types and imperative/programmatic types. The declarative form is the most common approach for using Injection.
+The API can logically be broken up into two categories - declarative types and imperative/programmatic types. The declarative form is the most common approach for using Service.
 
 The declarative API is small and based upon annotations. This is because most of the supporting annotation types actually come directly from both of the standard javax/jakarta inject and javax/jakarta annotation modules. These standard annotations are supplemented with these proprietary annotation types offered here from Injection:
 
@@ -72,7 +72,7 @@ public class BladeProvider implements InjectionPointProvider<AbstractBlade> {
 ```
 
 ## Injectable Constructs
-Any service can declare field, method, or constructor injection points. The only caveat is that these injectable elements must either be public or package private. Generally speaking, it is considered a best practice to (a) use only an injectable constructor, and (b) only inject <i>Provider</i> instances. Here is an example for best practice depicting all possible usages for injection types supported by Helidon Injection.
+Any service can declare field, method, or constructor injection points. The only caveat is that these injectable elements must either be public or package private. Generally speaking, it is considered a best practice to (a) use only an injectable constructor, and (b) only inject <i>Provider</i> instances. Here is an example for best practice depicting all possible usages for injection types supported by Helidon Service.
 
 ```java
 @Singleton
diff --git a/inject/api/src/main/java/io/helidon/inject/api/InjectionException.java b/inject/api/src/main/java/io/helidon/inject/api/InjectionException.java
index 7002ce91c59..cfe5388bddd 100644
--- a/inject/api/src/main/java/io/helidon/inject/api/InjectionException.java
+++ b/inject/api/src/main/java/io/helidon/inject/api/InjectionException.java
@@ -17,7 +17,7 @@
 package io.helidon.inject.api;
 
 /**
- * A general exception indicating that something failed related to Injection.
+ * A general exception indicating that something failed related to Service.
  *
  * @see InjectionServiceProviderException
  * @see ServiceProviderInjectionException
diff --git a/inject/api/src/main/java/io/helidon/inject/api/Services.java b/inject/api/src/main/java/io/helidon/inject/api/Services.java
index bef170287a4..5222baeeef5 100644
--- a/inject/api/src/main/java/io/helidon/inject/api/Services.java
+++ b/inject/api/src/main/java/io/helidon/inject/api/Services.java
@@ -26,7 +26,7 @@
  * application, along with the contracts (i.e., interfaces) they advertise, the qualifiers that optionally describe them, and oll
  * of each services' dependencies on other service contracts, etc.
  * <p>
- * Collectively these service instances are considered "the managed service instances" under Injection. A {@link ServiceProvider}
+ * Collectively these service instances are considered "the managed service instances" under Service. A {@link ServiceProvider}
  * wrapper
  * provides lifecycle management on the underlying service instances that each provider "manages" in terms of activation, scoping,
  * etc. The service providers are typically created during compile-time processing when the Injection APT processor is applied to your
diff --git a/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java b/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
index aed8ef2f21b..1ac02e754d1 100644
--- a/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
+++ b/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
@@ -35,7 +35,7 @@
 import static org.hamcrest.Matchers.lessThan;
 
 /**
- * Ensure the weights comparator from common works the way we expect it to. Sanity test for Injection.
+ * Ensure the weights comparator from common works the way we expect it to. Sanity test for Service.
  */
 class PriorityAndServiceTypeComparatorTest {
 
diff --git a/inject/runtime/src/main/java/io/helidon/inject/runtime/Versions.java b/inject/runtime/src/main/java/io/helidon/inject/runtime/Versions.java
index d636a2a04f0..dce17cb3726 100644
--- a/inject/runtime/src/main/java/io/helidon/inject/runtime/Versions.java
+++ b/inject/runtime/src/main/java/io/helidon/inject/runtime/Versions.java
@@ -30,7 +30,7 @@
 public class Versions {
 
     /**
-     * Version 1 - the initial release of Injection.
+     * Version 1 - the initial release of Service.
      */
     public static final String INJECT_VERSION_1 = "1";
 
diff --git a/inject/tools/src/main/java/io/helidon/inject/tools/CodeGenFiler.java b/inject/tools/src/main/java/io/helidon/inject/tools/CodeGenFiler.java
index d7451576208..a112df30434 100644
--- a/inject/tools/src/main/java/io/helidon/inject/tools/CodeGenFiler.java
+++ b/inject/tools/src/main/java/io/helidon/inject/tools/CodeGenFiler.java
@@ -118,7 +118,7 @@ static boolean filerWriterEnabled(boolean enabled) {
     }
 
     /**
-     * Returns the path to the target scratch directory for Injection.
+     * Returns the path to the target scratch directory for Service.
      *
      * @param targetOutputPath the target class output path
      * @return the target scratch path
diff --git a/metadata/hson/src/test/resources/new-service-registry.json b/metadata/hson/src/test/resources/new-service-registry.json
index de9d76b7038..e9bc2b79273 100644
--- a/metadata/hson/src/test/resources/new-service-registry.json
+++ b/metadata/hson/src/test/resources/new-service-registry.json
@@ -8,7 +8,7 @@
                 "descriptor": "io.helidon.metrics.CountedInterceptor__ServiceDescriptor",
                 "contracts": [
                     "io.helidon.metrics.CountedInterceptor",
-                    "io.helidon.service.inject.api.Interception.Interceptor"
+                    "io.helidon.service.registry.Interception.Interceptor"
                 ]
             }
         ]
diff --git a/service/README.md b/service/README.md
index 00ee19e08c6..daa46673506 100644
--- a/service/README.md
+++ b/service/README.md
@@ -1,6 +1,21 @@
 Helidon Service Registry
 ----
 
+All features are implemented in a way that can use no reflection, mostly through code generating required handling classes.
+
+Helidon Service Registry includes:
+
+- [Dependency Injection](#dependency-injection)
+- [Lifecycle Support](#service-lifecycle)
+- [Factories and Services](#factories-and-services)
+- [Aspect Oriented Programming (interceptors)](#interceptors)
+- [Events](events)
+- [Programmatic Lookup](#programmatic-lookup)
+- [Startup](#startup)
+- [Other](#other)
+- [Glossary](#glossary)
+
+
 # Core Service Registry
 
 Provides a replacement for Java ServiceLoader with basic inversion of control mechanism.
@@ -187,6 +202,437 @@ The format is as follows (using `//` to comment sections, not part of the format
 ]
 ```
 
-# Helidon Service Inject
+# Dependency Injection
+
+The basic building stone for inversion of control, dependency injection provides a mechanism to obtain an instance of a service
+at runtime, from the service registry, rather than constructing service instances through a constructor or a factory method.
+
+When using dependency injection, we can separate the concerns of "how to create a service instance" from
+"how to use the contract". The consumer of the contract is not burdened with the details of how to obtain a valid instance,
+and the provider of the service is not burdened with providing an API to build/setup a service instance.
+In some cases such interaction would be quite cumbersome, as we would need to carry a shared instance through constructors to
+reach the correct place where we want to create a service instance.
+
+One of the advantages of such an approach is the capability to exchange the service that implements a contract without the need
+to modify the consumers of such a contract.
+
+## Injection points
+
+In Helidon, dependency injection can be done in the following ways:
+
+- Through a constructor annotated with `@Service.Inject` - each parameter is considered an injection point; this is the
+  recommended way of injecting dependencies (as it can be unit tested easily, and fields can be declared `private final`)
+- Through field(s) annotated with `@Service.Inject` - each field is considered an injection point; this is not recommended, as
+  the fields must be accessible (at least package local), and cannot be declared as `final`
+
+An injection point is satisfied by a service with the highest weight implementing the requested contract.
+
+## Services
+
+Services are:
+
+1. Java classes annotated with one of the `Service.Scope` annotations, such as
+    - `@Service.Singleton` - up to one instance exists in the service registry
+    - `@Service.PerLookup` - an instance is created each time a lookup is done (injecting into an injection point is considered
+      a lookup as well)
+    - `@Service.PerRequest` - up to one instance exists in the service registry per request (what is a request is not defined in
+      the injection framework itself, but it matches concepts such as HTTP request/response interaction, or consuming of a
+      messaging message)
+2. Any class with `@Service.Inject` annotation that does not have a scope annotation. In such a case, the
+   service will be `@Service.PerLookup`.
+3. Any `core` service defined for Helidon Service Registry (using annotation `Service.Provider`), the scope is `PerLookup` if the
+   service implements a `Supplier`, and `@Singleton` otherwise; all dependencies are considered injection points
+
+Only services can have Injection points.
+
+## Qualifiers
+
+Any annotation "meta-annotated" with `@Service.Qualifier` is considered a qualifier.
+Qualifier annotations can be used to "qualify" injection points and services.
+
+If an injection points is qualified (it has one or more qualifiers), it will only be satisfied with services that match all
+the specified qualifiers.
+
+### Named
+
+One qualifier is provided out-of-the-box - the `@Service.Named` (and `@Service.NamedByType` which does the same thing,
+only the name is the fully qualified class name of the provided class).
+
+Named instances are used by some feature of Helidon Inject itself.
+
+# Service Lifecycle
+
+The service registry manages lifecycle of services.
+
+To manage lifecycle, you can use the following annotations:
+
+- `@Service.PostConstruct` - a method annotated with this annotation will be invoked after the instance is constructed and fully
+  injected
+- `@Service.PreDestroy` - a method annotated with this annotation will be invoked after the service is no longer used by the
+  registry
+
+The behavior depends on the scope of the bean as follows:
+
+- `@Service.PerLookup` - only "post construct" lifecycle method is invoked, as we do not control the instance after is is
+  injected
+- Any other scope - the "pre destroy" lifecycle method is invoked when the scope is deactivated (Singletons on registry shutdown
+  or JVM shutdown)
+
+# Factories and Services
+
+Let's consider we have a contract named `MyContract`.
+
+The simple case is that we have a class that implements the contract, and that is a service, such as:
+
+```java
+
+@Service.Singleton
+class MyImpl implements MyContract {
+}
+```
+
+This means the service instance itself is an implementation of the contract, and when this service is used to satisfy an injection
+point, we will get an instance of `MyImpl`.
+
+But such an approach is only feasible if the contract is an interface, and we are fine with doing a full implementation.
+There may be cases, where this is not sufficient:
+
+- we need to provide an instance created by somebody else
+- the provided contract is not an interface
+- the provided instance may not be created at all (i.e. it is optional)
+
+This can be done by implementing one of the factory interfaces Helidon Inject supports:
+
+- `java.util.function.Supplier` - a factory that supplies a single instance (can also be `Supplier<Optional<MyContract>>`)
+- `io.helidon.service.registry.Service.ServicesFactory` - a factory that creates zero or more contract implementations
+- `io.helidon.service.registry.Service.InjectionPointFactory` - a factory that provides zero or more instances for each
+  injection point
+- `io.helidon.service.registry.Service.QualifiedFactory` - a factory that provides zero or more instances for a specific
+  qualifier and contract
+
+The factory interfaces above should provide enough tooling to implement any injection use case.
+
+# Interceptors
+
+Interception provides capability to intercept call to a constructor or a method (even to fields when used as injection points).
+
+Interception is (by default) only enabled for elements annotated with an annotation that is a `Interception.Intercepted`.
+Annotation processor configuration allows for creating interception "plumbing" for any annotation, or to disable it altogether.
+
+Interception works "around" the invocation, so it can:
+
+- do something before actual invocation
+- modify invocation parameters
+- do something after actual invocation
+- modify response
+- handle exceptions
+
+Annotation type: `io.helidon.service.registry.Interception`
+
+Annotations:
+
+| Annotation class   | Description                                                                                                                                                                                                                                                                                                                                    |
+|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `Intercepted`      | Marker for annotations that should trigger interception                                                                                                                                                                                                                                                                                        |
+| `Delegate`         | Marks a class as supporting interception delegation. Classes are not good candidates for delegation, as you need to create an instance that delegates to another instance, opening space for side-effects. To use a class, it must have an accessible no-arg constructor, and it should be designed not to have side-effects from construction |
+| `ExternalDelegate` | Add this to a service provider that provides a class that requires delegation, if the class is not part of your current project (i.e. you cannot annotate it with `Delegate`                                                                                                                                                                   | 
+
+Interfaces:
+
+| Interface class | Description                                                                                                                                                                                                                                          |
+|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `Interceptor`   | A service implementing this interface, and named with the annotation type (maybe using `NamedByType`) will be used as interceptor of methods annotated with that annotation. Interceptor must call `proceed` method to handle the interception chain |
+
+# Events
+
+Events allow in-application communication between services, by providing a mechanism to emit an event, and
+to create a consumer/consumers of events.
+
+One event can be delivered to (0..n) consumers.
+
+Basic terminology:
+
+- `Event Producer` - a service that calls an emitter (origin of an event)
+- `Event Emitter` - a service that emits an event to the event system
+- `Event Object` - an arbitrary object that is sent around as an event
+- `Event Observer` - a service that receives events, and has a method annotated with
+  `io.helidon.service.registry.Event.Observer`
+- `Qualified Event` - event published by an emitter providing a qualifier (annotation annotated with `Service.Qualifier`)
+
+## Emitting Events
+
+Event Emitters are code generated by Helidon. To create an Event Producer, simply inject the emitter.
+Event producers can be in any scope, the generated event emitter is always in `Service.Singleton` scope.
+
+A simple singleton service that injects an event emitter for event object of type `MyEventObject`.
+
+```java
+
+@Service.Singleton
+class MyService {
+    private final Event.Emitter<MyEventObject> emitter;
+
+    @Service.Inject
+    MyService(Event.Emitter<MyEventObject> emitter) {
+        this.emitter = emitter;
+    }
+}
+```
+
+To emit an event, you simply call `emitter.emit(myEventObjectInstance)`.
+The method will return once all event observers were notified (unless they are asynchronous - see below).
+In case any of the observers throws an exception, an `EventDispatchException` will be thrown with all exceptions caught added as
+suppressed (i.e. we will invoke all observers, even after we catch an exception).
+
+Event emitters are code generated for each Event Producer, so we may end up with more than one in the system. As all of them
+provide the exact same function, this is not an issue.
+
+_Explanation of the above statement: we cannot code generate classes into packages that do not belong to the current module, so we
+always code generate the emitter to the same package as the service that needs the emitter. Even though this may duplicate code,
+it is the only safe way we can do during annotation processing (where we do not have access to the classpath of the application)_
+
+## Consuming Events
+
+An event can be consumed by declaring an observer method.
+Event consumers can only be in `Service.Singleton` or `Service.PerLookup` scopes. The lookup is done exactly once, and all
+events are delivered to the same instance for the lifetime of the service registry.
+
+Helidon code generates an `EventObserverRegistration` service, which is used by the event manager to gather all observers for
+event handling.
+
+To create an event observer:
+
+- create an observer method, with a single parameter of the event type you want to observe
+- annotate the method with `Event.Observer`
+
+Example:
+
+```java
+
+@Event.Observer
+void event(MyEventObject eventObject) {
+    // do something with the event
+}
+```
+
+## Asynchronous Events
+
+Events can be emitted asynchronously, and event observer can be asynchronous.
+Executor service for asynchronous events can be provided via service registry, as a service that implements contract
+`java.util.concurrent.ExecutorService`, and is named `io.helidon.service.registry.EventManager`.
+If none is provided, the service will use a thread per task executor with Virtual threads, thread names will be prefixed with
+`inject-event-manager-`.
+
+### Asynchronous Event Producer
+
+Rules of asynchronous event producing:
+
+1. Method `Event.Emitter.emitAsync(..)` returns a `CompletionStage<MyEventType>`
+2. All *synchronous* Event Consumer are submitted to an executor service, and the returned completion stage will provide either
+   success (the event object itself), or will provide an exception, which will have `EventDispatchException` as a cause
+3. The method returns once all the event observers are submitted to the executor service (there is no guarantee that anything has
+   been delivered - we may have delivered 0 to n events (where n is number of synchronous observers))
+4. All *asynchronous* Event Observer are invoked outside of the returned completion stage
+
+### Asynchronous Observer
+
+Asynchronous observer methods are invoked from separate threads (through the executor service mentioned above), and their results
+are ignored by the Event Emitter; if there is an exception thrown from the observer method, it is logged with `WARNING` log level
+into logger named `io.helidon.service.registry.EventManager`.
+
+To declare an asynchronous observer use annotation `Event.AsyncObserver` instead of `Event.Observer`.
+
+Example:
+
+```java
+
+@Event.AsyncObserver
+void event(MyEventObject eventObject) {
+    // handle event
+}
+```
+
+## Qualified Events
+
+A Qualified Event is only delivered to Event Consumers that use the same qualifier.
+
+### Qualified Event Producer
+
+A qualified event can be produced with two options:
+
+1. The injection point of `Event.Emitter` (the constructor parameter, or field) is annotated with a qualifier annotation
+2. The `Event.Emitter.emit(..)` method is called with explicit qualifier(s), note that if combined, the qualifier specified by the
+   injection point will always be present!
+
+Example (combination of both):
+
+```java
+import io.helidon.service.registry.Qualifier;
+
+// class declaration
+private static final Qualifier BLUE = Qualifier.create(Blue.class);
+
+        @Service.Inject
+        EventEmitter(@Black Event.Emitter<EventObject> event) {
+            // the event producer will implicitly have Black qualifier added
+            this.event = event;
+        }
+
+        void emit(MyEventObject eventObject) {
+            // the event will be emitted with both Blue and Black qualifiers
+            this.event.emit(eventObject, BLUE);
+        }
+```
+
+### Qualified Event Observers
+
+To consume a qualified event, observer method must be annotated with the correct qualifier(s).
+
+Example:
+
+```java
+
+@Service.Singleton
+class EventObserver {
+    @Event.Observer
+    @Black
+    void event(MyEventObject eventObject) {
+        // handle event that is qualified with Black (and none other)
+    }
+}
+```
+
+# Programmatic Lookup
+
+As usual with Helidon, what can be done via automation (dependency injection in this case) can also be done programmatically.
+
+The service registry can be used and handled "from outside" - you can create a registry instance, lookup services, call methods on
+them.
+
+It can also be used "from inside" - you can inject an `ServiceRegistry` into your services. In case this approach is done, we
+cannot work around lookup costs as we can when only dependency injection is used.
+
+To create a registry instance:
+
+```java
+// create an instance of a registry manager - can be configured and shut down
+var registryManager = ServiceRegistryManager.create();
+// get the associated service registry
+var registry = registryManager.registry();
+```
+
+Note that all instances are created lazily, so the registry will do "nothing" by default. If a service does something during
+construction or post construction, you must lookup an instance from the registry first.
+
+Special registry operations:
+
+- `List<ServiceInfo> lookupServices(Lookup lookup)` - get all service descriptors that match the lookup
+- `Optional<T> get(ServiceInfo)` - get an instance for the provided service descriptor
+
+The common registry operations are grouped by method name. Acceptable parameters are described below.
+
+Registry methods:
+
+- `T get(...)` - immediately get an instance of a contract from the registry; throws if implementation not available
+- `Optional<T> first(...)` - immediately get an instance of a contract from the registry; there may not be an implementation
+  available
+- `List<T> all(...)` - immediately get all instances of a contract from the registry; result may be empty
+- `Supplier<T> supply(...)` - get a supplier of an instance; the service may be instantiated only when `get` is called
+- `Supplier<Optional<T>> supplyFirst(...)` - get a supplier of an optional instance
+- `Supplier<List<T>> supplyAll(...)` - get a supplier of all instances
+
+Lookup parameter options:
+
+- `Class<?>` - the contract we are looking for
+- `TypeName` - the same, but using Helidon abstraction of type names (may have type arguments)
+- `Lookup` - a full search criteria for a registry lookup
+
+# Startup
+
+The following options are available to start a service registry (and the application):
+
+1. Use API to create an `io.helidon.service.registry.ServiceRegistryManager`
+2. Use the Helidon startup class `io.helidon.Main`, which will use the injection main class through service loader
+3. Use a generated main class, by default named `ApplicationMain` in the main package of the application (supports customization)
+
+## Generated Main Class
+
+To generate a main class, the Helidon Service Inject Maven plugin must be configured.
+This is expected to be configured only for an application (i.e. not for library modules) - this is the reason we do not generate it automatically.
+
+The generated main class will contain full, reflection less configuration of the service registry. It registers all services directly through API, and disables service discovery from classpath.
+
+The Main class can also be customized; to do this:
+1. Create a custom class (let's call it `CustomMain` as an example)
+2. The class must extend the injection main class (`public abstract class CustomMain extends InjectionMain`)
+3. The class must be annotated with `@Service.Main`, so it is discovered by annotation processor
+4. Implement any desired methods; the generated class will only implement `serviceDescriptors(ServiceRegistryConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
+
+For details on how to configure your build, see [Maven Plugin](../maven-plugin/README.md).
+
+# Other
+
+## API types quick reference
+
+Annotation type: `io.helidon.service.registry.Injection`
+
+Annotations:
+
+| Annotation class | Description                                                                                                               |
+|------------------|---------------------------------------------------------------------------------------------------------------------------|
+| `Inject`         | Marks element as an injection point; although we prefer constructor injection, field and method injection works as well   |
+| `Qualifier`      | Marker for annotations that are qualifiers                                                                                |
+| `Named`          | A qualifier that provides a name                                                                                          |
+| `NamedByType`    | An equivalent of `Named`, that uses the fully qualified class name of the configured class as name                        |
+| `Scope`          | Marker for annotations that are scopes                                                                                    |
+| `PerLookup`      | Service instance is created per lookup (either for injection point, or via registry lookup)                               |
+| `Singleton`      | Singleton scope - a service registry will create zero or one instances of this service (instantiation is lazy)            |
+| `PerRequest`     | Request scope - a service registry will create zero or one instance of this service per request scope instance            |
+| `RunLevel`       | A "layer" in which this service should be instantiated; not executed by injection, will be used when starting application |
+| `PerInstance`    | Create a service instance for each instance of the configured contract available in registry (usually for named)          |
+| `InstanceName`   | Parameter or field that will be injected with the name this service instance is created for (see `PerInstance`)           |
+| `Describe`       | Create a descriptor for a type that is not a service itself, but an instance would be provided at scope creation time     | 
+
+Interfaces:
+
+| Interface class         | Description                                                                                                     |
+|-------------------------|-----------------------------------------------------------------------------------------------------------------|
+| `ServicesFactory`       | A service factory that creates zero or more qualified service instances at runtime                              |
+| `InjectionPointFactory` | A service factory that creates values for specific injection points                                             |
+| `QualifiedFactory`      | A service factory to resolve qualified injection points of any type (used for example by config value injection |
+| `QualifiedInstance`     | Used as a return type of some of the interfaces above, not to be implemented by users                           |
+| `ScopeHandler`          | Extension point to support additional scopes                                                                    |
+
+## Injection point options
+
+An injection point may have the following forms (`Contract` stands for a contract interface, or class):
+
+Instance based:
+
+1. `Contract` - injects an instance of the contract with the highest weight from the registry
+2. `Optional<Contract>` - same as previous, the contract may not have an implementation available in registry
+3. `List<Contract>` - a list of all available instances in the registry
+
+Supplier based (to break cyclic dependency, and to create instances as late as possible):
+
+1. `Supplier<Contract>`
+2. `Supplier<Optional<Contract>>`
+3. `Supplier<List<Contract>>`
+
+Service instance based (to obtain registry metadata in addition to the instance):
+
+1. `ServiceInstance<Contract>`
+2. `Optional<ServiceInstance<Contract>>`
+3. `List<ServiceInstance<Contract>>`
+
+# Glossary
+
+| Term            | Description                                                                                                                                                                                                   |
+|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Core Service    | A class annotated with `@Service.Provider`                                                                                                                                                                    |
+| Contract        | A class extended by a service, or an interface implemented by a service, can be used to lookup instances                                                                                                      |
+| Dependency      | A "Core Service" constructor parameter (type must be another service or a "Contract")                                                                                                                         |
+| Service         | A class annotated with one of the scope annotations, or a core service                                                                                                                                        |
+| Factory         | A "Core Service" or "Service" that implements one of the factory interfaces; Core service is a factory only if it implements a `Supplier                                                                      |
+| Injection Point | Field annotated with `@Service.Inject`, or a constructor parameter of a constructor used for injection (either the only accessible constructor, or the only constructor annotated with `@Service.Inject`) |
 
-See details in [Helidon Inject](inject/README.md).
\ No newline at end of file
diff --git a/service/inject/codegen/pom.xml b/service/builder/pom.xml
similarity index 60%
rename from service/inject/codegen/pom.xml
rename to service/builder/pom.xml
index c743c516b47..edebd907274 100644
--- a/service/inject/codegen/pom.xml
+++ b/service/builder/pom.xml
@@ -21,39 +21,33 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.inject</groupId>
-        <artifactId>helidon-service-inject-project</artifactId>
+        <groupId>io.helidon.service</groupId>
+        <artifactId>helidon-service-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-inject-codegen</artifactId>
-    <name>Helidon Service Inject Codegen</name>
+    <artifactId>helidon-service-builder</artifactId>
+    <name>Helidon Service Builder</name>
     <description>
-        Code generation for Helidon Service Inject applications
+        Support for service registry in builders.
+        This must be separate from service registry itself, as we would create a cyclic dependency otherwise.
+        This module adds support for using service registry to discover service providers and services from
+        registry.
     </description>
 
     <dependencies>
         <dependency>
             <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-types</artifactId>
+            <artifactId>helidon-common-config</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.codegen</groupId>
-            <artifactId>helidon-codegen</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.codegen</groupId>
-            <artifactId>helidon-codegen-class-model</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-codegen</artifactId>
+            <groupId>io.helidon.builder</groupId>
+            <artifactId>helidon-builder-api</artifactId>
         </dependency>
     </dependencies>
 </project>
diff --git a/service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java b/service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java
new file mode 100644
index 00000000000..e525265e51d
--- /dev/null
+++ b/service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java
@@ -0,0 +1,458 @@
+package io.helidon.service.builder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import io.helidon.builder.api.Prototype;
+import io.helidon.common.config.Config;
+import io.helidon.common.config.ConfigException;
+import io.helidon.common.config.ConfiguredProvider;
+import io.helidon.common.config.NamedService;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.Services;
+
+/**
+ * Support for services from service registry in a generated builder.
+ * <p>
+ * All public methods on this type are used from generated code.
+ */
+public final class BuilderRegistrySupport {
+    private static final System.Logger PROVIDER_LOGGER = System.getLogger(Prototype.class.getName() + ".provider");
+
+    /**
+     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
+     * the mapping to a provider.
+     * Type of service, used to map to {@link io.helidon.common.config.ConfiguredProvider#configKey()}, which is the
+     * default "type" of a configured provider. It is then used in {@link io.helidon.common.config.NamedService#type()},
+     * to allow multiple instances of the same "type" with different "name".
+     */
+    private static final String KEY_SERVICE_TYPE = "type";
+    /**
+     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
+     * the name of an instance.
+     * It is then used in {@link io.helidon.common.config.NamedService#name()}
+     * to allow multiple instances of the same "type" with different "name".
+     * In case of object type configurations, name is taken from the configuration node name.
+     */
+    private static final String KEY_SERVICE_NAME = "name";
+    /**
+     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
+     * whether a service provider of the type is enabled.
+     * Each service from a {@link io.helidon.common.config.ConfiguredProvider} can be enabled/disabled through
+     * configuration. If marked as {@code enabled = false}, the service will be ignored and not added.
+     */
+    private static final String KEY_SERVICE_ENABLED = "enabled";
+
+    private BuilderRegistrySupport() {
+    }
+
+    /**
+     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     *
+     * @param config          configuration of the option
+     * @param configKey       configuration key associated with this option
+     * @param serviceRegistry service registry instance
+     * @param providerType    type of the service provider (contract)
+     * @param configType      type of the configuration
+     * @param allFromRegistry whether to use all services from the registry
+     * @param existingValues  existing values that was explicitly configured by the user
+     * @param <T>             type of the service
+     * @return instances from the user augmented with instances from the registry
+     */
+    public static <T extends NamedService> List<T> discoverServices(Config config,
+                                                                    String configKey,
+                                                                    ServiceRegistry serviceRegistry,
+                                                                    Class<? extends ConfiguredProvider<T>> providerType,
+                                                                    Class<T> configType,
+                                                                    boolean allFromRegistry,
+                                                                    List<T> existingValues) {
+
+        // type and name is a unique identification of a service - for services already defined on the builder
+        // do not add them from configuration (as this would duplicate service instances)
+        Set<TypeAndName> ignoredServices = new HashSet<>();
+        existingValues.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
+
+        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromRegistry);
+        Config providersConfig = config.get(configKey);
+
+        List<ConfiguredService> configuredServices = new ArrayList<>();
+
+        // all child nodes of the current node
+        List<Config> serviceConfigList = providersConfig.asNodeList()
+                .orElseGet(List::of);
+        boolean isList = providersConfig.isList();
+
+        for (Config serviceConfig : serviceConfigList) {
+            configuredServices.add(configuredService(serviceConfig, isList));
+        }
+
+        // now we have all service configurations, we can start building up instances
+        if (providersConfig.isList()) {
+            // driven by order of declaration in config
+            return servicesFromList(new RealRegistry(serviceRegistry),
+                                    providerType,
+                                    configType,
+                                    configuredServices,
+                                    discoverServices,
+                                    ignoredServices);
+        } else {
+            // driven by service loader order
+            return servicesFromObject(providersConfig,
+                                      new RealRegistry(serviceRegistry),
+                                      providerType,
+                                      configType,
+                                      configuredServices,
+                                      discoverServices,
+                                      ignoredServices);
+        }
+    }
+
+    /**
+     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     *
+     * @param config           configuration of the option
+     * @param configKey        configuration key associated with this option
+     * @param serviceRegistry  service registry instance
+     * @param providerType     type of the service provider (contract)
+     * @param configType       type of the configuration
+     * @param discoverServices whether to discover services from registry
+     * @param existingValue    existing value that was explicitly configured by the user
+     * @param <T>              type of the service
+     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
+     */
+    public static <T extends NamedService> Optional<T>
+    discoverService(Config config,
+                    String configKey,
+                    ServiceRegistry serviceRegistry,
+                    Class<? extends ConfiguredProvider<T>> providerType,
+                    Class<T> configType,
+                    boolean discoverServices,
+                    Optional<T> existingValue) {
+
+        // there is an explicit configuration for this service, ignore configuration
+        if (existingValue.isPresent()) {
+            return Optional.empty();
+        }
+
+        // all child nodes of the current node
+        List<Config> serviceConfigList = config.get(configKey).asNodeList()
+                .orElseGet(List::of);
+
+        // if more than one is configured in config, fail
+        // if more than one exists in service loader, use the first one
+        if (serviceConfigList.size() > 1) {
+            throw new ConfigException("There can only be one provider configured for " + config.key());
+        }
+
+        List<T> services = discoverServices(config,
+                                            configKey,
+                                            serviceRegistry,
+                                            providerType,
+                                            configType,
+                                            discoverServices,
+                                            List.of());
+
+        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
+    }
+
+    /**
+     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     * This method uses static access (when no registry is explicitly defined).
+     *
+     * @param config          configuration of the option
+     * @param configKey       configuration key associated with this option
+     * @param providerType    type of the service provider (contract)
+     * @param configType      type of the configuration
+     * @param allFromRegistry whether to use all services from the registry
+     * @param existingValues  existing values that was explicitly configured by the user
+     * @param <T>             type of the service
+     * @return instances from the user augmented with instances from the registry
+     */
+    public static <T extends NamedService> List<T> discoverServices(Config config,
+                                                                    String configKey,
+                                                                    Class<? extends ConfiguredProvider<T>> providerType,
+                                                                    Class<T> configType,
+                                                                    boolean allFromRegistry,
+                                                                    List<T> existingValues) {
+
+        // type and name is a unique identification of a service - for services already defined on the builder
+        // do not add them from configuration (as this would duplicate service instances)
+        Set<TypeAndName> ignoredServices = new HashSet<>();
+        existingValues.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
+
+        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromRegistry);
+        Config providersConfig = config.get(configKey);
+
+        List<ConfiguredService> configuredServices = new ArrayList<>();
+
+        // all child nodes of the current node
+        List<Config> serviceConfigList = providersConfig.asNodeList()
+                .orElseGet(List::of);
+        boolean isList = providersConfig.isList();
+
+        for (Config serviceConfig : serviceConfigList) {
+            configuredServices.add(configuredService(serviceConfig, isList));
+        }
+
+        // now we have all service configurations, we can start building up instances
+        if (providersConfig.isList()) {
+            // driven by order of declaration in config
+            return servicesFromList(StaticAccessRegistry.INSTANCE,
+                                    providerType,
+                                    configType,
+                                    configuredServices,
+                                    discoverServices,
+                                    ignoredServices);
+        } else {
+            // driven by service loader order
+            return servicesFromObject(providersConfig,
+                                      StaticAccessRegistry.INSTANCE,
+                                      providerType,
+                                      configType,
+                                      configuredServices,
+                                      discoverServices,
+                                      ignoredServices);
+        }
+    }
+
+    /**
+     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     * This method uses static access (when no registry is explicitly defined).
+     *
+     * @param config           configuration of the option
+     * @param configKey        configuration key associated with this option
+     * @param providerType     type of the service provider (contract)
+     * @param configType       type of the configuration
+     * @param discoverServices whether to discover services from registry
+     * @param existingValue    existing value that was explicitly configured by the user
+     * @param <T>              type of the service
+     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
+     */
+    public static <T extends NamedService> Optional<T>
+    discoverService(Config config,
+                    String configKey,
+                    Class<? extends ConfiguredProvider<T>> providerType,
+                    Class<T> configType,
+                    boolean discoverServices,
+                    Optional<T> existingValue) {
+
+        // there is an explicit configuration for this service, ignore configuration
+        if (existingValue.isPresent()) {
+            return Optional.empty();
+        }
+
+        // all child nodes of the current node
+        List<Config> serviceConfigList = config.get(configKey).asNodeList()
+                .orElseGet(List::of);
+
+        // if more than one is configured in config, fail
+        // if more than one exists in service loader, use the first one
+        if (serviceConfigList.size() > 1) {
+            throw new ConfigException("There can only be one provider configured for " + config.key());
+        }
+
+        List<T> services = discoverServices(config,
+                                            configKey,
+                                            providerType,
+                                            configType,
+                                            discoverServices,
+                                            List.of());
+
+        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
+    }
+
+    private static ConfiguredService configuredService(Config serviceConfig, boolean isList) {
+        if (isList) {
+            // order is significant
+            String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(null);
+            String name = serviceConfig.get(KEY_SERVICE_NAME).asString().orElse(type);
+            boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
+
+            Config usedConfig = serviceConfig;
+            if (type == null) {
+                // nested approach (we are on the first node of the list, we need to go deeper)
+                List<Config> configs = serviceConfig.asNodeList().orElseGet(List::of);
+                if (configs.size() != 1) {
+                    throw new ConfigException(
+                            "Service provider configuration defined as a list must have a single node that is the type, "
+                                    + "with children containing the provider configuration. Failed on: " + serviceConfig.key());
+                }
+                usedConfig = configs.getFirst();
+                name = usedConfig.name();
+                type = usedConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
+                enabled = usedConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(enabled);
+            }
+            return new ConfiguredService(new TypeAndName(type, name), usedConfig, enabled);
+        }
+        // just collect each node, order will be determined by weight
+
+        String name = serviceConfig.name(); // name is the config node name for object types
+        String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
+        boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
+
+        return new ConfiguredService(new TypeAndName(type, name), serviceConfig, enabled);
+    }
+
+    private static <T extends NamedService> List<T>
+    servicesFromList(RegistryWrap serviceRegistry,
+                     Class<? extends ConfiguredProvider<T>> providerType,
+                     Class<T> configType,
+                     List<ConfiguredService> configuredServices,
+                     boolean allFromServiceLoader,
+                     Set<TypeAndName> ignoredServices) {
+        Map<String, ConfiguredProvider<T>> allProvidersByType = new HashMap<>();
+        Map<String, ConfiguredProvider<T>> unusedProvidersByType = new LinkedHashMap<>();
+
+        serviceRegistry.all(providerType)
+                .forEach(provider -> {
+                    allProvidersByType.put(provider.configKey(), provider);
+                    unusedProvidersByType.put(provider.configKey(), provider);
+                });
+
+        List<T> result = new ArrayList<>();
+
+        // first add all configured
+        for (ConfiguredService service : configuredServices) {
+            TypeAndName typeAndName = service.typeAndName();
+            if (!ignoredServices.add(typeAndName)) {
+                unusedProvidersByType.remove(typeAndName.type());
+
+                if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                    PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + typeAndName
+                            + " is already added in builder, ignoring configured one.");
+                }
+
+                continue;
+            }
+            ConfiguredProvider<T> provider = allProvidersByType.get(typeAndName.type());
+            if (provider == null) {
+                throw new ConfigException("Unknown provider configured. Expecting a provider with type \"" + typeAndName.type()
+                                                  + "\", but only the following providers are supported: "
+                                                  + allProvidersByType.keySet() + ", "
+                                                  + "provider interface: " + providerType.getName()
+                                                  + ", configured service: " + configType.getName());
+            }
+            unusedProvidersByType.remove(typeAndName.type());
+            if (service.enabled()) {
+                result.add(provider.create(service.serviceConfig(), typeAndName.name()));
+            }
+        }
+
+        // then (if desired) add the rest
+        if (allFromServiceLoader) {
+            unusedProvidersByType.forEach((type, provider) -> {
+                if (ignoredServices.add(new TypeAndName(type, type))) {
+                    result.add(provider.create(Config.empty(), type));
+                }
+            });
+        }
+
+        return result;
+    }
+
+    private static <T extends NamedService> List<T>
+    servicesFromObject(Config providersConfig,
+                       RegistryWrap serviceRegistry,
+                       Class<? extends ConfiguredProvider<T>> providerType,
+                       Class<T> configType,
+                       List<ConfiguredService> configuredServices,
+                       boolean allFromServiceLoader,
+                       Set<TypeAndName> ignoredServices) {
+        // order is determined by service loader
+        Set<String> availableProviders = new HashSet<>();
+        Map<String, ConfiguredService> allConfigs = new HashMap<>();
+        configuredServices.forEach(it -> allConfigs.put(it.typeAndName().type, it));
+        Set<String> unusedConfigs = new HashSet<>(allConfigs.keySet());
+
+        List<T> result = new ArrayList<>();
+
+        List<? extends ConfiguredProvider<T>> all = serviceRegistry.all(providerType);
+        for (ConfiguredProvider<T> provider : all) {
+            ConfiguredService configuredService = allConfigs.get(provider.configKey());
+            availableProviders.add(provider.configKey());
+            unusedConfigs.remove(provider.configKey());
+            if (configuredService == null) {
+                if (allFromServiceLoader) {
+                    // even though the specific key does not exist, we want to have the real config tree, so we can get to the
+                    // root of it
+                    // when there is no configuration, the name defaults to the type
+                    String type = provider.configKey();
+                    if (ignoredServices.add(new TypeAndName(type, type))) {
+                        result.add(provider.create(providersConfig.get(type), type));
+                    } else {
+                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + new TypeAndName(type, type)
+                                    + " is already added in builder, ignoring configured one.");
+                        }
+                    }
+                }
+            } else {
+                if (configuredService.enabled()) {
+                    if (ignoredServices.add(configuredService.typeAndName())) {
+                        result.add(provider.create(configuredService.serviceConfig(),
+                                                   configuredService.typeAndName().name()));
+                    } else {
+                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + configuredService.typeAndName()
+                                    + " is already added in builder, ignoring configured one.");
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!unusedConfigs.isEmpty()) {
+            throw new ConfigException("Unknown provider configured. Expected providers with types: " + unusedConfigs
+                                              + ", but only the following providers are supported: " + availableProviders
+                                              + ", provider interface: " + providerType.getName()
+                                              + ", configured service: " + configType.getName());
+        }
+        return result;
+    }
+
+    private interface RegistryWrap {
+        <T> List<T> all(Class<T> type);
+    }
+
+    private record TypeAndName(String type, String name) {
+    }
+
+    private record ConfiguredService(TypeAndName typeAndName, Config serviceConfig, boolean enabled) {
+    }
+
+    private static final class StaticAccessRegistry implements RegistryWrap {
+        public static final StaticAccessRegistry INSTANCE = new StaticAccessRegistry();
+
+        @Override
+        public <T> List<T> all(Class<T> type) {
+            return Services.all(type);
+        }
+    }
+
+    private static final class RealRegistry implements RegistryWrap {
+        private final ServiceRegistry serviceRegistry;
+
+        private RealRegistry(ServiceRegistry serviceRegistry) {
+            this.serviceRegistry = serviceRegistry;
+        }
+
+        @Override
+        public <T> List<T> all(Class<T> type) {
+            return serviceRegistry.all(type);
+        }
+    }
+}
diff --git a/service/builder/src/main/java/module-info.java b/service/builder/src/main/java/module-info.java
new file mode 100644
index 00000000000..e278a9bfc05
--- /dev/null
+++ b/service/builder/src/main/java/module-info.java
@@ -0,0 +1,6 @@
+module io.helidon.service.builder {
+    requires transitive io.helidon.common.config;
+    requires transitive io.helidon.service.registry;
+
+    exports io.helidon.service.builder;
+}
\ No newline at end of file
diff --git a/service/codegen/README.md b/service/codegen/README.md
index 81f627e24de..5e9a9604806 100644
--- a/service/codegen/README.md
+++ b/service/codegen/README.md
@@ -3,14 +3,20 @@ Service Codegen
 
 # Supported annotations
 
-| Annotation        | Processed by     | Description                         |
-|-------------------|------------------|-------------------------------------|
-| @Service.Provider | ServiceExtension | Generates a core service descriptor |
-
+| Annotation           | Description                                                                         |
+|----------------------|-------------------------------------------------------------------------------------|
+| @Service.Provider    | Generates a core service descriptor                                                 |
+| @Service.Inject      | Type with an injection point is a per lookup service unless it has scope annotation |
+| @Service.Describe    | Generates a service descriptor for a contract without a service implementation      |
+| @Service.PerInstance | A service instantiated based on another service                                     |
+| @Service.Scope       | Scoped service (meta-annotation)                                                    |
 
 # Supported options
+
 Options can be configured as annotation processor options, when running via annotation processor.
 
-| Option                                          | Used by          | Description                                                                                                                                                              |
-|-------------------------------------------------|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `helidon.registry.autoAddNonContractInterfaces` | ServiceExtension | If set to `true`, all implemented interfaces and super types are considered a contract; by default, `@Service.Contract` or `@Service.ExternalContracts` must be in place |
\ No newline at end of file
+| Option                                          | Default    | Description                                                                                                                                                              |
+|-------------------------------------------------|------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `helidon.registry.autoAddNonContractInterfaces` | `true`     | If set to `true`, all implemented interfaces and super types are considered a contract; by default, `@Service.Contract` or `@Service.ExternalContracts` must be in place |
+| `helidon.registry.interceptionStrategy`         | `EXPLICIT` | How to handle generation of interceptor invokers (NONE, EXPLICIT, ALL_RUNTIME, ALL_RETAINED)                                                                             |
+| `helidon.registry.scopeMetaAnnotations`         | N/A        | Set of annotations that mark scopes that are not Helidon scopes                                                                                                          
\ No newline at end of file
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Assignments.java b/service/codegen/src/main/java/io/helidon/service/codegen/Assignments.java
similarity index 90%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Assignments.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/Assignments.java
index b09c7f8ca7f..c72c6584638 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Assignments.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/Assignments.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.List;
 import java.util.Optional;
@@ -22,9 +22,8 @@
 
 import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.inject.codegen.spi.InjectAssignment;
-import io.helidon.service.inject.codegen.spi.InjectAssignmentProvider;
+import io.helidon.service.codegen.spi.InjectAssignment;
+import io.helidon.service.codegen.spi.InjectAssignmentProvider;
 
 class Assignments {
     private final List<InjectAssignment> assingments;
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/CodegenHelper.java b/service/codegen/src/main/java/io/helidon/service/codegen/CodegenHelper.java
new file mode 100644
index 00000000000..f045136684d
--- /dev/null
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/CodegenHelper.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.codegen;
+
+import java.util.Iterator;
+import java.util.List;
+
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.TypeInfo;
+
+import static io.helidon.service.codegen.ServiceCodegenTypes.GENERATED_ANNOTATION;
+import static io.helidon.service.codegen.ServiceCodegenTypes.LIST_OF_ANNOTATIONS;
+
+/**
+ * Helper methods to code generate that are used from more than one type.
+ */
+final class CodegenHelper {
+    private CodegenHelper() {
+    }
+
+    static void annotationsField(ClassModel.Builder classModel, TypeInfo service) {
+        classModel.addField(annotations -> annotations
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .name("ANNOTATIONS")
+                .type(LIST_OF_ANNOTATIONS)
+                .addContent(List.class)
+                .addContent(".of(")
+                .update(it -> {
+                    Iterator<Annotation> iterator = service.annotations()
+                            .stream()
+                            .filter(annot -> !annot.typeName().equals(GENERATED_ANNOTATION))
+                            .iterator();
+                    while (iterator.hasNext()) {
+                        Annotation next = iterator.next();
+                        it.addContentCreate(next);
+                        if (iterator.hasNext()) {
+                            it.addContent(", ");
+                        }
+                    }
+                })
+                .addContent(")"));
+    }
+}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedElements.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedElements.java
similarity index 96%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedElements.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/DescribedElements.java
index 185e9c28dc0..06b4c2c6725 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedElements.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedElements.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.Collection;
 import java.util.List;
@@ -73,7 +73,7 @@ private DescribedElements(Set<ElementSignature> interceptedMethods,
      * @return described elements for a service
      */
     static DescribedElements create(CodegenContext ctx,
-                                    Interception interception,
+                                    InterceptionSupport interception,
                                     Collection<ResolvedType> contracts,
                                     TypeInfo serviceTypeInfo) {
         var all = TypedElements.gatherElements(ctx, contracts, serviceTypeInfo)
@@ -85,7 +85,7 @@ static DescribedElements create(CodegenContext ctx,
                 .map(TypedElementInfo::signature)
                 .collect(Collectors.toUnmodifiableSet());
 
-        var intercepted = interception.maybeIntercepted(serviceTypeInfo, all);
+        var intercepted = interception.interception().maybeIntercepted(serviceTypeInfo, all);
         var interceptedMethods = intercepted.stream()
                 .map(TypedElements.ElementMeta::element)
                 .filter(ElementInfoPredicates::isMethod)
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedService.java
similarity index 82%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/DescribedService.java
index 11c3647dc2e..aeb0dbb9e3b 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedService.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedService.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -29,20 +29,17 @@
 import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.RegistryRoundContext;
-import io.helidon.service.codegen.ServiceContracts;
-import io.helidon.service.codegen.ServiceSuperType;
-
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_NAMED;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_INSTANCE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_POINT_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_QUALIFIED_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_SERVICES_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_G_WRAPPER_IP_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_G_WRAPPER_SERVICES_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY;
+
+import static io.helidon.service.codegen.ServiceCodegenAnnotations.WILDCARD_NAMED;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_G_WRAPPER_IP_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_G_WRAPPER_SERVICES_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PER_INSTANCE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_INJECTION_POINT_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_QUALIFIED_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_SERVICES_FACTORY;
 
 /**
  * A service (as declared and annotated with a scope by the user).
@@ -50,8 +47,6 @@
  * implementation on its own.
  */
 class DescribedService {
-    private static final Annotation WILDCARD_NAMED = Annotation.create(INJECTION_NAMED, "*");
-
     private final DescribedType serviceType;
     private final DescribedType providedType;
 
@@ -92,7 +87,7 @@ private DescribedService(DescribedType serviceType,
 
     static DescribedService create(RegistryCodegenContext ctx,
                                    RegistryRoundContext roundContext,
-                                   Interception interception,
+                                   InterceptionSupport interception,
                                    TypeInfo serviceInfo,
                                    ServiceSuperType superType,
                                    TypeName scope) {
@@ -126,7 +121,7 @@ static DescribedService create(RegistryCodegenContext ctx,
             providedTypeInfo = response.providedTypeInfo();
             implementedInterfaceTypes.remove(TypeNames.SUPPLIER);
         }
-        response = serviceContracts.analyseFactory(INJECTION_SERVICES_FACTORY);
+        response = serviceContracts.analyseFactory(SERVICE_SERVICES_FACTORY);
         if (response.valid()) {
             // if this is not a service type, throw
             if (providerType != FactoryType.SERVICE) {
@@ -139,9 +134,9 @@ static DescribedService create(RegistryCodegenContext ctx,
             providedContracts.addAll(response.providedContracts());
             providedTypeName = response.providedType();
             providedTypeInfo = response.providedTypeInfo();
-            implementedInterfaceTypes.remove(INJECTION_SERVICES_FACTORY);
+            implementedInterfaceTypes.remove(SERVICE_SERVICES_FACTORY);
         }
-        response = serviceContracts.analyseFactory(INJECTION_POINT_FACTORY);
+        response = serviceContracts.analyseFactory(SERVICE_INJECTION_POINT_FACTORY);
         if (response.valid()) {
             // if this is not a service type, throw
             if (providerType != FactoryType.SERVICE) {
@@ -154,9 +149,9 @@ static DescribedService create(RegistryCodegenContext ctx,
             providedContracts.addAll(response.providedContracts());
             providedTypeName = response.providedType();
             providedTypeInfo = response.providedTypeInfo();
-            implementedInterfaceTypes.remove(INJECTION_POINT_FACTORY);
+            implementedInterfaceTypes.remove(SERVICE_INJECTION_POINT_FACTORY);
         }
-        response = serviceContracts.analyseFactory(INJECTION_QUALIFIED_FACTORY);
+        response = serviceContracts.analyseFactory(SERVICE_QUALIFIED_FACTORY);
         if (response.valid()) {
             // if this is not a service type, throw
             if (providerType != FactoryType.SERVICE) {
@@ -168,10 +163,10 @@ static DescribedService create(RegistryCodegenContext ctx,
             directContracts.add(ResolvedType.create(response.providedType()));
             providedContracts.addAll(response.providedContracts());
             qualifiedProviderQualifier = ServiceContracts
-                    .requiredTypeArgument(implementedInterfaceTypes.remove(INJECTION_QUALIFIED_FACTORY), 1);
+                    .requiredTypeArgument(implementedInterfaceTypes.remove(SERVICE_QUALIFIED_FACTORY), 1);
             providedTypeName = response.providedType();
             providedTypeInfo = response.providedTypeInfo();
-            implementedInterfaceTypes.remove(INJECTION_QUALIFIED_FACTORY);
+            implementedInterfaceTypes.remove(SERVICE_QUALIFIED_FACTORY);
         }
 
         // add direct contracts
@@ -243,10 +238,9 @@ TypeName providerInterface() {
         return switch (providerType()) {
             case NONE, SERVICE -> serviceType.typeName();
             case SUPPLIER -> createType(TypeNames.SUPPLIER, providedType.typeName());
-            case SERVICES -> createType(INJECTION_SERVICES_FACTORY, providedType.typeName());
-            case INJECTION_POINT -> createType(INJECTION_POINT_FACTORY, providedType.typeName());
-            case QUALIFIED ->
-                    createType(INJECTION_QUALIFIED_FACTORY, providedType.typeName(), qualifiedProviderQualifier);
+            case SERVICES -> createType(SERVICE_SERVICES_FACTORY, providedType.typeName());
+            case INJECTION_POINT -> createType(SERVICE_INJECTION_POINT_FACTORY, providedType.typeName());
+            case QUALIFIED -> createType(SERVICE_QUALIFIED_FACTORY, providedType.typeName(), qualifiedProviderQualifier);
         };
     }
 
@@ -299,14 +293,13 @@ private static TypeName createType(TypeName... types) {
 
     private static Set<Annotation> gatherQualifiers(TypeInfo serviceTypeInfo) {
         Set<Annotation> qualifiers = new LinkedHashSet<>();
-        if (serviceTypeInfo.hasAnnotation(INJECTION_PER_INSTANCE)) {
+        if (serviceTypeInfo.hasAnnotation(SERVICE_ANNOTATION_PER_INSTANCE)) {
             qualifiers.add(WILDCARD_NAMED);
         }
 
         for (Annotation annotation : serviceTypeInfo.annotations()) {
-            if (annotation.hasMetaAnnotation(InjectCodegenTypes.INJECTION_QUALIFIER)
-                    || serviceTypeInfo.hasMetaAnnotation(annotation.typeName(),
-                                                         InjectCodegenTypes.INJECTION_QUALIFIER)) {
+            if (serviceTypeInfo.hasMetaAnnotation(annotation.typeName(),
+                                                  SERVICE_ANNOTATION_QUALIFIER)) {
                 qualifiers.add(annotation);
             }
         }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedType.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedType.java
similarity index 98%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedType.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/DescribedType.java
index 4afecde9352..5fed2d13637 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/DescribedType.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescribedType.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.Objects;
 import java.util.Set;
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/EventEmitterObserverProvider.java
similarity index 91%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/EventEmitterObserverProvider.java
index e4c01742ad6..34c75e13b3e 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/EventEmitterObserverProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.HashSet;
 import java.util.Map;
@@ -33,16 +33,15 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.RegistryRoundContext;
-import io.helidon.service.inject.codegen.spi.InjectCodegenObserver;
-import io.helidon.service.inject.codegen.spi.InjectCodegenObserverProvider;
+import io.helidon.service.codegen.spi.InjectCodegenObserver;
+import io.helidon.service.codegen.spi.InjectCodegenObserverProvider;
 
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.EVENT_EMITTER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.EVENT_MANAGER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_INJECT;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_SINGLETON;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.EVENT_EMITTER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.EVENT_MANAGER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_INJECT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_SINGLETON;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_QUALIFIERS;
 
 /**
  * {@link java.util.ServiceLoader} provider implementation that generates services for event emitters.
@@ -125,7 +124,7 @@ private void generateEventEmitter(RegistryRoundContext roundContext,
                     .accessModifier(AccessModifier.PACKAGE_PRIVATE)
                     .description("Event emitter service for {@link " + eventObject.fqName() + "}.")
                     .addInterface(emitterInterface(eventObject))
-                    .addAnnotation(Annotation.create(INJECTION_SINGLETON));
+                    .addAnnotation(Annotation.create(SERVICE_ANNOTATION_SINGLETON));
 
             // constant for event type
             classModel.addField(eventObjectConstant -> eventObjectConstant
@@ -150,7 +149,7 @@ private void generateEventEmitter(RegistryRoundContext roundContext,
 
             // constructor
             classModel.addConstructor(ctr -> ctr
-                    .addAnnotation(Annotation.create(INJECTION_INJECT))
+                    .addAnnotation(Annotation.create(SERVICE_ANNOTATION_INJECT))
                     .accessModifier(AccessModifier.PACKAGE_PRIVATE)
                     .addParameter(eventManager -> eventManager
                             .type(EVENT_MANAGER)
@@ -176,9 +175,9 @@ private void addMergeQualifiers(ClassModel.Builder classModel) {
                     .name("mergeQualifiers")
                     .addParameter(qualifiers -> qualifiers
                             .name("qualifiers")
-                            .type(INJECT_QUALIFIER)
+                            .type(SERVICE_QUALIFIER)
                             .vararg(true))
-                    .returnType(InjectionExtension.SET_OF_QUALIFIERS)
+                    .returnType(SET_OF_QUALIFIERS)
                     .addContentLine("if (qualifiers.length == 0) {")
                     .addContentLine("return QUALIFIERS;")
                     .addContentLine("}")
@@ -207,7 +206,7 @@ private void addEmit(ClassModel.Builder classModel,
                             .name("eventObject"))
                     .addParameter(qualifiers -> qualifiers
                             .vararg(true)
-                            .type(INJECT_QUALIFIER)
+                            .type(SERVICE_QUALIFIER)
                             .name("qualifiers"))
                     .update(it -> {
                         if (!returnType.equals(TypeNames.PRIMITIVE_VOID)) {
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventObserverExtensionProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/EventObserverExtensionProvider.java
similarity index 91%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventObserverExtensionProvider.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/EventObserverExtensionProvider.java
index d8275f687ae..6e65fb60c89 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventObserverExtensionProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/EventObserverExtensionProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.Collection;
 import java.util.Map;
@@ -33,17 +33,15 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.RegistryRoundContext;
 import io.helidon.service.codegen.spi.RegistryCodegenExtension;
 import io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider;
 
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.EVENT_MANAGER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.EVENT_OBSERVER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.EVENT_OBSERVER_ASYNC;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_INJECT;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_SINGLETON;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_EVENT_OBSERVER_REGISTRATION;
+import static io.helidon.service.codegen.ServiceCodegenTypes.EVENT_MANAGER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.EVENT_OBSERVER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.EVENT_OBSERVER_ASYNC;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_INJECT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_SINGLETON;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_G_EVENT_OBSERVER_REGISTRATION;
 
 /**
  * {@link java.util.ServiceLoader} provider implementation that adds support for generating event observer registrations.
@@ -147,8 +145,8 @@ private void generateObserverRegistration(RegistryRoundContext roundContext,
                     .type(generatedType)
                     .accessModifier(AccessModifier.PACKAGE_PRIVATE)
                     .description("Event observer registration service for {@link " + eventObject.fqName() + "}.")
-                    .addInterface(INJECT_G_EVENT_OBSERVER_REGISTRATION)
-                    .addAnnotation(Annotation.create(INJECTION_SINGLETON));
+                    .addInterface(SERVICE_G_EVENT_OBSERVER_REGISTRATION)
+                    .addAnnotation(Annotation.create(SERVICE_ANNOTATION_SINGLETON));
 
             // constant for event type
             classModel.addField(eventObjectConstant -> eventObjectConstant
@@ -172,7 +170,7 @@ private void generateObserverRegistration(RegistryRoundContext roundContext,
 
             // constructor
             classModel.addConstructor(ctr -> ctr
-                    .addAnnotation(Annotation.create(INJECTION_INJECT))
+                    .addAnnotation(Annotation.create(SERVICE_ANNOTATION_INJECT))
                     .accessModifier(AccessModifier.PACKAGE_PRIVATE)
                     .addParameter(eventObserver -> eventObserver
                             .type(serviceTypeName)
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/FactoryType.java b/service/codegen/src/main/java/io/helidon/service/codegen/FactoryType.java
similarity index 97%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/FactoryType.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/FactoryType.java
index 58ac1f7f7dd..f27d97152df 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/FactoryType.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/FactoryType.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 /**
  * Described service type.
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java b/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
deleted file mode 100644
index 3fcc867a56d..00000000000
--- a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
+++ /dev/null
@@ -1,717 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.codegen;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import io.helidon.codegen.CodegenException;
-import io.helidon.codegen.CodegenUtil;
-import io.helidon.codegen.ElementInfoPredicates;
-import io.helidon.codegen.TypeHierarchy;
-import io.helidon.codegen.classmodel.ClassModel;
-import io.helidon.codegen.classmodel.Javadoc;
-import io.helidon.codegen.classmodel.Method;
-import io.helidon.codegen.classmodel.TypeArgument;
-import io.helidon.common.Weight;
-import io.helidon.common.Weighted;
-import io.helidon.common.types.AccessModifier;
-import io.helidon.common.types.Annotation;
-import io.helidon.common.types.Annotations;
-import io.helidon.common.types.ElementKind;
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeInfo;
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-import io.helidon.common.types.TypedElementInfo;
-
-/**
- * Generates a service descriptor.
- */
-public class GenerateServiceDescriptor {
-    static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
-            .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
-            .build();
-    private static final TypeName LIST_OF_DEPENDENCIES = TypeName.builder(TypeNames.LIST)
-            .addTypeArgument(ServiceCodegenTypes.SERVICE_DEPENDENCY)
-            .build();
-    private static final TypeName DESCRIPTOR_TYPE = TypeName.builder(ServiceCodegenTypes.SERVICE_DESCRIPTOR)
-            .addTypeArgument(TypeName.create("T"))
-            .build();
-    private static final TypeName ANY_GENERIC_TYPE = TypeName.builder(TypeNames.GENERIC_TYPE)
-            .addTypeArgument(TypeName.create("?"))
-            .build();
-
-    private final TypeName generator;
-    private final RegistryCodegenContext ctx;
-    private final RegistryRoundContext roundCtx;
-    private final Collection<TypeInfo> services;
-    private final TypeInfo typeInfo;
-
-    private GenerateServiceDescriptor(TypeName generator,
-                                      RegistryCodegenContext ctx,
-                                      RegistryRoundContext roundCtx,
-                                      Collection<TypeInfo> allServices,
-                                      TypeInfo service) {
-        this.generator = generator;
-        this.ctx = ctx;
-        this.roundCtx = roundCtx;
-        this.services = allServices;
-        this.typeInfo = service;
-    }
-
-    /**
-     * Generate a service descriptor for the provided service type info.
-     *
-     * @param generator    type of the generator responsible for this event
-     * @param ctx          context of code generation
-     * @param roundContext current round context
-     * @param allServices  all services processed in this round of processing
-     * @param service      service to create a descriptor for
-     * @return class model builder of the service descriptor
-     */
-    public static ClassModel.Builder generate(TypeName generator,
-                                              RegistryCodegenContext ctx,
-                                              RegistryRoundContext roundContext,
-                                              Collection<TypeInfo> allServices,
-                                              TypeInfo service) {
-        return new GenerateServiceDescriptor(generator,
-                                             ctx,
-                                             roundContext,
-                                             allServices,
-                                             service)
-                .generate();
-    }
-
-    static void declareConstructorParams(Method.Builder method, List<CoreDependency> params) {
-        // for each parameter, obtain its value from context
-        for (CoreDependency param : params) {
-            method.addContent(param.typeName())
-                    .addContent(" ")
-                    .addContent(param.name())
-                    .addContent(" = ctx__helidonRegistry.dependency(")
-                    .addContent(param.dependencyConstant())
-                    .addContentLine(");");
-        }
-        if (!params.isEmpty()) {
-            method.addContentLine("");
-        }
-    }
-
-    private ClassModel.Builder generate() {
-        if (typeInfo.kind() == ElementKind.INTERFACE) {
-            throw new CodegenException("We can only generate service descriptors for classes, interface was requested: ",
-                                       typeInfo.originatingElementValue());
-        }
-
-        CoreService service = CoreService.create(ctx, roundCtx, typeInfo, services);
-        TypeName serviceType = service.serviceType();
-        TypeName descriptorType = service.descriptorType();
-
-        ClassModel.Builder classModel = ClassModel.builder()
-                .copyright(CodegenUtil.copyright(generator,
-                                                 serviceType,
-                                                 descriptorType))
-                .addAnnotation(CodegenUtil.generatedAnnotation(generator,
-                                                               serviceType,
-                                                               descriptorType,
-                                                               "1",
-                                                               ""))
-                .type(descriptorType)
-                .addGenericArgument(TypeArgument.create("T extends " + serviceType.fqName()))
-                .javadoc(Javadoc.builder()
-                                 .add("Service descriptor for {@link " + serviceType.fqName() + "}.")
-                                 .addGenericArgument("T", "type of the service, for extensibility")
-                                 .build())
-                // we need to keep insertion order, as constants may depend on each other
-                .sortStaticFields(false);
-
-        // declare the class
-
-        if (service.superType().present()) {
-            classModel.superType(service.superType().descriptorType());
-        } else {
-            classModel.addInterface(DESCRIPTOR_TYPE);
-        }
-
-        singletonInstanceField(classModel, serviceType, descriptorType);
-
-        serviceTypeMethod(classModel, service);
-        descriptorTypeMethod(classModel, service);
-        contractsMethod(classModel, service);
-
-        // public fields are last, so they do not intersect with private fields (it is not as nice to read)
-        // they cannot be first, as they require some of the private fields
-        dependencyFields(classModel, service);
-        // dependencies require IP IDs, so they really must be last
-        dependenciesMethod(classModel, service);
-
-        // add protected constructor
-        classModel.addConstructor(constructor -> constructor.description("Constructor with no side effects")
-                .accessModifier(AccessModifier.PROTECTED));
-
-        // methods (some methods define fields as well)
-        isAbstractMethod(classModel, service);
-        instantiateMethod(classModel, service);
-        postConstructMethod(classModel, service);
-        preDestroyMethod(classModel, service);
-        weightMethod(classModel, service);
-
-        // service type is an implicit contract
-        Set<ResolvedType> serviceContracts = new HashSet<>(service.contracts());
-        Set<ResolvedType> factoryContracts = new HashSet<>(service.factoryContracts());
-        if (factoryContracts.isEmpty()) {
-            serviceContracts.add(ResolvedType.create(serviceType));
-        } else {
-            factoryContracts.add(ResolvedType.create(serviceType));
-        }
-
-        roundCtx.addDescriptor("core",
-                               serviceType,
-                               descriptorType,
-                               classModel,
-                               weight(typeInfo).orElse(Weighted.DEFAULT_WEIGHT),
-                               serviceContracts,
-                               factoryContracts,
-                               typeInfo.originatingElementValue());
-
-        return classModel;
-    }
-
-    private void addTypeConstant(ClassModel.Builder classModel,
-                                 TypeName typeName,
-                                 String constantName) {
-        String stringType = typeName.resolvedName();
-        // constants for dependency parameter types (used by next section)
-        classModel.addField(field -> field
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .type(TypeNames.TYPE_NAME)
-                .name(constantName)
-                .update(it -> {
-                    if (stringType.indexOf('.') < 0) {
-                        // there is no package, we must use class (if this is a generic type, we have a problem)
-                        it.addContent(TypeNames.TYPE_NAME)
-                                .addContent(".create(")
-                                .addContent(typeName)
-                                .addContent(".class)");
-                    } else {
-                        it.addContentCreate(typeName);
-                    }
-                }));
-    }
-
-    private void addGenericTypeConstant(ClassModel.Builder classModel,
-                                        TypeName typeName,
-                                        String constantName) {
-        classModel.addField(field -> field
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .type(ANY_GENERIC_TYPE)
-                .name(constantName)
-                .update(it -> {
-                    if (typeName.primitive()) {
-                        it.addContent(TypeNames.GENERIC_TYPE)
-                                .addContent(".create(")
-                                .addContent(typeName.className())
-                                .addContent(".class)");
-                    } else {
-                        it.addContent("new ")
-                                .addContent(TypeNames.GENERIC_TYPE)
-                                .addContent("<")
-                                .addContent(typeName)
-                                .addContent(">() {}");
-                    }
-                })
-        );
-    }
-
-    private void contracts(TypeInfo typeInfo,
-                           boolean contractEligible,
-                           Set<TypeName> collectedContracts,
-                           Set<String> collectedFullyQualified) {
-        TypeName typeName = typeInfo.typeName();
-
-        boolean addedThisContract = false;
-        if (contractEligible) {
-            collectedContracts.add(typeName);
-            addedThisContract = true;
-            if (!collectedFullyQualified.add(typeName.resolvedName())) {
-                // let us go no further, this type was already processed
-                return;
-            }
-        }
-
-        if (typeName.isSupplier()) {
-            // this may be the interface itself, and then it does not have a type argument
-            if (!typeName.typeArguments().isEmpty()) {
-                // factory must have a type argument (and the type argument is an automatic contract
-                TypeName providedType = typeName.typeArguments().getFirst();
-                // and we support Supplier<Optional<X>> as well
-                if (!providedType.generic()) {
-                    // supplier is a contract
-                    collectedContracts.add(TypeNames.SUPPLIER);
-
-                    if (providedType.isOptional() && !providedType.typeArguments().isEmpty()) {
-                        providedType = providedType.typeArguments().getFirst();
-                        // we still have supplier as a contract
-                        collectedFullyQualified.add(TypeNames.SUPPLIER.fqName());
-                        collectedContracts.add(TypeNames.SUPPLIER);
-                        if (providedType.generic()) {
-                            providedType = null;
-                        } else {
-                            // and also optional
-                            collectedFullyQualified.add(TypeNames.OPTIONAL.fqName());
-                            collectedContracts.add(TypeNames.OPTIONAL);
-                            contractsFromProvidedType(collectedContracts, collectedFullyQualified, providedType);
-                        }
-                    } else {
-                        contractsFromProvidedType(collectedContracts, collectedFullyQualified, providedType);
-                    }
-
-                    if (providedType != null && !collectedFullyQualified.add(providedType.resolvedName())) {
-                        // let us go no further, this type was already processed
-                        return;
-                    }
-                }
-            }
-
-            // provider itself is a contract
-            if (!addedThisContract) {
-                collectedContracts.add(typeName);
-                if (!collectedFullyQualified.add(typeName.resolvedName())) {
-                    // let us go no further, this type was already processed
-                    return;
-                }
-            }
-        }
-
-        // add contracts from interfaces and types annotated as @Contract
-        if (Annotations.findFirst(ServiceCodegenTypes.SERVICE_ANNOTATION_CONTRACT,
-                                  TypeHierarchy.hierarchyAnnotations(ctx, typeInfo)).isPresent()) {
-            collectedContracts.add(typeInfo.typeName());
-        }
-
-        // add contracts from @ExternalContracts
-        typeInfo.findAnnotation(ServiceCodegenTypes.SERVICE_ANNOTATION_EXTERNAL_CONTRACTS)
-                .ifPresent(it -> collectedContracts.addAll(it.typeValues().orElseGet(List::of)));
-
-        // go through hierarchy
-        typeInfo.superTypeInfo().ifPresent(it -> contracts(it,
-                                                           contractEligible,
-                                                           collectedContracts,
-                                                           collectedFullyQualified
-        ));
-        // interfaces are considered contracts by default
-        typeInfo.interfaceTypeInfo().forEach(it -> contracts(it,
-                                                             contractEligible,
-                                                             collectedContracts,
-                                                             collectedFullyQualified
-        ));
-    }
-
-    private void contractsFromProvidedType(Set<TypeName> collectedContracts,
-                                           Set<String> collectedFullyQualified,
-                                           TypeName providedType) {
-        Optional<TypeInfo> providedTypeInfo = ctx.typeInfo(providedType);
-        if (providedTypeInfo.isPresent()) {
-            contracts(providedTypeInfo.get(),
-                      true,
-                      collectedContracts,
-                      collectedFullyQualified
-            );
-        } else {
-            collectedContracts.add(providedType);
-        }
-    }
-
-    private void singletonInstanceField(ClassModel.Builder classModel, TypeName serviceType, TypeName descriptorType) {
-        // singleton instance of the descriptor
-        classModel.addField(instance -> instance.description("Global singleton instance for this descriptor.")
-                .accessModifier(AccessModifier.PUBLIC)
-                .isStatic(true)
-                .isFinal(true)
-                .type(descriptorInstanceType(serviceType, descriptorType))
-                .name("INSTANCE")
-                .defaultValueContent("new " + descriptorType.className() + "<>()"));
-    }
-
-    private void dependencyFields(ClassModel.Builder classModel, CoreService service) {
-
-        // first add all types
-        for (var genericConstant : service.constants().genericConstants()) {
-            addGenericTypeConstant(classModel, genericConstant.type(), genericConstant.constantName());
-        }
-        for (var typeNameConstant : service.constants().typeNameConstants()) {
-            addTypeConstant(classModel, typeNameConstant.type(), typeNameConstant.constantName());
-        }
-
-        // and then add all dependencies (these use the types created above)
-        for (CoreDependency dependency : service.dependencies()) {
-            classModel.addField(field -> field
-                    // must be public, used in generated Injection__Binding to bind services
-                    .accessModifier(AccessModifier.PUBLIC)
-                    .isStatic(true)
-                    .isFinal(true)
-                    .type(ServiceCodegenTypes.SERVICE_DEPENDENCY)
-                    .name(dependency.dependencyConstant())
-                    .description(dependencyDescription(service, dependency))
-                    .addContent(ServiceCodegenTypes.SERVICE_DEPENDENCY)
-                    .addContentLine(".builder()")
-                    .increaseContentPadding()
-                    .increaseContentPadding()
-                    .addContent(".typeName(")
-                    .addContent(dependency.typeNameConstant())
-                    .addContentLine(")")
-                    .addContent(".name(\"")
-                    .addContent(dependency.name())
-                    .addContentLine("\")")
-                    .addContentLine(".service(SERVICE_TYPE)")
-                    .addContentLine(".descriptor(DESCRIPTOR_TYPE)")
-                    .addContent(".descriptorConstant(\"")
-                    .addContent(dependency.dependencyConstant())
-                    .addContentLine("\")")
-                    .addContent(".contract(")
-                    .addContent(dependency.contractTypeConstant())
-                    .addContentLine(")")
-                    .addContent(".contractType(")
-                    .addContent(dependency.genericTypeConstant())
-                    .addContentLine(")")
-                    .addContent(".build()")
-                    .decreaseContentPadding()
-                    .decreaseContentPadding());
-        }
-    }
-
-    private String dependencyDescription(CoreService service, CoreDependency dependency) {
-        TypedElementInfo constructor = dependency.constructor();
-        TypeName serviceType = service.serviceType();
-        StringBuilder result = new StringBuilder("Dependency for ");
-        boolean servicePublic = typeInfo.accessModifier() == AccessModifier.PUBLIC;
-        boolean elementPublic = constructor.accessModifier() == AccessModifier.PUBLIC;
-
-        if (servicePublic) {
-            result.append("{@link ")
-                    .append(serviceType.fqName());
-            if (!elementPublic) {
-                result.append("}");
-            }
-        } else {
-            result.append(serviceType.classNameWithEnclosingNames());
-        }
-
-        if (servicePublic && elementPublic) {
-            // full javadoc reference
-            result
-                    .append("#")
-                    .append(serviceType.className())
-                    .append("(")
-                    .append(toDescriptionSignature(constructor, true))
-                    .append(")")
-                    .append("}");
-        } else {
-            // just text
-            result.append("(")
-                    .append(toDescriptionSignature(constructor, false))
-                    .append(")");
-        }
-
-        result
-                .append(", parameter ")
-                .append(dependency.name())
-                .append(".");
-        return result.toString();
-    }
-
-    private String toDescriptionSignature(TypedElementInfo method, boolean javadoc) {
-        if (javadoc) {
-            return method.parameterArguments()
-                    .stream()
-                    .map(it -> it.typeName().fqName())
-                    .collect(Collectors.joining(", "));
-        } else {
-            return method.parameterArguments()
-                    .stream()
-                    .map(it -> it.typeName().classNameWithEnclosingNames() + " " + it.elementName())
-                    .collect(Collectors.joining(", "));
-        }
-    }
-
-    private void dependenciesMethod(ClassModel.Builder classModel, CoreService service) {
-        classModel.addField(dependencies -> dependencies
-                .isStatic(true)
-                .isFinal(true)
-                .name("DEPENDENCIES")
-                .type(LIST_OF_DEPENDENCIES)
-                .addContent(List.class)
-                .addContent(".of(")
-                .update(it -> {
-                    var iterator = service.dependencies().iterator();
-                    while (iterator.hasNext()) {
-                        it.addContent(iterator.next().dependencyConstant());
-                        if (iterator.hasNext()) {
-                            it.addContent(", ");
-                        }
-                    }
-                })
-                .addContent(")"));
-
-        // List<Dependency> dependencies()
-        boolean hasSuperType = service.superType().present();
-        if (hasSuperType || !service.dependencies().isEmpty()) {
-            classModel.addMethod(method -> method.addAnnotation(Annotations.OVERRIDE)
-                    .returnType(LIST_OF_DEPENDENCIES)
-                    .name("dependencies")
-                    .update(it -> {
-                        if (hasSuperType) {
-                            it.addContentLine("return combineDependencies(DEPENDENCIES, super.dependencies());");
-                        } else {
-                            it.addContentLine("return DEPENDENCIES;");
-                        }
-                    }));
-        }
-    }
-
-    private void serviceTypeMethod(ClassModel.Builder classModel, CoreService service) {
-        classModel.addField(field -> field
-                .isStatic(true)
-                .isFinal(true)
-                .accessModifier(AccessModifier.PRIVATE)
-                .type(TypeNames.TYPE_NAME)
-                .name("SERVICE_TYPE")
-                .addContentCreate(service.serviceType().genericTypeName()));
-
-        // TypeName serviceType()
-        classModel.addMethod(method -> method.addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeNames.TYPE_NAME)
-                .name("serviceType")
-                .addContentLine("return SERVICE_TYPE;"));
-    }
-
-    private void descriptorTypeMethod(ClassModel.Builder classModel, CoreService service) {
-        classModel.addField(field -> field
-                .isStatic(true)
-                .isFinal(true)
-                .accessModifier(AccessModifier.PRIVATE)
-                .type(TypeNames.TYPE_NAME)
-                .name("DESCRIPTOR_TYPE")
-                .addContentCreate(service.descriptorType().genericTypeName()));
-
-        // TypeName descriptorType()
-        classModel.addMethod(method -> method.addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeNames.TYPE_NAME)
-                .name("descriptorType")
-                .addContentLine("return DESCRIPTOR_TYPE;"));
-    }
-
-    private void contractsMethod(ClassModel.Builder classModel, CoreService service) {
-        var contracts = service.contracts();
-        var factoryContracts = service.factoryContracts();
-        var superType = service.superType();
-
-        if (!contracts.isEmpty() || superType.present()) {
-            // we must declare the contracts method
-            classModel.addField(contractsField -> contractsField
-                    .isStatic(true)
-                    .isFinal(true)
-                    .name("CONTRACTS")
-                    .type(SET_OF_RESOLVED_TYPES)
-                    .addContent(Set.class)
-                    .addContent(".of(")
-                    .update(it -> {
-                        Iterator<ResolvedType> iterator = contracts.iterator();
-                        while (iterator.hasNext()) {
-                            it.addContentCreate(iterator.next());
-                            if (iterator.hasNext()) {
-                                it.addContent(", ");
-                            }
-                        }
-                    })
-                    .addContent(")"));
-
-            // Set<Class<?>> contracts()
-            classModel.addMethod(method -> method
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .name("contracts")
-                    .returnType(SET_OF_RESOLVED_TYPES)
-                    .addContentLine("return CONTRACTS;"));
-        }
-
-        if (!factoryContracts.isEmpty() || superType.present()) {
-            // we must declare the contracts method
-            classModel.addField(contractsField -> contractsField
-                    .isStatic(true)
-                    .isFinal(true)
-                    .name("FACTORY_CONTRACTS")
-                    .type(SET_OF_RESOLVED_TYPES)
-                    .addContent(Set.class)
-                    .addContent(".of(")
-                    .update(it -> {
-                        Iterator<ResolvedType> iterator = factoryContracts.iterator();
-                        while (iterator.hasNext()) {
-                            it.addContentCreate(iterator.next());
-                            if (iterator.hasNext()) {
-                                it.addContent(", ");
-                            }
-                        }
-                    })
-                    .addContent(")"));
-
-            // Set<Class<?>> factoryContracts()
-            classModel.addMethod(method -> method
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .name("factoryContracts")
-                    .returnType(SET_OF_RESOLVED_TYPES)
-                    .addContentLine("return FACTORY_CONTRACTS;"));
-        }
-    }
-
-    private void instantiateMethod(ClassModel.Builder classModel, CoreService service) {
-        if (service.isAbstract()) {
-            return;
-        }
-
-        // T instantiate(DependencyContext ctx__helidonRegistry)
-        classModel.addMethod(method -> method.addAnnotation(Annotations.OVERRIDE)
-                .returnType(service.serviceType())
-                .name("instantiate")
-                .addParameter(ctxParam -> ctxParam.type(ServiceCodegenTypes.SERVICE_DEPENDENCY_CONTEXT)
-                        .name("ctx__helidonRegistry"))
-                .update(it -> createInstantiateBody(service.serviceType(), it, service.dependencies())));
-    }
-
-    private void postConstructMethod(ClassModel.Builder classModel, CoreService service) {
-        // postConstruct()
-        lifecycleMethod(typeInfo, ServiceCodegenTypes.SERVICE_ANNOTATION_POST_CONSTRUCT).ifPresent(method -> {
-            classModel.addMethod(postConstruct -> postConstruct.name("postConstruct")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .addParameter(instance -> instance.type(service.serviceType())
-                            .name("instance"))
-                    .addContentLine("instance." + method.elementName() + "();"));
-        });
-    }
-
-    private void preDestroyMethod(ClassModel.Builder classModel, CoreService service) {
-        // preDestroy
-        lifecycleMethod(typeInfo, ServiceCodegenTypes.SERVICE_ANNOTATION_PRE_DESTROY).ifPresent(method -> {
-            classModel.addMethod(preDestroy -> preDestroy.name("preDestroy")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .addParameter(instance -> instance.type(service.serviceType())
-                            .name("instance"))
-                    .addContentLine("instance." + method.elementName() + "();"));
-        });
-    }
-
-    private Optional<TypedElementInfo> lifecycleMethod(TypeInfo typeInfo, TypeName annotationType) {
-        List<TypedElementInfo> list = typeInfo.elementInfo()
-                .stream()
-                .filter(ElementInfoPredicates.hasAnnotation(annotationType))
-                .toList();
-        if (list.isEmpty()) {
-            return Optional.empty();
-        }
-        if (list.size() > 1) {
-            throw new IllegalStateException("There is more than one method annotated with " + annotationType.fqName()
-                                                    + ", which is not allowed on type " + typeInfo.typeName().fqName());
-        }
-        TypedElementInfo method = list.getFirst();
-        if (method.accessModifier() == AccessModifier.PRIVATE) {
-            throw new CodegenException("Method annotated with " + annotationType.fqName()
-                                               + ", is private, which is not supported: " + typeInfo.typeName().fqName()
-                                               + "#" + method.elementName(),
-                                       method.originatingElementValue());
-        }
-        if (!method.parameterArguments().isEmpty()) {
-            throw new CodegenException("Method annotated with " + annotationType.fqName()
-                                               + ", has parameters, which is not supported: " + typeInfo.typeName().fqName()
-                                               + "#" + method.elementName(),
-                                       method.originatingElementValue());
-        }
-        if (!method.typeName().equals(TypeNames.PRIMITIVE_VOID)) {
-            throw new CodegenException("Method annotated with " + annotationType.fqName()
-                                               + ", is not void, which is not supported: " + typeInfo.typeName().fqName()
-                                               + "#" + method.elementName(),
-                                       method.originatingElementValue());
-        }
-        return Optional.of(method);
-    }
-
-    private void createInstantiateBody(TypeName serviceType,
-                                       Method.Builder method,
-                                       List<CoreDependency> params) {
-        declareConstructorParams(method, params);
-        String paramsDeclaration = params.stream()
-                .map(CoreDependency::name)
-                .collect(Collectors.joining(", "));
-
-        // return new MyImpl(parameter, parameter2)
-        method.addContent("return new ")
-                .addContent(serviceType.genericTypeName())
-                .addContent("(")
-                .addContent(paramsDeclaration)
-                .addContentLine(");");
-    }
-
-    private void isAbstractMethod(ClassModel.Builder classModel, CoreService service) {
-        if (!service.isAbstract() && service.superType().empty()) {
-            return;
-        }
-        // only override for abstract types (and subtypes, where we do not want to check if super is abstract), default is false
-        classModel.addMethod(isAbstract -> isAbstract
-                .name("isAbstract")
-                .returnType(TypeNames.PRIMITIVE_BOOLEAN)
-                .addAnnotation(Annotations.OVERRIDE)
-                .addContentLine("return " + service.isAbstract() + ";"));
-    }
-
-    private void weightMethod(ClassModel.Builder classModel, CoreService service) {
-        boolean hasSuperType = service.superType().present();
-        // double weight()
-        Optional<Double> weight = weight(typeInfo);
-
-        if (!hasSuperType && weight.isEmpty()) {
-            return;
-        }
-        double usedWeight = weight.orElse(Weighted.DEFAULT_WEIGHT);
-        if (!hasSuperType && usedWeight == Weighted.DEFAULT_WEIGHT) {
-            return;
-        }
-
-        classModel.addMethod(weightMethod -> weightMethod.name("weight")
-                .addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeNames.PRIMITIVE_DOUBLE)
-                .addContentLine("return " + usedWeight + ";"));
-    }
-
-    private Optional<Double> weight(TypeInfo typeInfo) {
-        return typeInfo.findAnnotation(TypeName.create(Weight.class))
-                .flatMap(Annotation::doubleValue);
-    }
-
-    private TypeName descriptorInstanceType(TypeName serviceType, TypeName descriptorType) {
-        return TypeName.builder(descriptorType)
-                .addTypeArgument(serviceType)
-                .build();
-    }
-}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptedTypeGenerator.java b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptedTypeGenerator.java
similarity index 96%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptedTypeGenerator.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/InterceptedTypeGenerator.java
index 54d80e344a2..88c0ccd19e5 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptedTypeGenerator.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptedTypeGenerator.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -32,9 +32,12 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.codegen.RegistryCodegenContext;
 
 import static io.helidon.codegen.CodegenUtil.toConstantName;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_INVOKER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_METADATA;
+import static io.helidon.service.codegen.ServiceCodegenTypes.LIST_OF_ANNOTATIONS;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_QUALIFIERS;
 
 class InterceptedTypeGenerator {
     public static final String INTERCEPT_META_PARAM = "helidonInject__interceptMeta";
@@ -259,7 +262,7 @@ ClassModel.Builder generate() {
     }
 
     private static TypeName invokerType(TypeName type) {
-        return TypeName.builder(InjectCodegenTypes.INTERCEPT_INVOKER)
+        return TypeName.builder(INTERCEPT_INVOKER)
                 .addTypeArgument(type.boxed())
                 .build();
     }
@@ -267,13 +270,13 @@ private static TypeName invokerType(TypeName type) {
     private void generateConstructor(ClassModel.Builder classModel) {
         classModel.addConstructor(constructor -> constructor
                 .accessModifier(AccessModifier.PACKAGE_PRIVATE)
-                .addParameter(interceptMeta -> interceptMeta.type(InjectCodegenTypes.INTERCEPT_METADATA)
+                .addParameter(interceptMeta -> interceptMeta.type(INTERCEPT_METADATA)
                         .name(INTERCEPT_META_PARAM))
                 .addParameter(descriptor -> descriptor.type(descriptorType)
                         .name(SERVICE_DESCRIPTOR_PARAM))
-                .addParameter(qualifiers -> qualifiers.type(InjectionExtension.SET_OF_QUALIFIERS)
+                .addParameter(qualifiers -> qualifiers.type(SET_OF_QUALIFIERS)
                         .name(TYPE_QUALIFIERS_PARAM))
-                .addParameter(qualifiers -> qualifiers.type(InjectionExtension.LIST_OF_ANNOTATIONS)
+                .addParameter(qualifiers -> qualifiers.type(LIST_OF_ANNOTATIONS)
                         .name(TYPE_ANNOTATIONS_PARAM))
                 .update(this::addConstructorParameters)
                 .update(this::callSuperConstructor)
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Interception.java b/service/codegen/src/main/java/io/helidon/service/codegen/Interception.java
similarity index 98%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Interception.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/Interception.java
index daf856bacc1..ad4ffc04493 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Interception.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/Interception.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -29,6 +29,8 @@
 import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeNames;
 
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_INTERCEPTED;
+
 final class Interception {
     private static final Annotation RUNTIME_RETENTION = Annotation.create(Retention.class, RetentionPolicy.RUNTIME.name());
     private static final Annotation CLASS_RETENTION = Annotation.create(Retention.class, RetentionPolicy.CLASS.name());
@@ -154,7 +156,7 @@ private boolean hasInterceptTrigger(TypeInfo typeInfo, TypedElements.ElementMeta
     private boolean hasInterceptTrigger(TypeInfo typeInfo, Annotated element) {
         for (Annotation annotation : element.annotations()) {
             if (interceptionStrategy.ordinal() >= InterceptionStrategy.EXPLICIT.ordinal()) {
-                if (typeInfo.hasMetaAnnotation(annotation.typeName(), InjectCodegenTypes.INTERCEPTION_INTERCEPTED)) {
+                if (typeInfo.hasMetaAnnotation(annotation.typeName(), INTERCEPTION_INTERCEPTED)) {
                     return true;
                 }
             }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionStrategy.java b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptionStrategy.java
similarity index 95%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionStrategy.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/InterceptionStrategy.java
index eb2e6fa630f..583fbd2181c 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionStrategy.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptionStrategy.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 /**
  * Possible strategies to interception.
@@ -22,7 +22,7 @@
  * <p>
  * The strategy is (in Helidon inject) only honored at compilation time. At runtime, it can only be enabled or disabled.
  */
-enum InterceptionStrategy {
+public enum InterceptionStrategy {
     /**
      * No annotations will qualify in triggering interceptor creation (interception is disabled).
      */
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionSupport.java b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptionSupport.java
similarity index 96%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionSupport.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/InterceptionSupport.java
index 01538aa753b..4c6bf827952 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InterceptionSupport.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/InterceptionSupport.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.EnumSet;
 import java.util.HashSet;
@@ -35,16 +35,14 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.RegistryRoundContext;
 
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_DESCRIPTOR;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_METADATA;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_METADATA;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_DESCRIPTOR;
 import static java.util.function.Predicate.not;
 
 final class InterceptionSupport {
     private static final TypeName GENERATOR = TypeName.create(InterceptionSupport.class);
-    private static final TypeName DESCRIPTOR_TYPE = TypeName.builder(INJECT_SERVICE_DESCRIPTOR)
+    private static final TypeName DESCRIPTOR_TYPE = TypeName.builder(SERVICE_DESCRIPTOR)
             .addTypeArgument(TypeName.create("?"))
             .build();
     private static final String INTERCEPT_META_PARAM = "interceptMeta";
@@ -55,20 +53,13 @@ final class InterceptionSupport {
     private final RegistryCodegenContext ctx;
     private final Interception interception;
 
-    private InterceptionSupport(RegistryCodegenContext ctx, Interception interception) {
+    InterceptionSupport(RegistryCodegenContext ctx, Interception interception) {
         this.ctx = ctx;
         this.interception = interception;
     }
 
-    /**
-     * Create a new instance.
-     *
-     * @param ctx codegen context
-     * @return a new interception support instance
-     */
-    static InterceptionSupport create(RegistryCodegenContext ctx) {
-        return new InterceptionSupport(ctx,
-                                       new Interception(InjectOptions.INTERCEPTION_STRATEGY.value(ctx.options())));
+    Interception interception() {
+        return interception;
     }
 
     /**
@@ -151,7 +142,6 @@ TypeName generateDelegateInterception(RegistryRoundContext roundContext,
                                                      elementMetas,
                                                      otherMethods);
         }
-
     }
 
     /**
@@ -273,7 +263,7 @@ private TypeName generateInterceptionDelegateClass(RegistryRoundContext roundCon
                                                                ""));
 
         // add type annotations
-        InjectionExtension.annotationsField(classModel, typeInfo);
+        CodegenHelper.annotationsField(classModel, typeInfo);
         // this is a special case, where we may not have the correct descriptor
         InterceptedTypeGenerator.generateElementInfoFields(classModel, definitions);
         InterceptedTypeGenerator.generateInvokerFields(classModel, definitions);
@@ -373,7 +363,7 @@ private TypeName generateInterceptionDelegateInterface(RegistryRoundContext roun
                                                                ""));
 
         // add type annotations
-        InjectionExtension.annotationsField(classModel, typeInfo);
+        CodegenHelper.annotationsField(classModel, typeInfo);
         // this is a special case, where we may not have the correct descriptor
         InterceptedTypeGenerator.generateElementInfoFields(classModel, definitions);
         InterceptedTypeGenerator.generateInvokerFields(classModel, definitions);
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MapNamedByTypeMapperProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/MapNamedByTypeMapperProvider.java
similarity index 82%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MapNamedByTypeMapperProvider.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/MapNamedByTypeMapperProvider.java
index f3871649d53..ba5ab5c7108 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MapNamedByTypeMapperProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/MapNamedByTypeMapperProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.Collection;
 import java.util.Set;
@@ -29,6 +29,9 @@
 import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.TypeName;
 
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_NAMED;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_NAMED_BY_TYPE;
+
 /**
  * A {@link java.util.ServiceLoader} provider implementation to map class named annotations to named annotations.
  */
@@ -45,7 +48,7 @@ public MapNamedByTypeMapperProvider() {
 
     @Override
     public Set<TypeName> supportedAnnotations() {
-        return Set.of(InjectCodegenTypes.INJECTION_NAMED_BY_TYPE);
+        return Set.of(SERVICE_ANNOTATION_NAMED_BY_TYPE);
     }
 
     @Override
@@ -60,12 +63,12 @@ private NamedByTypeMapper() {
 
         @Override
         public boolean supportsAnnotation(Annotation annotation) {
-            return annotation.typeName().equals(InjectCodegenTypes.INJECTION_NAMED_BY_TYPE);
+            return annotation.typeName().equals(SERVICE_ANNOTATION_NAMED_BY_TYPE);
         }
 
         @Override
         public Collection<Annotation> mapAnnotation(CodegenContext ctx, Annotation original, ElementKind elementKind) {
-            return Set.of(Annotation.create(InjectCodegenTypes.INJECTION_NAMED, original.value().orElse("")));
+            return Set.of(Annotation.create(SERVICE_ANNOTATION_NAMED, original.value().orElse("")));
         }
     }
 }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MethodDefinition.java b/service/codegen/src/main/java/io/helidon/service/codegen/MethodDefinition.java
similarity index 97%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MethodDefinition.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/MethodDefinition.java
index c1da2cb22a2..0d351a4947c 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/MethodDefinition.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/MethodDefinition.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.List;
 
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ParamDefinition.java b/service/codegen/src/main/java/io/helidon/service/codegen/ParamDefinition.java
similarity index 98%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ParamDefinition.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/ParamDefinition.java
index f99f6812542..28b0f0fd2c4 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ParamDefinition.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ParamDefinition.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.List;
 import java.util.Set;
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Qualifiers.java b/service/codegen/src/main/java/io/helidon/service/codegen/Qualifiers.java
similarity index 82%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Qualifiers.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/Qualifiers.java
index e67bbbe4671..e00c6c266ea 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/Qualifiers.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/Qualifiers.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.Iterator;
 import java.util.Set;
@@ -25,7 +25,9 @@
 import io.helidon.common.types.Annotated;
 import io.helidon.common.types.Annotation;
 
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_QUALIFIERS;
 
 final class Qualifiers {
     private Qualifiers() {
@@ -34,7 +36,7 @@ private Qualifiers() {
     static Set<Annotation> qualifiers(Annotated annotated) {
         return annotated.annotations()
                 .stream()
-                .filter(it -> it.hasMetaAnnotation(INJECTION_QUALIFIER))
+                .filter(it -> it.hasMetaAnnotation(SERVICE_ANNOTATION_QUALIFIER))
                 .collect(Collectors.toUnmodifiableSet());
     }
 
@@ -43,7 +45,7 @@ static void generateQualifiersConstant(ClassModel.Builder classModel, Set<Annota
                 .isStatic(true)
                 .isFinal(true)
                 .name("QUALIFIERS")
-                .type(InjectionExtension.SET_OF_QUALIFIERS)
+                .type(SET_OF_QUALIFIERS)
                 .addContent(Set.class)
                 .addContent(".of(")
                 .update(it -> {
@@ -60,14 +62,14 @@ static void generateQualifiersConstant(ClassModel.Builder classModel, Set<Annota
 
     private static void codeGenQualifier(Field.Builder field, Annotation qualifier) {
         if (qualifier.value().isPresent()) {
-            field.addContent(InjectCodegenTypes.INJECT_QUALIFIER)
+            field.addContent(SERVICE_QUALIFIER)
                     .addContent(".create(")
                     .addContentCreate(qualifier.typeName())
                     .addContent(", \"" + qualifier.value().get() + "\")");
             return;
         }
 
-        field.addContent(InjectCodegenTypes.INJECT_QUALIFIER)
+        field.addContent(SERVICE_QUALIFIER)
                 .addContent(".create(")
                 .addContentCreate(qualifier.typeName())
                 .addContent(")");
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
new file mode 100644
index 00000000000..49211680d99
--- /dev/null
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
@@ -0,0 +1,9 @@
+package io.helidon.service.codegen;
+
+import io.helidon.common.types.Annotation;
+
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_NAMED;
+
+class ServiceCodegenAnnotations {
+    static final Annotation WILDCARD_NAMED = Annotation.create(SERVICE_ANNOTATION_NAMED, "*");
+}
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
index 0ed9c08ff5b..1e0e11cea24 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
@@ -18,6 +18,7 @@
 
 import io.helidon.common.Generated;
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
 
 /**
  * Types used in code generation of Helidon Service.
@@ -27,6 +28,28 @@ public final class ServiceCodegenTypes {
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Provider}.
      */
     public static final TypeName SERVICE_ANNOTATION_PROVIDER = TypeName.create("io.helidon.service.registry.Service.Provider");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Singleton}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_SINGLETON = TypeName.create("io.helidon.service.registry.Service.Singleton");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Singleton}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_PER_LOOKUP = TypeName.create("io.helidon.service.registry.Service.PerLookup");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Inject}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_INJECT = TypeName.create("io.helidon.service.registry.Service.Inject");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.RunLevel}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_RUN_LEVEL =
+            TypeName.create("io.helidon.service.registry.Service.RunLevel");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.ScopeHandler}.
+     */
+    public static final TypeName SERVICE_SCOPE_HANDLER =
+            TypeName.create("io.helidon.service.registry.Service.ScopeHandler");
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.PreDestroy}.
      */
@@ -37,6 +60,37 @@ public final class ServiceCodegenTypes {
      */
     public static final TypeName SERVICE_ANNOTATION_POST_CONSTRUCT =
             TypeName.create("io.helidon.service.registry.Service.PostConstruct");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Describe}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_DESCRIBE =
+            TypeName.create("io.helidon.service.registry.Service.Describe");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.PerInstance}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_PER_INSTANCE =
+            TypeName.create("io.helidon.service.registry.Service.PerInstance");
+
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Scope}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_SCOPE =
+            TypeName.create("io.helidon.service.registry.Service.Scope");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Qualifier}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_QUALIFIER =
+            TypeName.create("io.helidon.service.registry.Service.Qualifier");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Named}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_NAMED =
+            TypeName.create("io.helidon.service.registry.Service.Named");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.NamedByType}.
+     */
+    public static final TypeName SERVICE_ANNOTATION_NAMED_BY_TYPE =
+            TypeName.create("io.helidon.service.registry.Service.NamedByType");
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.Contract}.
      */
@@ -56,6 +110,21 @@ public final class ServiceCodegenTypes {
      */
     public static final TypeName SERVICE_DESCRIPTOR =
             TypeName.create("io.helidon.service.registry.ServiceDescriptor");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.ServiceFactory}.
+     */
+    public static final TypeName SERVICE_SERVICES_FACTORY = TypeName.create("io.helidon.service.registry.Service"
+                                                                                    + ".ServicesFactory");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.InjectionPointFactory}.
+     */
+    public static final TypeName SERVICE_INJECTION_POINT_FACTORY = TypeName.create(
+            "io.helidon.service.registry.Service.InjectionPointFactory");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Service.QualifiedFactory}.
+     */
+    public static final TypeName SERVICE_QUALIFIED_FACTORY = TypeName.create(
+            "io.helidon.service.registry.Service.QualifiedFactory");
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Dependency}.
      */
@@ -64,6 +133,68 @@ public final class ServiceCodegenTypes {
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.DependencyContext}.
      */
     public static final TypeName SERVICE_DEPENDENCY_CONTEXT = TypeName.create("io.helidon.service.registry.DependencyContext");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Qualifier}.
+     */
+    public static final TypeName SERVICE_QUALIFIER = TypeName.create("io.helidon.service.registry.Qualifier");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.FactoryType}.
+     */
+    public static final TypeName SERVICE_FACTORY_TYPE = TypeName.create("io.helidon.service.registry.FactoryType");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceInstance}.
+     */
+    public static final TypeName SERVICE_SERVICE_INSTANCE = TypeName.create("io.helidon.service.registry.ServiceInstance");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Binding}.
+     */
+    public static final TypeName SERVICE_BINDING =
+            TypeName.create("io.helidon.service.registry.Binding");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.DependencyPlanBinder}.
+     */
+    public static final TypeName SERVICE_PLAN_BINDER =
+            TypeName.create("io.helidon.service.registry.DependencyPlanBinder");
+
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceRegistryConfig}.
+     */
+    public static final TypeName SERVICE_CONFIG =
+            TypeName.create("io.helidon.service.registry.ServiceRegistryConfig");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceRegistry}.
+     */
+    public static final TypeName SERVICE_REGISTRY =
+            TypeName.create("io.helidon.service.registry.ServiceRegistry");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceRegistryManager}.
+     */
+    public static final TypeName SERVICE_REGISTRY_MANAGER =
+            TypeName.create("io.helidon.service.registry.ServiceRegistryManager");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.PerInstanceDescriptor}.
+     */
+    public static final TypeName SERVICE_G_PER_INSTANCE_DESCRIPTOR = TypeName.create(
+            "io.helidon.service.registry.GeneratedService.PerInstanceDescriptor");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.QualifiedFactoryDescriptor}.
+     */
+    public static final TypeName SERVICE_G_QUALIFIED_FACTORY_DESCRIPTOR = TypeName.create(
+            "io.helidon.service.registry.GeneratedService.QualifiedFactoryDescriptor");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.ScopeHandlerDescriptor}.
+     */
+    public static final TypeName SERVICE_G_SCOPE_HANDLER_DESCRIPTOR = TypeName.create(
+            "io.helidon.service.registry.GeneratedService.ScopeHandlerDescriptor");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code "io.helidon.service.registry.GeneratedService.DependencySupport"}.
+     */
+    public static final TypeName SERVICE_G_DEPENDENCY_SUPPORT = TypeName.create(
+            "io.helidon.service.registry.GeneratedService.DependencySupport");
+
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.builder.api.Prototype.Blueprint}.
      */
@@ -74,6 +205,132 @@ public final class ServiceCodegenTypes {
      */
     public static final TypeName GENERATED_ANNOTATION = TypeName.create(Generated.class);
 
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.Event.Observer}.
+     */
+    public static final TypeName EVENT_OBSERVER = TypeName.create("io.helidon.service.registry.Event.Observer");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.Event.AsyncObserver}.
+     */
+    public static final TypeName EVENT_OBSERVER_ASYNC = TypeName.create("io.helidon.service.registry.Event.AsyncObserver");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.Event.Emitter}.
+     */
+    public static final TypeName EVENT_EMITTER = TypeName.create("io.helidon.service.registry.Event.Emitter");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.EventManager}.
+     */
+    public static final TypeName EVENT_MANAGER = TypeName.create("io.helidon.service.registry.EventManager");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.EventObserverRegistration}.
+     */
+    public static final TypeName SERVICE_G_EVENT_OBSERVER_REGISTRATION =
+            TypeName.create("io.helidon.service.registry.GeneratedService.EventObserverRegistration");
+
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.Intercepted}.
+     */
+    public static final TypeName INTERCEPTION_INTERCEPTED =
+            TypeName.create("io.helidon.service.registry.Interception.Intercepted");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.Delegate}.
+     */
+    public static final TypeName INTERCEPTION_DELEGATE = TypeName.create("io.helidon.service.registry.Interception.Delegate");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.ExternalDelegates}.
+     */
+    public static final TypeName INTERCEPTION_EXTERNAL_DELEGATE =
+            TypeName.create("io.helidon.service.registry.Interception.ExternalDelegate");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.InvocationException}.
+     */
+    public static final TypeName INTERCEPT_EXCEPTION =
+            TypeName.create("io.helidon.service.registry.InterceptionException");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.InterceptionMetadata}.
+     */
+    public static final TypeName INTERCEPT_METADATA = TypeName.create(
+            "io.helidon.service.registry.InterceptionMetadata");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Invoker}.
+     */
+    public static final TypeName INTERCEPT_INVOKER =
+            TypeName.create("io.helidon.service.registry.InterceptionInvoker");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.SupplierFactoryInterceptionWrapper}.
+     */
+    public static final TypeName INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY =
+            TypeName.create("io.helidon.service.registry.GeneratedService.SupplierFactoryInterceptionWrapper");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.ServicesFactoryInterceptionWrapper}.
+     */
+    public static final TypeName INTERCEPT_G_WRAPPER_SERVICES_FACTORY =
+            TypeName.create("io.helidon.service.registry.GeneratedService.ServicesFactoryInterceptionWrapper");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.IpFactoryInterceptionWrapper}.
+     */
+    public static final TypeName INTERCEPT_G_WRAPPER_IP_FACTORY =
+            TypeName.create("io.helidon.service.registry.GeneratedService.IpFactoryInterceptionWrapper");
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.GeneratedService.QualifiedFactoryInterceptionWrapper}.
+     */
+    public static final TypeName INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY =
+            TypeName.create("io.helidon.service.registry.GeneratedService.QualifiedFactoryInterceptionWrapper");
+
+    /**
+     * A Set of Qualifier.
+     */
+    public static final TypeName SET_OF_QUALIFIERS = TypeName.builder(TypeNames.SET)
+            .addTypeArgument(SERVICE_QUALIFIER)
+            .build();
+
+    /**
+     * A list of Qualifier.
+     */
+    public static final TypeName LIST_OF_ANNOTATIONS = TypeName.builder(TypeNames.LIST)
+            .addTypeArgument(TypeNames.ANNOTATION)
+            .build();
+
+    /**
+     * A set of ResolvedType.
+     */
+    public static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
+            .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
+            .build();
+    /**
+     * A set of String.
+     */
+    public static final TypeName SET_OF_STRINGS = TypeName.builder(TypeNames.SET)
+            .addTypeArgument(TypeNames.STRING)
+            .build();
+    /**
+     * A list of Dependency.
+     */
+    public static final TypeName LIST_OF_DEPENDENCIES = TypeName.builder(TypeNames.LIST)
+            .addTypeArgument(ServiceCodegenTypes.SERVICE_DEPENDENCY)
+            .build();
+
+    /**
+     * A {@code GenericType<T>}.
+     */
+    public static final TypeName GENERIC_T_TYPE = TypeName.createFromGenericDeclaration("T");
+
+    /**
+     * A {@code GenericType<?>}.
+     */
+    public static final TypeName ANY_GENERIC_TYPE = TypeName.builder(TypeNames.GENERIC_TYPE)
+            .addTypeArgument(TypeNames.WILDCARD)
+            .build();
+
     private ServiceCodegenTypes() {
     }
 }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
similarity index 84%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
index 9ae22e16a18..8c27de412f3 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
@@ -1,20 +1,4 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -25,7 +9,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
@@ -41,7 +24,6 @@
 import io.helidon.codegen.classmodel.Javadoc;
 import io.helidon.codegen.classmodel.Method;
 import io.helidon.codegen.classmodel.TypeArgument;
-import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
 import io.helidon.common.types.AccessModifier;
@@ -56,456 +38,104 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.RegistryRoundContext;
-import io.helidon.service.codegen.ServiceCodegenTypes;
-import io.helidon.service.codegen.ServiceSuperType;
-import io.helidon.service.codegen.spi.RegistryCodegenExtension;
-import io.helidon.service.inject.codegen.spi.InjectAssignment;
-import io.helidon.service.inject.codegen.spi.InjectCodegenObserver;
-import io.helidon.service.inject.codegen.spi.InjectCodegenObserverProvider;
+import io.helidon.service.codegen.spi.InjectAssignment;
+import io.helidon.service.codegen.spi.InjectCodegenObserver;
 
 import static io.helidon.codegen.CodegenUtil.toConstantName;
+import static io.helidon.service.codegen.CodegenHelper.annotationsField;
+import static io.helidon.service.codegen.ServiceCodegenTypes.ANY_GENERIC_TYPE;
 import static io.helidon.service.codegen.ServiceCodegenTypes.BUILDER_BLUEPRINT;
-import static io.helidon.service.codegen.ServiceCodegenTypes.GENERATED_ANNOTATION;
+import static io.helidon.service.codegen.ServiceCodegenTypes.GENERIC_T_TYPE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_DELEGATE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_EXCEPTION;
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPT_METADATA;
+import static io.helidon.service.codegen.ServiceCodegenTypes.LIST_OF_DEPENDENCIES;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_INJECT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_NAMED;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PER_INSTANCE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PER_LOOKUP;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_DESCRIBE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_INJECT;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_MAIN;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_NAMED;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_INSTANCE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_LOOKUP;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_SCOPE_HANDLER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_SINGLETON;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_FACTORY_TYPE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_IP_SUPPORT;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_SCOPE_HANDLER_DESCRIPTOR;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_INSTANCE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_DELEGATE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPT_METADATA;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_QUALIFIER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_RUN_LEVEL;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_SCOPE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_SINGLETON;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_DEPENDENCY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_FACTORY_TYPE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_G_DEPENDENCY_SUPPORT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_G_PER_INSTANCE_DESCRIPTOR;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_G_QUALIFIED_FACTORY_DESCRIPTOR;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_G_SCOPE_HANDLER_DESCRIPTOR;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_SCOPE_HANDLER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_SERVICE_INSTANCE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_QUALIFIERS;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_RESOLVED_TYPES;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_STRINGS;
 import static java.util.function.Predicate.not;
 
-class InjectionExtension implements RegistryCodegenExtension {
-    static final TypeName LIST_OF_ANNOTATIONS = TypeName.builder(TypeNames.LIST)
-            .addTypeArgument(TypeNames.ANNOTATION)
-            .build();
-    static final TypeName SET_OF_QUALIFIERS = TypeName.builder(TypeNames.SET)
-            .addTypeArgument(InjectCodegenTypes.INJECT_QUALIFIER)
-            .build();
-    static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
-            .addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
-            .build();
-    static final TypeName SET_OF_SIGNATURES = TypeName.builder(TypeNames.SET)
-            .addTypeArgument(TypeNames.STRING)
-            .build();
-    private static final TypeName LIST_OF_IP_IDS = TypeName.builder(TypeNames.LIST)
-            .addTypeArgument(InjectCodegenTypes.INJECT_INJECTION_POINT)
-            .build();
-    private static final TypeName SERVICE_SOURCE_TYPE = TypeName.builder(InjectCodegenTypes.INJECT_SERVICE_DESCRIPTOR)
+public class ServiceDescriptorCodegen {
+    private static final TypeName GENERATOR = TypeName.create(ServiceExtension.class);
+    private static final TypeName DESCRIPTOR_TYPE = TypeName.builder(ServiceCodegenTypes.SERVICE_DESCRIPTOR)
             .addTypeArgument(TypeName.create("T"))
             .build();
-    private static final TypeName GENERATOR = TypeName.create(InjectionExtension.class);
-    private static final TypeName GENERIC_T_TYPE = TypeName.createFromGenericDeclaration("T");
-    private static final TypeName ANY_GENERIC_TYPE = TypeName.builder(TypeNames.GENERIC_TYPE)
-            .addTypeArgument(TypeName.create("?"))
-            .build();
 
-    private final RegistryCodegenContext ctx;
+    private final InterceptionSupport interception;
     private final Assignments assignments;
-    private final Interception interception;
-    private final InterceptionSupport interceptionSupport;
     private final Set<TypeName> scopeMetaAnnotations;
     private final List<InjectCodegenObserver> observers;
+    private final RegistryCodegenContext ctx;
 
-    private volatile boolean mainClassGenerated;
-    private volatile String packageName;
+    private String packageName;
 
-    InjectionExtension(RegistryCodegenContext codegenContext) {
-        this.ctx = codegenContext;
+    ServiceDescriptorCodegen(RegistryCodegenContext ctx,
+                             List<InjectCodegenObserver> observers,
+                             InterceptionSupport interceptionSupport) {
+        this.ctx = ctx;
+        this.observers = observers;
+        this.interception = interceptionSupport;
+        this.assignments = new Assignments(ctx);
 
-        CodegenOptions options = codegenContext.options();
-        this.interception = new Interception(InjectOptions.INTERCEPTION_STRATEGY.value(options));
-        this.scopeMetaAnnotations = InjectOptions.SCOPE_META_ANNOTATIONS.value(options);
+        CodegenOptions options = ctx.options();
+        this.scopeMetaAnnotations = ServiceOptions.SCOPE_META_ANNOTATIONS.value(options);
 
-        this.interceptionSupport = InterceptionSupport.create(ctx);
-        this.assignments = new Assignments(ctx);
-        this.observers = HelidonServiceLoader.create(ServiceLoader.load(InjectCodegenObserverProvider.class,
-                                                                        InjectionExtension.class.getClassLoader()))
-                .stream()
-                .map(it -> it.create(codegenContext))
-                .toList();
         this.packageName = CodegenOptions.CODEGEN_PACKAGE.findValue(options)
                 .orElse(null);
-        this.mainClassGenerated = !options.enabled(InjectOptions.APPLICATION_MAIN_GENERATE);
-    }
-
-    static void annotationsField(ClassModel.Builder classModel, TypeInfo service) {
-        classModel.addField(annotations -> annotations
-                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .name("ANNOTATIONS")
-                .type(LIST_OF_ANNOTATIONS)
-                .addContent(List.class)
-                .addContent(".of(")
-                .update(it -> {
-                    Iterator<Annotation> iterator = service.annotations()
-                            .stream()
-                            .filter(annot -> !annot.typeName().equals(GENERATED_ANNOTATION))
-                            .iterator();
-                    while (iterator.hasNext()) {
-                        Annotation next = iterator.next();
-                        it.addContentCreate(next);
-                        if (iterator.hasNext()) {
-                            it.addContent(", ");
-                        }
-                    }
-                })
-                .addContent(")"));
-    }
-
-    static List<ParamDefinition> declareCtrParamsAndGetThem(Method.Builder method, List<ParamDefinition> params) {
-        List<ParamDefinition> constructorParams = params.stream()
-                .filter(it -> it.kind() == ElementKind.CONSTRUCTOR)
-                .toList();
-
-        // for each parameter, obtain its value from context
-        for (ParamDefinition param : constructorParams) {
-            method.addContent(param.declaredType())
-                    .addContent(" ")
-                    .addContent(param.ipParamName())
-                    .addContent(" = ")
-                    .update(it -> param.assignmentHandler().accept(it))
-                    .addContentLine(";");
-        }
-        if (!params.isEmpty()) {
-            method.addContentLine("");
-        }
-        return constructorParams;
-    }
-
-    @Override
-    public void process(RegistryRoundContext roundContext) {
-        if (this.packageName == null) {
-            // first try from module
-            this.packageName = ctx.module()
-                    .flatMap(ModuleInfo::firstUnqualifiedExport)
-                    .orElse(null);
-            // then use the first from source code
-            if (packageName == null) {
-                packageName = roundContext.types()
-                        .stream()
-                        .map(TypeInfo::typeName)
-                        .map(TypeName::packageName)
-                        .findFirst()
-                        .orElse(null);
-            }
-        }
-
-        Collection<TypeInfo> mainClasses = roundContext.annotatedTypes(INJECTION_MAIN);
-        if (!mainClasses.isEmpty()) {
-            generateMain(roundContext, mainClasses);
-        }
-
-        List<TypeInfo> descriptorsRequired = new ArrayList<>(roundContext.types());
-        mainClasses.forEach(descriptorsRequired::remove);
-
-        for (TypeInfo typeInfo : descriptorsRequired) {
-            if (typeInfo.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)) {
-                generateInterceptionExternalDelegates(roundContext, typeInfo);
-            }
-            if (typeInfo.hasAnnotation(INJECTION_DESCRIBE)) {
-                generateScopeDescriptor(roundContext, typeInfo, typeInfo.annotation(INJECTION_DESCRIBE));
-            } else {
-                generateDescriptor(roundContext, descriptorsRequired, typeInfo);
-            }
-        }
-
-        notifyObservers(roundContext, descriptorsRequired);
-    }
-
-    @Override
-    public void processingOver() {
-        if (!mainClassGenerated) {
-            generateMain();
-        }
-    }
-
-    private static void addAnnotationValue(ContentBuilder<?> contentBuilder, Object objectValue) {
-        switch (objectValue) {
-        case String value -> contentBuilder.addContent("\"" + value + "\"");
-        case Boolean value -> contentBuilder.addContent(String.valueOf(value));
-        case Long value -> contentBuilder.addContent(String.valueOf(value) + 'L');
-        case Double value -> contentBuilder.addContent(String.valueOf(value) + 'D');
-        case Integer value -> contentBuilder.addContent(String.valueOf(value));
-        case Byte value -> contentBuilder.addContent("(byte)" + value);
-        case Character value -> contentBuilder.addContent("'" + value + "'");
-        case Short value -> contentBuilder.addContent("(short)" + value);
-        case Float value -> contentBuilder.addContent(String.valueOf(value) + 'F');
-        case Class<?> value -> contentBuilder.addContentCreate(TypeName.create(value));
-        case TypeName value -> contentBuilder.addContentCreate(value);
-        case Annotation value -> contentBuilder.addContentCreate(value);
-        case Enum<?> value -> toEnumValue(contentBuilder, value);
-        case List<?> values -> toListValues(contentBuilder, values);
-        default -> throw new IllegalStateException("Unexpected annotation value type " + objectValue.getClass()
-                .getName() + ": " + objectValue);
-        }
-    }
-
-    private static void toListValues(ContentBuilder<?> contentBuilder, List<?> values) {
-        contentBuilder.addContent(List.class)
-                .addContent(".of(");
-        int size = values.size();
-        for (int i = 0; i < size; i++) {
-            Object value = values.get(i);
-            addAnnotationValue(contentBuilder, value);
-            if (i != size - 1) {
-                contentBuilder.addContent(",");
-            }
-        }
-        contentBuilder.addContent(")");
-    }
-
-    private static void toEnumValue(ContentBuilder<?> contentBuilder, Enum<?> enumValue) {
-        contentBuilder.addContent(enumValue.getDeclaringClass())
-                .addContent(".")
-                .addContent(enumValue.name());
-    }
-
-    private static void addInterfaceAnnotations(List<Annotation> elementAnnotations,
-                                                List<TypedElements.DeclaredElement> declaredElements) {
-
-        for (TypedElements.DeclaredElement declaredElement : declaredElements) {
-            declaredElement.element()
-                    .annotations()
-                    .forEach(it -> addInterfaceAnnotation(elementAnnotations, it));
-        }
-    }
-
-    private static void addInterfaceAnnotation(List<Annotation> elementAnnotations, Annotation annotation) {
-        // only add if not already there
-        if (!elementAnnotations.contains(annotation)) {
-            elementAnnotations.add(annotation);
-        }
-    }
-
-    private TypeName generateProvidedInterceptionDelegate(RegistryRoundContext roundContext, DescribedService service) {
-        DescribedType providedDescriptor = service.providedDescriptor();
-        TypeInfo typeInfo = providedDescriptor
-                .typeInfo();
-
-        TypeName expectedInterceptionDelegate = interceptionSupport.interceptedDelegateType(typeInfo.typeName());
-
-        // now we need to check this is generated
-        if (ctx.typeInfo(expectedInterceptionDelegate).isPresent()) {
-            // it was already generated for another provider maybe
-            return expectedInterceptionDelegate;
-        } else {
-            if (canDelegate(service.serviceDescriptor().typeInfo(),
-                            typeInfo)) {
-                // we must generate it right now
-                interceptionSupport.generateDelegateInterception(roundContext,
-                                                                 typeInfo,
-                                                                 providedDescriptor.elements(),
-                                                                 expectedInterceptionDelegate);
-
-                return expectedInterceptionDelegate;
-            }
-
-            throw new CodegenException("Attempting to create delegate interception for non interface type. "
-                                               + "If the type is ready to be delegated, annotate it with "
-                                               + INTERCEPTION_DELEGATE.fqName() + ", or annotate the service provider with "
-                                               + INTERCEPTION_EXTERNAL_DELEGATE.fqName()
-                                               + "(" + typeInfo.typeName().classNameWithEnclosingNames()
-                                               + ".class) if it is not under your control",
-                                       service.serviceDescriptor().typeInfo().originatingElementValue());
-        }
     }
 
-    private boolean canDelegate(TypeInfo providerType, TypeInfo providedType) {
-        // interfaces are always supported
-        if (providedType.kind() == ElementKind.INTERFACE) {
-            return true;
-        }
-        // it is itself marked as a delegate
-        if (providedType.hasAnnotation(INTERCEPTION_DELEGATE)) {
-            return true;
-        }
-        // only if marked as external delegate
-        return providerType.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)
-                && providerType.annotation(INTERCEPTION_EXTERNAL_DELEGATE)
-                .typeValue().map(it -> providedType.typeName().equals(it))
-                .orElse(false);
-    }
-
-    private void generateInterceptionExternalDelegates(RegistryRoundContext roundContext, TypeInfo typeInfo) {
-        Annotation annotation = typeInfo.annotation(INTERCEPTION_EXTERNAL_DELEGATE);
-        List<TypeName> typeNames = annotation.typeValues().orElseGet(List::of);
-        boolean supportClasses = annotation.booleanValue("classDelegates").orElse(false);
-
-        for (TypeName typeName : typeNames) {
-            TypeInfo delegateType = ctx.typeInfo(typeName)
-                    .orElseThrow(() -> new CodegenException("Cannot resolve type " + typeName.fqName() + " for "
-                                                                    + " external interception delegates",
-                                                            typeInfo.originatingElementValue()));
-            if (!supportClasses && typeInfo.kind() != ElementKind.INTERFACE) {
-                throw new CodegenException("Attempting to create external delegate interception for non interface type: "
-                                                   + typeName.fqName(),
-                                           typeInfo.originatingElementValue());
-            }
-            interceptionSupport.generateDelegateInterception(roundContext,
-                                                             delegateType,
-                                                             delegateType.typeName(),
-                                                             typeInfo.typeName().packageName());
-        }
+    /**
+     * When used from outside, we do not support interception
+     * This method is intended for types generated by a Maven plugin, that have limited functions.
+     *
+     * @param ctx codegen context
+     * @return a new codegen instance
+     */
+    public static ServiceDescriptorCodegen create(RegistryCodegenContext ctx) {
+        Interception interception = new Interception(InterceptionStrategy.NONE);
+        return new ServiceDescriptorCodegen(ctx,
+                                            List.of(),
+                                            new InterceptionSupport(ctx, interception));
     }
 
-    private void generateScopeDescriptor(RegistryRoundContext roundContext, TypeInfo serviceInfo, Annotation describeAnnotation) {
-        DescribedService service = DescribedService.create(ctx,
-                                                           roundContext,
-                                                           interception,
-                                                           serviceInfo,
-                                                           ServiceSuperType.create(),
-                                                           describeAnnotation.typeValue().orElse(INJECTION_SINGLETON));
-
-        DescribedType serviceDescriptor = service.serviceDescriptor();
-        TypeName serviceTypeName = serviceDescriptor.typeName();
-
-        ClassModel.Builder classModel = ClassModel.builder()
-                .copyright(CodegenUtil.copyright(GENERATOR,
-                                                 serviceTypeName,
-                                                 service.descriptorType()))
-                .addAnnotation(CodegenUtil.generatedAnnotation(GENERATOR,
-                                                               serviceTypeName,
-                                                               service.descriptorType(),
-                                                               "1",
-                                                               ""))
-                .addInterface(SERVICE_SOURCE_TYPE)
-                .type(service.descriptorType())
-                .addGenericArgument(TypeArgument.create("T extends " + serviceTypeName.fqName()))
-                .javadoc(Javadoc.builder()
-                                 .add("Service descriptor for {@link " + serviceTypeName.fqName() + "}.")
-                                 .addGenericArgument("T", "type of the service, for extensibility")
-                                 .build())
-                // we need to keep insertion order, as constants may depend on each other
-                .sortStaticFields(false);
-
-        var contracts = serviceDescriptor.contracts();
-
-        singletonInstanceField(classModel, service);
-
-        serviceTypeMethod(classModel, service);
-        descriptorTypeMethod(classModel, service);
-        scopeMethod(classModel, service);
-        contractsMethod(classModel, service, contracts, Set.of());
-
-        // annotations of the type
-        annotationsField(classModel, serviceDescriptor.typeInfo());
-        // add protected constructor
-        classModel.addConstructor(constructor -> constructor.description("Constructor with no side effects")
-                .accessModifier(AccessModifier.PROTECTED));
-        // methods (some methods define fields as well)
-        qualifiersMethod(classModel, service);
-        weightMethod(classModel, service);
-        runLevelMethod(classModel, service);
-        factoryType(classModel, service, FactoryType.NONE);
-
-        // service type is an implicit contract
-        Set<ResolvedType> serviceContracts = new HashSet<>(contracts);
-        serviceContracts.add(ResolvedType.create(serviceTypeName));
-
-        roundContext.addDescriptor("inject",
-                                   serviceTypeName,
-                                   service.descriptorType(),
-                                   classModel,
-                                   weight(serviceDescriptor.typeInfo()).orElse(Weighted.DEFAULT_WEIGHT),
-                                   serviceContracts,
-                                   Set.of(),
-                                   serviceDescriptor.typeInfo().originatingElementValue());
-    }
-
-    private void generateMain() {
-        if (packageName == null) {
-            throw new CodegenException("Cannot determine package name for the generated main class. "
-                                               + "Please use option " + CodegenOptions.CODEGEN_PACKAGE.name()
-                                               + " to specify it");
-        }
-        // generate main class if it doe not exist
-        String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
-        TypeName generatedType = TypeName.builder()
-                .packageName(packageName)
-                .className(className)
-                .build();
-
-        ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
-                                                                               Set.of(),
-                                                                               INJECT_MAIN,
-                                                                               generatedType,
-                                                                               false,
-                                                                               false,
-                                                                               (a, b, c) -> {
-                                                                             },
-                                                                               (a, b, c) -> {
-                                                                             });
-        ctx.filer()
-                .writeSourceFile(applicationMain.build(), GENERATOR);
-    }
-
-    private void generateMain(RegistryRoundContext roundCtx, Collection<TypeInfo> customMainClasses) {
-        TypeInfo customMain = customMainClasses.iterator().next();
-
-        if (customMainClasses.size() != 1) {
-            String names = customMainClasses.stream()
-                    .map(TypeInfo::typeName)
-                    .map(TypeName::fqName)
-                    .collect(Collectors.joining(", "));
-            throw new CodegenException("There can only be one class annotated with " + INJECTION_MAIN.fqName() + ", "
-                                               + "but discovered more than one: " + names,
-                                       customMain.originatingElementValue());
-        }
+    /**
+     * Describe a service type.
+     *
+     * @param generator type of the generator
+     * @param roundCtx  round context
+     * @param services  all types that are going to be described
+     * @param typeInfo  type info of the service type
+     */
+    public void service(TypeName generator, RegistryRoundContext roundCtx, Collection<TypeInfo> services, TypeInfo typeInfo) {
+        packageName(roundCtx);
 
-        // we always generate the main class, even when there is no Maven plugin
-        mainClassGenerated = true;
-        String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
-        TypeName generatedType = TypeName.builder()
-                .packageName(customMain.typeName().packageName())
-                .className(className)
-                .build();
-        ApplicationMainGenerator.validate(customMain);
-        var declaredSignatures = ApplicationMainGenerator.declaredSignatures(customMain);
-
-        ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
-                                                                               declaredSignatures,
-                                                                               customMain.typeName(),
-                                                                               generatedType,
-                                                                               true,
-                                                                               false,
-                                                                               (a, b, c) -> {
-                                                                             },
-                                                                               (a, b, c) -> {
-                                                                             });
-        roundCtx.addGeneratedType(generatedType,
-                                  applicationMain,
-                                  GENERATOR);
-    }
-
-    // we are generating source code, that requires multiple lines
-    // I would rather keep this method readable, then to put multiple statements in a single line
-    @SuppressWarnings("checkstyle:MethodLength")
-    private void generateDescriptor(RegistryRoundContext roundContext,
-                                    Collection<TypeInfo> services,
-                                    TypeInfo typeInfo) {
         if (typeInfo.kind() == ElementKind.INTERFACE || typeInfo.kind() == ElementKind.ANNOTATION_TYPE) {
             // we cannot support multiple inheritance, so full descriptors for interfaces do not make sense
             return;
         }
 
-        TypeName scope = scope(typeInfo).orElse(INJECTION_PER_LOOKUP);
+        TypeName scope = scope(typeInfo);
+
         DescribedService service = DescribedService.create(ctx,
-                                                           roundContext,
+                                                           roundCtx,
                                                            interception,
                                                            typeInfo,
                                                            superType(typeInfo, services),
@@ -527,7 +157,7 @@ private void generateDescriptor(RegistryRoundContext roundContext,
                constructorInjectElement,
                fieldInjectElements);
 
-        notifyIpObservers(roundContext, service, params);
+        notifyIpObservers(roundCtx, service, params);
 
         ClassModel.Builder classModel = ClassModel.builder()
                 .copyright(CodegenUtil.copyright(GENERATOR,
@@ -567,9 +197,9 @@ private void generateDescriptor(RegistryRoundContext roundContext,
                     contracts = Set.of();
                     factoryContracts = Set.of();
                     // generate delegate injection (unless already generated) in current package
-                    TypeName delegateType = generateProvidedInterceptionDelegate(roundContext, service);
+                    TypeName delegateType = generateProvidedInterceptionDelegate(roundCtx, service);
                     // then generate a service that injects the original service, and wraps provider method(s) using delegation
-                    generateDelegationService(roundContext, service, delegateType);
+                    generateDelegationService(roundCtx, service, delegateType);
                 } else {
                     contracts = service.providedDescriptor().contracts();
                     factoryContracts = service.serviceDescriptor().contracts();
@@ -582,11 +212,8 @@ private void generateDescriptor(RegistryRoundContext roundContext,
         // declare the class
         if (service.superType().present()) {
             classModel.superType(service.superType().descriptorType());
-            if (service.superType().serviceType().equals("core")) {
-                classModel.addInterface(SERVICE_SOURCE_TYPE);
-            }
         } else {
-            classModel.addInterface(SERVICE_SOURCE_TYPE);
+            classModel.addInterface(DESCRIPTOR_TYPE);
         }
 
         // the basic fields and methods
@@ -650,334 +277,258 @@ private void generateDescriptor(RegistryRoundContext roundContext,
             metaInfFactoryContracts.add(ResolvedType.create(serviceTypeName));
         }
 
-        roundContext.addDescriptor("inject",
-                                   serviceTypeName,
-                                   service.descriptorType(),
-                                   classModel,
-                                   weight(typeInfo).orElse(Weighted.DEFAULT_WEIGHT),
-                                   metaInfServiceContracts,
-                                   metaInfFactoryContracts,
-                                   typeInfo.originatingElementValue());
+        roundCtx.addDescriptor("core",
+                               serviceTypeName,
+                               service.descriptorType(),
+                               classModel,
+                               weight(typeInfo).orElse(Weighted.DEFAULT_WEIGHT),
+                               metaInfServiceContracts,
+                               metaInfFactoryContracts,
+                               typeInfo.originatingElementValue());
 
         if (serviceElements.methodsIntercepted()) {
-            generateInterceptedType(roundContext, typeInfo, service, constructorInjectElement);
+            generateInterceptedType(roundCtx, typeInfo, service, constructorInjectElement);
         }
     }
 
-    private void generateDelegationService(RegistryRoundContext roundContext,
-                                           DescribedService service,
-                                           TypeName delegateType) {
-        TypeName typeName = service.serviceDescriptor().typeName();
+    /**
+     * Describe a service type.
+     *
+     * @param roundCtx round context
+     * @param services all types that are going to be described
+     * @param typeInfo type info of the service type
+     */
+    void service(RegistryRoundContext roundCtx, Collection<TypeInfo> services, TypeInfo typeInfo) {
+        service(GENERATOR, roundCtx, services, typeInfo);
+    }
 
-        String typeNameSuffix = "__Interception_Wrapper";
-        TypeName wrapperType = TypeName.builder()
-                .packageName(typeName.packageName())
-                .className(typeName.classNameWithEnclosingNames().replace('.', '_') + typeNameSuffix)
-                .build();
-        var classModel = ClassModel.builder()
-                .type(wrapperType)
-                .addAnnotation(Annotation.create(service.scope()))
-                .addInterface(service.providerInterface())
-                .superType(service.interceptionWrapperSuperType())
-                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
+    /**
+     * Describe a type annotated with {@code @Service.Describe}.
+     *
+     * @param roundCtx           round context
+     * @param typeInfo           type info of the annotated type
+     * @param describeAnnotation describe annotation
+     */
+    void describe(RegistryRoundContext roundCtx, TypeInfo typeInfo, Annotation describeAnnotation) {
+        packageName(roundCtx);
+
+        DescribedService service = DescribedService.create(ctx,
+                                                           roundCtx,
+                                                           interception,
+                                                           typeInfo,
+                                                           ServiceSuperType.create(),
+                                                           describeAnnotation.typeValue().orElse(SERVICE_ANNOTATION_SINGLETON));
+
+        DescribedType serviceDescriptor = service.serviceDescriptor();
+        TypeName serviceTypeName = serviceDescriptor.typeName();
+
+        ClassModel.Builder classModel = ClassModel.builder()
                 .copyright(CodegenUtil.copyright(GENERATOR,
-                                                 typeName,
-                                                 wrapperType))
+                                                 serviceTypeName,
+                                                 service.descriptorType()))
                 .addAnnotation(CodegenUtil.generatedAnnotation(GENERATOR,
-                                                               typeName,
-                                                               wrapperType,
+                                                               serviceTypeName,
+                                                               service.descriptorType(),
                                                                "1",
-                                                               ""));
-        service.qualifiers()
-                .forEach(classModel::addAnnotation);
+                                                               ""))
+                .addInterface(DESCRIPTOR_TYPE)
+                .type(service.descriptorType())
+                .addGenericArgument(TypeArgument.create("T extends " + serviceTypeName.fqName()))
+                .javadoc(Javadoc.builder()
+                                 .add("Service descriptor for {@link " + serviceTypeName.fqName() + "}.")
+                                 .addGenericArgument("T", "type of the service, for extensibility")
+                                 .build())
+                // we need to keep insertion order, as constants may depend on each other
+                .sortStaticFields(false);
 
-        classModel.addField(interceptMeta -> interceptMeta
-                .type(INTERCEPT_METADATA)
-                .name("interceptMeta")
-                .isFinal(true)
-                .accessModifier(AccessModifier.PRIVATE));
+        var contracts = serviceDescriptor.contracts();
 
-        classModel.addConstructor(ctr -> ctr
-                .addAnnotation(Annotation.create(INJECTION_INJECT))
-                .addParameter(delegate -> delegate
-                        .update(it -> service.qualifiers().forEach(it::addAnnotation))
-                        .type(typeName)
-                        .name("delegate"))
-                .addParameter(interceptMeta -> interceptMeta
-                        .type(INTERCEPT_METADATA)
-                        .name("interceptMeta"))
-                .addContentLine("super(delegate);")
-                .addContentLine("this.interceptMeta = interceptMeta;")
-        );
+        singletonInstanceField(classModel, service);
 
-        TypeName descriptorType = service.descriptorType();
-        classModel.addMethod(wrap -> wrap
-                .addAnnotation(Annotations.OVERRIDE)
-                .accessModifier(AccessModifier.PROTECTED)
-                .name("wrap")
-                .returnType(service.providedDescriptor().typeName())
-                .addParameter(instance -> instance
-                        .type(service.providedDescriptor().typeName())
-                        .name("instance"))
-                .addContent("return ")
-                .addContent(delegateType)
-                .addContentLine(".create(")
-                .increaseContentPadding()
-                .increaseContentPadding()
-                .addContentLine("interceptMeta,")
-                .addContent(descriptorType)
-                .addContentLine(".INSTANCE,")
-                .addContentLine("instance);")
-        );
+        serviceTypeMethod(classModel, service);
+        descriptorTypeMethod(classModel, service);
+        scopeMethod(classModel, service);
+        contractsMethod(classModel, service, contracts, Set.of());
 
-        roundContext.addGeneratedType(wrapperType,
-                                      classModel,
-                                      typeName,
-                                      service.serviceDescriptor().typeInfo().originatingElementValue());
+        // annotations of the type
+        annotationsField(classModel, serviceDescriptor.typeInfo());
+        // add protected constructor
+        classModel.addConstructor(constructor -> constructor.description("Constructor with no side effects")
+                .accessModifier(AccessModifier.PROTECTED));
+        // methods (some methods define fields as well)
+        qualifiersMethod(classModel, service);
+        weightMethod(classModel, service);
+        runLevelMethod(classModel, service);
+        factoryType(classModel, service, FactoryType.NONE);
+
+        // service type is an implicit contract
+        Set<ResolvedType> serviceContracts = new HashSet<>(contracts);
+        serviceContracts.add(ResolvedType.create(serviceTypeName));
+
+        roundCtx.addDescriptor("core",
+                               serviceTypeName,
+                               service.descriptorType(),
+                               classModel,
+                               weight(serviceDescriptor.typeInfo()).orElse(Weighted.DEFAULT_WEIGHT),
+                               serviceContracts,
+                               Set.of(),
+                               serviceDescriptor.typeInfo().originatingElementValue());
     }
 
-    private void factoryType(ClassModel.Builder classModel, DescribedService service, FactoryType factoryType) {
-        if (service.superType().empty() && factoryType == FactoryType.SERVICE) {
-            // default
-            return;
+    private static void addAnnotationValue(ContentBuilder<?> contentBuilder, Object objectValue) {
+        switch (objectValue) {
+        case String value -> contentBuilder.addContent("\"" + value + "\"");
+        case Boolean value -> contentBuilder.addContent(String.valueOf(value));
+        case Long value -> contentBuilder.addContent(String.valueOf(value) + 'L');
+        case Double value -> contentBuilder.addContent(String.valueOf(value) + 'D');
+        case Integer value -> contentBuilder.addContent(String.valueOf(value));
+        case Byte value -> contentBuilder.addContent("(byte)" + value);
+        case Character value -> contentBuilder.addContent("'" + value + "'");
+        case Short value -> contentBuilder.addContent("(short)" + value);
+        case Float value -> contentBuilder.addContent(String.valueOf(value) + 'F');
+        case Class<?> value -> contentBuilder.addContentCreate(TypeName.create(value));
+        case TypeName value -> contentBuilder.addContentCreate(value);
+        case Annotation value -> contentBuilder.addContentCreate(value);
+        case Enum<?> value -> toEnumValue(contentBuilder, value);
+        case List<?> values -> toListValues(contentBuilder, values);
+        default -> throw new IllegalStateException("Unexpected annotation value type " + objectValue.getClass()
+                .getName() + ": " + objectValue);
         }
-        classModel.addMethod(providerTypeMethod -> providerTypeMethod
-                .name("factoryType")
-                .accessModifier(AccessModifier.PUBLIC)
-                .addAnnotation(Annotations.OVERRIDE)
-                .returnType(INJECT_FACTORY_TYPE)
-                .addContent("return ")
-                .addContent(INJECT_FACTORY_TYPE)
-                .addContent(".")
-                .addContent(factoryType.name())
-                .addContentLine(";")
-        );
     }
 
-    private void methodElementFields(ClassModel.Builder classModel,
-                                     DescribedService service) {
-        Set<ElementSignature> elementSignatures = service.serviceDescriptor()
-                .elements()
-                .interceptedMethods();
-        List<TypedElements.ElementMeta> interceptedElements = service.serviceDescriptor()
-                .elements()
-                .interceptedElements()
-                .stream()
-                .filter(it -> elementSignatures.contains(it.element().signature()))
-                .collect(Collectors.toUnmodifiableList());
-        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
-
-        for (TypedElements.ElementMeta element : interceptedElements) {
-            var method = element.element();
-            String uniqueName = ctx.uniqueName(typeInfo, method);
-            String constantName = "METHOD_" + toConstantName(uniqueName);
-
-            // add inherited annotations from interfaces
-            List<Annotation> elementAnnotations = new ArrayList<>(method.annotations());
-            addInterfaceAnnotations(elementAnnotations, element.abstractMethods());
-            TypedElementInfo typedElementInfo = TypedElementInfo.builder()
-                    .from(method)
-                    .annotations(elementAnnotations)
-                    .build();
-            classModel.addField(constant -> constant
-                    .description("Element info for method: {@code " + method.signature() + "}.")
-                    .accessModifier(AccessModifier.PUBLIC)
-                    .isStatic(true)
-                    .isFinal(true)
-                    .type(TypeNames.TYPED_ELEMENT_INFO)
-                    .name(constantName)
-                    .addContentCreate(typedElementInfo));
+    private static void toListValues(ContentBuilder<?> contentBuilder, List<?> values) {
+        contentBuilder.addContent(List.class)
+                .addContent(".of(");
+        int size = values.size();
+        for (int i = 0; i < size; i++) {
+            Object value = values.get(i);
+            addAnnotationValue(contentBuilder, value);
+            if (i != size - 1) {
+                contentBuilder.addContent(",");
+            }
         }
-        /*
-        TypedElements.gatherElements(typeInfo)
-                .stream()
-                .filter(element -> ElementInfoPredicates.isMethod(element.element()))
-                .filter(element -> !ElementInfoPredicates.isPrivate(element.element()))
-                .forEach(element -> {
-                    var method = element.element();
-                    String uniqueName = ctx.uniqueName(typeInfo, method);
-                    String constantName = "METHOD_" + toConstantName(uniqueName);
-
-                    // add inherited annotations from interfaces
-                    List<Annotation> elementAnnotations = new ArrayList<>(method.annotations());
-                    addInterfaceAnnotations(elementAnnotations, element.abstractMethods());
-                    TypedElementInfo typedElementInfo = TypedElementInfo.builder()
-                            .from(method)
-                            .annotations(elementAnnotations)
-                            .build();
-                    classModel.addField(constant -> constant
-                            .description("Element info for method: {@code " + method.signature() + "}.")
-                            .accessModifier(AccessModifier.PUBLIC)
-                            .isStatic(true)
-                            .isFinal(true)
-                            .type(TypeNames.TYPED_ELEMENT_INFO)
-                            .name(constantName)
-                            .addContentCreate(typedElementInfo));
-                });
-         */
+        contentBuilder.addContent(")");
     }
 
-    private void generateInterceptedType(RegistryRoundContext roundContext,
-                                         TypeInfo typeInfo,
-                                         DescribedService service,
-                                         TypedElementInfo constructorInjectElement) {
-        TypeName typeName = service.serviceDescriptor().typeName();
-
-        TypeName interceptedType = interceptedTypeName(typeName);
+    private static void toEnumValue(ContentBuilder<?> contentBuilder, Enum<?> enumValue) {
+        contentBuilder.addContent(enumValue.getDeclaringClass())
+                .addContent(".")
+                .addContent(enumValue.name());
+    }
 
-        var generator = new InterceptedTypeGenerator(ctx,
-                                                     typeInfo,
-                                                     typeName,
-                                                     service.descriptorType(),
-                                                     interceptedType,
-                                                     constructorInjectElement,
-                                                     service.serviceDescriptor()
-                                                             .elements()
-                                                             .interceptedElements()
-                                                             .stream()
-                                                             .filter(it -> it.element().kind() == ElementKind.METHOD)
-                                                             .toList());
+    private static void addInterfaceAnnotations(List<Annotation> elementAnnotations,
+                                                List<TypedElements.DeclaredElement> declaredElements) {
 
-        roundContext.addGeneratedType(interceptedType,
-                                      generator.generate(),
-                                      typeName,
-                                      typeInfo.originatingElementValue());
+        for (TypedElements.DeclaredElement declaredElement : declaredElements) {
+            declaredElement.element()
+                    .annotations()
+                    .forEach(it -> addInterfaceAnnotation(elementAnnotations, it));
+        }
     }
 
-    private TypeName interceptedTypeName(TypeName serviceType) {
-        return TypeName.builder(serviceType)
-                .className(serviceType.classNameWithEnclosingNames().replace('.', '_') + "__Intercepted")
-                .enclosingNames(List.of())
-                .build();
+    private static void addInterfaceAnnotation(List<Annotation> elementAnnotations, Annotation annotation) {
+        // only add if not already there
+        if (!elementAnnotations.contains(annotation)) {
+            elementAnnotations.add(annotation);
+        }
     }
 
-    private void qualifiedProvider(ClassModel.Builder classModel, DescribedService service) {
-        var typeName = service.qualifiedProviderQualifier();
-        if (typeName == null) {
-            // just use default from interface, we only need to declare this on a type that explicitly implements
-            // QualifiedProvider
-            return;
-        }
-        classModel.addInterface(INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR);
+    private static List<ParamDefinition> declareCtrParamsAndGetThem(Method.Builder method, List<ParamDefinition> params) {
+        List<ParamDefinition> constructorParams = params.stream()
+                .filter(it -> it.kind() == ElementKind.CONSTRUCTOR)
+                .toList();
 
-        classModel.addField(qpField -> qpField
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .name("QP_QUALIFIER")
-                .type(TypeNames.TYPE_NAME)
-                .addContentCreate(typeName)
-        );
-        classModel.addMethod(qpMethod ->
-                                     qpMethod
-                                             .accessModifier(AccessModifier.PUBLIC)
-                                             .returnType(TypeNames.TYPE_NAME)
-                                             .name("qualifierType")
-                                             .addAnnotation(Annotations.OVERRIDE)
-                                             .addContentLine("return QP_QUALIFIER;")
-        );
+        // for each parameter, obtain its value from context
+        for (ParamDefinition param : constructorParams) {
+            method.addContent(param.declaredType())
+                    .addContent(" ")
+                    .addContent(param.ipParamName())
+                    .addContent(" = ")
+                    .update(it -> param.assignmentHandler().accept(it))
+                    .addContentLine(";");
+        }
+        if (!params.isEmpty()) {
+            method.addContentLine("");
+        }
+        return constructorParams;
     }
 
-    private void scopeHandler(TypeInfo typeInfo, ClassModel.Builder classModel, Set<ResolvedType> contracts) {
-        if (contracts.stream()
-                .noneMatch(it -> it.type().equals(INJECTION_SCOPE_HANDLER))) {
+    private void notifyIpObservers(RegistryRoundContext roundContext, DescribedService service, List<ParamDefinition> params) {
+        if (observers.isEmpty()) {
             return;
         }
 
-        TypeName handledScope = findHandledScope(typeInfo);
-
-        classModel.addInterface(INJECT_G_SCOPE_HANDLER_DESCRIPTOR);
-        classModel.addField(scopeField -> scopeField
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .name("SCOPE_HANDLER_SCOPE")
-                .type(TypeNames.TYPE_NAME)
-                .addContentCreate(handledScope));
-
-        classModel.addMethod(handledScopeMethod -> handledScopeMethod
-                .accessModifier(AccessModifier.PUBLIC)
-                .addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeNames.TYPE_NAME)
-                .name("handledScope")
-                .addContentLine("return SCOPE_HANDLER_SCOPE;"));
+        for (ParamDefinition param : params) {
+            TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+            TypedElementInfo owningElement = param.owningElement();
+            TypedElementInfo ipElement = param.elementInfo();
+            observers.forEach(it -> it.onInjectionPoint(
+                    roundContext,
+                    typeInfo,
+                    owningElement,
+                    ipElement));
+        }
     }
 
-    private TypeName findHandledScope(TypeInfo typeInfo) {
-        return typeInfo.findAnnotation(INJECTION_NAMED)
-                .flatMap(Annotation::value)
-                .map(TypeName::create)
-                .orElseThrow(() -> new CodegenException(
-                        "Type implementing ScopeHandler must be qualified with the scope type name: " + typeInfo.typeName()));
+    private void packageName(RegistryRoundContext roundCtx) {
+        if (this.packageName == null) {
+            // first try from module
+            this.packageName = ctx.module()
+                    .flatMap(ModuleInfo::firstUnqualifiedExport)
+                    .orElse(null);
+            // then use the first from source code
+            if (packageName == null) {
+                packageName = roundCtx.types()
+                        .stream()
+                        .map(TypeInfo::typeName)
+                        .map(TypeName::packageName)
+                        .findFirst()
+                        .orElse(null);
+            }
+        }
     }
 
-    private void createForMethod(ClassModel.Builder classModel,
-                                 DescribedService service) {
-
-        TypeInfo serviceTypeInfo = service.serviceDescriptor().typeInfo();
-        TypeName serviceTypeName = service.serviceDescriptor().typeName();
+    private TypeName scope(TypeInfo service) {
+        Set<TypeName> result = new LinkedHashSet<>();
 
-        Optional<Annotation> createFor = serviceTypeInfo.findAnnotation(INJECTION_PER_INSTANCE);
-        if (service.superType().empty() && createFor.isEmpty()) {
-            // this is the default
-            return;
-        }
-        if (createFor.isPresent()) {
-            if (service.providerType() != FactoryType.SERVICE) {
-                throw new CodegenException("Service " + serviceTypeName.classNameWithEnclosingNames()
-                                                   + " is annotated with @"
-                                                   + INJECTION_PER_INSTANCE.classNameWithEnclosingNames()
-                                                   + ", and as such it must not implement any "
-                                                   + "provider interfaces. Provider type: " + service.providerType(),
-                                           serviceTypeInfo.originatingElementValue());
+        for (Annotation anno : service.annotations()) {
+            TypeName annoType = anno.typeName();
+            if (service.hasMetaAnnotation(annoType, SERVICE_ANNOTATION_SCOPE)) {
+                result.add(annoType);
+                continue;
             }
-
-            TypeName createForType = createFor.get()
-                    .typeValue()
-                    .orElseThrow(() -> new CodegenException(INJECTION_PER_INSTANCE.fqName()
-                                                                    + ".value() is required, yet not found on type: "
-                                                                    + serviceTypeName.fqName()));
-
-            String createForClassName = createForType.className();
-            if (createForClassName.endsWith("Blueprint")) {
-                // this may be a config blueprint, use the config instance
-                Optional<TypeInfo> createForTypeInfo = ctx.typeInfo(createForType);
-                if (createForTypeInfo.isPresent()) {
-                    if (createForTypeInfo.get().hasAnnotation(BUILDER_BLUEPRINT)) {
-                        createForType = TypeName.builder(createForType)
-                                .className(createForClassName.substring(0, createForClassName.length() - "Blueprint".length()))
-                                .build();
-                    }
+            for (TypeName scopeMetaAnnotation : scopeMetaAnnotations) {
+                if (service.hasMetaAnnotation(annoType, scopeMetaAnnotation)) {
+                    result.add(annoType);
                 }
             }
+        }
 
-            if (createForType.packageName().isBlank()) {
-                throw new CodegenException(INJECTION_PER_INSTANCE.classNameWithEnclosingNames()
-                                                   + " type used on " + serviceTypeName.fqName() + " does not have a "
-                                                   + "package defined. Package is mandatory. If the type is a generated"
-                                                   + " prototype, please use the Blueprint type instead.");
-            }
+        if (result.size() > 1) {
+            throw new CodegenException("Type " + service.typeName().fqName() + " has more than one scope defined. "
+                                               + "This is not supported. Scopes. " + result);
+        }
 
-            // used from lambda
-            TypeName createForTypeFinal = createForType;
-            classModel.addInterface(InjectCodegenTypes.INJECT_G_PER_INSTANCE_DESCRIPTOR);
+        if (!result.isEmpty()) {
+            return result.iterator().next();
+        }
 
-            classModel.addField(createForField -> createForField
-                    .accessModifier(AccessModifier.PRIVATE)
-                    .isStatic(true)
-                    .isFinal(true)
-                    .name("CREATE_FOR")
-                    .type(TypeNames.TYPE_NAME)
-                    .addContentCreate(createForTypeFinal));
+        if (service.hasAnnotation(SERVICE_ANNOTATION_PER_INSTANCE)) {
+            return SERVICE_ANNOTATION_SINGLETON;
+        }
 
-            classModel.addMethod(createForMethod -> createForMethod
-                    .accessModifier(AccessModifier.PUBLIC)
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .returnType(TypeNames.TYPE_NAME)
-                    .name("createFor")
-                    .addContentLine("return CREATE_FOR;"));
+        if (service.hasAnnotation(SERVICE_ANNOTATION_PROVIDER)) {
+            // if supplier, per lookup, otherwise singleton; will be removed once we remove Service.Provider (if we remove it)
+            if (service.interfaceTypeInfo()
+                    .stream()
+                    .map(TypeInfo::typeName)
+                    .anyMatch(TypeNames.SUPPLIER::equals)) {
+                return SERVICE_ANNOTATION_PER_LOOKUP;
+            }
+            return SERVICE_ANNOTATION_SINGLETON;
         }
 
+        return SERVICE_ANNOTATION_PER_LOOKUP;
     }
 
     private ServiceSuperType superType(TypeInfo typeInfo, Collection<TypeInfo> services) {
@@ -1013,19 +564,19 @@ private TypedElementInfo injectConstructor(TypeInfo typeInfo) {
         var constructors = typeInfo.elementInfo()
                 .stream()
                 .filter(it -> it.kind() == ElementKind.CONSTRUCTOR)
-                .filter(it -> it.hasAnnotation(InjectCodegenTypes.INJECTION_INJECT))
+                .filter(it -> it.hasAnnotation(SERVICE_ANNOTATION_INJECT))
                 .collect(Collectors.toUnmodifiableList());
         if (constructors.size() > 1) {
             throw new CodegenException("There can only be one constructor annotated with "
-                                               + InjectCodegenTypes.INJECTION_INJECT.fqName() + ", but there were "
+                                               + SERVICE_ANNOTATION_INJECT.fqName() + ", but there were "
                                                + constructors.size(),
                                        typeInfo.originatingElementValue());
         }
         if (!constructors.isEmpty()) {
-            // @Injection.Inject
+            // @Service.Inject
             TypedElementInfo first = constructors.getFirst();
             if (ElementInfoPredicates.isPrivate(first)) {
-                throw new CodegenException("Constructor annotated with " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+                throw new CodegenException("Constructor annotated with " + SERVICE_ANNOTATION_INJECT.fqName()
                                                    + " must not be private.");
             }
             return first;
@@ -1060,21 +611,21 @@ private List<TypedElementInfo> fieldInjectElements(TypeInfo typeInfo) {
                 .stream()
                 .filter(not(ElementInfoPredicates::isStatic))
                 .filter(ElementInfoPredicates::isField)
-                .filter(ElementInfoPredicates.hasAnnotation(InjectCodegenTypes.INJECTION_INJECT))
+                .filter(ElementInfoPredicates.hasAnnotation(SERVICE_ANNOTATION_INJECT))
                 .toList();
         var firstFound = injectFields.stream()
                 .filter(ElementInfoPredicates::isPrivate)
                 .findFirst();
         if (firstFound.isPresent()) {
             if (typeInfo.kind() == ElementKind.RECORD) {
-                throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+                throw new CodegenException("Discovered " + SERVICE_ANNOTATION_INJECT.fqName()
                                                    + " annotation on record field(s). This is not supported. "
                                                    + "If this is the only constructor, you can remove the Inject annotation; "
                                                    + "if you need to inject the default constructor, kindly create an explicit"
                                                    + " default constructor and annotate it with Inject.",
                                            firstFound.get().originatingElementValue());
             }
-            throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+            throw new CodegenException("Discovered " + SERVICE_ANNOTATION_INJECT.fqName()
                                                + " annotation on private field(s). We cannot support private field injection.",
                                        firstFound.get().originatingElementValue());
         }
@@ -1082,13 +633,37 @@ private List<TypedElementInfo> fieldInjectElements(TypeInfo typeInfo) {
                 .filter(ElementInfoPredicates::isStatic)
                 .findFirst();
         if (firstFound.isPresent()) {
-            throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+            throw new CodegenException("Discovered " + SERVICE_ANNOTATION_INJECT.fqName()
                                                + " annotation on static field(s).",
                                        firstFound.get().originatingElementValue());
         }
         return injectFields;
     }
 
+    private void params(Collection<TypeInfo> services,
+                        DescribedService describedService,
+                        List<MethodDefinition> methods,
+                        List<ParamDefinition> params,
+                        TypedElementInfo constructor,
+                        List<TypedElementInfo> fieldInjectElements) {
+        AtomicInteger paramCounter = new AtomicInteger();
+        AtomicInteger methodCounter = new AtomicInteger();
+
+        if (!constructor.parameterArguments().isEmpty()) {
+            injectConstructorParams(describedService, params, paramCounter, constructor);
+        }
+
+        fieldInjectElements
+                .forEach(it -> fieldParam(describedService, params, paramCounter, it));
+
+        methods.addAll(methodParams(services,
+                                    describedService,
+                                    params,
+                                    methodCounter,
+                                    paramCounter));
+
+    }
+
     private List<MethodDefinition> methodParams(Collection<TypeInfo> services,
                                                 DescribedService service,
                                                 List<ParamDefinition> allParams,
@@ -1103,7 +678,7 @@ private List<MethodDefinition> methodParams(Collection<TypeInfo> services,
                 .filter(not(ElementInfoPredicates::isPrivate))
                 .filter(not(ElementInfoPredicates::isStatic))
                 .filter(ElementInfoPredicates::isMethod)
-                .filter(ElementInfoPredicates.hasAnnotation(InjectCodegenTypes.INJECTION_INJECT))
+                .filter(ElementInfoPredicates.hasAnnotation(SERVICE_ANNOTATION_INJECT))
                 .toList();
 
         List<MethodDefinition> result = new ArrayList<>();
@@ -1150,7 +725,7 @@ private List<MethodDefinition> methodParams(Collection<TypeInfo> services,
                 .filter(ElementInfoPredicates::isMethod)
                 .filter(not(ElementInfoPredicates::isStatic))
                 .filter(not(ElementInfoPredicates::isPrivate))
-                .filter(it -> !it.hasAnnotation(InjectCodegenTypes.INJECTION_INJECT))
+                .filter(it -> !it.hasAnnotation(SERVICE_ANNOTATION_INJECT))
                 .toList();
 
         // some of the methods we declare that do not have @Inject may disable injection, we need to check that
@@ -1165,7 +740,7 @@ private List<MethodDefinition> methodParams(Collection<TypeInfo> services,
                                                              .map(TypedElementInfo::typeName)
                                                              .toList(),
                                                      serviceType.packageName(),
-                                                     InjectCodegenTypes.INJECTION_INJECT);
+                                                     SERVICE_ANNOTATION_INJECT);
             if (overrides.isPresent()) {
                 // we do override a method, we need to declare it
                 result.add(toMethodDefinition(service,
@@ -1246,133 +821,44 @@ private List<ParamDefinition> toMethodParams(DescribedService service,
                 .toList();
     }
 
-    /**
-     * Find if there is a method in the hierarchy that this method overrides.
-     *
-     * @param services            list of services being processed
-     * @param type                first immediate supertype we will be checking
-     * @param method              method we are investigating
-     * @param arguments           method signature
-     * @param currentPackage      package of the current type declaring the method
-     * @param expectedAnnotations only look for methods annotated with a specific annotation
-     * @return type name of the top level declaring type of this method
-     */
-    private Optional<TypeName> overrides(Collection<TypeInfo> services,
-                                         TypeInfo type,
-                                         TypedElementInfo method,
-                                         List<TypeName> arguments,
-                                         String currentPackage,
-                                         TypeName... expectedAnnotations) {
-
-        String methodName = method.elementName();
-        // we look only for exact match (including types)
-        Optional<TypedElementInfo> found = type.elementInfo()
+    private void injectConstructorParams(DescribedService service,
+                                         List<ParamDefinition> result,
+                                         AtomicInteger paramCounter,
+                                         TypedElementInfo constructor) {
+        constructor.parameterArguments()
                 .stream()
-                .filter(ElementInfoPredicates::isMethod)
-                .filter(not(ElementInfoPredicates::isPrivate))
-                .filter(ElementInfoPredicates.elementName(methodName))
-                .filter(it -> {
-                    for (TypeName expectedAnnotation : expectedAnnotations) {
-                        if (!it.hasAnnotation(expectedAnnotation)) {
-                            return false;
-                        }
-                    }
-                    return true;
+                .map(param -> {
+                    String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
+                    var assignment = translateParameter(param.typeName(), constantName);
+                    return new ParamDefinition(constructor,
+                                               null,
+                                               param,
+                                               constantName,
+                                               param.typeName(),
+                                               assignment.usedType(),
+                                               assignment.codeGenerator(),
+                                               ElementKind.CONSTRUCTOR,
+                                               constructor.elementName(),
+                                               param.elementName(),
+                                               param.elementName(),
+                                               false,
+                                               param.annotations(),
+                                               qualifiers(service, param),
+                                               contract(service.serviceDescriptor().typeName()
+                                                                .fqName() + " Constructor parameter: " + param.elementName(),
+                                                        assignment.usedType()),
+                                               constructor.accessModifier(),
+                                               "<init>");
                 })
-                .filter(ElementInfoPredicates.hasParams(arguments))
-                .findFirst();
-
-        // if found, we either return this one, or look further up the hierarchy
-        if (found.isPresent()) {
-            TypedElementInfo superMethod = found.get();
+                .forEach(result::add);
+    }
 
-            // method has same signature, but is package local and is in a different package
-            boolean realOverride = superMethod.accessModifier() != AccessModifier.PACKAGE_PRIVATE
-                    || currentPackage.equals(type.typeName().packageName());
-
-            if (realOverride) {
-                // let's find the declaring type
-                ServiceSuperType superType = superType(type, services);
-                if (superType.present()) {
-                    // do not care about annotations, we already have a match
-                    var fromSuperHierarchy = overrides(services, superType.typeInfo(), method, arguments, currentPackage);
-                    return Optional.of(fromSuperHierarchy.orElseGet(type::typeName));
-                }
-                // there is no supertype, this type declares the method
-                return Optional.of(type.typeName());
-            }
-        }
-
-        // we did not find a method on this type, let's look above
-        ServiceSuperType superType = superType(type, services);
-        if (superType.present()) {
-            return overrides(services, superType.typeInfo(), method, arguments, currentPackage, expectedAnnotations);
-        }
-        return Optional.empty();
-    }
-
-    private void params(Collection<TypeInfo> services,
-                        DescribedService describedService,
-                        List<MethodDefinition> methods,
-                        List<ParamDefinition> params,
-                        TypedElementInfo constructor,
-                        List<TypedElementInfo> fieldInjectElements) {
-        AtomicInteger paramCounter = new AtomicInteger();
-        AtomicInteger methodCounter = new AtomicInteger();
-
-        if (!constructor.parameterArguments().isEmpty()) {
-            injectConstructorParams(describedService, params, paramCounter, constructor);
-        }
-
-        fieldInjectElements
-                .forEach(it -> fieldParam(describedService, params, paramCounter, it));
-
-        methods.addAll(methodParams(services,
-                                    describedService,
-                                    params,
-                                    methodCounter,
-                                    paramCounter));
-
-    }
-
-    private void injectConstructorParams(DescribedService service,
-                                         List<ParamDefinition> result,
-                                         AtomicInteger paramCounter,
-                                         TypedElementInfo constructor) {
-        constructor.parameterArguments()
-                .stream()
-                .map(param -> {
-                    String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
-                    var assignment = translateParameter(param.typeName(), constantName);
-                    return new ParamDefinition(constructor,
-                                               null,
-                                               param,
-                                               constantName,
-                                               param.typeName(),
-                                               assignment.usedType(),
-                                               assignment.codeGenerator(),
-                                               ElementKind.CONSTRUCTOR,
-                                               constructor.elementName(),
-                                               param.elementName(),
-                                               param.elementName(),
-                                               false,
-                                               param.annotations(),
-                                               qualifiers(service, param),
-                                               contract(service.serviceDescriptor().typeName()
-                                                                .fqName() + " Constructor parameter: " + param.elementName(),
-                                                        assignment.usedType()),
-                                               constructor.accessModifier(),
-                                               "<init>");
-                })
-                .forEach(result::add);
-    }
-
-    private void fieldParam(DescribedService describedService,
-                            List<ParamDefinition> result,
-                            AtomicInteger paramCounter,
-                            TypedElementInfo field) {
-        String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
-        var assignment = translateParameter(field.typeName(), constantName);
+    private void fieldParam(DescribedService describedService,
+                            List<ParamDefinition> result,
+                            AtomicInteger paramCounter,
+                            TypedElementInfo field) {
+        String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
+        var assignment = translateParameter(field.typeName(), constantName);
 
         result.add(new ParamDefinition(field,
                                        null,
@@ -1395,13 +881,17 @@ private void fieldParam(DescribedService describedService,
                                        null));
     }
 
+    private InjectAssignment.Assignment translateParameter(TypeName typeName, String constantName) {
+        return assignments.assignment(typeName, "ctx__helidonInject.dependency(" + constantName + ")");
+    }
+
     private Set<Annotation> qualifiers(DescribedService service, Annotated element) {
         Set<Annotation> result = new LinkedHashSet<>();
 
         for (Annotation anno : element.annotations()) {
             if (service.serviceDescriptor()
                     .typeInfo()
-                    .hasMetaAnnotation(anno.typeName(), InjectCodegenTypes.INJECTION_QUALIFIER)) {
+                    .hasMetaAnnotation(anno.typeName(), SERVICE_ANNOTATION_QUALIFIER)) {
                 result.add(anno);
             }
         }
@@ -1433,7 +923,7 @@ private TypeName contract(String description, TypeName typeName) {
                                                            + description);
             }
             TypeName firstType = typeName.typeArguments().getFirst();
-            if (firstType.equals(INJECT_SERVICE_INSTANCE)) {
+            if (firstType.equals(SERVICE_SERVICE_INSTANCE)) {
                 if (typeName.typeArguments().isEmpty()) {
                     throw new IllegalArgumentException("Injection point with Optional<ServiceInstance> type must have a"
                                                                + " declared type argument: " + description);
@@ -1449,7 +939,7 @@ private TypeName contract(String description, TypeName typeName) {
                                                            + description);
             }
             TypeName firstType = typeName.typeArguments().getFirst();
-            if (firstType.equals(INJECT_SERVICE_INSTANCE)) {
+            if (firstType.equals(SERVICE_SERVICE_INSTANCE)) {
                 if (typeName.typeArguments().isEmpty()) {
                     throw new IllegalArgumentException("Injection point with List<ServiceInstance> type must have a"
                                                                + " declared type argument: " + description);
@@ -1466,7 +956,7 @@ private TypeName contract(String description, TypeName typeName) {
             }
             return contract(description, typeName.typeArguments().getFirst());
         }
-        if (typeName.equals(INJECT_SERVICE_INSTANCE)) {
+        if (typeName.equals(SERVICE_SERVICE_INSTANCE)) {
             if (typeName.typeArguments().isEmpty()) {
                 throw new IllegalArgumentException("Injection point with ServiceInstance type must have a"
                                                            + " declared type argument: " + description);
@@ -1477,120 +967,69 @@ private TypeName contract(String description, TypeName typeName) {
         return typeName;
     }
 
-    private Map<String, GenericTypeDeclaration> genericTypes(ClassModel.Builder classModel,
-                                                             List<ParamDefinition> params,
-                                                             List<MethodDefinition> methods) {
-        // we must use map by string (as type name is equal if the same class, not full generic declaration)
-        Map<String, GenericTypeDeclaration> result = new LinkedHashMap<>();
-        AtomicInteger counter = new AtomicInteger();
-
-        for (ParamDefinition param : params) {
-            result.computeIfAbsent(param.translatedType().resolvedName(),
-                                   type -> {
-                                       var response = new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
-                                                                                 param.declaredType());
-                                       addTypeConstant(classModel, param.translatedType(), response);
-                                       return response;
-                                   });
-            result.computeIfAbsent(param.contract().resolvedName(),
-                                   type -> {
-                                       var response = new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
-                                                                                 param.declaredType());
-                                       addTypeConstant(classModel, param.contract(), response);
-                                       return response;
-                                   });
-        }
-
-        for (MethodDefinition method : methods) {
-            for (ParamDefinition param : method.params()) {
-                result.computeIfAbsent(param.declaredType().resolvedName(),
-                                       type -> {
-                                           var response =
-                                                   new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
-                                                                              param.declaredType());
-                                           addTypeConstant(classModel,
-                                                           param.declaredType(),
-                                                           response
-                                           );
-                                           return response;
-                                       });
-            }
-        }
-
-        return result;
-    }
+    /**
+     * Find if there is a method in the hierarchy that this method overrides.
+     *
+     * @param services            list of services being processed
+     * @param type                first immediate supertype we will be checking
+     * @param method              method we are investigating
+     * @param arguments           method signature
+     * @param currentPackage      package of the current type declaring the method
+     * @param expectedAnnotations only look for methods annotated with a specific annotation
+     * @return type name of the top level declaring type of this method
+     */
+    private Optional<TypeName> overrides(Collection<TypeInfo> services,
+                                         TypeInfo type,
+                                         TypedElementInfo method,
+                                         List<TypeName> arguments,
+                                         String currentPackage,
+                                         TypeName... expectedAnnotations) {
 
-    private void addTypeConstant(ClassModel.Builder classModel,
-                                 TypeName typeName,
-                                 GenericTypeDeclaration generic) {
-        String stringType = typeName.resolvedName();
-        // constants for injection point parameter types (used by next section)
-        classModel.addField(field -> field
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .type(TypeNames.TYPE_NAME)
-                .name(generic.constantName())
-                .update(it -> {
-                    if (stringType.indexOf('.') < 0) {
-                        // there is no package, we must use class (if this is a generic type, we have a problem)
-                        it.addContent(TypeNames.TYPE_NAME)
-                                .addContent(".create(")
-                                .addContent(typeName)
-                                .addContent(".class)");
-                    } else {
-                        it.addContentCreate(typeName);
-                    }
-                }));
-        classModel.addField(field -> field
-                .accessModifier(AccessModifier.PRIVATE)
-                .isStatic(true)
-                .isFinal(true)
-                .type(ANY_GENERIC_TYPE)
-                .name("G" + generic.constantName())
-                .update(it -> {
-                    if (typeName.primitive()) {
-                        it.addContent(TypeNames.GENERIC_TYPE)
-                                .addContent(".create(")
-                                .addContent(typeName.className())
-                                .addContent(".class)");
-                    } else {
-                        it.addContent("new ")
-                                .addContent(TypeNames.GENERIC_TYPE)
-                                .addContent("<")
-                                .addContent(typeName)
-                                .addContent(">() {}");
+        String methodName = method.elementName();
+        // we look only for exact match (including types)
+        Optional<TypedElementInfo> found = type.elementInfo()
+                .stream()
+                .filter(ElementInfoPredicates::isMethod)
+                .filter(not(ElementInfoPredicates::isPrivate))
+                .filter(ElementInfoPredicates.elementName(methodName))
+                .filter(it -> {
+                    for (TypeName expectedAnnotation : expectedAnnotations) {
+                        if (!it.hasAnnotation(expectedAnnotation)) {
+                            return false;
+                        }
                     }
+                    return true;
                 })
-        );
-    }
+                .filter(ElementInfoPredicates.hasParams(arguments))
+                .findFirst();
 
-    private Optional<TypeName> scope(TypeInfo service) {
-        Set<TypeName> result = new LinkedHashSet<>();
+        // if found, we either return this one, or look further up the hierarchy
+        if (found.isPresent()) {
+            TypedElementInfo superMethod = found.get();
 
-        for (Annotation anno : service.annotations()) {
-            TypeName annoType = anno.typeName();
-            if (service.hasMetaAnnotation(annoType, InjectCodegenTypes.INJECTION_SCOPE)) {
-                result.add(annoType);
-                continue;
-            }
-            for (TypeName scopeMetaAnnotation : scopeMetaAnnotations) {
-                if (service.hasMetaAnnotation(annoType, scopeMetaAnnotation)) {
-                    result.add(annoType);
+            // method has same signature, but is package local and is in a different package
+            boolean realOverride = superMethod.accessModifier() != AccessModifier.PACKAGE_PRIVATE
+                    || currentPackage.equals(type.typeName().packageName());
+
+            if (realOverride) {
+                // let's find the declaring type
+                ServiceSuperType superType = superType(type, services);
+                if (superType.present()) {
+                    // do not care about annotations, we already have a match
+                    var fromSuperHierarchy = overrides(services, superType.typeInfo(), method, arguments, currentPackage);
+                    return Optional.of(fromSuperHierarchy.orElseGet(type::typeName));
                 }
+                // there is no supertype, this type declares the method
+                return Optional.of(type.typeName());
             }
         }
 
-        if (result.size() > 1) {
-            throw new CodegenException("Type " + service.typeName().fqName() + " has more than one scope defined. "
-                                               + "This is not supported. Scopes. " + result);
-        }
-
-        if (result.isEmpty() && service.hasAnnotation(INJECTION_PER_INSTANCE)) {
-            result.add(INJECTION_SINGLETON);
+        // we did not find a method on this type, let's look above
+        ServiceSuperType superType = superType(type, services);
+        if (superType.present()) {
+            return overrides(services, superType.typeInfo(), method, arguments, currentPackage, expectedAnnotations);
         }
-
-        return result.stream().findFirst();
+        return Optional.empty();
     }
 
     private void singletonInstanceField(ClassModel.Builder classModel, DescribedService service) {
@@ -1614,11 +1053,11 @@ private void injectionPointFields(ClassModel.Builder classModel,
                     .accessModifier(AccessModifier.PUBLIC)
                     .isStatic(true)
                     .isFinal(true)
-                    .type(InjectCodegenTypes.INJECT_INJECTION_POINT)
+                    .type(SERVICE_DEPENDENCY)
                     .name(param.constantName())
                     .description(ipIdDescription(service, param))
                     .update(it -> {
-                        it.addContent(InjectCodegenTypes.INJECT_INJECTION_POINT)
+                        it.addContent(SERVICE_DEPENDENCY)
                                 .addContentLine(".builder()")
                                 .increaseContentPadding()
                                 .increaseContentPadding()
@@ -1780,7 +1219,7 @@ private void dependenciesField(ClassModel.Builder classModel, List<ParamDefiniti
                 .isStatic(true)
                 .isFinal(true)
                 .name("DEPENDENCIES")
-                .type(LIST_OF_IP_IDS)
+                .type(LIST_OF_DEPENDENCIES)
                 .addContent(List.class)
                 .addContent(".of(")
                 .update(it -> {
@@ -1935,17 +1374,17 @@ private void contractsMethod(ClassModel.Builder classModel,
     }
 
     private void dependenciesMethod(ClassModel.Builder classModel, DescribedService service, List<ParamDefinition> params) {
-        // List<Ip> dependencies()
+        // List<Dependency> dependencies()
         boolean hasSuperType = service.superType().present();
         if (hasSuperType || !params.isEmpty()) {
             classModel.addMethod(method -> method.addAnnotation(Annotations.OVERRIDE)
-                    .returnType(LIST_OF_IP_IDS)
+                    .returnType(LIST_OF_DEPENDENCIES)
                     .name("dependencies")
                     .update(it -> {
                         if (hasSuperType && !service.superType().serviceType().equals("core")) {
                             it.addContent("return ")
-                                    .addContent(INJECT_G_IP_SUPPORT)
-                                    .addContentLine(".combineIps(DEPENDENCIES, super.dependencies());");
+                                    .addContent(SERVICE_G_DEPENDENCY_SUPPORT)
+                                    .addContentLine(".combineDependencies(DEPENDENCIES, super.dependencies());");
                         } else {
                             // when super type is a core service, it only can have constructor dependencies - no need to combine
                             it.addContentLine("return DEPENDENCIES;");
@@ -1973,7 +1412,7 @@ private void instantiateMethod(ClassModel.Builder classModel,
                 .name("instantiate")
                 .addParameter(ctxParam -> ctxParam.type(ServiceCodegenTypes.SERVICE_DEPENDENCY_CONTEXT)
                         .name("ctx__helidonInject"))
-                .addParameter(interceptMeta -> interceptMeta.type(InjectCodegenTypes.INTERCEPT_METADATA)
+                .addParameter(interceptMeta -> interceptMeta.type(INTERCEPT_METADATA)
                         .name("interceptMeta__helidonInject"))
                 .update(it -> {
                     if (elements.constructorIntercepted()) {
@@ -1987,7 +1426,7 @@ private void instantiateMethod(ClassModel.Builder classModel,
             classModel.addMethod(method -> method.returnType(serviceDescriptor.typeName())
                     .name("doInstantiate")
                     .accessModifier(AccessModifier.PRIVATE)
-                    .addParameter(interceptMeta -> interceptMeta.type(InjectCodegenTypes.INTERCEPT_METADATA)
+                    .addParameter(interceptMeta -> interceptMeta.type(INTERCEPT_METADATA)
                             .name("interceptMeta"))
                     .addParameter(ctrParams -> ctrParams.type(TypeName.create("Object..."))
                             .name("params"))
@@ -2022,7 +1461,7 @@ private void createInstantiateInterceptBody(Method.Builder method,
                 .addContentLine("throw e__helidonInject;")
                 .addContentLine("} catch (Exception e__helidonInject) {")
                 .addContent(" throw new ")
-                .addContent(InjectCodegenTypes.INTERCEPT_EXCEPTION)
+                .addContent(INTERCEPT_EXCEPTION)
                 .addContentLine("(\"Failed to instantiate \" + SERVICE_TYPE.fqName(), e__helidonInject, false);")
                 .addContentLine("}");
     }
@@ -2137,9 +1576,9 @@ private void injectMethod(ClassModel.Builder classModel,
                 .name("inject")
                 .addParameter(ctxParam -> ctxParam.type(ServiceCodegenTypes.SERVICE_DEPENDENCY_CONTEXT)
                         .name("ctx__helidonInject"))
-                .addParameter(interceptMeta -> interceptMeta.type(InjectCodegenTypes.INTERCEPT_METADATA)
+                .addParameter(interceptMeta -> interceptMeta.type(INTERCEPT_METADATA)
                         .name("interceptMeta__helidonInject"))
-                .addParameter(injectedParam -> injectedParam.type(SET_OF_SIGNATURES)
+                .addParameter(injectedParam -> injectedParam.type(SET_OF_STRINGS)
                         .name("injected__helidonInject"))
                 .addParameter(instanceParam -> instanceParam.type(GENERIC_T_TYPE)
                         .name("instance__helidonInject"))
@@ -2383,8 +1822,8 @@ private void scopeMethod(ClassModel.Builder classModel, DescribedService service
         // TypeName scope()
         TypeName scope = service.scope();
 
-        if (scope.packageName().equals(INJECTION_SINGLETON.packageName())
-                && scope.enclosingNames().size() == 1 && scope.enclosingNames().getFirst().equals("Injection")) {
+        if (scope.packageName().equals(SERVICE_ANNOTATION_SINGLETON.packageName())
+                && scope.enclosingNames().size() == 1 && scope.enclosingNames().getFirst().equals("Service")) {
             // only method
             classModel.addMethod(scopeMethod -> scopeMethod.name("scope")
                     .addAnnotation(Annotations.OVERRIDE)
@@ -2408,111 +1847,530 @@ private void scopeMethod(ClassModel.Builder classModel, DescribedService service
         }
     }
 
-    private void weightMethod(ClassModel.Builder classModel, DescribedService service) {
-        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+    private void weightMethod(ClassModel.Builder classModel, DescribedService service) {
+        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+
+        boolean hasSuperType = service.superType().present();
+        // double weight()
+        Optional<Double> weight = weight(typeInfo);
+
+        if (!hasSuperType && weight.isEmpty()) {
+            return;
+        }
+        double usedWeight = weight.orElse(Weighted.DEFAULT_WEIGHT);
+        if (!hasSuperType && usedWeight == Weighted.DEFAULT_WEIGHT) {
+            return;
+        }
+
+        classModel.addMethod(weightMethod -> weightMethod.name("weight")
+                .addAnnotation(Annotations.OVERRIDE)
+                .returnType(TypeNames.PRIMITIVE_DOUBLE)
+                .addContentLine("return " + usedWeight + ";"));
+    }
+
+    private Optional<Double> weight(TypeInfo typeInfo) {
+        return typeInfo.findAnnotation(TypeName.create(Weight.class))
+                .flatMap(Annotation::doubleValue);
+    }
+
+    private void runLevelMethod(ClassModel.Builder classModel, DescribedService service) {
+        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+
+        boolean hasSuperType = service.superType().present();
+        // double runLevel()
+        Optional<Double> runLevel = runLevel(typeInfo);
+
+        if (!hasSuperType && runLevel.isEmpty()) {
+            return;
+        }
+
+        if (runLevel.isEmpty()) {
+            classModel.addMethod(runLevelMethod -> runLevelMethod.name("runLevel")
+                    .addAnnotation(Annotations.OVERRIDE)
+                    .returnType(TypeName.builder(TypeNames.OPTIONAL)
+                                        .addTypeArgument(TypeNames.BOXED_DOUBLE)
+                                        .build())
+                    .addContent("return ")
+                    .addContent(Optional.class)
+                    .addContentLine(".empty();"));
+            return;
+        }
+
+        double usedRunLevel = runLevel.get();
+
+        classModel.addMethod(runLevelMethod -> runLevelMethod.name("runLevel")
+                .addAnnotation(Annotations.OVERRIDE)
+                .returnType(TypeName.builder(TypeNames.OPTIONAL)
+                                    .addTypeArgument(TypeNames.BOXED_DOUBLE)
+                                    .build())
+                .addContent("return ")
+                .addContent(Optional.class)
+                .addContent(".of(")
+                .addContent(String.valueOf(usedRunLevel))
+                .addContentLine("D);"));
+    }
+
+    private Optional<Double> runLevel(TypeInfo typeInfo) {
+        return typeInfo.findAnnotation(SERVICE_ANNOTATION_RUN_LEVEL)
+                .flatMap(Annotation::doubleValue);
+    }
+
+    private TypeName descriptorInstanceType(TypeName serviceType, TypeName descriptorType) {
+        return TypeName.builder(descriptorType)
+                .addTypeArgument(serviceType)
+                .build();
+    }
+
+    private TypeName generateProvidedInterceptionDelegate(RegistryRoundContext roundContext, DescribedService service) {
+        DescribedType providedDescriptor = service.providedDescriptor();
+        TypeInfo typeInfo = providedDescriptor
+                .typeInfo();
+
+        TypeName expectedInterceptionDelegate = interception.interceptedDelegateType(typeInfo.typeName());
+
+        // now we need to check this is generated
+        if (ctx.typeInfo(expectedInterceptionDelegate).isPresent()) {
+            // it was already generated for another provider maybe
+            return expectedInterceptionDelegate;
+        } else {
+            if (canDelegate(service.serviceDescriptor().typeInfo(),
+                            typeInfo)) {
+                // we must generate it right now
+                interception.generateDelegateInterception(roundContext,
+                                                          typeInfo,
+                                                          providedDescriptor.elements(),
+                                                          expectedInterceptionDelegate);
+
+                return expectedInterceptionDelegate;
+            }
+
+            throw new CodegenException("Attempting to create delegate interception for non interface type. "
+                                               + "If the type is ready to be delegated, annotate it with "
+                                               + INTERCEPTION_DELEGATE.fqName() + ", or annotate the service provider with "
+                                               + INTERCEPTION_EXTERNAL_DELEGATE.fqName()
+                                               + "(" + typeInfo.typeName().classNameWithEnclosingNames()
+                                               + ".class) if it is not under your control",
+                                       service.serviceDescriptor().typeInfo().originatingElementValue());
+        }
+    }
+
+    private boolean canDelegate(TypeInfo providerType, TypeInfo providedType) {
+        // interfaces are always supported
+        if (providedType.kind() == ElementKind.INTERFACE) {
+            return true;
+        }
+        // it is itself marked as a delegate
+        if (providedType.hasAnnotation(INTERCEPTION_DELEGATE)) {
+            return true;
+        }
+        // only if marked as external delegate
+        return providerType.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)
+                && providerType.annotation(INTERCEPTION_EXTERNAL_DELEGATE)
+                .typeValue().map(it -> providedType.typeName().equals(it))
+                .orElse(false);
+    }
+
+    private void generateDelegationService(RegistryRoundContext roundContext,
+                                           DescribedService service,
+                                           TypeName delegateType) {
+        TypeName typeName = service.serviceDescriptor().typeName();
+
+        String typeNameSuffix = "__Interception_Wrapper";
+        TypeName wrapperType = TypeName.builder()
+                .packageName(typeName.packageName())
+                .className(typeName.classNameWithEnclosingNames().replace('.', '_') + typeNameSuffix)
+                .build();
+        var classModel = ClassModel.builder()
+                .type(wrapperType)
+                .addAnnotation(Annotation.create(service.scope()))
+                .addInterface(service.providerInterface())
+                .superType(service.interceptionWrapperSuperType())
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
+                .copyright(CodegenUtil.copyright(GENERATOR,
+                                                 typeName,
+                                                 wrapperType))
+                .addAnnotation(CodegenUtil.generatedAnnotation(GENERATOR,
+                                                               typeName,
+                                                               wrapperType,
+                                                               "1",
+                                                               ""));
+        service.qualifiers()
+                .forEach(classModel::addAnnotation);
+
+        classModel.addField(interceptMeta -> interceptMeta
+                .type(INTERCEPT_METADATA)
+                .name("interceptMeta")
+                .isFinal(true)
+                .accessModifier(AccessModifier.PRIVATE));
+
+        classModel.addConstructor(ctr -> ctr
+                .addAnnotation(Annotation.create(SERVICE_ANNOTATION_INJECT))
+                .addParameter(delegate -> delegate
+                        .update(it -> service.qualifiers().forEach(it::addAnnotation))
+                        .type(typeName)
+                        .name("delegate"))
+                .addParameter(interceptMeta -> interceptMeta
+                        .type(INTERCEPT_METADATA)
+                        .name("interceptMeta"))
+                .addContentLine("super(delegate);")
+                .addContentLine("this.interceptMeta = interceptMeta;")
+        );
+
+        TypeName descriptorType = service.descriptorType();
+        classModel.addMethod(wrap -> wrap
+                .addAnnotation(Annotations.OVERRIDE)
+                .accessModifier(AccessModifier.PROTECTED)
+                .name("wrap")
+                .returnType(service.providedDescriptor().typeName())
+                .addParameter(instance -> instance
+                        .type(service.providedDescriptor().typeName())
+                        .name("instance"))
+                .addContent("return ")
+                .addContent(delegateType)
+                .addContentLine(".create(")
+                .increaseContentPadding()
+                .increaseContentPadding()
+                .addContentLine("interceptMeta,")
+                .addContent(descriptorType)
+                .addContentLine(".INSTANCE,")
+                .addContentLine("instance);")
+        );
+
+        roundContext.addGeneratedType(wrapperType,
+                                      classModel,
+                                      typeName,
+                                      service.serviceDescriptor().typeInfo().originatingElementValue());
+    }
+
+    private void factoryType(ClassModel.Builder classModel, DescribedService service, FactoryType factoryType) {
+        if (service.superType().empty() && factoryType == FactoryType.SERVICE) {
+            // default
+            return;
+        }
+        classModel.addMethod(providerTypeMethod -> providerTypeMethod
+                .name("factoryType")
+                .accessModifier(AccessModifier.PUBLIC)
+                .addAnnotation(Annotations.OVERRIDE)
+                .returnType(SERVICE_FACTORY_TYPE)
+                .addContent("return ")
+                .addContent(SERVICE_FACTORY_TYPE)
+                .addContent(".")
+                .addContent(factoryType.name())
+                .addContentLine(";")
+        );
+    }
+
+    private void methodElementFields(ClassModel.Builder classModel,
+                                     DescribedService service) {
+        Set<ElementSignature> elementSignatures = service.serviceDescriptor()
+                .elements()
+                .interceptedMethods();
+        List<TypedElements.ElementMeta> interceptedElements = service.serviceDescriptor()
+                .elements()
+                .interceptedElements()
+                .stream()
+                .filter(it -> elementSignatures.contains(it.element().signature()))
+                .collect(Collectors.toUnmodifiableList());
+        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+
+        for (TypedElements.ElementMeta element : interceptedElements) {
+            var method = element.element();
+            String uniqueName = ctx.uniqueName(typeInfo, method);
+            String constantName = "METHOD_" + toConstantName(uniqueName);
+
+            // add inherited annotations from interfaces
+            List<Annotation> elementAnnotations = new ArrayList<>(method.annotations());
+            addInterfaceAnnotations(elementAnnotations, element.abstractMethods());
+            TypedElementInfo typedElementInfo = TypedElementInfo.builder()
+                    .from(method)
+                    .annotations(elementAnnotations)
+                    .build();
+            classModel.addField(constant -> constant
+                    .description("Element info for method: {@code " + method.signature() + "}.")
+                    .accessModifier(AccessModifier.PUBLIC)
+                    .isStatic(true)
+                    .isFinal(true)
+                    .type(TypeNames.TYPED_ELEMENT_INFO)
+                    .name(constantName)
+                    .addContentCreate(typedElementInfo));
+        }
+        /*
+        TypedElements.gatherElements(typeInfo)
+                .stream()
+                .filter(element -> ElementInfoPredicates.isMethod(element.element()))
+                .filter(element -> !ElementInfoPredicates.isPrivate(element.element()))
+                .forEach(element -> {
+                    var method = element.element();
+                    String uniqueName = ctx.uniqueName(typeInfo, method);
+                    String constantName = "METHOD_" + toConstantName(uniqueName);
+
+                    // add inherited annotations from interfaces
+                    List<Annotation> elementAnnotations = new ArrayList<>(method.annotations());
+                    addInterfaceAnnotations(elementAnnotations, element.abstractMethods());
+                    TypedElementInfo typedElementInfo = TypedElementInfo.builder()
+                            .from(method)
+                            .annotations(elementAnnotations)
+                            .build();
+                    classModel.addField(constant -> constant
+                            .description("Element info for method: {@code " + method.signature() + "}.")
+                            .accessModifier(AccessModifier.PUBLIC)
+                            .isStatic(true)
+                            .isFinal(true)
+                            .type(TypeNames.TYPED_ELEMENT_INFO)
+                            .name(constantName)
+                            .addContentCreate(typedElementInfo));
+                });
+         */
+    }
+
+    private void generateInterceptedType(RegistryRoundContext roundContext,
+                                         TypeInfo typeInfo,
+                                         DescribedService service,
+                                         TypedElementInfo constructorInjectElement) {
+        TypeName typeName = service.serviceDescriptor().typeName();
+
+        TypeName interceptedType = interceptedTypeName(typeName);
+
+        var generator = new InterceptedTypeGenerator(ctx,
+                                                     typeInfo,
+                                                     typeName,
+                                                     service.descriptorType(),
+                                                     interceptedType,
+                                                     constructorInjectElement,
+                                                     service.serviceDescriptor()
+                                                             .elements()
+                                                             .interceptedElements()
+                                                             .stream()
+                                                             .filter(it -> it.element().kind() == ElementKind.METHOD)
+                                                             .toList());
+
+        roundContext.addGeneratedType(interceptedType,
+                                      generator.generate(),
+                                      typeName,
+                                      typeInfo.originatingElementValue());
+    }
 
-        boolean hasSuperType = service.superType().present();
-        // double weight()
-        Optional<Double> weight = weight(typeInfo);
+    private TypeName interceptedTypeName(TypeName serviceType) {
+        return TypeName.builder(serviceType)
+                .className(serviceType.classNameWithEnclosingNames().replace('.', '_') + "__Intercepted")
+                .enclosingNames(List.of())
+                .build();
+    }
 
-        if (!hasSuperType && weight.isEmpty()) {
+    private void qualifiedProvider(ClassModel.Builder classModel, DescribedService service) {
+        var typeName = service.qualifiedProviderQualifier();
+        if (typeName == null) {
+            // just use default from interface, we only need to declare this on a type that explicitly implements
+            // QualifiedProvider
             return;
         }
-        double usedWeight = weight.orElse(Weighted.DEFAULT_WEIGHT);
-        if (!hasSuperType && usedWeight == Weighted.DEFAULT_WEIGHT) {
+        classModel.addInterface(SERVICE_G_QUALIFIED_FACTORY_DESCRIPTOR);
+
+        classModel.addField(qpField -> qpField
+                .accessModifier(AccessModifier.PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .name("QP_QUALIFIER")
+                .type(TypeNames.TYPE_NAME)
+                .addContentCreate(typeName)
+        );
+        classModel.addMethod(qpMethod ->
+                                     qpMethod
+                                             .accessModifier(AccessModifier.PUBLIC)
+                                             .returnType(TypeNames.TYPE_NAME)
+                                             .name("qualifierType")
+                                             .addAnnotation(Annotations.OVERRIDE)
+                                             .addContentLine("return QP_QUALIFIER;")
+        );
+    }
+
+    private void scopeHandler(TypeInfo typeInfo, ClassModel.Builder classModel, Set<ResolvedType> contracts) {
+        if (contracts.stream()
+                .noneMatch(it -> it.type().equals(SERVICE_SCOPE_HANDLER))) {
             return;
         }
 
-        classModel.addMethod(weightMethod -> weightMethod.name("weight")
+        TypeName handledScope = findHandledScope(typeInfo);
+
+        classModel.addInterface(SERVICE_G_SCOPE_HANDLER_DESCRIPTOR);
+        classModel.addField(scopeField -> scopeField
+                .accessModifier(AccessModifier.PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .name("SCOPE_HANDLER_SCOPE")
+                .type(TypeNames.TYPE_NAME)
+                .addContentCreate(handledScope));
+
+        classModel.addMethod(handledScopeMethod -> handledScopeMethod
+                .accessModifier(AccessModifier.PUBLIC)
                 .addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeNames.PRIMITIVE_DOUBLE)
-                .addContentLine("return " + usedWeight + ";"));
+                .returnType(TypeNames.TYPE_NAME)
+                .name("handledScope")
+                .addContentLine("return SCOPE_HANDLER_SCOPE;"));
     }
 
-    private Optional<Double> weight(TypeInfo typeInfo) {
-        return typeInfo.findAnnotation(TypeName.create(Weight.class))
-                .flatMap(Annotation::doubleValue);
+    private TypeName findHandledScope(TypeInfo typeInfo) {
+        return typeInfo.findAnnotation(SERVICE_ANNOTATION_NAMED)
+                .flatMap(Annotation::value)
+                .map(TypeName::create)
+                .orElseThrow(() -> new CodegenException(
+                        "Type implementing ScopeHandler must be qualified with the scope type name: " + typeInfo.typeName()));
     }
 
-    private void runLevelMethod(ClassModel.Builder classModel, DescribedService service) {
-        TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
+    private void createForMethod(ClassModel.Builder classModel,
+                                 DescribedService service) {
 
-        boolean hasSuperType = service.superType().present();
-        // double runLevel()
-        Optional<Double> runLevel = runLevel(typeInfo);
+        TypeInfo serviceTypeInfo = service.serviceDescriptor().typeInfo();
+        TypeName serviceTypeName = service.serviceDescriptor().typeName();
 
-        if (!hasSuperType && runLevel.isEmpty()) {
+        Optional<Annotation> createFor = serviceTypeInfo.findAnnotation(SERVICE_ANNOTATION_PER_INSTANCE);
+        if (service.superType().empty() && createFor.isEmpty()) {
+            // this is the default
             return;
         }
+        if (createFor.isPresent()) {
+            if (service.providerType() != FactoryType.SERVICE) {
+                throw new CodegenException("Service " + serviceTypeName.classNameWithEnclosingNames()
+                                                   + " is annotated with @"
+                                                   + SERVICE_ANNOTATION_PER_INSTANCE.classNameWithEnclosingNames()
+                                                   + ", and as such it must not implement any "
+                                                   + "provider interfaces. Provider type: " + service.providerType(),
+                                           serviceTypeInfo.originatingElementValue());
+            }
 
-        if (runLevel.isEmpty()) {
-            classModel.addMethod(runLevelMethod -> runLevelMethod.name("runLevel")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .returnType(TypeName.builder(TypeNames.OPTIONAL)
-                                        .addTypeArgument(TypeNames.BOXED_DOUBLE)
-                                        .build())
-                    .addContent("return ")
-                    .addContent(Optional.class)
-                    .addContentLine(".empty();"));
-            return;
-        }
+            TypeName createForType = createFor.get()
+                    .typeValue()
+                    .orElseThrow(() -> new CodegenException(SERVICE_ANNOTATION_PER_INSTANCE.fqName()
+                                                                    + ".value() is required, yet not found on type: "
+                                                                    + serviceTypeName.fqName()));
 
-        double usedRunLevel = runLevel.get();
+            String createForClassName = createForType.className();
+            if (createForClassName.endsWith("Blueprint")) {
+                // this may be a config blueprint, use the config instance
+                Optional<TypeInfo> createForTypeInfo = ctx.typeInfo(createForType);
+                if (createForTypeInfo.isPresent()) {
+                    if (createForTypeInfo.get().hasAnnotation(BUILDER_BLUEPRINT)) {
+                        createForType = TypeName.builder(createForType)
+                                .className(createForClassName.substring(0, createForClassName.length() - "Blueprint".length()))
+                                .build();
+                    }
+                }
+            }
 
-        classModel.addMethod(runLevelMethod -> runLevelMethod.name("runLevel")
-                .addAnnotation(Annotations.OVERRIDE)
-                .returnType(TypeName.builder(TypeNames.OPTIONAL)
-                                    .addTypeArgument(TypeNames.BOXED_DOUBLE)
-                                    .build())
-                .addContent("return ")
-                .addContent(Optional.class)
-                .addContent(".of(")
-                .addContent(String.valueOf(usedRunLevel))
-                .addContentLine("D);"));
-    }
+            if (createForType.packageName().isBlank()) {
+                throw new CodegenException(SERVICE_ANNOTATION_PER_INSTANCE.classNameWithEnclosingNames()
+                                                   + " type used on " + serviceTypeName.fqName() + " does not have a "
+                                                   + "package defined. Package is mandatory. If the type is a generated"
+                                                   + " prototype, please use the Blueprint type instead.");
+            }
 
-    private Optional<Double> runLevel(TypeInfo typeInfo) {
-        return typeInfo.findAnnotation(InjectCodegenTypes.INJECTION_RUN_LEVEL)
-                .flatMap(Annotation::doubleValue);
-    }
+            // used from lambda
+            TypeName createForTypeFinal = createForType;
+            classModel.addInterface(SERVICE_G_PER_INSTANCE_DESCRIPTOR);
 
-    private void notifyIpObservers(RegistryRoundContext roundContext, DescribedService service, List<ParamDefinition> params) {
-        if (observers.isEmpty()) {
-            return;
-        }
+            classModel.addField(createForField -> createForField
+                    .accessModifier(AccessModifier.PRIVATE)
+                    .isStatic(true)
+                    .isFinal(true)
+                    .name("CREATE_FOR")
+                    .type(TypeNames.TYPE_NAME)
+                    .addContentCreate(createForTypeFinal));
 
-        for (ParamDefinition param : params) {
-            TypeInfo typeInfo = service.serviceDescriptor().typeInfo();
-            TypedElementInfo owningElement = param.owningElement();
-            TypedElementInfo ipElement = param.elementInfo();
-            observers.forEach(it -> it.onInjectionPoint(
-                    roundContext,
-                    typeInfo,
-                    owningElement,
-                    ipElement));
+            classModel.addMethod(createForMethod -> createForMethod
+                    .accessModifier(AccessModifier.PUBLIC)
+                    .addAnnotation(Annotations.OVERRIDE)
+                    .returnType(TypeNames.TYPE_NAME)
+                    .name("createFor")
+                    .addContentLine("return CREATE_FOR;"));
         }
     }
 
-    private void notifyObservers(RegistryRoundContext roundContext, Collection<TypeInfo> descriptorsRequired) {
-        if (observers.isEmpty()) {
-            return;
+    private Map<String, GenericTypeDeclaration> genericTypes(ClassModel.Builder classModel,
+                                                             List<ParamDefinition> params,
+                                                             List<MethodDefinition> methods) {
+        // we must use map by string (as type name is equal if the same class, not full generic declaration)
+        Map<String, GenericTypeDeclaration> result = new LinkedHashMap<>();
+        AtomicInteger counter = new AtomicInteger();
+
+        for (ParamDefinition param : params) {
+            result.computeIfAbsent(param.translatedType().resolvedName(),
+                                   type -> {
+                                       var response = new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
+                                                                                 param.declaredType());
+                                       addTypeConstant(classModel, param.translatedType(), response);
+                                       return response;
+                                   });
+            result.computeIfAbsent(param.contract().resolvedName(),
+                                   type -> {
+                                       var response = new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
+                                                                                 param.declaredType());
+                                       addTypeConstant(classModel, param.contract(), response);
+                                       return response;
+                                   });
         }
 
-        // we have correct classloader set in current thread context
-        Set<TypedElementInfo> elements = descriptorsRequired.stream()
-                .flatMap(it -> it.elementInfo().stream())
-                .collect(Collectors.toSet());
-        observers.forEach(it -> it.onProcessingEvent(roundContext, elements));
-    }
+        for (MethodDefinition method : methods) {
+            for (ParamDefinition param : method.params()) {
+                result.computeIfAbsent(param.declaredType().resolvedName(),
+                                       type -> {
+                                           var response =
+                                                   new GenericTypeDeclaration("TYPE_" + counter.getAndIncrement(),
+                                                                              param.declaredType());
+                                           addTypeConstant(classModel,
+                                                           param.declaredType(),
+                                                           response
+                                           );
+                                           return response;
+                                       });
+            }
+        }
 
-    private InjectAssignment.Assignment translateParameter(TypeName typeName, String constantName) {
-        return assignments.assignment(typeName, "ctx__helidonInject.dependency(" + constantName + ")");
+        return result;
     }
 
-    private TypeName descriptorInstanceType(TypeName serviceType, TypeName descriptorType) {
-        return TypeName.builder(descriptorType)
-                .addTypeArgument(serviceType)
-                .build();
+    private void addTypeConstant(ClassModel.Builder classModel,
+                                 TypeName typeName,
+                                 GenericTypeDeclaration generic) {
+        String stringType = typeName.resolvedName();
+        // constants for injection point parameter types (used by next section)
+        classModel.addField(field -> field
+                .accessModifier(AccessModifier.PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .type(TypeNames.TYPE_NAME)
+                .name(generic.constantName())
+                .update(it -> {
+                    if (stringType.indexOf('.') < 0) {
+                        // there is no package, we must use class (if this is a generic type, we have a problem)
+                        it.addContent(TypeNames.TYPE_NAME)
+                                .addContent(".create(")
+                                .addContent(typeName)
+                                .addContent(".class)");
+                    } else {
+                        it.addContentCreate(typeName);
+                    }
+                }));
+        classModel.addField(field -> field
+                .accessModifier(AccessModifier.PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .type(ANY_GENERIC_TYPE)
+                .name("G" + generic.constantName())
+                .update(it -> {
+                    if (typeName.primitive()) {
+                        it.addContent(TypeNames.GENERIC_TYPE)
+                                .addContent(".create(")
+                                .addContent(typeName.className())
+                                .addContent(".class)");
+                    } else {
+                        it.addContent("new ")
+                                .addContent(TypeNames.GENERIC_TYPE)
+                                .addContent("<")
+                                .addContent(typeName)
+                                .addContent(">() {}");
+                    }
+                })
+        );
     }
 
     private record GenericTypeDeclaration(String constantName,
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtension.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtension.java
index 0b8d8888277..c67b297bc54 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtension.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtension.java
@@ -17,37 +17,99 @@
 package io.helidon.service.codegen;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenOptions;
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypedElementInfo;
+import io.helidon.service.codegen.spi.InjectCodegenObserver;
+import io.helidon.service.codegen.spi.InjectCodegenObserverProvider;
 import io.helidon.service.codegen.spi.RegistryCodegenExtension;
 
-class ServiceExtension implements RegistryCodegenExtension {
-    private static final TypeName GENERATOR = TypeName.create(ServiceExtension.class);
+import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_DESCRIBE;
 
+class ServiceExtension implements RegistryCodegenExtension {
     private final RegistryCodegenContext ctx;
+    private final InterceptionSupport interceptionSupport;
+    private final List<InjectCodegenObserver> observers;
+    private final ServiceDescriptorCodegen descriptorCodegen;
 
-    ServiceExtension(RegistryCodegenContext codegenContext) {
+    ServiceExtension(RegistryCodegenContext codegenContext, List<InjectCodegenObserverProvider> observerProviders) {
         this.ctx = codegenContext;
+        this.observers = observerProviders.stream()
+                .map(it -> it.create(codegenContext))
+                .toList();
+
+        CodegenOptions options = ctx.options();
+        Interception interception = new Interception(ServiceOptions.INTERCEPTION_STRATEGY.value(options));
+
+        this.interceptionSupport = new InterceptionSupport(ctx, interception);
+        this.descriptorCodegen = new ServiceDescriptorCodegen(ctx,
+                                                              observers,
+                                                              interceptionSupport);
     }
 
     @Override
-    public void process(RegistryRoundContext roundContext) {
-        Collection<TypeInfo> descriptorsRequired = roundContext.types();
+    public void process(RegistryRoundContext roundCtx) {
+
+        Collection<TypeInfo> descriptorsRequired = roundCtx.types();
 
         for (TypeInfo typeInfo : descriptorsRequired) {
-            generateDescriptor(roundContext, descriptorsRequired, typeInfo);
+            if (typeInfo.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)) {
+                generateInterceptionExternalDelegates(roundCtx, typeInfo);
+            }
+            if (typeInfo.hasAnnotation(SERVICE_ANNOTATION_DESCRIBE)) {
+                descriptorCodegen.describe(roundCtx,
+                                           typeInfo,
+                                           typeInfo.annotation(SERVICE_ANNOTATION_DESCRIBE));
+            } else {
+                descriptorCodegen.service(roundCtx,
+                                          descriptorsRequired,
+                                          typeInfo);
+            }
         }
+
+        notifyObservers(roundCtx, descriptorsRequired);
     }
 
-    private void generateDescriptor(RegistryRoundContext roundContext,
-                                    Collection<TypeInfo> descriptorsRequired,
-                                    TypeInfo typeInfo) {
+    private void generateInterceptionExternalDelegates(RegistryRoundContext roundContext, TypeInfo typeInfo) {
+        Annotation annotation = typeInfo.annotation(INTERCEPTION_EXTERNAL_DELEGATE);
+        List<TypeName> typeNames = annotation.typeValues().orElseGet(List::of);
+        boolean supportClasses = annotation.booleanValue("classDelegates").orElse(false);
+
+        for (TypeName typeName : typeNames) {
+            TypeInfo delegateType = ctx.typeInfo(typeName)
+                    .orElseThrow(() -> new CodegenException("Cannot resolve type " + typeName.fqName() + " for "
+                                                                    + " external interception delegates",
+                                                            typeInfo.originatingElementValue()));
+            if (!supportClasses && typeInfo.kind() != ElementKind.INTERFACE) {
+                throw new CodegenException("Attempting to create external delegate interception for non interface type: "
+                                                   + typeName.fqName(),
+                                           typeInfo.originatingElementValue());
+            }
+            interceptionSupport.generateDelegateInterception(roundContext,
+                                                             delegateType,
+                                                             delegateType.typeName(),
+                                                             typeInfo.typeName().packageName());
+        }
+    }
+
+    private void notifyObservers(RegistryRoundContext roundContext, Collection<TypeInfo> descriptorsRequired) {
+        if (observers.isEmpty()) {
+            return;
+        }
 
-        GenerateServiceDescriptor.generate(GENERATOR,
-                                           ctx,
-                                           roundContext,
-                                           descriptorsRequired,
-                                           typeInfo);
+        // we have correct classloader set in current thread context
+        Set<TypedElementInfo> elements = descriptorsRequired.stream()
+                .flatMap(it -> it.elementInfo().stream())
+                .collect(Collectors.toSet());
+        observers.forEach(it -> it.onProcessingEvent(roundContext, elements));
     }
 }
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtensionProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtensionProvider.java
index a1aeff58861..b579855cd07 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtensionProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceExtensionProvider.java
@@ -16,18 +16,35 @@
 
 package io.helidon.service.codegen;
 
+import java.util.List;
+import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import io.helidon.codegen.Option;
+import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.types.TypeName;
+import io.helidon.service.codegen.spi.InjectCodegenObserverProvider;
 import io.helidon.service.codegen.spi.RegistryCodegenExtension;
 import io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider;
 
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_DESCRIBE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_INJECT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PER_INSTANCE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_SCOPE;
+
 /**
  * A {@link java.util.ServiceLoader} provider implementation that adds code generation for Helidon Service Registry.
  * This extension creates service descriptors.
  */
 public class ServiceExtensionProvider implements RegistryCodegenExtensionProvider {
+    private static final List<InjectCodegenObserverProvider> OBSERVER_PROVIDERS =
+            HelidonServiceLoader.create(ServiceLoader.load(InjectCodegenObserverProvider.class,
+                                                           ServiceExtensionProvider.class.getClassLoader()))
+                    .asList();
+
     /**
      * Required default constructor for {@link java.util.ServiceLoader}.
      *
@@ -35,21 +52,34 @@ public class ServiceExtensionProvider implements RegistryCodegenExtensionProvide
      */
     @Deprecated
     public ServiceExtensionProvider() {
-        super();
     }
 
     @Override
     public Set<Option<?>> supportedOptions() {
-        return Set.of(ServiceOptions.AUTO_ADD_NON_CONTRACT_INTERFACES);
+        return Stream.concat(Stream.of(ServiceOptions.AUTO_ADD_NON_CONTRACT_INTERFACES,
+                                       ServiceOptions.INTERCEPTION_STRATEGY,
+                                       ServiceOptions.SCOPE_META_ANNOTATIONS),
+                             OBSERVER_PROVIDERS.stream()
+                                     .map(InjectCodegenObserverProvider::supportedOptions)
+                                     .flatMap(Set::stream))
+                .collect(Collectors.toSet());
     }
 
     @Override
     public Set<TypeName> supportedAnnotations() {
-        return Set.of(ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER);
+        return Set.of(SERVICE_ANNOTATION_PROVIDER,
+                      SERVICE_ANNOTATION_DESCRIBE,
+                      SERVICE_ANNOTATION_PER_INSTANCE,
+                      SERVICE_ANNOTATION_INJECT);
+    }
+
+    @Override
+    public Set<TypeName> supportedMetaAnnotations() {
+        return Set.of(SERVICE_ANNOTATION_SCOPE);
     }
 
     @Override
     public RegistryCodegenExtension create(RegistryCodegenContext codegenContext) {
-        return new ServiceExtension(codegenContext);
+        return new ServiceExtension(codegenContext, OBSERVER_PROVIDERS);
     }
 }
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceOptions.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceOptions.java
index 8967fa1f1ce..4212a0cdab9 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceOptions.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceOptions.java
@@ -45,6 +45,27 @@ public final class ServiceOptions {
                              Set.of(TypeName.create(Serializable.class)),
                              TypeName::create,
                              new GenericType<Set<TypeName>>() { });
+    /**
+     * Which {@code InterceptionStrategy} to use.
+     */
+    public static final Option<InterceptionStrategy> INTERCEPTION_STRATEGY =
+            Option.create("helidon.registry.interceptionStrategy",
+                          "Which interception strategy to use (NONE, EXPLICIT, ALL_RUNTIME, ALL_RETAINED)",
+                          InterceptionStrategy.EXPLICIT,
+                          InterceptionStrategy::valueOf,
+                          GenericType.create(InterceptionStrategy.class));
+
+    /**
+     * Additional meta annotations that mark scope annotations. This can be used to include
+     * jakarta.enterprise.context.NormalScope annotated types as scopes.
+     */
+    public static final Option<Set<TypeName>> SCOPE_META_ANNOTATIONS =
+            Option.createSet("helidon.registry.scopeMetaAnnotations",
+                             "Additional meta annotations that mark scope annotations. This can be used to include"
+                                     + "jakarta.enterprise.context.NormalScope annotated types as scopes.",
+                             Set.of(),
+                             TypeName::create,
+                             new GenericType<Set<TypeName>>() { });
 
     private ServiceOptions() {
     }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/TypedElements.java b/service/codegen/src/main/java/io/helidon/service/codegen/TypedElements.java
similarity index 99%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/TypedElements.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/TypedElements.java
index 58660594a9d..feb073b2762 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/TypedElements.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/TypedElements.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen;
+package io.helidon.service.codegen;
 
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/AssignmentImpl.java b/service/codegen/src/main/java/io/helidon/service/codegen/spi/AssignmentImpl.java
similarity index 96%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/AssignmentImpl.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/spi/AssignmentImpl.java
index 40fa5f6107e..5c24e34409d 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/AssignmentImpl.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/spi/AssignmentImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen.spi;
+package io.helidon.service.codegen.spi;
 
 import java.util.function.Consumer;
 
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignment.java b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignment.java
similarity index 98%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignment.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignment.java
index b676b7298c3..d85b837cd3a 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignment.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignment.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen.spi;
+package io.helidon.service.codegen.spi;
 
 import java.util.Optional;
 import java.util.function.Consumer;
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignmentProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignmentProvider.java
similarity index 95%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignmentProvider.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignmentProvider.java
index ceb50937fa1..7d7946efc47 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectAssignmentProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectAssignmentProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen.spi;
+package io.helidon.service.codegen.spi;
 
 import io.helidon.codegen.CodegenContext;
 
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserver.java b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserver.java
similarity index 97%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserver.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserver.java
index d62ba2d9acb..f07639d6748 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserver.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserver.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen.spi;
+package io.helidon.service.codegen.spi;
 
 import java.util.Set;
 
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserverProvider.java b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserverProvider.java
similarity index 96%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserverProvider.java
rename to service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserverProvider.java
index 1d67c8bb8b9..40e6b50703c 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/InjectCodegenObserverProvider.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/spi/InjectCodegenObserverProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.codegen.spi;
+package io.helidon.service.codegen.spi;
 
 import java.util.Set;
 
diff --git a/service/codegen/src/main/java/module-info.java b/service/codegen/src/main/java/module-info.java
index b2b67e9496a..c29f4ffa069 100644
--- a/service/codegen/src/main/java/module-info.java
+++ b/service/codegen/src/main/java/module-info.java
@@ -29,9 +29,17 @@
     exports io.helidon.service.codegen.spi;
 
     uses io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider;
+    uses io.helidon.service.codegen.spi.InjectCodegenObserverProvider;
+    uses io.helidon.service.codegen.spi.InjectAssignmentProvider;
 
     provides io.helidon.codegen.spi.CodegenExtensionProvider
             with io.helidon.service.codegen.ServiceRegistryCodegenProvider;
     provides io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider
-            with io.helidon.service.codegen.ServiceExtensionProvider;
+            with io.helidon.service.codegen.ServiceExtensionProvider,
+                    io.helidon.service.codegen.EventObserverExtensionProvider;
+    provides io.helidon.codegen.spi.AnnotationMapperProvider
+            with io.helidon.service.codegen.MapNamedByTypeMapperProvider;
+    provides io.helidon.service.codegen.spi.InjectCodegenObserverProvider
+            with io.helidon.service.codegen.EventEmitterObserverProvider;
+
 }
\ No newline at end of file
diff --git a/service/inject/README.md b/service/inject/README.md
deleted file mode 100644
index 304f35e63a2..00000000000
--- a/service/inject/README.md
+++ /dev/null
@@ -1,453 +0,0 @@
-Inject Service Registry
-----
-
-An extension to the core service registry.
-
-All features are implemented in a way that can use no reflection, mostly through code generating required handling classes.
-
-Helidon Inject includes:
-
-- [Dependency Injection](#dependency-injection)
-- [Lifecycle Support](#service-lifecycle)
-- [Factories and Services](#factories-and-services)
-- [Aspect Oriented Programming (interceptors)](#interceptors)
-- [Events](events)
-- [Programmatic Lookup](#programmatic-lookup)
-- [Startup](#startup)
-- [Other](#other)
-- [Glossary](#glossary)
-
-# Dependency Injection
-
-The basic building stone for inversion of control, dependency injection provides a mechanism to obtain an instance of a service
-at runtime, from the service registry, rather than constructing service instances through a constructor or a factory method.
-
-When using dependency injection, we can separate the concerns of "how to create a service instance" from
-"how to use the contract". The consumer of the contract is not burdened with the details of how to obtain a valid instance,
-and the provider of the service is not burdened with providing an API to build/setup a service instance.
-In some cases such interaction would be quite cumbersome, as we would need to carry a shared instance through constructors to
-reach the correct place where we want to create a service instance.
-
-One of the advantages of such an approach is the capability to exchange the service that implements a contract without the need
-to modify the consumers of such a contract.
-
-## Injection points
-
-In Helidon, dependency injection can be done in the following ways:
-
-- Through a constructor annotated with `@Injection.Inject` - each parameter is considered an injection point; this is the
-  recommended way of injecting dependencies (as it can be unit tested easily, and fields can be declared `private final`)
-- Through field(s) annotated with `@Injection.Inject` - each field is considered an injection point; this is not recommended, as
-  the fields must be accessible (at least package local), and cannot be declared as `final`
-
-An injection point is satisfied by a service with the highest weight implementing the requested contract.
-
-## Services
-
-Services are:
-
-1. Java classes annotated with one of the `Injection.Scope` annotations, such as
-    - `@Injection.Singleton` - up to one instance exists in the service registry
-    - `@Injection.PerLookup` - an instance is created each time a lookup is done (injecting into an injection point is considered
-      a lookup as well)
-    - `@Injection.PerRequest` - up to one instance exists in the service registry per request (what is a request is not defined in
-      the injection framework itself, but it matches concepts such as HTTP request/response interaction, or consuming of a
-      messaging message)
-2. Any class with `@Injection.Inject` annotation that does not have a scope annotation. In such a case, the
-   service will be `@Injection.PerLookup`.
-3. Any `core` service defined for Helidon Service Registry (using annotation `Service.Provider`), the scope is `PerLookup` if the
-   service implements a `Supplier`, and `@Singleton` otherwise; all dependencies are considered injection points
-
-Only services can have Injection points.
-
-## Qualifiers
-
-Any annotation "meta-annotated" with `@Injection.Qualifier` is considered a qualifier.
-Qualifier annotations can be used to "qualify" injection points and services.
-
-If an injection points is qualified (it has one or more qualifiers), it will only be satisfied with services that match all
-the specified qualifiers.
-
-### Named
-
-One qualifier is provided out-of-the-box - the `@Injection.Named` (and `@Injection.NamedByType` which does the same thing,
-only the name is the fully qualified class name of the provided class).
-
-Named instances are used by some feature of Helidon Inject itself.
-
-# Service Lifecycle
-
-The service registry manages lifecycle of services.
-
-To manage lifecycle, you can use the following annotations:
-
-- `@Injection.PostConstruct` - a method annotated with this annotation will be invoked after the instance is constructed and fully
-  injected
-- `@Injection.PreDestroy` - a method annotated with this annotation will be invoked after the service is no longer used by the
-  registry
-
-The behavior depends on the scope of the bean as follows:
-
-- `@Injection.PerLookup` - only "post construct" lifecycle method is invoked, as we do not control the instance after is is
-  injected
-- Any other scope - the "pre destroy" lifecycle method is invoked when the scope is deactivated (Singletons on registry shutdown
-  or JVM shutdown)
-
-# Factories and Services
-
-Let's consider we have a contract named `MyContract`.
-
-The simple case is that we have a class that implements the contract, and that is a service, such as:
-
-```java
-
-@Injection.Singleton
-class MyImpl implements MyContract {
-}
-```
-
-This means the service instance itself is an implementation of the contract, and when this service is used to satisfy an injection
-point, we will get an instance of `MyImpl`.
-
-But such an approach is only feasible if the contract is an interface, and we are fine with doing a full implementation.
-There may be cases, where this is not sufficient:
-
-- we need to provide an instance created by somebody else
-- the provided contract is not an interface
-- the provided instance may not be created at all (i.e. it is optional)
-
-This can be done by implementing one of the factory interfaces Helidon Inject supports:
-
-- `java.util.function.Supplier` - a factory that supplies a single instance (can also be `Supplier<Optional<MyContract>>`)
-- `io.helidon.service.inject.api.Injection.ServicesFactory` - a factory that creates zero or more contract implementations
-- `io.helidon.service.inject.api.Injection.InjectionPointFactory` - a factory that provides zero or more instances for each
-  injection point
-- `io.helidon.service.inject.api.Injection.QualifiedFactory` - a factory that provides zero or more instances for a specific
-  qualifier and contract
-
-The factory interfaces above should provide enough tooling to implement any injection use case.
-
-# Interceptors
-
-Interception provides capability to intercept call to a constructor or a method (even to fields when used as injection points).
-
-Interception is (by default) only enabled for elements annotated with an annotation that is a `Interception.Intercepted`.
-Annotation processor configuration allows for creating interception "plumbing" for any annotation, or to disable it altogether.
-
-Interception works "around" the invocation, so it can:
-
-- do something before actual invocation
-- modify invocation parameters
-- do something after actual invocation
-- modify response
-- handle exceptions
-
-Annotation type: `io.helidon.service.inject.api.Interception`
-
-Annotations:
-
-| Annotation class   | Description                                                                                                                                                                                                                                                                                                                                    |
-|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `Intercepted`      | Marker for annotations that should trigger interception                                                                                                                                                                                                                                                                                        |
-| `Delegate`         | Marks a class as supporting interception delegation. Classes are not good candidates for delegation, as you need to create an instance that delegates to another instance, opening space for side-effects. To use a class, it must have an accessible no-arg constructor, and it should be designed not to have side-effects from construction |
-| `ExternalDelegate` | Add this to a service provider that provides a class that requires delegation, if the class is not part of your current project (i.e. you cannot annotate it with `Delegate`                                                                                                                                                                   | 
-
-Interfaces:
-
-| Interface class | Description                                                                                                                                                                                                                                          |
-|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `Interceptor`   | A service implementing this interface, and named with the annotation type (maybe using `NamedByType`) will be used as interceptor of methods annotated with that annotation. Interceptor must call `proceed` method to handle the interception chain |
-
-# Events
-
-Events allow in-application communication between services, by providing a mechanism to emit an event, and
-to create a consumer/consumers of events.
-
-One event can be delivered to (0..n) consumers.
-
-Basic terminology:
-
-- `Event Producer` - a service that calls an emitter (origin of an event)
-- `Event Emitter` - a service that emits an event to the event system
-- `Event Object` - an arbitrary object that is sent around as an event
-- `Event Observer` - a service that receives events, and has a method annotated with
-  `io.helidon.service.inject.api.Event.Observer`
-- `Qualified Event` - event published by an emitter providing a qualifier (annotation annotated with `Injection.Qualifier`)
-
-## Emitting Events
-
-Event Emitters are code generated by Helidon. To create an Event Producer, simply inject the emitter.
-Event producers can be in any scope, the generated event emitter is always in `Injection.Singleton` scope.
-
-A simple singleton service that injects an event emitter for event object of type `MyEventObject`.
-
-```java
-
-@Injection.Singleton
-class MyService {
-    private final Event.Emitter<MyEventObject> emitter;
-
-    @Injection.Inject
-    MyService(Event.Emitter<MyEventObject> emitter) {
-        this.emitter = emitter;
-    }
-}
-```
-
-To emit an event, you simply call `emitter.emit(myEventObjectInstance)`.
-The method will return once all event observers were notified (unless they are asynchronous - see below).
-In case any of the observers throws an exception, an `EventDispatchException` will be thrown with all exceptions caught added as
-suppressed (i.e. we will invoke all observers, even after we catch an exception).
-
-Event emitters are code generated for each Event Producer, so we may end up with more than one in the system. As all of them
-provide the exact same function, this is not an issue.
-
-_Explanation of the above statement: we cannot code generate classes into packages that do not belong to the current module, so we
-always code generate the emitter to the same package as the service that needs the emitter. Even though this may duplicate code,
-it is the only safe way we can do during annotation processing (where we do not have access to the classpath of the application)_
-
-## Consuming Events
-
-An event can be consumed by declaring an observer method.
-Event consumers can only be in `Injection.Singleton` or `Injection.PerLookup` scopes. The lookup is done exactly once, and all
-events are delivered to the same instance for the lifetime of the service registry.
-
-Helidon code generates an `EventObserverRegistration` service, which is used by the event manager to gather all observers for
-event handling.
-
-To create an event observer:
-
-- create an observer method, with a single parameter of the event type you want to observe
-- annotate the method with `Event.Observer`
-
-Example:
-
-```java
-
-@Event.Observer
-void event(MyEventObject eventObject) {
-    // do something with the event
-}
-```
-
-## Asynchronous Events
-
-Events can be emitted asynchronously, and event observer can be asynchronous.
-Executor service for asynchronous events can be provided via service registry, as a service that implements contract
-`java.util.concurrent.ExecutorService`, and is named `io.helidon.service.inject.api.EventManager`.
-If none is provided, the service will use a thread per task executor with Virtual threads, thread names will be prefixed with
-`inject-event-manager-`.
-
-### Asynchronous Event Producer
-
-Rules of asynchronous event producing:
-
-1. Method `Event.Emitter.emitAsync(..)` returns a `CompletionStage<MyEventType>`
-2. All *synchronous* Event Consumer are submitted to an executor service, and the returned completion stage will provide either
-   success (the event object itself), or will provide an exception, which will have `EventDispatchException` as a cause
-3. The method returns once all the event observers are submitted to the executor service (there is no guarantee that anything has
-   been delivered - we may have delivered 0 to n events (where n is number of synchronous observers))
-4. All *asynchronous* Event Observer are invoked outside of the returned completion stage
-
-### Asynchronous Observer
-
-Asynchronous observer methods are invoked from separate threads (through the executor service mentioned above), and their results
-are ignored by the Event Emitter; if there is an exception thrown from the observer method, it is logged with `WARNING` log level
-into logger named `io.helidon.service.inject.api.EventManager`.
-
-To declare an asynchronous observer use annotation `Event.AsyncObserver` instead of `Event.Observer`.
-
-Example:
-
-```java
-
-@Event.AsyncObserver
-void event(MyEventObject eventObject) {
-    // handle event
-}
-```
-
-## Qualified Events
-
-A Qualified Event is only delivered to Event Consumers that use the same qualifier.
-
-### Qualified Event Producer
-
-A qualified event can be produced with two options:
-
-1. The injection point of `Event.Emitter` (the constructor parameter, or field) is annotated with a qualifier annotation
-2. The `Event.Emitter.emit(..)` method is called with explicit qualifier(s), note that if combined, the qualifier specified by the
-   injection point will always be present!
-
-Example (combination of both):
-
-```java
-import io.helidon.service.inject.api.Qualifier;
-
-// class declaration
-private static final Qualifier BLUE = Qualifier.create(Blue.class);
-
-        @Injection.Inject
-        EventEmitter(@Black Event.Emitter<EventObject> event) {
-            // the event producer will implicitly have Black qualifier added
-            this.event = event;
-        }
-
-        void emit(MyEventObject eventObject) {
-            // the event will be emitted with both Blue and Black qualifiers
-            this.event.emit(eventObject, BLUE);
-        }
-```
-
-### Qualified Event Observers
-
-To consume a qualified event, observer method must be annotated with the correct qualifier(s).
-
-Example:
-
-```java
-
-@Injection.Singleton
-class EventObserver {
-    @Event.Observer
-    @Black
-    void event(MyEventObject eventObject) {
-        // handle event that is qualified with Black (and none other)
-    }
-}
-```
-
-# Programmatic Lookup
-
-As usual with Helidon, what can be done via automation (dependency injection in this case) can also be done programmatically.
-
-The service registry can be used and handled "from outside" - you can create a registry instance, lookup services, call methods on
-them.
-
-It can also be used "from inside" - you can inject an `InjectRegistry` into your services. In case this approach is done, we
-cannot work around lookup costs as we can when only dependency injection is used.
-
-To create a registry instance:
-
-```java
-// create an instance of a registry manager - can be configured and shut down
-var registryManager = InjectRegistryManager.create();
-// get the associated service registry
-var registry = registryManager.registry();
-```
-
-Note that all instances are created lazily, so the registry will do "nothing" by default. If a service does something during
-construction or post construction, you must lookup an instance from the registry first.
-
-Special registry operations:
-
-- `List<InjectServiceInfo> lookupServices(Lookup lookup)` - get all service descriptors that match the lookup
-- `Optional<T> get(ServiceInfo)` - get an instance for the provided service descriptor
-
-The common registry operations are grouped by method name. Acceptable parameters are described below.
-
-Registry methods:
-
-- `T get(...)` - immediately get an instance of a contract from the registry; throws if implementation not available
-- `Optional<T> first(...)` - immediately get an instance of a contract from the registry; there may not be an implementation
-  available
-- `List<T> all(...)` - immediately get all instances of a contract from the registry; result may be empty
-- `Supplier<T> supply(...)` - get a supplier of an instance; the service may be instantiated only when `get` is called
-- `Supplier<Optional<T>> supplyFirst(...)` - get a supplier of an optional instance
-- `Supplier<List<T>> supplyAll(...)` - get a supplier of all instances
-
-Lookup parameter options:
-
-- `Class<?>` - the contract we are looking for
-- `TypeName` - the same, but using Helidon abstraction of type names (may have type arguments)
-- `Lookup` - a full search criteria for a registry lookup
-
-# Startup
-
-The following options are available to start a service registry (and the application):
-
-1. Use API to create an `io.helidon.service.inject.InjectRegistryManager`
-2. Use the Helidon startup class `io.helidon.Main`, which will use the injection main class through service loader
-3. Use a generated main class, by default named `ApplicationMain` in the main package of the application (supports customization)
-
-## Generated Main Class
-
-To generate a main class, the Helidon Service Inject Maven plugin must be configured.
-This is expected to be configured only for an application (i.e. not for library modules) - this is the reason we do not generate it automatically.
-
-The generated main class will contain full, reflection less configuration of the service registry. It registers all services directly through API, and disables service discovery from classpath.
-
-The Main class can also be customized; to do this:
-1. Create a custom class (let's call it `CustomMain` as an example)
-2. The class must extend the injection main class (`public abstract class CustomMain extends InjectionMain`)
-3. The class must be annotated with `@Injection.Main`, so it is discovered by annotation processor
-4. Implement any desired methods; the generated class will only implement `serviceDescriptors(InjectConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
-
-For details on how to configure your build, see [Maven Plugin](../maven-plugin/README.md).
-
-# Other
-
-## API types quick reference
-
-Annotation type: `io.helidon.service.inject.api.Injection`
-
-Annotations:
-
-| Annotation class | Description                                                                                                               |
-|------------------|---------------------------------------------------------------------------------------------------------------------------|
-| `Inject`         | Marks element as an injection point; although we prefer constructor injection, field and method injection works as well   |
-| `Qualifier`      | Marker for annotations that are qualifiers                                                                                |
-| `Named`          | A qualifier that provides a name                                                                                          |
-| `NamedByType`    | An equivalent of `Named`, that uses the fully qualified class name of the configured class as name                        |
-| `Scope`          | Marker for annotations that are scopes                                                                                    |
-| `PerLookup`      | Service instance is created per lookup (either for injection point, or via registry lookup)                               |
-| `Singleton`      | Singleton scope - a service registry will create zero or one instances of this service (instantiation is lazy)            |
-| `PerRequest`     | Request scope - a service registry will create zero or one instance of this service per request scope instance            |
-| `RunLevel`       | A "layer" in which this service should be instantiated; not executed by injection, will be used when starting application |
-| `PerInstance`    | Create a service instance for each instance of the configured contract available in registry (usually for named)          |
-| `InstanceName`   | Parameter or field that will be injected with the name this service instance is created for (see `PerInstance`)           |
-| `Describe`       | Create a descriptor for a type that is not a service itself, but an instance would be provided at scope creation time     | 
-
-Interfaces:
-
-| Interface class         | Description                                                                                                     |
-|-------------------------|-----------------------------------------------------------------------------------------------------------------|
-| `ServicesFactory`       | A service factory that creates zero or more qualified service instances at runtime                              |
-| `InjectionPointFactory` | A service factory that creates values for specific injection points                                             |
-| `QualifiedFactory`      | A service factory to resolve qualified injection points of any type (used for example by config value injection |
-| `QualifiedInstance`     | Used as a return type of some of the interfaces above, not to be implemented by users                           |
-| `ScopeHandler`          | Extension point to support additional scopes                                                                    |
-
-## Injection point options
-
-An injection point may have the following forms (`Contract` stands for a contract interface, or class):
-
-Instance based:
-
-1. `Contract` - injects an instance of the contract with the highest weight from the registry
-2. `Optional<Contract>` - same as previous, the contract may not have an implementation available in registry
-3. `List<Contract>` - a list of all available instances in the registry
-
-Supplier based (to break cyclic dependency, and to create instances as late as possible):
-
-1. `Supplier<Contract>`
-2. `Supplier<Optional<Contract>>`
-3. `Supplier<List<Contract>>`
-
-Service instance based (to obtain registry metadata in addition to the instance):
-
-1. `ServiceInstance<Contract>`
-2. `Optional<ServiceInstance<Contract>>`
-3. `List<ServiceInstance<Contract>>`
-
-# Glossary
-
-| Term            | Description                                                                                                                                                                                                   |
-|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Core Service    | A class annotated with `@Service.Provider`                                                                                                                                                                    |
-| Contract        | A class extended by a service, or an interface implemented by a service, can be used to lookup instances                                                                                                      |
-| Dependency      | A "Core Service" constructor parameter (type must be another service or a "Contract")                                                                                                                         |
-| Service         | A class annotated with one of the scope annotations, or a core service                                                                                                                                        |
-| Factory         | A "Core Service" or "Service" that implements one of the factory interfaces; Core service is a factory only if it implements a `Supplier                                                                      |
-| Injection Point | Field annotated with `@Injection.Inject`, or a constructor parameter of a constructor used for injection (either the only accessible constructor, or the only constructor annotated with `@Injection.Inject`) |
-
diff --git a/service/inject/api/pom.xml b/service/inject/api/pom.xml
deleted file mode 100644
index b2e7dc72deb..00000000000
--- a/service/inject/api/pom.xml
+++ /dev/null
@@ -1,114 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service.inject</groupId>
-        <artifactId>helidon-service-inject-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>helidon-service-inject-api</artifactId>
-    <name>Helidon Service Inject API</name>
-    <description>
-        API to declare services that use injection.
-    </description>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-config</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-types</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.builder</groupId>
-            <artifactId>helidon-builder-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-registry</artifactId>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-apt</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.builder</groupId>
-                            <artifactId>helidon-builder-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-                <dependencies>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-apt</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.builder</groupId>
-                        <artifactId>helidon-builder-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                </dependencies>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Configuration.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/Configuration.java
deleted file mode 100644
index 13612d63d9c..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Configuration.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.function.Function;
-
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.types.TypeName;
-
-/**
- * Configuration related types used with Helidon injection.
- */
-public final class Configuration {
-    private Configuration() {
-    }
-
-    /**
-     * Configuration property, can be used when using Helidon declarative.
-     */
-    @Target(ElementType.PARAMETER)
-    @Retention(RetentionPolicy.CLASS)
-    @Documented
-    @Injection.Qualifier
-    public @interface Value {
-        /**
-         * Configuration key (from the config root) to find the value.
-         * <p>
-         * Default configuration key is {@code <class_name>.<field_name>} for field injection (if supported),
-         * and {@code <className>.<constructor_param_name>} for constructor injection. The {@code <class_name>}
-         * is the fully qualified class name of the type that uses this annotation.
-         * <p>
-         * Note that parameter names are not retained for runtime, so the parameter name when not using
-         * build time processing would be generated by the JVM.
-         * <p>
-         * A default value can be specified as part of the key definition, separated by {@code :} (colon) from
-         * the key, such as:
-         * <pre>
-         *     public MyType(@Config.Value("app.greeting:Ciao") String greeting) {
-         *     }
-         * </pre>
-         * This would look in configuration tree for key {@code app.greeting}, and if not found, would use
-         * {@code Ciao} as the default value. If default value is not defined, and the property does not exist,
-         * an exception would be thrown at runtime.
-         * <p>
-         * Default values will have string converters applied if the type is not {@link String}.
-         * To provide a more complex default, such as when mapping a configuration tree to an object, use
-         * {@link #defaultProvider()} instead.
-         *
-         * @return configuration value key, with possible default value
-         */
-        String value() default "";
-
-        /**
-         * A class that provides the default value
-         * of the type expected by the injected field/parameter, it must be accessible through service registry.
-         *
-         * @return default provider class
-         */
-        Class<? extends Function<Config, ?>> defaultProvider() default NoProvider.class;
-
-        /**
-         * Default value of {@link Value#defaultProvider()}.
-         */
-        final class NoProvider implements Function<Config, Object> {
-            /**
-             * Type name of this class.
-             */
-            public static final TypeName TYPE = TypeName.create(NoProvider.class);
-
-            private NoProvider() {
-            }
-
-            @Override
-            public Object apply(Config config) {
-                throw new ConfigException("This default value provider should not be used");
-            }
-        }
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/GeneratedInjectService.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/GeneratedInjectService.java
deleted file mode 100644
index 0e70bdd7a44..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/GeneratedInjectService.java
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import io.helidon.common.GenericType;
-import io.helidon.common.types.ElementKind;
-import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Service;
-
-/**
- * All types in this class are used from generated code for services.
- */
-public final class GeneratedInjectService {
-    private GeneratedInjectService() {
-    }
-
-    /**
-     * Each descriptor for s service that is implements {@link io.helidon.service.inject.api.Injection.QualifiedFactory}
-     * implements this interface to provide information about the qualifier it supports.
-     */
-    public interface QualifiedFactoryDescriptor {
-        /**
-         * Type of qualifier a {@link io.helidon.service.inject.api.Injection.QualifiedFactory} provides.
-         *
-         * @return type name of the qualifier this qualified factory can provide instances for
-         */
-        TypeName qualifierType();
-    }
-
-    /**
-     * Each descriptor for s service that is annotated with {@link io.helidon.service.inject.api.Injection.PerInstance}
-     * implements this interface to provide information about the type that drives it.
-     */
-    public interface PerInstanceDescriptor {
-        /**
-         * Service instances may be created for instances of another service.
-         * If a type is created for another type, it inherits ALL qualifiers of the type that it is based on.
-         *
-         * @return create for service type
-         */
-        TypeName createFor();
-    }
-
-    /**
-     * Each descriptor for a service that implements {@link io.helidon.service.inject.api.Injection.ScopeHandler}
-     * implements this interface to provide information about the scope it handles.
-     */
-    public interface ScopeHandlerDescriptor {
-        /**
-         * Scope handled by the scope handler service.
-         *
-         * @return type of the scope handled (annotation)
-         */
-        TypeName handledScope();
-    }
-
-    /**
-     * For event observers an observer registration is generated, so it can be picked-up by the
-     * {@link io.helidon.service.inject.api.EventManager} implementation at runtime.
-     */
-    @Service.Contract
-    public interface EventObserverRegistration {
-        /**
-         * Register with the event manager.
-         *
-         * @param manager event manager
-         */
-        void register(EventManager manager);
-    }
-
-    /**
-     * Utility type to provide method to combine injection point information for inheritance support.
-     */
-    public static final class IpSupport {
-        private IpSupport() {
-        }
-
-        /**
-         * Combine dependencies from this type with dependencies from supertype.
-         * This is a utility for code generated types.
-         *
-         * @param myType    this type's dependencies
-         * @param superType super type's dependencies
-         * @return a new list without constructor dependencies from super type
-         */
-        public static List<Ip> combineIps(List<Ip> myType, List<Ip> superType) {
-            List<Ip> result = new ArrayList<>(myType);
-
-            // always inject all fields
-            result.addAll(superType.stream()
-                                  .filter(it -> it.elementKind() == ElementKind.FIELD)
-                                  .toList());
-            // ignore constructors, as we only need to inject constructor on the instantiated type
-
-            // and only add methods that are not already injected on existing type
-            Set<String> injectedMethods = myType.stream()
-                    .filter(it -> it.elementKind() == ElementKind.METHOD)
-                    .map(Ip::method)
-                    .flatMap(Optional::stream)
-                    .collect(Collectors.toSet());
-
-            result.addAll(superType.stream()
-                                  .filter(it -> it.elementKind() == ElementKind.METHOD)
-                                  .filter(it -> it.method().isPresent())
-                                  .filter(it -> injectedMethods.add(it.method().get())) // we check presence above
-                                  .toList());
-
-            return List.copyOf(result);
-        }
-    }
-
-    /**
-     * Intercepted wrapper for generated interception delegates.
-     *
-     * @param <T> type of the provided contratc
-     */
-    abstract static class InterceptionWrapper<T> {
-        /**
-         * Wrap a qualified instance so the actual instance is correctly intercepted.
-         *
-         * @param qualifiedInstance qualified instance created by appropriate factory
-         * @return qualified instance with wrapped instance
-         */
-        protected Injection.QualifiedInstance<T> wrapQualifiedInstance(Injection.QualifiedInstance<T> qualifiedInstance) {
-            return Injection.QualifiedInstance.create(wrap(qualifiedInstance.get()), qualifiedInstance.qualifiers());
-        }
-
-        /**
-         * Wrap the instance for interception.
-         * This method is code generated.
-         *
-         * @param originalInstance instance to wrap
-         * @return wrapped instance
-         */
-        protected abstract T wrap(T originalInstance);
-    }
-
-    /**
-     * Wrapper for generated Service factories that implement a {@link java.util.function.Supplier} of a service.
-     *
-     * @param <T> type of the provided contract
-     */
-    public abstract static class SupplierFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
-            implements Supplier<T> {
-        private final Supplier<T> delegate;
-
-        /**
-         * Creates a new instance delegating service instantiation to the provided supplier.
-         *
-         * @param delegate used to obtain service instance that will be {@link #wrap(Object) wrapped} for interception
-         */
-        protected SupplierFactoryInterceptionWrapper(Supplier<T> delegate) {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public T get() {
-            return wrap(delegate.get());
-        }
-    }
-
-    /**
-     * Wrapper for generated Service factories that implement a
-     * {@link io.helidon.service.inject.api.Injection.ServicesFactory}.
-     *
-     * @param <T> type of the provided contract
-     */
-    public abstract static class ServicesFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
-            implements Injection.ServicesFactory<T> {
-        private final Injection.ServicesFactory<T> delegate;
-
-        /**
-         * Creates a new instance delegating service instantiation to the provided services factory.
-         *
-         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
-         */
-        protected ServicesFactoryInterceptionWrapper(Injection.ServicesFactory<T> delegate) {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public List<Injection.QualifiedInstance<T>> services() {
-            return delegate.services()
-                    .stream()
-                    .map(this::wrapQualifiedInstance)
-                    .collect(Collectors.toUnmodifiableList());
-        }
-    }
-
-    /**
-     * Wrapper for generated Service factories that implement a
-     * {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}.
-     *
-     * @param <T> type of the provided contract
-     */
-    public abstract static class IpFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
-            implements Injection.InjectionPointFactory<T> {
-        private final Injection.InjectionPointFactory<T> delegate;
-
-        /**
-         * Creates a new instance delegating service instantiation to the provided injection point factory.
-         *
-         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
-         */
-        protected IpFactoryInterceptionWrapper(Injection.InjectionPointFactory<T> delegate) {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public List<Injection.QualifiedInstance<T>> list(Lookup lookup) {
-            return delegate.first(lookup)
-                    .stream()
-                    .map(this::wrapQualifiedInstance)
-                    .collect(Collectors.toUnmodifiableList());
-        }
-
-        @Override
-        public Optional<Injection.QualifiedInstance<T>> first(Lookup lookup) {
-            return delegate.first(lookup)
-                    .map(this::wrapQualifiedInstance);
-        }
-    }
-
-    /**
-     * Wrapper for generated Service factories that implement a
-     * {@link io.helidon.service.inject.api.Injection.QualifiedFactory}.
-     *
-     * @param <T> type of the provided contract
-     * @param <A> type of the qualifier annotation
-     */
-    public abstract static class QualifiedFactoryInterceptionWrapper<T, A extends Annotation> extends InterceptionWrapper<T>
-            implements Injection.QualifiedFactory<T, A> {
-        private final Injection.QualifiedFactory<T, A> delegate;
-
-        /**
-         * Creates a new instance delegating service instantiation to the provided qualified factory.
-         *
-         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
-         */
-        protected QualifiedFactoryInterceptionWrapper(Injection.QualifiedFactory<T, A> delegate) {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public List<Injection.QualifiedInstance<T>> list(Qualifier qualifier, Lookup lookup, GenericType<T> type) {
-            return delegate.list(qualifier, lookup, type)
-                    .stream()
-                    .map(this::wrapQualifiedInstance)
-                    .collect(Collectors.toUnmodifiableList());
-        }
-
-        @Override
-        public Optional<Injection.QualifiedInstance<T>> first(Qualifier qualifier, Lookup lookup, GenericType<T> type) {
-            return delegate.first(qualifier, lookup, type)
-                    .map(this::wrapQualifiedInstance);
-        }
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectRegistry.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectRegistry.java
deleted file mode 100644
index 4da62e8fc78..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectRegistry.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Supplier;
-
-import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Service;
-
-/**
- * Entry point to services with injection support in Helidon.
- * <p>
- * The service registry has knowledge about all the services within your application.
- * <p>
- * This is the full service registry with injection support.
- */
-@Service.Contract
-@Injection.Describe
-public interface InjectRegistry extends io.helidon.service.registry.ServiceRegistry {
-    /**
-     * {@link io.helidon.service.metadata.DescriptorMetadata#registryType()} for inject services.
-     */
-    String REGISTRY_TYPE_INJECT = "inject";
-
-    /**
-     * Type name of this interface.
-     */
-    TypeName TYPE = TypeName.create(InjectRegistry.class);
-
-    /**
-     * Get the first service instance matching the lookup with the expectation that there is a match available.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return the best service instance matching the lookup, cast to the expected type; please use a {@code Object} as the type
-     *         if the result may contain an unknown instance
-     * @throws io.helidon.service.registry.ServiceRegistryException if there is no service that could satisfy the lookup, or the
-     *                                                              resolution to instance failed
-     */
-    <T> T get(Lookup lookup);
-
-    /**
-     * Get the first service instance matching the contract with the expectation that there may not be a match available.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return the best service instance matching the lookup, cast to the expected type; please use a {@code Object} as the type
-     *         if the result may contain an unknown instance
-     */
-    <T> Optional<T> first(Lookup lookup);
-
-    /**
-     * Get all service instances matching the lookup with the expectation that there may not be a match available.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return list of services matching the criteria, may be empty if none matched, or no instances were provided
-     */
-    <T> List<T> all(Lookup lookup);
-
-    /**
-     * Get the first service supplier matching the lookup with the expectation that there is a match available.
-     * The provided {@link java.util.function.Supplier#get()} may throw an
-     * {@link io.helidon.service.registry.ServiceRegistryException} in case the matching service cannot provide a value (either
-     * because
-     * of scope mismatch, or because there is no available instance, and we use a runtime resolution through
-     * {@link io.helidon.service.inject.api.Injection.ServicesFactory},
-     * {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}, or similar).
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return the best service supplier matching the lookup, cast to the expected type; please use a {@code Object} as the type
-     *         if the result may contain an unknown instance
-     * @throws io.helidon.service.registry.ServiceRegistryException if there is no service that could satisfy the lookup
-     */
-    <T> Supplier<T> supply(Lookup lookup);
-
-    /**
-     * Find the first service matching the lookup with the expectation that there may not be a match available.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return the best service matching the lookup, cast to the expected type; please use a {@code Object} as the type
-     *         if the result may contain an unknown instance
-     */
-    <T> Supplier<Optional<T>> supplyFirst(Lookup lookup);
-
-    /**
-     * Lookup a supplier of all services matching the lookup with the expectation that there may not be a match available.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
-     *               you have configured appropriate contracts in the lookup, as we cannot infer this
-     * @return supplier of list of services ordered, may be empty if there is no match
-     */
-    <T> Supplier<List<T>> supplyAll(Lookup lookup);
-
-    /**
-     * A lookup method operating on the service descriptors, rather than service instances.
-     * This is useful for tools that need to analyze the structure of the registry,
-     * for testing etc.
-     * The returned instances are either the actual instances registered with the registry, or an inject
-     * based wrapper if the service is from core registry. Use {@link InjectServiceInfo#coreInfo()} to get the actual instance
-     * if instance equality is required.
-     * <p>
-     * The registry is optimized for look-ups based on service type and service contracts, all other
-     * lookups trigger a full registry scan.
-     *
-     * @param lookup lookup criteria to find matching services
-     * @return a list of service descriptors that match the lookup criteria
-     */
-    List<InjectServiceInfo> lookupServices(Lookup lookup);
-
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceDescriptor.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceDescriptor.java
deleted file mode 100644
index 67efdc89e2f..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceDescriptor.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.util.Set;
-
-import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.ServiceDescriptor;
-
-/**
- * A descriptor of a service. In addition to providing service metadata, this also allows instantiation
- * and injection to the service instance. The descriptor is usually code generated, though it can be
- * handcrafted (it must be annotated with {@link io.helidon.service.registry.Service.Descriptor} in such a case).
- *
- * @param <T> type of the service this descriptor describes
- */
-public interface InjectServiceDescriptor<T> extends ServiceDescriptor<T>, InjectServiceInfo {
-    /**
-     * Create a new service instance.
-     *
-     * @param ctx                  injection context with all injection points data
-     * @param interceptionMetadata interception metadata to use when the constructor should be intercepted
-     * @return a new instance, must be of the type T or a subclass
-     */
-    // we cannot return T, as it does not allow us to correctly handle inheritance
-    default Object instantiate(DependencyContext ctx, InterceptionMetadata interceptionMetadata) {
-        throw new IllegalStateException("Cannot instantiate type " + serviceType().fqName() + ", as it is either abstract,"
-                                                + " or an interface.");
-    }
-
-    /**
-     * Inject fields and methods.
-     *
-     * @param ctx                  injection context
-     * @param interceptionMetadata interception metadata to support interception of field injection
-     * @param injected             mutable set of already injected methods from subtypes
-     * @param instance             instance to update
-     */
-    default void inject(DependencyContext ctx,
-                        InterceptionMetadata interceptionMetadata,
-                        Set<String> injected,
-                        T instance) {
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceInfo.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceInfo.java
deleted file mode 100644
index f89144d2c03..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InjectServiceInfo.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-
-import io.helidon.common.types.TypeName;
-
-/**
- * Service metadata.
- */
-public interface InjectServiceInfo extends io.helidon.service.registry.ServiceInfo {
-    /**
-     * List of injection points required by this service (and possibly by its supertypes).
-     * Each dependency is a point of injection of one instance into
-     * constructor, method parameter, or a field.
-     *
-     * @return required dependencies
-     */
-    @Override
-    default List<Ip> dependencies() {
-        return List.of();
-    }
-
-    /**
-     * Service qualifiers.
-     *
-     * @return qualifiers
-     */
-    default Set<Qualifier> qualifiers() {
-        return Set.of();
-    }
-
-    /**
-     * Run level of this service.
-     *
-     * @return run level
-     */
-    default Optional<Double> runLevel() {
-        return Optional.empty();
-    }
-
-    /**
-     * Scope of this service.
-     *
-     * @return scope of the service
-     */
-    TypeName scope();
-
-    /**
-     * What factory type is the described service.
-     * Inject services can be any of the types in the {@link FactoryType enum}.
-     *
-     * @return factory type
-     */
-    default FactoryType factoryType() {
-        return FactoryType.SERVICE;
-    }
-
-    /**
-     * Returns the instance of the core service descriptor.
-     * As we use identity, this is a required method that MUST return the singleton instance of the service descriptor.
-     *
-     * @return singleton instance of the underlying service descriptor
-     */
-    default io.helidon.service.registry.ServiceInfo coreInfo() {
-        // for all injection based service descriptors this is enough
-        return this;
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
deleted file mode 100644
index 5a643e45993..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
+++ /dev/null
@@ -1,547 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Supplier;
-
-import io.helidon.common.GenericType;
-import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Service;
-
-/**
- * Injection annotations. These annotations can extend support provided through
- * {@link io.helidon.service.registry.Service} annotations for injection.
- * <p>
- * This is the entry point for any annotation related to service definition with injection support in Helidon Service Registry.
- * <p>
- * Explore annotations in this type to find out how to enhance your service behavior.
- * <p>
- * Note that to utilize Helidon Inject and its service registry, you need to configure annotation processor to generate
- * required source files.
- */
-public final class Injection {
-    private Injection() {
-    }
-
-    /**
-     * Method, constructor, or field marked with this annotation is considered as injectable, and its injection points
-     * will be satisfied with services from the service registry. An injection point is a field, or a single parameter.
-     * <p>
-     * An injection point may expect instance of a service, or a {@link java.util.function.Supplier} of the same.
-     * <p>
-     * Annotating an inaccessible component will always be marked as an error at compilation time
-     * (private fields, methods, constructors).
-     * <p>
-     * Annotating a final field will always be marked as an error at compilation time.
-     * <p>
-     * We recommend to use constructor injection, as field injection makes testing harder.
-     */
-    @Retention(RetentionPolicy.CLASS)
-    @Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
-    @Documented
-    public @interface Inject {
-    }
-
-    /**
-     * Marks annotations that act as qualifiers.
-     * <p>
-     * A qualifier annotation restricts the eligible service instances that can be injected into an injection point to those
-     * qualified by the same qualifier.
-     */
-    @Target(ElementType.ANNOTATION_TYPE)
-    @Retention(RetentionPolicy.CLASS)
-    @Documented
-    public @interface Qualifier {
-    }
-
-    /**
-     * A qualifier that can restrict injection to specifically named instances, or that qualifies services with that name.
-     */
-    @Qualifier
-    @Retention(RetentionPolicy.CLASS)
-    @Documented
-    @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.TYPE})
-    public @interface Named {
-        /**
-         * Type name of this annotation.
-         */
-        TypeName TYPE = TypeName.create(Named.class);
-        /**
-         * Represents a wildcard name (i.e., matches anything).
-         */
-        String WILDCARD_NAME = "*";
-        /**
-         * Default name to identify a default instance.
-         */
-        String DEFAULT_NAME = "@default";
-
-        /**
-         * The name.
-         *
-         * @return name this injection point requires, or this service provides, or a factory provides
-         */
-        String value();
-    }
-
-    /**
-     * Scope annotation.
-     * A scope defines the cardinality of instances. This is a meta-annotation used to define that an annotation is a scope.
-     * Note that a single service can only have one scope annotation, and that scopes are not inheritable.
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target(ElementType.ANNOTATION_TYPE)
-    @Inherited
-    public @interface Scope {
-    }
-
-    /**
-     * A partial scope that creates a new instance for each injection point/lookup.
-     * The "partial scope" means that the service instances are not managed. If this
-     * service gets injected, a new instance is created for each injection. The service is instantiated,
-     * post construct method (if any) is called, and then it is ignored (i.e. it never gets a pre destroy
-     * method invocation).
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-    @Scope
-    public @interface PerLookup {
-        /**
-         * Type name of this interface.
-         */
-        TypeName TYPE = TypeName.create(PerLookup.class);
-    }
-
-    /**
-     * A singleton service.
-     * The service registry will only contain a single instance of this service, and all injection points will be satisfied by
-     * the same instance.
-     * <p>
-     * A singleton instance is guaranteed to have its constructor, post-construct, and pre-destroy methods invoked once within
-     * the lifecycle of the service registry.
-     * <p>
-     * Alternative to this annotation is {@link io.helidon.service.inject.api.Injection.PerLookup} (or no annotation on a type
-     * that has {@link Injection.Inject} on its elements). Such a service would be injected
-     * every time its factory is invoked (each injection point, or on call to {@link java.util.function.Supplier#get()} if
-     * supplier is injected), and {@link io.helidon.service.inject.api.Injection.PerRequest} for request bound instances.
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Scope
-    @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
-    public @interface Singleton {
-        /**
-         * Type name of this annotation.
-         */
-        TypeName TYPE = TypeName.create(Singleton.class);
-    }
-
-    /**
-     * A service with an instance per request.
-     * Injections to different scopes are supported, but must be through a {@link java.util.function.Supplier},
-     * as we do not provide a proxy mechanism for instances.
-     * <p>
-     * Request scope is not started by default. If you want to use request scope, you can add the following
-     * library to your classpath to add support for it:
-     * <ul>
-     *     <li>{@code io.helidon.declarative.webserver:helidon-declarative-webserver-request-scope}</li>
-     * </ul>
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Scope
-    @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-    public @interface PerRequest {
-        /**
-         * This interface type.
-         */
-        TypeName TYPE = TypeName.create(PerRequest.class);
-    }
-
-    /**
-     * This annotation is effectively the same as {@link Injection.Named}
-     * where the {@link Injection.Named#value()} is a {@link Class}
-     * name instead of a {@link String}. The name that would be used is the fully qualified name of the type.
-     */
-    @Qualifier
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    public @interface NamedByType {
-        /**
-         * Type name of this interface.
-         * {@link io.helidon.common.types.TypeName} is used in Helidon Inject APIs.
-         */
-        TypeName TYPE = TypeName.create(NamedByType.class);
-
-        /**
-         * The class used will function as the name.
-         *
-         * @return the class
-         */
-        Class<?> value();
-    }
-
-    /**
-     * Indicates the desired startup sequence for a service class. This is not used internally by Injection, but is available as a
-     * convenience to the caller in support for a specific startup sequence for service activations.
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target(ElementType.TYPE)
-    public @interface RunLevel {
-
-        /**
-         * Represents an eager singleton that should be started at "startup". Note, however, that callers control the actual
-         * activation for these services, not the injection framework itself, as shown below:         * <pre>
-         * {@code
-         * registry.all(Lookup.builder()
-         *     .runLevel(Injection.RunLevel.STARTUP)
-         *     .build());
-         * }
-         * </pre>
-         */
-        double STARTUP = 10D;
-
-        /**
-         * Represents services that have the concept of "serving" something, such as webserver.
-         */
-        double SERVER = 50D;
-
-        /**
-         * Anything > 0 is left to the underlying provider implementation's discretion for meaning; this is just a default for
-         * something that is deemed "other than startup".
-         */
-        double NORMAL = 100D;
-
-        /**
-         * The service ranking applied when not declared explicitly.
-         *
-         * @return the startup int value, defaulting to {@link #NORMAL}
-         */
-        double value() default NORMAL;
-    }
-
-    /**
-     * A service that has instances created for each named instance of the service it is driven by.
-     * The instance created will have the same {@link Injection.Named} qualifier as the
-     * driving instance (in addition to all qualifiers defined on this service).
-     * <p>
-     * There are a few restrictions on this type of services:
-     * <ul>
-     * <li>The service MUST NOT implement {@link java.util.function.Supplier}</li>
-     * <li>The service MUST NOT implement {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}</li>
-     * <li>The service MUST NOT implement {@link io.helidon.service.inject.api.Injection.ServicesFactory}</li>
-     * <li>All types that inherit from this service will also inherit the driven by</li>
-     * <li>There MAY be an injection point of the type defined in {@link #value()}, without any qualifiers -
-     * this injection point will be satisfied by the driving instance</li>
-     * <li>There MAY be a {@link String} injection point qualified with
-     * {@link io.helidon.service.inject.api.Injection.InstanceName} - this injection point will be satisfied by the
-     * name of the driving instance</li>
-     * </ul>
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target(ElementType.TYPE)
-    public @interface PerInstance {
-        /**
-         * The service type driving this service. If the service provides more than one instance,
-         * the instances MUST be {@link Injection.Named}.
-         *
-         * @return type of the service driving instances of this service
-         */
-        Class<?> value();
-    }
-
-    /**
-     * For types that are {@link io.helidon.service.inject.api.Injection.PerInstance}, an injection point (field, parameter) can
-     * be annotated with this annotation to receive the name qualifier associated with this instance.
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target({ElementType.PARAMETER, ElementType.FIELD})
-    @Qualifier
-    public @interface InstanceName {
-        /**
-         * Type name of this interface.
-         * {@link io.helidon.common.types.TypeName} is used in Helidon Inject APIs.
-         */
-        TypeName TYPE = TypeName.create(InstanceName.class);
-    }
-
-    /**
-     * Describe the annotated type. This will generate a service descriptor that cannot create an instance.
-     * This is useful for scoped instances that are provided when the scope is activated.
-     * <p>
-     * This annotation will ignore type hierarchy (the descriptor will never have a super type).
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target(ElementType.TYPE)
-    public @interface Describe {
-        /**
-         * Customize the scope to use, defaults to {@link io.helidon.service.inject.api.Injection.Singleton}.
-         *
-         * @return scope to use for the generated service descriptor
-         */
-        Class<? extends Annotation> value() default Singleton.class;
-    }
-
-    /**
-     * Marks a custom main class (should be declared as {@code abstract}).
-     * This is a required annotation to make sure the generated main class extends the user's main class.
-     * Note that the custom main class MUST extend the {@code io.helidon.service.inject.InjectionMain} to customize
-     * startup sequence.
-     * The name {@code ApplicationMain} is reserved by service registry, and cannot be used for your custom main class;
-     * the generated name can be modified through {@code Maven} plugin configuration and annotation processor configuration.
-     * <p>
-     * The generated main class adds registration of all available services to injection config,
-     * and disables service discovery to prevent any and all reflection done by service registry itself.
-     * <p>
-     * To have correct startup of your application, use the {@code ApplicationMain} as your application entry point
-     * (such as a {@code mainClass} configured in {@code pom.xml} when using Maven and Helidon application parents).
-     */
-    @Documented
-    @Retention(RetentionPolicy.CLASS)
-    @Target(ElementType.TYPE)
-    public @interface Main {
-    }
-
-    /**
-     * Provides an ability to create more than one service instance from a single service definition.
-     * This is useful when the cardinality can only be determined at runtime.
-     *
-     * @param <T> type of the provided services
-     */
-    public interface ServicesFactory<T> {
-        /**
-         * Type name of this interface.
-         */
-        TypeName TYPE = TypeName.create(ServicesFactory.class);
-
-        /**
-         * List of service instances.
-         * Each instance may have a different set of qualifiers.
-         * <p>
-         * The following is inherited from this factory:
-         * <ul>
-         *     <li>Set of contracts, except for {@link io.helidon.service.inject.api.Injection.ServicesFactory}</li>
-         *     <li>Scope</li>
-         *     <li>Run level</li>
-         *     <li>Weight</li>
-         * </ul>
-         *
-         * @return qualified suppliers of service instances
-         */
-        List<QualifiedInstance<T>> services();
-    }
-
-    /**
-     * Provides ability to contextualize the injected service by the target receiver of the injection point dynamically
-     * at runtime. This API will provide service instances of type {@code T}.
-     * <p>
-     * The ordering of services, and the preferred service itself, is determined by the service registry implementation.
-     * <p>
-     * The service registry does not make any assumptions about qualifiers of the instances being created, though they should
-     * be either the same as the injection point factory itself, or a subset of it, so the service can be discovered through
-     * one of the lookup methods (i.e. the injection point factory may be annotated with a
-     * {@link Named} with {@link Named#WILDCARD_NAME}
-     * value, and each instance provided may use a more specific name qualifier).
-     *
-     * @param <T> the type that the factory produces
-     */
-    public interface InjectionPointFactory<T> {
-        /**
-         * Type name of this interface.
-         */
-        TypeName TYPE = TypeName.create(InjectionPointFactory.class);
-
-        /**
-         * Get (or create) an instance of this service type for the given injection point context. This is logically the same
-         * as using the first element of the result from calling {@link #list(io.helidon.service.inject.api.Lookup)}.
-         *
-         * @param lookup the service query
-         * @return the best service instance matching the criteria, if any matched, with qualifiers (if any)
-         */
-        Optional<QualifiedInstance<T>> first(Lookup lookup);
-
-        /**
-         * Get (or create) a list of instances matching the criteria for the given injection point context.
-         *
-         * @param lookup the service query
-         * @return the service instances matching criteria for the lookup in order of weight, or empty if none matching
-         */
-        default List<QualifiedInstance<T>> list(Lookup lookup) {
-            return first(lookup).map(List::of).orElseGet(List::of);
-        }
-    }
-
-    /**
-     * A factory to resolve qualified injection points of any type.
-     * <p>
-     * As compared to {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}, this type is capable of resolving ANY injection
-     * point as long as it is annotated by the qualifier. The contract of the injection point depends on how the implementation
-     * service declares the type parameters of this interface. If you use any type other than {@link java.lang.Object}, that will
-     * be the only supported contract, otherwise any type is expected to be supported.
-     * <p>
-     * A good practice is to create an accompanying codegen extension that validates injection points at build time.
-     *
-     * @param <T> type of the provided instance, the special case is {@link java.lang.Object} - if used, we consider this
-     *            factory to be capable of handling ANY type, and will allow injection points with any type as long as it is
-     *            qualified by the qualifier
-     * @param <A> type of qualifier supported by this factory
-     */
-    public interface QualifiedFactory<T, A extends Annotation> {
-        /**
-         * Type name of this interface.
-         */
-        TypeName TYPE = TypeName.create(QualifiedFactory.class);
-
-        /**
-         * Get the first instance (if any) matching the qualifier and type.
-         *
-         * @param qualifier the qualifier this type supports (same type as the {@code A} type this type implements)
-         * @param lookup    full lookup used to obtain the value, may contain the actual injection point
-         * @param type      type to be injected (or type requested)
-         * @return the qualified instance matching the request, or an empty optional if none match
-         */
-        Optional<QualifiedInstance<T>> first(io.helidon.service.inject.api.Qualifier qualifier,
-                                             Lookup lookup,
-                                             GenericType<T> type);
-
-        /**
-         * Get all instances matching the qualifier and type.
-         *
-         * @param qualifier the qualifier this type supports (same type as the {@code A} type this type implements)
-         * @param lookup    full lookup used to obtain the value, may contain the actual injection point
-         * @param type      type to be injected (or type requested)
-         * @return the qualified instance matching the request, or an empty optional if none match
-         */
-        default List<QualifiedInstance<T>> list(io.helidon.service.inject.api.Qualifier qualifier,
-                                                Lookup lookup,
-                                                GenericType<T> type) {
-            return first(qualifier, lookup, type)
-                    .map(List::of)
-                    .orElseGet(List::of);
-        }
-    }
-
-    /**
-     * An instance with its qualifiers.
-     * Some services are allowed to create more than one instance, and there may be a need
-     * to use different qualifiers than the factory service uses.
-     *
-     * @param <T> type of instance, as provided by the service
-     * @see io.helidon.service.inject.api.Injection.ServicesFactory
-     */
-    public interface QualifiedInstance<T> extends Supplier<T> {
-        /**
-         * Create a new qualified instance.
-         *
-         * @param instance   the instance
-         * @param qualifiers qualifiers to use
-         * @param <T>        type of the instance
-         * @return a new qualified instance
-         */
-        static <T> QualifiedInstance<T> create(T instance, io.helidon.service.inject.api.Qualifier... qualifiers) {
-            return new QualifiedInstanceImpl<>(instance, Set.of(qualifiers));
-        }
-
-        /**
-         * Create a new qualified instance.
-         *
-         * @param instance   the instance
-         * @param qualifiers qualifiers to use
-         * @param <T>        type of the instance
-         * @return a new qualified instance
-         */
-        static <T> QualifiedInstance<T> create(T instance, Set<io.helidon.service.inject.api.Qualifier> qualifiers) {
-            return new QualifiedInstanceImpl<>(instance, qualifiers);
-        }
-
-        /**
-         * Get the instance that the registry manages (or an instance that is unmanaged, if the provider is in
-         * {@link io.helidon.service.inject.api.Injection.PerLookup}, or if the instance is created by a factory).
-         * The instance must be guaranteed to be constructed and if managed by the registry, and activation scope is not limited,
-         * then injected as well.
-         *
-         * @return instance
-         */
-        @Override
-        T get();
-
-        /**
-         * Qualifiers of the instance.
-         *
-         * @return qualifiers of the service instance
-         */
-        Set<io.helidon.service.inject.api.Qualifier> qualifiers();
-    }
-
-    /**
-     * Extension point for the service registry to support new scopes.
-     * <p>
-     * Implementation must be qualified with the fully qualified name of the corresponding scope annotation class.
-     *
-     * @see io.helidon.service.inject.api.Injection.Named
-     * @see io.helidon.service.inject.api.Injection.NamedByType
-     */
-    @Service.Contract
-    public interface ScopeHandler {
-        /**
-         * Type name of this interface.
-         * Service registry uses {@link io.helidon.common.types.TypeName} in its APIs.
-         */
-        TypeName TYPE = TypeName.create(ScopeHandler.class);
-
-        /**
-         * Get the current scope if available.
-         *
-         * @return current scope instance, or empty if the scope is not active
-         */
-        Optional<io.helidon.service.inject.api.Scope> currentScope();
-
-
-        /**
-         * Activate the given scope.
-         *
-         * @param scope scope to activate
-         */
-        default void activate(io.helidon.service.inject.api.Scope scope) {
-            scope.registry().activate();
-        }
-
-        /**
-         * De-activate the given scope.
-         *
-         * @param scope scope to de-activate
-         */
-        default void deactivate(io.helidon.service.inject.api.Scope scope) {
-            scope.registry().deactivate();
-        }
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/IpBlueprint.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/IpBlueprint.java
deleted file mode 100644
index 6bbaadfc218..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/IpBlueprint.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import java.util.Optional;
-import java.util.Set;
-
-import io.helidon.builder.api.Option;
-import io.helidon.builder.api.Prototype;
-import io.helidon.common.types.AccessModifier;
-import io.helidon.common.types.Annotation;
-import io.helidon.common.types.ElementKind;
-import io.helidon.service.registry.Dependency;
-
-/**
- * Unique identification, and metadata of an injection point.
- */
-@Prototype.Blueprint
-@Prototype.CustomMethods(IpSupport.CustomMethods.class)
-interface IpBlueprint extends Dependency {
-    /**
-     * Kind of element we inject into (constructor, field, method).
-     *
-     * @return element kind (for parameters, the containing element)
-     */
-    @Option.Default("CONSTRUCTOR")
-    ElementKind elementKind();
-
-    /**
-     * The qualifier type annotations on this element.
-     *
-     * @return the qualifier type annotations on this element
-     */
-    @Option.Singular
-    @Option.Redundant(stringValue = false)
-    // kind + service type + name is a unique identification already
-    Set<Qualifier> qualifiers();
-
-    /**
-     * The access modifier on the injection point/receiver.
-     * Defaults to {@link io.helidon.common.types.AccessModifier#PACKAGE_PRIVATE}.
-     *
-     * @return the access
-     */
-    @Option.Default("PACKAGE_PRIVATE")
-    @Option.Redundant
-    // kind + service type + name is a unique identification already
-    AccessModifier access();
-
-    /**
-     * The annotations on this element.
-     *
-     * @return the annotations on this element
-     */
-    @Option.Singular
-    @Option.Redundant
-    // kind + service type + name is a unique identification already
-    Set<Annotation> annotations();
-
-    /**
-     * Top level method that declares this method.
-     * This is to provide information about overridden methods, as we should only inject such methods once.
-     *
-     * @return unique identification of a declaring method
-     */
-    @Option.Redundant(stringValue = false)
-    Optional<String> method();
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/IpSupport.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/IpSupport.java
deleted file mode 100644
index 5bc90079794..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/IpSupport.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.api;
-
-import io.helidon.builder.api.Prototype;
-import io.helidon.common.types.ElementKind;
-import io.helidon.service.registry.Dependency;
-
-final class IpSupport {
-    private IpSupport() {
-    }
-
-    final class CustomMethods {
-        private CustomMethods() {
-        }
-
-        /**
-         * Return the dependency if it is an instance of {@link io.helidon.service.inject.api.Ip},
-         * or create an Ip that is equivalent to the dependency.
-         *
-         * @param dependency dependency to convert to injection point
-         * @return injection point
-         */
-        @Prototype.FactoryMethod
-        static Ip create(Dependency dependency) {
-            if (dependency instanceof Ip ip) {
-                return ip;
-            }
-            return Ip.builder()
-                    .from(dependency)
-                    .elementKind(ElementKind.CONSTRUCTOR)
-                    .build();
-        }
-    }
-}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/package-info.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/package-info.java
deleted file mode 100644
index 2e26bd5b36d..00000000000
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/package-info.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * API required to define services, and to compile the code generated sources for Helidon Inject,
- * with a core service registry implementation (replacement for {@link java.util.ServiceLoader}).
- * <p>
- * The following main entry points for declaring services are available:
- * <ul>
- *     <li>{@link io.helidon.service.registry.Service} - for core registry</li>
- *     <li>{@link io.helidon.service.inject.api.Injection} - for injection support</li>
- *     <li>{@link io.helidon.service.inject.api.Interception} - for interception</li>
- * </ul>
- */
-package io.helidon.service.inject.api;
diff --git a/service/inject/api/src/main/java/module-info.java b/service/inject/api/src/main/java/module-info.java
deleted file mode 100644
index 96636cbe113..00000000000
--- a/service/inject/api/src/main/java/module-info.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Service registry with injection support API.
- */
-module io.helidon.service.inject.api {
-    requires transitive io.helidon.common.config;
-    requires transitive io.helidon.service.registry;
-    requires transitive io.helidon.builder.api;
-    requires transitive io.helidon.common.types;
-
-    exports io.helidon.service.inject.api;
-}
\ No newline at end of file
diff --git a/service/inject/codegen/README.md b/service/inject/codegen/README.md
deleted file mode 100644
index 296d6414550..00000000000
--- a/service/inject/codegen/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-Service Inject Codegen
----------------
-
-# Supported annotations
-
-| Annotation                         | Description                                                                         |
-|------------------------------------|-------------------------------------------------------------------------------------|
-| @Injection.Inject                  | Type with an injection point is a per lookup service unless it has scope annotation |
-| @Injection.Describe                | Generates a service descriptor for a contract without a service implementation      |
-| @Injection.PerInstance             | A service instantiated based on another service                                     |
-| @Injection.Scope (meta-annotation) | Scoped service                                                                      | 
-
-# Supported options
-
-Options can be configured as annotation processor options, when running via annotation processor.
-
-| Option                                          | Description                                                                                                                                                              |
-|-------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `helidon.registry.autoAddNonContractInterfaces` | If set to `true`, all implemented interfaces and super types are considered a contract; by default, `@Service.Contract` or `@Service.ExternalContracts` must be in place |
-| `helidon.inject.interceptionStrategy`           | How to handle generation of interceptor invokers (NONE, EXPLICIT, ALL_RUNTIME, ALL_RETAINED)                                                                             |
-| `helidon.inject.scopeMetaAnnotations`           | Set of annotations that mark scopes that are not Helidon scopes                                                                                                          |
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
deleted file mode 100644
index 4ba8d39126e..00000000000
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.codegen;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import io.helidon.codegen.CodegenException;
-import io.helidon.codegen.CodegenUtil;
-import io.helidon.codegen.ElementInfoPredicates;
-import io.helidon.codegen.classmodel.ClassModel;
-import io.helidon.codegen.classmodel.Method;
-import io.helidon.common.types.AccessModifier;
-import io.helidon.common.types.Annotations;
-import io.helidon.common.types.ElementSignature;
-import io.helidon.common.types.TypeInfo;
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-import io.helidon.common.types.TypedElementInfo;
-
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.DOUBLE_ARRAY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG_BUILDER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.STRING_ARRAY;
-import static java.util.function.Predicate.not;
-
-/**
- * Utility for {@value #CLASS_NAME} class generation.
- */
-public final class ApplicationMainGenerator {
-    /**
-     * Default class name of the generated main class.
-     */
-    public static final String CLASS_NAME = "ApplicationMain";
-    /**
-     * Signature of the {@code serviceDescriptors} method (this method is abstract in InjectionMain).
-     */
-    private static final ElementSignature METHOD_SERVICE_DESCRIPTORS = ElementSignature.createMethod(
-            TypeNames.PRIMITIVE_VOID,
-            "serviceDescriptors",
-            List.of(INJECT_CONFIG_BUILDER));
-    /**
-     * Signature of the {@code discoverServices} method.
-     */
-    private static final ElementSignature METHOD_DISCOVER_SERVICES = ElementSignature.createMethod(
-            TypeNames.PRIMITIVE_BOOLEAN,
-            "discoverServices",
-            List.of());
-    /**
-     * Signature of the {@code runLevels} method.
-     */
-    private static final ElementSignature METHOD_RUN_LEVELS = ElementSignature.createMethod(
-            DOUBLE_ARRAY,
-            "runLevels",
-            List.of(INJECT_CONFIG, INJECT_REGISTRY));
-
-    private ApplicationMainGenerator() {
-    }
-
-    /**
-     * Generate the common parts of the type.
-     *
-     * <ul>
-     *     <li>Class declaration with javadoc, @Generated, and copyright, with name {@value #CLASS_NAME}</li>
-     *     <li>Protected constructor with javadoc</li>
-     *     <li>{@code public static void main} method with javadoc</li>
-     * </ul>
-     *
-     * @param generator                 generator type name
-     * @param declaredSignatures        signatures declared on custom main class (if any)
-     * @param superType                 super type of the generated class
-     * @param generatedType             the type to generate
-     * @param discoverServices          whether to discover services (false when all services are manually registered to the
-     *                                  builder)
-     * @param addRunLevels              whether to add run levels from discovered services
-     * @param serviceDescriptorsHandler handler of the service descriptor method
-     * @param runLevelHandler           handler of the run level method
-     * @return class model builder
-     */
-    @SuppressWarnings("checkstyle:ParameterNumber") // all parameters are mandatory
-    public static ClassModel.Builder generate(TypeName generator,
-                                              Set<ElementSignature> declaredSignatures,
-                                              TypeName superType,
-                                              TypeName generatedType,
-                                              boolean discoverServices,
-                                              boolean addRunLevels,
-                                              CodeGeneratorHandler serviceDescriptorsHandler,
-                                              CodeGeneratorHandler runLevelHandler) {
-        ClassModel.Builder classModel = ClassModel.builder()
-                .type(generatedType)
-                .accessModifier(AccessModifier.PUBLIC)
-                .copyright(CodegenUtil.copyright(generator,
-                                                 generator,
-                                                 generatedType))
-                .addAnnotation(CodegenUtil.generatedAnnotation(generator,
-                                                               generatedType,
-                                                               generatedType,
-                                                               "1",
-                                                               ""))
-                .superType(superType)
-                .addDescriptionLine("Main class generated for Helidon Inject Application.")
-                .isFinal(true);
-
-        classModel.addConstructor(ctr -> ctr
-                .accessModifier(AccessModifier.PACKAGE_PRIVATE));
-
-        classModel.addMethod(main -> main
-                .accessModifier(AccessModifier.PUBLIC)
-                .isStatic(true)
-                .returnType(TypeNames.PRIMITIVE_VOID)
-                .description("Start the application.")
-                .name("main")
-                .addParameter(args -> args
-                        .type(STRING_ARRAY)
-                        .description("Command line arguments.")
-                        .name("args"))
-                .update(it -> mainMethodBody(generatedType, it)));
-
-        if (!declaredSignatures.contains(METHOD_SERVICE_DESCRIPTORS)) {
-            // only create this method if it is not created by the user
-            classModel.addMethod(methodModel -> methodModel
-                    .name("serviceDescriptors")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .accessModifier(AccessModifier.PROTECTED)
-                    .returnType(TypeNames.PRIMITIVE_VOID)
-                    .addParameter(config -> config
-                            .type(INJECT_CONFIG_BUILDER)
-                            .name("config"))
-                    .update(it -> serviceDescriptorsHandler.handle(classModel, it, "config")));
-        }
-
-        if (discoverServices && !declaredSignatures.contains(METHOD_DISCOVER_SERVICES)) {
-            classModel.addMethod(discoverServicesMethod -> discoverServicesMethod
-                    .name("discoverServices")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .accessModifier(AccessModifier.PROTECTED)
-                    .returnType(TypeNames.PRIMITIVE_BOOLEAN)
-                    .addContentLine("return true;"));
-        }
-
-        if (addRunLevels && !declaredSignatures.contains(METHOD_RUN_LEVELS)) {
-            classModel.addMethod(runLevels -> runLevels
-                    .name("runLevels")
-                    .addAnnotation(Annotations.OVERRIDE)
-                    .accessModifier(AccessModifier.PUBLIC)
-                    .returnType(DOUBLE_ARRAY)
-                    .addParameter(config -> config
-                            .type(INJECT_CONFIG)
-                            .name("config"))
-                    .addParameter(registry -> registry
-                            .type(INJECT_REGISTRY)
-                            .name("registry"))
-                    .addContentLine("return new double[] {")
-                    .update(it -> runLevelHandler.handle(classModel, it, "config"))
-                    .addContentLine("};"));
-        }
-
-        return classModel;
-    }
-
-    /**
-     * Provides all relevant signatures that may override methods from {@code InjectionMain}.
-     *
-     * @param customMain type to analyze
-     * @return set of method signatures that are non-private, non-static
-     */
-    public static Set<ElementSignature> declaredSignatures(TypeInfo customMain) {
-        return customMain.elementInfo()
-                .stream()
-                .filter(ElementInfoPredicates::isMethod)
-                .filter(not(ElementInfoPredicates::isStatic))
-                .filter(not(ElementInfoPredicates::isPrivate))
-                .map(TypedElementInfo::signature)
-                .collect(Collectors.toUnmodifiableSet());
-    }
-
-    /**
-     * Validate a type, to make sure it is a valid custom main class.
-     *
-     * @param customMain type to validate
-     */
-    public static void validate(TypeInfo customMain) {
-        Optional<TypeInfo> superType = customMain.superTypeInfo();
-        if (superType.isEmpty()) {
-            throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
-                                               + customMain.typeName().fqName() + " does not extend any class",
-                                       customMain.originatingElementValue());
-        }
-        if (!superType.get().typeName().equals(INJECT_MAIN)) {
-            throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
-                                               + customMain.typeName().fqName() + " extends " + superType.get().typeName(),
-                                       customMain.originatingElementValue());
-        }
-        if (customMain.accessModifier() == AccessModifier.PRIVATE) {
-            throw new CodegenException("Custom main class must be accessible (non-private) class, but "
-                                               + customMain.typeName().fqName() + " is private.",
-                                       customMain.originatingElementValue());
-        }
-        if (customMain.elementInfo()
-                .stream()
-                .filter(ElementInfoPredicates::isMethod)
-                .filter(ElementInfoPredicates::isStatic)
-                .filter(not(ElementInfoPredicates::isPrivate))
-                .filter(ElementInfoPredicates.elementName("main"))
-                .anyMatch(ElementInfoPredicates.hasParams(TypeName.create(String[].class)))) {
-            throw new CodegenException("Custom main class must not declare a static main(String[]) method, as it is code "
-                                               + "generated into the ApplicationMain class, but "
-                                               + customMain.typeName().fqName() + " declares it.",
-                                       customMain.originatingElementValue());
-        }
-        if (customMain.elementInfo()
-                .stream()
-                .filter(ElementInfoPredicates::isConstructor)
-                .filter(not(ElementInfoPredicates::isPrivate))
-                .noneMatch(ElementInfoPredicates.hasParams())) {
-            throw new CodegenException("Custom main class must have an accessible no-argument constructor, but "
-                                               + customMain.typeName().fqName() + " does not.",
-                                       customMain.originatingElementValue());
-        }
-    }
-
-    private static void mainMethodBody(TypeName type, Method.Builder method) {
-        method.addContent("new ")
-                .addContent(type)
-                .addContentLine("().start(args);");
-    }
-
-    /**
-     * Handler to generated method serviceDescriptors in {@value #CLASS_NAME} class.
-     */
-    @FunctionalInterface
-    public interface CodeGeneratorHandler {
-        /**
-         * Handle the class model (to allow adding constants and helper methods), and method model (to add the body).
-         *
-         * @param classModel      class model of the generated main
-         * @param methodModel     method model of the serviceDescriptors method
-         * @param configParamName name of the parameter of {@code InjectConfig.Builder}
-         */
-        void handle(ClassModel.Builder classModel, Method.Builder methodModel, String configParamName);
-    }
-}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
deleted file mode 100644
index 2737c061821..00000000000
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
+++ /dev/null
@@ -1,272 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.codegen;
-
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-
-/**
- * Types for code generation from Helidon Service Inject API and Helidon Service Inject.
- */
-public class InjectCodegenTypes {
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Point}.
-     */
-    public static final TypeName INJECTION_INJECT = TypeName.create("io.helidon.service.inject.api.Injection.Inject");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Singleton}.
-     */
-    public static final TypeName INJECTION_SINGLETON = TypeName.create("io.helidon.service.inject.api.Injection.Singleton");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Named}.
-     */
-    public static final TypeName INJECTION_NAMED = TypeName.create("io.helidon.service.inject.api.Injection.Named");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.NamedByType}.
-     */
-    public static final TypeName INJECTION_NAMED_BY_TYPE =
-            TypeName.create("io.helidon.service.inject.api.Injection.NamedByType");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Qualifier}.
-     */
-    public static final TypeName INJECTION_QUALIFIER = TypeName.create("io.helidon.service.inject.api.Injection.Qualifier");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Describe}.
-     */
-    public static final TypeName INJECTION_DESCRIBE = TypeName.create("io.helidon.service.inject.api.Injection.Describe");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Scope}.
-     */
-    public static final TypeName INJECTION_SCOPE = TypeName.create("io.helidon.service.inject.api.Injection.Scope");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.PerLookup}.
-     */
-    public static final TypeName INJECTION_PER_LOOKUP = TypeName.create("io.helidon.service.inject.api.Injection.PerLookup");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.PerInstance}.
-     */
-    public static final TypeName INJECTION_PER_INSTANCE = TypeName.create("io.helidon.service.inject.api.Injection.PerInstance");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.RunLevel}.
-     */
-    public static final TypeName INJECTION_RUN_LEVEL = TypeName.create("io.helidon.service.inject.api.Injection.RunLevel");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Main}.
-     */
-    public static final TypeName INJECTION_MAIN = TypeName.create("io.helidon.service.inject.api.Injection.Main");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectionPointFactory}.
-     */
-    public static final TypeName INJECTION_POINT_FACTORY = TypeName.create(
-            "io.helidon.service.inject.api.Injection.InjectionPointFactory");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.ScopeHandler}.
-     */
-    public static final TypeName INJECTION_SCOPE_HANDLER =
-            TypeName.create("io.helidon.service.inject.api.Injection.ScopeHandler");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServicesFactory}.
-     */
-    public static final TypeName INJECTION_SERVICES_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.Injection.ServicesFactory");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.QualifiedFactory}.
-     */
-    public static final TypeName INJECTION_QUALIFIED_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.Injection.QualifiedFactory");
-
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.Intercepted}.
-     */
-    public static final TypeName INTERCEPTION_INTERCEPTED =
-            TypeName.create("io.helidon.service.inject.api.Interception.Intercepted");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.Delegate}.
-     */
-    public static final TypeName INTERCEPTION_DELEGATE = TypeName.create("io.helidon.service.inject.api.Interception.Delegate");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Interception.ExternalDelegates}.
-     */
-    public static final TypeName INTERCEPTION_EXTERNAL_DELEGATE =
-            TypeName.create("io.helidon.service.inject.api.Interception.ExternalDelegate");
-
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.FactoryType}.
-     */
-    public static final TypeName INJECT_FACTORY_TYPE = TypeName.create("io.helidon.service.inject.api.FactoryType");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Qualifier}.
-     */
-    public static final TypeName INJECT_QUALIFIER = TypeName.create("io.helidon.service.inject.api.Qualifier");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Ip}.
-     */
-    public static final TypeName INJECT_INJECTION_POINT = TypeName.create("io.helidon.service.inject.api.Ip");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.ServiceInstance}.
-     */
-    public static final TypeName INJECT_SERVICE_INSTANCE = TypeName.create("io.helidon.service.inject.api.ServiceInstance");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectServiceDescriptor}.
-     */
-    public static final TypeName INJECT_SERVICE_DESCRIPTOR =
-            TypeName.create("io.helidon.service.inject.api.InjectServiceDescriptor");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig.Builder}.
-     */
-    public static final TypeName INJECT_CONFIG_BUILDER =
-            TypeName.create("io.helidon.service.inject.InjectConfig.Builder");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig}.
-     */
-    public static final TypeName INJECT_CONFIG =
-            TypeName.create("io.helidon.service.inject.InjectConfig");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectRegistry}.
-     */
-    public static final TypeName INJECT_REGISTRY =
-            TypeName.create("io.helidon.service.inject.api.InjectRegistry");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectRegistryManager}.
-     */
-    public static final TypeName INJECT_REGISTRY_MANAGER =
-            TypeName.create("io.helidon.service.inject.InjectRegistryManager");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionMain}.
-     */
-    public static final TypeName INJECT_MAIN =
-            TypeName.create("io.helidon.service.inject.InjectionMain");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.Binding}.
-     */
-    public static final TypeName INJECT_BINDING =
-            TypeName.create("io.helidon.service.inject.Binding");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionPlanBinder}.
-     */
-    public static final TypeName INJECT_PLAN_BINDER =
-            TypeName.create("io.helidon.service.inject.InjectionPlanBinder");
-
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InvocationException}.
-     */
-    public static final TypeName INTERCEPT_EXCEPTION =
-            TypeName.create("io.helidon.service.inject.api.InterceptionException");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.InterceptionMetadata}.
-     */
-    public static final TypeName INTERCEPT_METADATA = TypeName.create(
-            "io.helidon.service.inject.api.InterceptionMetadata");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.Invoker}.
-     */
-    public static final TypeName INTERCEPT_INVOKER =
-            TypeName.create("io.helidon.service.inject.api.InterceptionInvoker");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.PerInstanceDescriptor}.
-     */
-    public static final TypeName INJECT_G_PER_INSTANCE_DESCRIPTOR = TypeName.create(
-            "io.helidon.service.inject.api.GeneratedInjectService.PerInstanceDescriptor");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.QualifiedFactoryDescriptor}.
-     */
-    public static final TypeName INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR = TypeName.create(
-            "io.helidon.service.inject.api.GeneratedInjectService.QualifiedFactoryDescriptor");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.ScopeHandlerDescriptor}.
-     */
-    public static final TypeName INJECT_G_SCOPE_HANDLER_DESCRIPTOR = TypeName.create(
-            "io.helidon.service.inject.api.GeneratedInjectService.ScopeHandlerDescriptor");
-    /**
-     * {@link io.helidon.common.types.TypeName} for {@code "io.helidon.service.inject.api.GeneratedInjectService.IpSupport"}.
-     */
-    public static final TypeName INJECT_G_IP_SUPPORT = TypeName.create(
-            "io.helidon.service.inject.api.GeneratedInjectService.IpSupport");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.SupplierFactoryInterceptionWrapper}.
-     */
-    public static final TypeName INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.SupplierFactoryInterceptionWrapper");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.ServicesFactoryInterceptionWrapper}.
-     */
-    public static final TypeName INTERCEPT_G_WRAPPER_SERVICES_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.ServicesFactoryInterceptionWrapper");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.IpFactoryInterceptionWrapper}.
-     */
-    public static final TypeName INTERCEPT_G_WRAPPER_IP_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.IpFactoryInterceptionWrapper");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.QualifiedFactoryInterceptionWrapper}.
-     */
-    public static final TypeName INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY =
-            TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.QualifiedFactoryInterceptionWrapper");
-
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.Event.Observer}.
-     */
-    public static final TypeName EVENT_OBSERVER = TypeName.create("io.helidon.service.inject.api.Event.Observer");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.Event.AsyncObserver}.
-     */
-    public static final TypeName EVENT_OBSERVER_ASYNC = TypeName.create("io.helidon.service.inject.api.Event.AsyncObserver");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.Event.Emitter}.
-     */
-    public static final TypeName EVENT_EMITTER = TypeName.create("io.helidon.service.inject.api.Event.Emitter");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.EventManager}.
-     */
-    public static final TypeName EVENT_MANAGER = TypeName.create("io.helidon.service.inject.api.EventManager");
-    /**
-     * {@link io.helidon.common.types.TypeName} for
-     * {@code io.helidon.service.inject.api.GeneratedInjectService.EventObserverRegistration}.
-     */
-    public static final TypeName INJECT_G_EVENT_OBSERVER_REGISTRATION =
-            TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.EventObserverRegistration");
-
-    /**
-     * {@link io.helidon.common.types.TypeName} for String array.
-     */
-    public static final TypeName STRING_ARRAY = TypeName.builder()
-            .from(TypeNames.STRING)
-            .array(true)
-            .build();
-    /**
-     * {@link io.helidon.common.types.TypeName} for primitive double array.
-     */
-    public static final TypeName DOUBLE_ARRAY = TypeName.builder()
-            .from(TypeNames.PRIMITIVE_DOUBLE)
-            .array(true)
-            .build();
-
-
-    private InjectCodegenTypes() {
-    }
-}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
deleted file mode 100644
index 41cf8b1ddfc..00000000000
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.codegen;
-
-import java.util.Set;
-import java.util.function.Function;
-
-import io.helidon.codegen.Option;
-import io.helidon.common.GenericType;
-import io.helidon.common.types.TypeName;
-
-/**
- * Supported options specific to Helidon Inject.
- */
-public final class InjectOptions {
-    /**
-     * Which {@code InterceptionStrategy} to use.
-     */
-    public static final Option<InterceptionStrategy> INTERCEPTION_STRATEGY =
-            Option.create("helidon.inject.interceptionStrategy",
-                          "Which interception strategy to use (NONE, EXPLICIT, ALL_RUNTIME, ALL_RETAINED)",
-                          InterceptionStrategy.EXPLICIT,
-                          InterceptionStrategy::valueOf,
-                          GenericType.create(InterceptionStrategy.class));
-
-    /**
-     * Additional meta annotations that mark scope annotations. This can be used to include
-     * jakarta.enterprise.context.NormalScope annotated types as scopes.
-     */
-    public static final Option<Set<TypeName>> SCOPE_META_ANNOTATIONS =
-            Option.createSet("helidon.inject.scopeMetaAnnotations",
-                             "Additional meta annotations that mark scope annotations. This can be used to include"
-                                     + "jakarta.enterprise.context.NormalScope annotated types as scopes.",
-                             Set.of(),
-                             TypeName::create,
-                             new GenericType<Set<TypeName>>() { });
-
-    /**
-     * Name of the generated Main class for Injection. Defaults to
-     * {@value ApplicationMainGenerator#CLASS_NAME}.
-     * The same property must be provided to the maven plugin, to correctly update the generated class.
-     * To configure package name, use {@link io.helidon.codegen.CodegenOptions#CODEGEN_PACKAGE} option.
-     */
-    public static final Option<String> APPLICATION_MAIN_CLASS_NAME =
-            Option.create("helidon.inject.application.main.class.name",
-                          "Name of the generated Main class for Helidon Injection.",
-                          ApplicationMainGenerator.CLASS_NAME,
-                          Function.identity(),
-                          GenericType.STRING);
-
-    /**
-     * Whether to generate main class for Helidon Injection.
-     * Defaults to false. In case a custom main class is present (annotated with Injection.Main), this option is ignored.
-     * <p>
-     * As main class only makes sense for the end application, this is set to {@code false} by default, so we do not generate
-     * main classes for library modules.
-     */
-    public static final Option<Boolean> APPLICATION_MAIN_GENERATE =
-            Option.create("helidon.inject.application.main.generate",
-                          "Whether to generate Main class for Helidon Injection.",
-                          false,
-                          Boolean::parseBoolean,
-                          GenericType.create(Boolean.class));
-
-    private InjectOptions() {
-    }
-}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
deleted file mode 100644
index fa8b4979485..00000000000
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.codegen;
-
-import java.util.List;
-import java.util.ServiceLoader;
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import io.helidon.codegen.Option;
-import io.helidon.common.HelidonServiceLoader;
-import io.helidon.common.Weight;
-import io.helidon.common.Weighted;
-import io.helidon.common.types.TypeName;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.ServiceOptions;
-import io.helidon.service.codegen.spi.RegistryCodegenExtension;
-import io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider;
-import io.helidon.service.inject.codegen.spi.InjectCodegenObserverProvider;
-
-/**
- * A {@link java.util.ServiceLoader} provider implementation that adds code generation for Helidon Inject.
- * This extension creates service descriptors, and intercepted types.
- */
-@Weight(Weighted.DEFAULT_WEIGHT - 20) // lower weight than config beans, as we may need them
-public class InjectionExtensionProvider implements RegistryCodegenExtensionProvider {
-    private static final List<InjectCodegenObserverProvider> OBSERVER_PROVIDERS =
-            HelidonServiceLoader.create(ServiceLoader.load(InjectCodegenObserverProvider.class,
-                                                           InjectionExtension.class.getClassLoader()))
-                    .asList();
-
-    /**
-     * Required default constructor for {@link java.util.ServiceLoader}.
-     *
-     * @deprecated only for {@link java.util.ServiceLoader}
-     */
-    @Deprecated
-    public InjectionExtensionProvider() {
-        super();
-    }
-
-    @Override
-    public Set<Option<?>> supportedOptions() {
-        return Stream.concat(Stream.of(
-                                     ServiceOptions.AUTO_ADD_NON_CONTRACT_INTERFACES,
-                                     InjectOptions.INTERCEPTION_STRATEGY,
-                                     InjectOptions.SCOPE_META_ANNOTATIONS
-                             ),
-                             OBSERVER_PROVIDERS.stream()
-                                     .map(InjectCodegenObserverProvider::supportedOptions)
-                                     .flatMap(Set::stream))
-                .collect(Collectors.toUnmodifiableSet());
-    }
-
-    @Override
-    public Set<TypeName> supportedAnnotations() {
-        return Set.of(InjectCodegenTypes.INJECTION_INJECT,
-                      InjectCodegenTypes.INJECTION_DESCRIBE,
-                      InjectCodegenTypes.INJECTION_PER_INSTANCE,
-                      InjectCodegenTypes.INJECTION_MAIN);
-    }
-
-    @Override
-    public Set<TypeName> supportedMetaAnnotations() {
-        return Set.of(InjectCodegenTypes.INJECTION_SCOPE);
-    }
-
-    @Override
-    public RegistryCodegenExtension create(RegistryCodegenContext codegenContext) {
-        return new InjectionExtension(codegenContext);
-    }
-}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/package-info.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/package-info.java
deleted file mode 100644
index d371221a9cd..00000000000
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/spi/package-info.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * SPI for code generation for Helidon Service Injection.
- */
-package io.helidon.service.inject.codegen.spi;
diff --git a/service/inject/codegen/src/main/java/module-info.java b/service/inject/codegen/src/main/java/module-info.java
deleted file mode 100644
index 7920f8a194a..00000000000
--- a/service/inject/codegen/src/main/java/module-info.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Code generation for Helidon Service Registry.
- */
-module io.helidon.service.inject.codegen {
-    requires transitive io.helidon.builder.api;
-    requires transitive io.helidon.codegen.classmodel;
-    requires transitive io.helidon.codegen;
-    requires transitive io.helidon.service.codegen;
-    requires jdk.jshell;
-
-    exports io.helidon.service.inject.codegen;
-    exports io.helidon.service.inject.codegen.spi;
-
-    uses io.helidon.service.inject.codegen.spi.InjectCodegenObserverProvider;
-    uses io.helidon.service.inject.codegen.spi.InjectAssignmentProvider;
-
-    provides io.helidon.service.codegen.spi.RegistryCodegenExtensionProvider
-            with io.helidon.service.inject.codegen.InjectionExtensionProvider,
-                    io.helidon.service.inject.codegen.EventObserverExtensionProvider;
-
-    provides io.helidon.codegen.spi.AnnotationMapperProvider
-            with io.helidon.service.inject.codegen.MapNamedByTypeMapperProvider;
-
-    provides io.helidon.service.inject.codegen.spi.InjectCodegenObserverProvider
-            with io.helidon.service.inject.codegen.EventEmitterObserverProvider;
-}
\ No newline at end of file
diff --git a/service/inject/inject/etc/spotbugs/exclude.xml b/service/inject/inject/etc/spotbugs/exclude.xml
deleted file mode 100644
index abb161e69c0..00000000000
--- a/service/inject/inject/etc/spotbugs/exclude.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<FindBugsFilter
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="https://github.com/spotbugs/filter/3.0.0"
-        xsi:schemaLocation="https://github.com/spotbugs/filter/3.0.0 https://raw.githubusercontent.com/spotbugs/spotbugs/3.1.0/spotbugs/etc/findbugsfilter.xsd">
-
-    <Match>
-        <!-- I cannot figure this one out, the method is called and invokes post-construct on instances,
-         why is it identified as useless? -->
-        <Class name="io.helidon.service.inject.Activators$PerInstanceActivator"/>
-        <Method name="postConstruct"/>
-        <Bug pattern="UC_USELESS_VOID_METHOD"/>
-    </Match>
-
-</FindBugsFilter>
diff --git a/service/inject/inject/pom.xml b/service/inject/inject/pom.xml
deleted file mode 100644
index fab2a878377..00000000000
--- a/service/inject/inject/pom.xml
+++ /dev/null
@@ -1,171 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service.inject</groupId>
-        <artifactId>helidon-service-inject-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>helidon-service-inject</artifactId>
-    <name>Helidon Service Inject</name>
-    <description>
-        Full injection support on top of service registry
-    </description>
-
-    <properties>
-        <spotbugs.exclude>etc/spotbugs/exclude.xml</spotbugs.exclude>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.helidon</groupId>
-            <artifactId>helidon</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-configurable</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-config</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-types</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.logging</groupId>
-            <artifactId>helidon-logging-common</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.builder</groupId>
-            <artifactId>helidon-builder-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.metrics</groupId>
-            <artifactId>helidon-metrics-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-mapper</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-metadata</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-registry</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common.features</groupId>
-            <artifactId>helidon-common-features-api</artifactId>
-            <optional>true</optional>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-apt</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.builder</groupId>
-                            <artifactId>helidon-builder-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.common.features</groupId>
-                            <artifactId>helidon-common-features-processor</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.config.metadata</groupId>
-                            <artifactId>helidon-config-metadata-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-                <dependencies>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-apt</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.builder</groupId>
-                        <artifactId>helidon-builder-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.common.features</groupId>
-                        <artifactId>helidon-common-features-processor</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.config.metadata</groupId>
-                        <artifactId>helidon-config-metadata-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                </dependencies>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigProvider.java
deleted file mode 100644
index b2fbc023440..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigProvider.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.function.Supplier;
-
-import io.helidon.common.Weight;
-import io.helidon.common.config.Config;
-import io.helidon.service.registry.Service;
-
-@Service.Provider
-@Weight(0.1) // a very low weight, as this just provides an empty config
-class ConfigProvider implements Supplier<Config> {
-    private final Config config = Config.empty();
-
-    @Override
-    public Config get() {
-        return config;
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigValueProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigValueProvider.java
deleted file mode 100644
index 124dea7c238..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ConfigValueProvider.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import io.helidon.common.GenericType;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.ConfigValue;
-import io.helidon.common.mapper.MapperManager;
-import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Configuration;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.registry.ServiceRegistry;
-
-@Injection.Singleton
-class ConfigValueProvider implements Injection.QualifiedFactory<Object, Configuration.Value> {
-    private final ServiceRegistry registry;
-    private final Supplier<Config> config;
-
-    ConfigValueProvider(ServiceRegistry registry, Supplier<Config> config) {
-        this.registry = registry;
-        this.config = config;
-    }
-
-    @Override
-    public Optional<Injection.QualifiedInstance<Object>> first(Qualifier qualifier, Lookup lookup, GenericType<Object> type) {
-        String value = qualifier.stringValue()
-                .orElseThrow(() -> new IllegalStateException("Annotation "
-                                                                     + Configuration.Value.class.getName()
-                                                                     + " must have a value defined, yet received it without "
-                                                                     + "value: " + qualifier));
-
-        // if it contains :, then it separates default value from key
-        String defaultValue = null;
-        String key;
-
-        if (value.contains(":")) {
-            int index = value.indexOf(':');
-
-            key = value.substring(0, index);
-            defaultValue = value.substring(index + 1);
-        } else {
-            if (value.isEmpty()) {
-                Ip ip = lookup.injectionPoint()
-                        .orElseThrow(() -> new IllegalStateException("Configuration.Value does not specify a value "
-                                                                             + "(configuration key), yet injection point is "
-                                                                             + "not provided. Cannot infer key."));
-                key = ip.service().fqName() + "." + ip.name();
-            } else {
-                key = value;
-            }
-        }
-
-        Config configInstance = config.get();
-        ConfigValue<?> configValue = configInstance.get(key)
-                .as(type.rawType());
-
-        Object result;
-        if (configValue.isEmpty()) {
-            result = defaultValue(configInstance, qualifier, type, defaultValue);
-        } else {
-            result = configValue.get();
-        }
-
-        return Optional.of(Injection.QualifiedInstance.create(result, qualifier));
-    }
-
-    @SuppressWarnings("unchecked")
-    private Object defaultValue(Config config,
-                                Qualifier qualifier,
-                                GenericType<Object> type,
-                                String defaultValue) {
-        if (defaultValue != null) {
-            return MapperManager.global()
-                    .map(defaultValue, GenericType.STRING, type, "config");
-        }
-
-        // there may be a provider
-        Optional<TypeName> typeName = qualifier.typeValue("defaultProvider");
-        if (typeName.isEmpty()) {
-            return null;
-        }
-        TypeName defaultProvider = typeName.get();
-        if (defaultProvider.equals(Configuration.Value.NoProvider.TYPE)) {
-            // no custom provider
-            return null;
-        }
-        Object provider = registry.first(defaultProvider)
-                .orElseThrow(() -> new ConfigException("Default value provider: " + defaultProvider.fqName()
-                                                               + " must be available through service registry,"
-                                                               + " maybe annotate it with @Service.Provider?"));
-
-        // provider implements Function<Config, ?>
-        Function<Config, Object> providerAsFunction = (Function<Config, Object>) provider;
-        return providerAsFunction.apply(config);
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/CoreWrappers.java b/service/inject/inject/src/main/java/io/helidon/service/inject/CoreWrappers.java
deleted file mode 100644
index 5157774b59c..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/CoreWrappers.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import io.helidon.common.types.ElementKind;
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceInfo;
-
-class CoreWrappers {
-    private CoreWrappers() {
-    }
-
-    static <T> InjectServiceDescriptor<T> create(ServiceDescriptor<T> serviceInfo) {
-        if (serviceInfo instanceof InjectServiceDescriptor<T> inj) {
-            return inj;
-        }
-        return new CoreDescriptor<>(serviceInfo);
-    }
-
-    static class CoreServiceInfo implements InjectServiceInfo {
-        private final ServiceInfo delegate;
-        private final TypeName scope;
-        private final FactoryType providerType;
-
-        private CoreServiceInfo(ServiceInfo delegate) {
-            this.delegate = delegate;
-            this.scope = scope(delegate);
-            this.providerType = delegate.factoryContracts().isEmpty()
-                    ? FactoryType.SERVICE
-                    : FactoryType.SUPPLIER;
-        }
-
-        @Override
-        public double weight() {
-            return delegate.weight();
-        }
-
-        @Override
-        public TypeName scope() {
-            return scope;
-        }
-
-        @Override
-        public TypeName serviceType() {
-            return delegate.serviceType();
-        }
-
-        @Override
-        public TypeName descriptorType() {
-            return delegate.descriptorType();
-        }
-
-        @Override
-        public Set<ResolvedType> contracts() {
-            return delegate.contracts();
-        }
-
-        @Override
-        public boolean isAbstract() {
-            return delegate.isAbstract();
-        }
-
-        @Override
-        public FactoryType factoryType() {
-            return providerType;
-        }
-
-        private static TypeName scope(ServiceInfo delegate) {
-            // if the core service is a supplier, we expect to get a new instance each time
-            // otherwise it is a de-facto singleton
-            return delegate.factoryContracts().isEmpty()
-                    ? Injection.Singleton.TYPE
-                    : Injection.PerLookup.TYPE;
-        }
-    }
-
-    static final class CoreDescriptor<T> extends CoreServiceInfo implements InjectServiceDescriptor<T> {
-        private final ServiceDescriptor<?> delegate;
-        private final List<Ip> injectionPoints;
-
-        CoreDescriptor(ServiceDescriptor<T> delegate) {
-            super(delegate);
-
-            this.delegate = delegate;
-
-            this.injectionPoints = delegate.dependencies()
-                    .stream()
-                    .map(it -> Ip.builder()
-                            .from(it)
-                            .elementKind(ElementKind.CONSTRUCTOR)
-                            .build())
-                    .collect(Collectors.toList());
-        }
-
-        @Override
-        public List<Ip> dependencies() {
-            return injectionPoints;
-        }
-
-        @Override
-        public Object instantiate(DependencyContext ctx) {
-            return delegate.instantiate(ctx);
-        }
-
-        @Override
-        public Object instantiate(DependencyContext ctx, InterceptionMetadata interceptionMetadata) {
-            return delegate.instantiate(ctx);
-        }
-
-        @Override
-        public io.helidon.service.registry.ServiceInfo coreInfo() {
-            return delegate;
-        }
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
deleted file mode 100644
index 3a0287053e0..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.List;
-import java.util.Optional;
-
-import io.helidon.builder.api.Option;
-import io.helidon.builder.api.Prototype;
-import io.helidon.common.configurable.LruCache;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.registry.ServiceRegistryConfig;
-
-/**
- * Helidon Inject configuration options.
- */
-@Prototype.Blueprint
-@Prototype.Configured("registry")
-interface InjectConfigBlueprint extends ServiceRegistryConfig {
-    /**
-     * LRU cache to use for caching lookup. Only needed if {@link #lookupCacheEnabled()} is set to {@code true}.
-     * This allows customization of the LRU cache.
-     *
-     * @return LRU cache to use for lookup caching, or empty to use the default instance (or when not used at all)
-     */
-    @Option.Configured
-    Optional<LruCache<Lookup, List<InjectServiceInfo>>> lookupCache();
-
-    /**
-     * Flag indicating whether service lookups
-     * (i.e., via {@link io.helidon.service.inject.api.InjectRegistry#first(io.helidon.service.inject.api.Lookup)}) are cached.
-     *
-     * @return the flag indicating whether service lookups are cached, defaults to {@code false}
-     */
-    @Option.Configured
-    boolean lookupCacheEnabled();
-
-    /**
-     * Flag indicating whether runtime interception is enabled.
-     * If set to {@code false}, methods will be invoked without any interceptors, even if interceptors are available.
-     *
-     * @return whether to intercept calls at runtime, defaults to {@code true}
-     */
-    @Option.Configured
-    @Option.DefaultBoolean(true)
-    boolean interceptionEnabled();
-
-    /**
-     * In certain conditions Injection services should be initialized but not started (i.e., avoiding calls to
-     * {@code PostConstruct}
-     * etc.). This can be used in special cases where the normal Injection startup should limit lifecycle up to a given phase.
-     *
-     * @return the phase to stop at during lifecycle
-     */
-    @Option.Configured
-    @Option.Default("ACTIVE")
-    Activator.Phase limitRuntimePhase();
-
-    /**
-     * Flag indicating whether compile-time generated {@link Binding}'s
-     * should be used at Injection's startup initialization.
-     * Even if set to {@code true}, this is effective only if an {@link io.helidon.service.inject.Binding}
-     * was generated using Helidon Service Maven Plugin.
-     *
-     * @return the flag indicating whether the provider is permitted to use binding generated code from compile-time,
-     *         defaults to {@code true}
-     * @see io.helidon.service.inject.Binding
-     */
-    @Option.Configured
-    @Option.DefaultBoolean(true)
-    boolean useBinding();
-
-    /**
-     * Maximal run level to handle when starting from the generated main class
-     * ({@link InjectionMain}). This setting is ignored when starting registry using
-     * other means, as run levels are not handled by default.
-     *
-     * @return maximal run level to lookup during application startup when using generated main class
-     */
-    @Option.Configured
-    @Option.DefaultDouble(Double.MAX_VALUE)
-    double maxRunLevel();
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManager.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManager.java
deleted file mode 100644
index 00345f489a4..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManager.java
+++ /dev/null
@@ -1,465 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.GeneratedInjectService;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectRegistry__ServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InterceptionMetadata__ServiceDescriptor;
-import io.helidon.service.inject.api.Scopes__ServiceDescriptor;
-import io.helidon.service.metadata.DescriptorMetadata;
-import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.DescriptorHandler;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceDiscovery;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
-import io.helidon.service.registry.ServiceRegistryException;
-import io.helidon.service.registry.ServiceRegistryManager;
-import io.helidon.service.registry.VirtualDescriptor;
-
-/**
- * Manager is responsible for managing the state of a {@link io.helidon.service.inject.api.InjectRegistry}.
- * Each manager instances owns a single service registry.
- * <p>
- * To use a singleton service across application, either pass it through parameters, or use
- * {@link io.helidon.service.registry.GlobalServiceRegistry}.
- */
-public class InjectRegistryManager implements ServiceRegistryManager {
-    static final Comparator<InjectServiceInfo> SERVICE_INFO_COMPARATOR = Comparator
-            .comparingDouble(InjectServiceInfo::weight)
-            .reversed()
-            .thenComparing((f, s) -> {
-                if (f.qualifiers().isEmpty() && s.qualifiers().isEmpty()) {
-                    return 0;
-                }
-                if (f.qualifiers().isEmpty()) {
-                    return -1;
-                }
-                if (s.qualifiers().isEmpty()) {
-                    return 1;
-                }
-                return 0;
-            })
-            .thenComparing(InjectServiceInfo::serviceType);
-    private static final System.Logger LOGGER = System.getLogger(InjectRegistryManager.class.getName());
-    private final ReentrantReadWriteLock lifecycleLock = new ReentrantReadWriteLock();
-    private final InjectConfig config;
-    private final ServiceDiscovery discovery;
-
-    private InjectServiceRegistryImpl registry;
-
-    InjectRegistryManager(InjectConfig config, ServiceDiscovery serviceDiscovery) {
-        this.config = config;
-        this.discovery = serviceDiscovery;
-    }
-
-    /**
-     * Create a new inject registry manager with default configuration.
-     *
-     * @return a new inject registry manager
-     */
-    public static InjectRegistryManager create() {
-        return create(InjectConfig.create());
-    }
-
-    /**
-     * Create a new inject registry manager with custom configuration.
-     *
-     * @param config configuration to use
-     * @return a new configured inject registry manager
-     */
-    public static InjectRegistryManager create(InjectConfig config) {
-        // we provide the service, this
-        return new InjectRegistryManager(config,
-                                         config.discoverServices()
-                                                 ? ServiceDiscovery.create()
-                                                 : ServiceDiscovery.noop());
-    }
-
-    @SuppressWarnings({"unchecked"})
-    @Override
-    public InjectRegistry registry() {
-        Lock readLock = lifecycleLock.readLock();
-        try {
-            readLock.lock();
-            if (registry != null) {
-                return registry;
-            }
-        } finally {
-            readLock.unlock();
-        }
-
-        Lock writeLock = lifecycleLock.writeLock();
-        try {
-            writeLock.lock();
-            if (registry != null) {
-                return registry;
-            }
-            // map of the service descriptor instance to Described (we need to have a single instance always used)
-            Map<io.helidon.service.registry.ServiceInfo, Described> descriptorToDescribed = new IdentityHashMap<>();
-
-            // scope handlers (scope type to service)
-            Map<TypeName, InjectServiceInfo> scopeHandlers = new HashMap<>();
-            // service descriptor singleton instance to its explicit value
-            Map<io.helidon.service.registry.ServiceInfo, Object> explicitInstances = new IdentityHashMap<>();
-            // implementation type to its manager
-            Map<TypeName, InjectServiceInfo> servicesByType = new HashMap<>();
-            // implemented contracts to their manager(s)
-            Map<ResolvedType, Set<InjectServiceInfo>> servicesByContract = new HashMap<>();
-            // map of qualifier type to a service info that can provide instances for it
-            Map<TypeName, Set<InjectServiceInfo>> qualifiedProvidersByQualifier = new HashMap<>();
-            // map of a qualifier type and contract to a service info
-            Map<TypedQualifiedProviderKey, Set<InjectServiceInfo>> typedQualifiedProviders =
-                    new HashMap<>();
-
-            List<ServiceDescriptor<Binding>> bindings = new ArrayList<>();
-
-            config.serviceInstances()
-                    .forEach((desc, instance) -> {
-                        var descriptor = desc;
-                        if (descriptor instanceof VirtualDescriptor) {
-                            // maybe we have a real descriptor for this type
-                            descriptor = virtualDescriptor(config, discovery, descriptor);
-                        }
-                        Described described = toDescribed(descriptorToDescribed, descriptor);
-                        bind(bindings,
-                             scopeHandlers,
-                             servicesByType,
-                             servicesByContract,
-                             qualifiedProvidersByQualifier,
-                             typedQualifiedProviders,
-                             described);
-                        explicitInstances.putIfAbsent(descriptor, instance);
-                    });
-
-            for (var descriptor : config.serviceDescriptors()) {
-                bind(bindings,
-                     scopeHandlers,
-                     servicesByType,
-                     servicesByContract,
-                     qualifiedProvidersByQualifier,
-                     typedQualifiedProviders,
-                     toDescribed(descriptorToDescribed, descriptor));
-            }
-
-            boolean logUnsupported = LOGGER.isLoggable(System.Logger.Level.TRACE);
-
-            for (var descriptorMeta : discovery.allMetadata()) {
-                String registryType = descriptorMeta.registryType();
-                if (!(DescriptorMetadata.REGISTRY_TYPE_CORE.equals(registryType) || "inject".equals(registryType))) {
-                    // we support only core and inject
-                    if (logUnsupported) {
-                        LOGGER.log(System.Logger.Level.TRACE,
-                                   "Ignoring service of type \"" + descriptorMeta.registryType() + "\": " + descriptorMeta);
-                    }
-                    continue;
-                }
-
-                ServiceDescriptor<?> descriptor = descriptorMeta.descriptor();
-                if (contains(descriptor.contracts(), Binding.TYPE)) {
-                    bindings.add((ServiceDescriptor<Binding>) descriptor);
-                    // applications are not bound to the registry
-                } else {
-                    Described described = toDescribed(descriptorToDescribed, descriptor);
-
-                    bind(bindings,
-                         scopeHandlers,
-                         servicesByType,
-                         servicesByContract,
-                         qualifiedProvidersByQualifier,
-                         typedQualifiedProviders,
-                         described);
-                }
-            }
-
-            // add service registry information (service registry cannot be overridden in any way)
-            InjectServiceDescriptor<?> scopesDescriptor = Scopes__ServiceDescriptor.INSTANCE;
-            Described scopedDescribed = new Described(scopesDescriptor, scopesDescriptor, false);
-            descriptorToDescribed.put(scopesDescriptor, scopedDescribed);
-
-            InjectServiceDescriptor<?> registryDescriptor = InjectRegistry__ServiceDescriptor.INSTANCE;
-            Described registryDescribed = new Described(registryDescriptor, registryDescriptor, false);
-            descriptorToDescribed.put(scopesDescriptor, registryDescribed);
-            bind(bindings,
-                 scopeHandlers,
-                 servicesByType,
-                 servicesByContract,
-                 qualifiedProvidersByQualifier,
-                 typedQualifiedProviders,
-                 registryDescribed);
-            // add injection metadata information
-            InjectServiceDescriptor<?> interceptDescriptor = InterceptionMetadata__ServiceDescriptor.INSTANCE;
-            Described described = new Described(interceptDescriptor, interceptDescriptor, false);
-            descriptorToDescribed.put(interceptDescriptor, described);
-            bind(bindings,
-                 scopeHandlers,
-                 servicesByType,
-                 servicesByContract,
-                 qualifiedProvidersByQualifier,
-                 typedQualifiedProviders,
-                 described);
-
-            registry = new InjectServiceRegistryImpl(config,
-                                                     descriptorToDescribed,
-                                                     scopeHandlers,
-                                                     explicitInstances,
-                                                     servicesByType,
-                                                     servicesByContract,
-                                                     qualifiedProvidersByQualifier,
-                                                     typedQualifiedProviders);
-
-            // now check if we have an application, and if so, apply it
-            if (config.useBinding()) {
-                for (ServiceDescriptor<Binding> binding : bindings) {
-                    // applications cannot have dependencies
-                    Binding bindingInstance = (Binding) binding.instantiate(DependencyContext.create(Map.of()));
-                    bindingInstance.configure(new ApplicationPlanBinder(bindingInstance, registry));
-                }
-            }
-
-            // and if application was not bound using binding(s), we need to create the bindings now
-            registry.ensureInjectionPlans();
-
-            return registry;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public void shutdown() {
-        Lock lock = lifecycleLock.writeLock();
-        try {
-            lock.lock();
-            if (registry == null) {
-                // registry was never requested,
-                return;
-            }
-
-            registry.close();
-            registry = null;
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    @SuppressWarnings("rawtypes")
-    private static ServiceDescriptor<?> virtualDescriptor(InjectConfig config,
-                                                          ServiceDiscovery discovery,
-                                                          ServiceDescriptor<?> descriptor) {
-        TypeName serviceType = descriptor.serviceType();
-        var fromConfig = config.serviceDescriptors()
-                .stream()
-                .filter(registered -> registered.serviceType().equals(serviceType))
-                .findFirst();
-        if (fromConfig.isPresent()) {
-            return fromConfig.get();
-        }
-
-        return discovery.allMetadata()
-                .stream()
-                .filter(handler -> contains(handler.contracts(), serviceType))
-                .map(DescriptorHandler::descriptor)
-                .filter(desc -> desc.serviceType().equals(serviceType))
-                .findFirst()
-                .map(it -> (ServiceDescriptor) it)
-                .orElse(descriptor);
-    }
-
-    private static boolean contains(Set<ResolvedType> contracts, TypeName type) {
-        return contracts.stream().anyMatch(it -> it.type().equals(type));
-    }
-
-    private Described toDescribed(Map<io.helidon.service.registry.ServiceInfo, Described> descriptorToDescribed,
-                                  ServiceDescriptor<?> descriptor) {
-        return descriptorToDescribed.computeIfAbsent(descriptor, it -> {
-            if (descriptor instanceof InjectServiceDescriptor<?> injectDescriptor) {
-                return new Described(descriptor, injectDescriptor, false);
-            } else {
-                return new Described(descriptor, CoreWrappers.create(descriptor), true);
-            }
-        });
-    }
-
-    @SuppressWarnings("unchecked")
-    private void bind(List<ServiceDescriptor<Binding>> bindings,
-                      Map<TypeName, InjectServiceInfo> scopeHandlers,
-                      Map<TypeName, InjectServiceInfo> servicesByType,
-                      Map<ResolvedType, Set<InjectServiceInfo>> servicesByContract,
-                      Map<TypeName, Set<InjectServiceInfo>> qualifiedProvidersByQualifier,
-                      Map<TypedQualifiedProviderKey, Set<InjectServiceInfo>> typedQualifiedProviders,
-                      Described described) {
-
-        InjectServiceDescriptor<?> descriptor = described.injectDescriptor();
-
-        if (contains(descriptor.contracts(), Binding.TYPE)) {
-            bindings.add((ServiceDescriptor<Binding>) described.coreDescriptor());
-            // application is not bound to the registry
-            return;
-        }
-
-        if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
-            if (descriptor.coreInfo() instanceof ServiceLoader__ServiceDescriptor sl) {
-                LOGGER.log(System.Logger.Level.TRACE,
-                           "Binding service loader descriptor: " + sl + ")");
-            } else {
-                LOGGER.log(System.Logger.Level.TRACE, "Binding service descriptor: " + descriptor.descriptorType()
-                        .fqName());
-            }
-        }
-
-        // by service type
-        servicesByType.putIfAbsent(descriptor.serviceType(), descriptor);
-        // service type is a contract as well (to make lookup easier)
-        servicesByContract.computeIfAbsent(ResolvedType.create(descriptor.serviceType()),
-                                           it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
-                .add(descriptor);
-
-        Set<ResolvedType> contracts = descriptor.contracts();
-        // by contract
-        for (ResolvedType contract : contracts) {
-            servicesByContract.computeIfAbsent(contract,
-                                               it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
-                    .add(descriptor);
-        }
-
-        // scope handlers have a very specific meaning
-        if (contains(contracts, Injection.ScopeHandler.TYPE)) {
-            if (!Injection.Singleton.TYPE.equals(descriptor.scope())) {
-                throw new ServiceRegistryException("Services that provide ScopeHandler contract MUST be in Singleton scope, but "
-                                                           + descriptor.serviceType().fqName() + " is in "
-                                                           + descriptor.scope().fqName() + " scope.");
-            }
-            if (descriptor instanceof GeneratedInjectService.ScopeHandlerDescriptor shd) {
-                scopeHandlers.putIfAbsent(shd.handledScope(), descriptor);
-            } else {
-                throw new ServiceRegistryException("Service descriptors of services that implement ScopeHandler MUST"
-                                                           + " implement ScopeHandlerDescriptor. Service "
-                                                           + descriptor.descriptorType().fqName() + " does not.");
-            }
-        }
-
-        if (descriptor.factoryType() == FactoryType.QUALIFIED) {
-            // a special kind of service that matches ANY qualifier instance of a specific type, and also may match
-            // a specific contract, or ANY contract
-            if (descriptor instanceof GeneratedInjectService.QualifiedFactoryDescriptor qpd) {
-                TypeName qualifierType = qpd.qualifierType();
-                if (contains(contracts, TypeNames.OBJECT)) {
-                    // matches any contract
-                    qualifiedProvidersByQualifier.computeIfAbsent(qualifierType, it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
-                            .add(descriptor);
-                } else {
-                    // contract specific
-                    Set<TypeName> realContracts = contracts.stream()
-                            .map(ResolvedType::type)
-                            .filter(Predicate.not(Injection.QualifiedFactory.TYPE::equals))
-                            .collect(Collectors.toSet());
-                    for (TypeName realContract : realContracts) {
-                        TypedQualifiedProviderKey key = new TypedQualifiedProviderKey(qualifierType,
-                                                                                      ResolvedType.create(realContract));
-                        typedQualifiedProviders.computeIfAbsent(key, it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
-                                .add(descriptor);
-                    }
-                }
-            } else {
-                throw new ServiceRegistryException("Service descriptors of services that implement QualifiedProvider MUST"
-                                                           + " implement QualifiedProviderDescriptor. Service "
-                                                           + descriptor.descriptorType().fqName() + " does not.");
-            }
-        }
-
-        // and bind factory types, as we can also lookup factories, but only types that are not provided by contracts
-        // as otherwise we would return a factory instance instead of constructed instance
-        // there are cases where the structure can "trick" us into thinking something is a factory contract, such as
-        // when an actual contract of the factory extends a Supplier that provides the same type as the factory itself
-        var factoryContracts = descriptor.factoryContracts();
-        for (ResolvedType factoryContract : factoryContracts) {
-            if (!contracts.contains(factoryContract)) {
-                servicesByContract.computeIfAbsent(factoryContract,
-                                                   it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
-                        .add(descriptor);
-            }
-        }
-    }
-
-    record TypedQualifiedProviderKey(TypeName qualifier, ResolvedType contract) {
-    }
-
-    /**
-     * @param coreDescriptor   instance that is generated and used to register injection points etc.
-     * @param injectDescriptor instance that satisfies the inject descriptor API
-     * @param isCore           if false, both are the same instance
-     */
-    record Described(ServiceDescriptor<?> coreDescriptor,
-                     InjectServiceDescriptor<?> injectDescriptor,
-                     boolean isCore) {
-    }
-
-    private static class ApplicationPlanBinder implements InjectionPlanBinder {
-        private static final System.Logger LOGGER = System.getLogger(ApplicationPlanBinder.class.getName());
-
-        private final Binding appInstance;
-        private final InjectServiceRegistryImpl registry;
-
-        private ApplicationPlanBinder(Binding appInstance, InjectServiceRegistryImpl registry) {
-            this.appInstance = appInstance;
-            this.registry = registry;
-        }
-
-        @Override
-        public Binder bindTo(ServiceInfo descriptor) {
-            ServiceManager<Object> serviceManager = registry.serviceManager(descriptor);
-
-            if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                LOGGER.log(System.Logger.Level.DEBUG, "binding injection plan to " + serviceManager);
-            }
-
-            return serviceManager.servicePlanBinder();
-        }
-
-        @Override
-        public void interceptors(ServiceInfo... descriptors) {
-            registry.interceptors(descriptors);
-        }
-
-        @Override
-        public String toString() {
-            return "Service binder for application: " + appInstance.name();
-        }
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManagerProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManagerProvider.java
deleted file mode 100644
index af5abd840fd..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectRegistryManagerProvider.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.function.Supplier;
-
-import io.helidon.service.registry.ServiceDiscovery;
-import io.helidon.service.registry.ServiceRegistryConfig;
-import io.helidon.service.registry.ServiceRegistryManager;
-import io.helidon.service.registry.spi.ServiceRegistryManagerProvider;
-
-/**
- * {@link java.util.ServiceLoader} provider implementation for
- * {@link io.helidon.service.registry.spi.ServiceRegistryManagerProvider} to provide a service registry
- * with injection and interception support.
- */
-public class InjectRegistryManagerProvider implements ServiceRegistryManagerProvider {
-    /**
-     * Required public constructor.
-     *
-     * @deprecated required for Java {@link java.util.ServiceLoader}
-     */
-    @Deprecated
-    public InjectRegistryManagerProvider() {
-    }
-
-    @Override
-    public ServiceRegistryManager create(ServiceRegistryConfig config,
-                                         ServiceDiscovery serviceDiscovery,
-                                         Supplier<ServiceRegistryManager> coreRegistryManager) {
-        InjectConfig injectConfig;
-        if (config instanceof InjectConfig ic) {
-            injectConfig = ic;
-        } else {
-            injectConfig = InjectConfig.builder()
-                    // we need to add appropriate configured options from config (if present)
-                    .update(it -> config.config().ifPresent(it::config))
-                    .from(config)
-                    .build();
-        }
-        return new InjectRegistryManager(injectConfig, serviceDiscovery);
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectServiceRegistryImpl.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectServiceRegistryImpl.java
deleted file mode 100644
index 8f9ab9ac9bf..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectServiceRegistryImpl.java
+++ /dev/null
@@ -1,654 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import io.helidon.common.LazyValue;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.GlobalConfig;
-import io.helidon.common.configurable.LruCache;
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-import io.helidon.metrics.api.Counter;
-import io.helidon.metrics.api.Meter;
-import io.helidon.metrics.api.MeterRegistry;
-import io.helidon.metrics.api.Metrics;
-import io.helidon.service.inject.InjectRegistryManager.TypedQualifiedProviderKey;
-import io.helidon.service.inject.ServiceSupplies.ServiceSupplyList;
-import io.helidon.service.inject.api.ActivationRequest;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectRegistry__ServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InstanceName__ServiceDescriptor;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.InterceptionMetadata__ServiceDescriptor;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.Scope;
-import io.helidon.service.inject.api.ScopeNotActiveException;
-import io.helidon.service.inject.api.ScopedRegistry;
-import io.helidon.service.inject.api.Scopes;
-import io.helidon.service.inject.api.Scopes__ServiceDescriptor;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
-
-import static io.helidon.service.inject.InjectRegistryManager.SERVICE_INFO_COMPARATOR;
-import static io.helidon.service.inject.LookupTrace.traceLookup;
-
-/**
- * Full-blown service registry with injection and interception support.
- * <p>
- * This implementation re-implements even the core registry, as we want the services to be capable of interoperating
- * (i.e. core services can receive inject services and vice-versa).
- */
-class InjectServiceRegistryImpl implements InjectRegistry, Scopes {
-    private static final AtomicInteger COUNTER = new AtomicInteger();
-
-    private final String id = String.valueOf(COUNTER.incrementAndGet());
-
-    private final ReadWriteLock stateLock = new ReentrantReadWriteLock();
-    private final Lock stateReadLock = stateLock.readLock();
-    private final Lock stateWriteLock = stateLock.writeLock();
-
-    // map of scope annotation to service info
-    private final Map<TypeName, InjectServiceInfo> scopeHandlerServices;
-    // map of service implementation class to service info
-    private final Map<TypeName, InjectServiceInfo> servicesByType;
-    // map of provided contracts to service info(s)
-    private final Map<ResolvedType, Set<InjectServiceInfo>> servicesByContract;
-    // map of qualifier annotations to service info(s)
-    private final Map<TypeName, Set<InjectServiceInfo>> qualifiedProvidersByQualifier;
-    // map of qualifier annotations and resolved type combination to service info(s)
-    private final Map<TypedQualifiedProviderKey, Set<InjectServiceInfo>> typedQualifiedProviders;
-
-    private final RegistryCounter lookupCounter;
-    private final RegistryCounter lookupScanCounter;
-    private final RegistryCounter cacheLookupCounter;
-    private final RegistryCounter cacheHitCounter;
-    private final boolean cacheEnabled;
-    private final LruCache<Lookup, List<InjectServiceInfo>> cache;
-
-    private final LazyValue<Scope> singletonScope = LazyValue
-            .create(() -> createScope(Injection.Singleton.TYPE, Optional::empty, id, Map.of()));
-
-    private final LazyValue<Scope> perLookupScope = LazyValue
-            .create(() -> createScope(Injection.PerLookup.TYPE, Optional::empty, id, Map.of()));
-    private final Map<TypeName, Injection.ScopeHandler> scopeHandlerInstances = new HashMap<>();
-    private final Lock scopeHandlerInstancesLock = new ReentrantLock();
-    private final boolean interceptionEnabled;
-    private final InterceptionMetadata interceptionMetadata;
-
-    // runtime fields (to obtain actual service instances)
-    // service descriptor to its manager
-    private final Map<ServiceInfo, ServiceManager<?>> servicesByDescriptor = new IdentityHashMap<>();
-    private final ActivationRequest activationRequest;
-    private Map<ServiceInfo, ServiceManager<Interception.Interceptor>> interceptors;
-
-    @SuppressWarnings("unchecked")
-    InjectServiceRegistryImpl(InjectConfig config,
-                              Map<ServiceInfo, InjectRegistryManager.Described> descriptorToDescribed,
-                              Map<TypeName, InjectServiceInfo> scopeHandlers,
-                              Map<ServiceInfo, Object> explicitInstances,
-                              Map<TypeName, InjectServiceInfo> servicesByType,
-                              Map<ResolvedType, Set<InjectServiceInfo>> servicesByContract,
-                              Map<TypeName, Set<InjectServiceInfo>> qualifiedProvidersByQualifier,
-                              Map<TypedQualifiedProviderKey, Set<InjectServiceInfo>> typedQualifiedProviders) {
-
-        this.interceptionEnabled = config.interceptionEnabled();
-        // this is a bit tricky - we are leaking our instance that is not yet finished, so it must
-        // not be accessed in the constructor!
-        this.interceptionMetadata = interceptionEnabled
-                ? InterceptionMetadataImpl.create(this)
-                : InterceptionMetadataImpl.noop();
-
-        // these must be bound here, as the instance exists now
-        // (and we do not want to allow post-constructor binding)
-        explicitInstances.put(Scopes__ServiceDescriptor.INSTANCE, this);
-        explicitInstances.put(InjectRegistry__ServiceDescriptor.INSTANCE, this);
-        explicitInstances.put(InterceptionMetadata__ServiceDescriptor.INSTANCE, interceptionMetadata);
-
-        this.cacheEnabled = config.lookupCacheEnabled();
-        this.cache = cacheEnabled ? config.lookupCache().orElseGet(LruCache::create) : null;
-
-        // no-op counters (registry needs config, too early
-        this.lookupCounter = new RegistryCounter();
-        this.lookupScanCounter = new RegistryCounter();
-        if (cacheEnabled) {
-            this.cacheLookupCounter = new RegistryCounter();
-            this.cacheHitCounter = new RegistryCounter();
-        } else {
-            this.cacheLookupCounter = null;
-            this.cacheHitCounter = null;
-        }
-
-        this.scopeHandlerServices = scopeHandlers;
-        this.servicesByType = servicesByType;
-        this.servicesByContract = servicesByContract;
-        this.qualifiedProvidersByQualifier = qualifiedProvidersByQualifier;
-        this.typedQualifiedProviders = typedQualifiedProviders;
-        this.activationRequest = ActivationRequest.builder()
-                .targetPhase(config.limitRuntimePhase())
-                .build();
-
-        /*
-        For each known service descriptor, create an appropriate service manager
-         */
-        descriptorToDescribed.forEach((descriptor, described) -> {
-            InjectServiceDescriptor<?> injectDescriptor = described.injectDescriptor();
-
-            Object instance = explicitInstances.get(descriptor);
-            ServiceProvider<Object> provider = new ServiceProvider<>(
-                    this,
-                    (InjectServiceDescriptor<Object>) described.injectDescriptor());
-
-            if (instance != null) {
-                Activator<Object> activator = Activators.create(provider, instance);
-                servicesByDescriptor.put(descriptor,
-                                         new ServiceManager<>(scopeSupplier(injectDescriptor),
-                                                              provider,
-                                                              true,
-                                                              () -> activator));
-            } else {
-                // we must always prefer explicit instances - so if specified, we will never override it
-                servicesByDescriptor.putIfAbsent(descriptor,
-                                                 new ServiceManager<>(scopeSupplier(injectDescriptor),
-                                                                      provider,
-                                                                      false,
-                                                                      Activators.create(this, provider)));
-            }
-        });
-
-        // make sure config is initialized as it should be
-        if (config.limitRuntimePhase().ordinal() >= Activator.Phase.ACTIVE.ordinal()) {
-            Config registryConfig = first(Config.class).orElseGet(GlobalConfig::config);
-            GlobalConfig.config(() -> registryConfig, true);
-
-            // Set-up metrics using metric registry
-            MeterRegistry meterRegistry = Metrics.globalRegistry();
-            this.lookupCounter.consumer = meterRegistry
-                    .getOrCreate(Counter.builder("io.helidon.inject.lookups")
-                                         .description("Number of lookups in the service registry")
-                                         .scope(Meter.Scope.VENDOR))::increment;
-            this.lookupScanCounter.consumer = meterRegistry
-                    .getOrCreate(Counter.builder("io.helidon.inject.scanLookups")
-                                         .description("Number of lookups that require registry scan")
-                                         .scope(Meter.Scope.VENDOR))::increment;
-            if (cacheEnabled) {
-                this.cacheLookupCounter.consumer = meterRegistry
-                        .getOrCreate(Counter.builder("io.helidon.inject.cacheLookups")
-                                             .description("Number of lookups in cache in the service registry")
-                                             .scope(Meter.Scope.VENDOR))::increment;
-                this.cacheHitCounter.consumer = meterRegistry
-                        .getOrCreate(Counter.builder("io.helidon.inject.cacheHits")
-                                             .description("Number of cache hits in the service registry")
-                                             .scope(Meter.Scope.VENDOR))::increment;
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <T> Optional<T> get(ServiceInfo serviceInfo) {
-        ServiceManager<?> serviceManager = servicesByDescriptor.get(serviceInfo);
-        if (serviceManager == null) {
-            return Optional.empty();
-        }
-        return (Optional<T>) new ServiceSupplies.ServiceSupplyOptional<>(Lookup.EMPTY, List.of(serviceManager(serviceInfo)))
-                .get();
-    }
-
-    @Override
-    public List<ServiceInfo> allServices(TypeName contract) {
-        return lookupServices(Lookup.create(contract))
-                .stream()
-                .map(InjectServiceInfo::coreInfo)
-                .collect(Collectors.toList());
-    }
-
-    @Override
-    public <T> T get(Lookup lookup) {
-        return this.<T>supply(lookup).get();
-    }
-
-    @Override
-    public <T> Optional<T> first(Lookup lookup) {
-        return this.<T>supplyFirst(lookup).get();
-    }
-
-    @Override
-    public <T> List<T> all(Lookup lookup) {
-        return this.<T>supplyAll(lookup).get();
-    }
-
-    @Override
-    public <T> Supplier<T> supply(Lookup lookup) {
-        List<ServiceManager<T>> managers = lookupManagers(lookup);
-
-        if (managers.isEmpty()) {
-            throw new ServiceRegistryException("There is no service in registry that matches this lookup: " + lookup);
-        }
-        return new ServiceSupplies.ServiceSupply<>(lookup, managers);
-    }
-
-    @Override
-    public <T> Supplier<Optional<T>> supplyFirst(Lookup lookup) {
-        List<ServiceManager<T>> managers = lookupManagers(lookup);
-
-        if (managers.isEmpty()) {
-            return Optional::empty;
-        }
-        return new ServiceSupplies.ServiceSupplyOptional<>(lookup, managers);
-    }
-
-    @Override
-    public <T> Supplier<List<T>> supplyAll(Lookup lookup) {
-        List<ServiceManager<T>> managers = lookupManagers(lookup);
-
-        if (managers.isEmpty()) {
-            return List::of;
-        }
-        return new ServiceSupplyList<>(lookup, managers);
-    }
-
-    @Override
-    public <T> T get(TypeName contract) {
-        return get(Lookup.create(contract));
-    }
-
-    @Override
-    public <T> Optional<T> first(TypeName contract) {
-        return first(Lookup.create(contract));
-    }
-
-    @Override
-    public <T> List<T> all(TypeName contract) {
-        return all(Lookup.create(contract));
-    }
-
-    @Override
-    public <T> Supplier<T> supply(TypeName contract) {
-        return supply(Lookup.create(contract));
-    }
-
-    @Override
-    public <T> Supplier<Optional<T>> supplyFirst(TypeName contract) {
-        return supplyFirst(Lookup.create(contract));
-    }
-
-    @Override
-    public <T> Supplier<List<T>> supplyAll(TypeName contract) {
-        return supplyAll(Lookup.create(contract));
-    }
-
-    @Override
-    public Scope createScope(TypeName scopeType, String id, Map<ServiceDescriptor<?>, Object> initialBindings) {
-        return createScope(scopeType,
-                           scopeHandler(scopeType),
-                           id,
-                           initialBindings);
-    }
-
-    @Override
-    public List<InjectServiceInfo> lookupServices(Lookup lookup) {
-        try {
-            stateReadLock.lock();
-            // a very special lookup
-            if (lookup.qualifiers().contains(Qualifier.CREATE_FOR_NAME)) {
-                if (lookup.qualifiers().size() != 1) {
-                    throw new ServiceRegistryException("Invalid injection lookup. @"
-                                                               + Injection.InstanceName.class.getName()
-                                                               + " must be the only qualifier used.");
-                }
-                if (!lookup.contracts().contains(ResolvedType.create(TypeNames.STRING))) {
-                    throw new ServiceRegistryException("Invalid injection lookup. @"
-                                                               + Injection.InstanceName.class.getName()
-                                                               + " must use String contract.");
-                }
-                if (lookup.contracts().size() != 1) {
-                    throw new ServiceRegistryException("Invalid injection lookup. @"
-                                                               + Injection.InstanceName.class.getName()
-                                                               + " must use String as the only contract.");
-                }
-                return List.of(InstanceName__ServiceDescriptor.INSTANCE);
-            }
-
-            lookupCounter.increment();
-
-            traceLookup(lookup, "start: {0}", lookup);
-
-            if (cacheEnabled) {
-                List<InjectServiceInfo> cacheResult = cache.get(lookup)
-                        .orElse(null);
-                cacheLookupCounter.increment();
-                if (cacheResult != null) {
-                    traceLookup(lookup, "from cache", cacheResult);
-                    cacheHitCounter.increment();
-                    return cacheResult;
-                }
-            }
-
-            List<InjectServiceInfo> result = new ArrayList<>();
-
-            if (lookup.serviceType().isPresent()) {
-                // when a specific service type is requested, we go for it
-                InjectServiceInfo exact = servicesByType.get(lookup.serviceType().get());
-                if (exact != null) {
-                    traceLookup(lookup, "by service type", result);
-                    result.add(exact);
-                    return result;
-                }
-            }
-
-            if (1 == lookup.contracts().size()) {
-                // a single contract is requested, we are ready for this ("indexed by contract")
-                ResolvedType theOnlyContractRequested = lookup.contracts().iterator().next();
-                Set<InjectServiceInfo> subsetOfMatches = servicesByContract.get(theOnlyContractRequested);
-                if (subsetOfMatches != null) {
-                    // the subset is ordered, cannot use parallel, also no need to re-order
-                    subsetOfMatches.stream()
-                            .filter(lookup::matches)
-                            .forEach(result::add);
-                    if (!result.isEmpty()) {
-                        traceLookup(lookup, "by single contract", result);
-                        return result;
-                    }
-                }
-            }
-
-            // table scan :-(
-            lookupScanCounter.increment();
-            servicesByType.values()
-                    .stream()
-                    .filter(lookup::matches)
-                    .sorted(SERVICE_INFO_COMPARATOR)
-                    .forEach(result::add);
-            traceLookup(lookup, "from full table scan", result);
-
-            if (result.isEmpty() && !lookup.qualifiers().isEmpty()) {
-                // check qualified providers
-                if (lookup.contracts().size() == 1) {
-                    ResolvedType contract = lookup.contracts().iterator().next();
-                    for (Qualifier qualifier : lookup.qualifiers()) {
-                        TypeName qualifierType = qualifier.typeName();
-                        Set<InjectServiceInfo> found = typedQualifiedProviders.get(new TypedQualifiedProviderKey(qualifierType,
-                                                                                                                 contract));
-                        if (found != null) {
-                            traceLookup(lookup, "from typed qualified providers", found);
-                            result.addAll(found);
-                        }
-                        found = qualifiedProvidersByQualifier.get(qualifierType);
-                        if (found != null) {
-                            traceLookup(lookup, "from typed qualified providers", found);
-                            result.addAll(found);
-                        }
-                    }
-                }
-            }
-
-            if (cacheEnabled) {
-                cache.put(lookup, result);
-            }
-
-            traceLookup(lookup, "full result", result);
-            return result;
-        } finally {
-            stateReadLock.unlock();
-        }
-    }
-
-    void ensureInjectionPlans() {
-        servicesByDescriptor.values()
-                .forEach(ServiceManager::ensureInjectionPlan);
-    }
-
-    void close() {
-        singletonScope.get()
-                .close();
-    }
-
-    List<ServiceInfo> servicesByContract(ResolvedType contract) {
-        Set<InjectServiceInfo> serviceInfos = servicesByContract.get(contract);
-        if (serviceInfos == null) {
-            return List.of();
-        }
-        return serviceInfos.stream()
-                .map(InjectServiceInfo::coreInfo)
-                .collect(Collectors.toList());
-    }
-
-    <T> List<ServiceManager<T>> lookupManagers(Lookup lookup) {
-        List<ServiceManager<T>> result = new ArrayList<>();
-
-        for (InjectServiceInfo service : lookupServices(lookup)) {
-            result.add(serviceManager(service.coreInfo()));
-        }
-
-        return result;
-    }
-
-    InterceptionMetadata interceptionMetadata() {
-        return interceptionMetadata;
-    }
-
-    ActivationRequest activationRequest() {
-        return activationRequest;
-    }
-
-    @SuppressWarnings("unchecked")
-    <T> ServiceManager<T> serviceManager(ServiceInfo info) {
-        ServiceManager<T> result = (ServiceManager<T>) servicesByDescriptor.get(info);
-        if (result == null) {
-            throw new ServiceRegistryException("Attempt to use service info not managed by this registry: " + info);
-        }
-        return result;
-    }
-
-    void interceptors(ServiceInfo... serviceInfos) {
-        if (!interceptionEnabled) {
-            return;
-        }
-        try {
-            stateWriteLock.lock();
-            if (this.interceptors == null) {
-                this.interceptors = new LinkedHashMap<>();
-            }
-            Set<InjectServiceInfo> ordered = new TreeSet<>(SERVICE_INFO_COMPARATOR);
-            for (ServiceInfo serviceInfo : serviceInfos) {
-                ServiceManager<Object> serviceManager = this.serviceManager(serviceInfo);
-                ordered.add(serviceManager.injectDescriptor());
-            }
-
-            // there may be more than one application, we need to add to existing
-            for (InjectServiceInfo injectServiceInfo : ordered) {
-                this.interceptors.computeIfAbsent(injectServiceInfo.coreInfo(),
-                                                  this::serviceManager);
-            }
-        } finally {
-            stateWriteLock.unlock();
-        }
-    }
-
-    List<ServiceManager<Interception.Interceptor>> interceptors() {
-        try {
-            stateReadLock.lock();
-            if (interceptors != null) {
-                return List.copyOf(interceptors.values());
-            }
-        } finally {
-            stateReadLock.unlock();
-        }
-        try {
-            stateWriteLock.lock();
-            if (interceptors == null) {
-                // we must preserve the order of services, as they are weight ordered!
-                this.interceptors = new LinkedHashMap<>();
-                List<ServiceManager<Interception.Interceptor>> serviceManagers =
-                        lookupManagers(Lookup.builder()
-                                               .addContract(Interception.Interceptor.class)
-                                               .addQualifier(Qualifier.WILDCARD_NAMED)
-                                               .build());
-                for (ServiceManager<Interception.Interceptor> serviceManager : serviceManagers) {
-                    this.interceptors.put(serviceManager.descriptor(), serviceManager);
-                }
-            }
-            return List.copyOf(interceptors.values());
-        } finally {
-            stateWriteLock.unlock();
-        }
-    }
-
-    private Scope createScope(TypeName scopeType,
-                              Injection.ScopeHandler scopeHandler,
-                              String id,
-                              Map<ServiceDescriptor<?>, Object> initialBindings) {
-        var registry = new ScopedRegistryImpl(this, scopeType, id, initialBindings);
-        var scope = new ScopeImpl(scopeType, scopeHandler, registry);
-        scopeHandler.activate(scope);
-        return scope;
-    }
-
-    private Supplier<Scope> scopeSupplier(InjectServiceInfo descriptor) {
-        TypeName scope = descriptor.scope();
-        if (Injection.Singleton.TYPE.equals(scope)) {
-            return singletonScope;
-        } else if (Injection.PerLookup.TYPE.equals(scope)) {
-            return perLookupScope;
-        } else {
-            // must be a lazy value, as the scope handler may not be available at the time this method is called
-            LazyValue<Injection.ScopeHandler> scopeHandler = LazyValue.create(() -> scopeHandler(scope));
-            return () -> scopeHandler.get()
-                    .currentScope() // must be called each time, as we must use the currently active scope, not a cached one
-                    .orElseThrow(() -> new ScopeNotActiveException("Scope not active for service: "
-                                                                           + descriptor.serviceType().fqName(),
-                                                                   scope));
-        }
-    }
-
-    private Injection.ScopeHandler scopeHandler(TypeName scope) {
-        scopeHandlerInstancesLock.lock();
-        try {
-            return scopeHandlerInstances.computeIfAbsent(scope, it -> {
-                InjectServiceInfo serviceInfo = scopeHandlerServices.get(scope);
-                if (serviceInfo == null) {
-                    throw new ServiceRegistryException("There is no scope handler service registered for scope: "
-                                                               + scope.fqName());
-                }
-                ServiceManager<?> serviceManager = servicesByDescriptor.get(serviceInfo.coreInfo());
-                return (Injection.ScopeHandler) serviceManager.activator()
-                        .instances(Lookup.EMPTY)
-                        .orElseThrow(() -> new ServiceRegistryException("Scope handler service did not return any instance for: "
-                                                                                + scope.fqName()))
-                        .getFirst() // List.getFirst() - Qualified instance
-                        .get();
-            });
-        } finally {
-            scopeHandlerInstancesLock.unlock();
-        }
-    }
-
-    private static class RegistryCounter implements Counter {
-        private volatile Consumer<Long> consumer;
-
-        RegistryCounter() {
-            consumer = it -> {
-            };
-        }
-
-        @Override
-        public void increment() {
-            increment(1);
-        }
-
-        @Override
-        public void increment(long amount) {
-            consumer.accept(amount);
-        }
-
-        @Override
-        public long count() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public Id id() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public Optional<String> baseUnit() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public Optional<String> description() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public Type type() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public Optional<String> scope() {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-
-        @Override
-        public <R> R unwrap(Class<? extends R> c) {
-            throw new UnsupportedOperationException("This is not a full counter");
-        }
-    }
-
-    private record ScopeImpl(TypeName scopeType,
-                             Injection.ScopeHandler handler,
-                             ScopedRegistry registry) implements Scope {
-
-        @Override
-        public void close() {
-            handler.deactivate(this);
-        }
-
-        @Override
-        public String toString() {
-            return "Scope for " + scopeType.fqName();
-        }
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
deleted file mode 100644
index 58b13960320..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.lang.System.Logger.Level;
-
-import io.helidon.Main;
-import io.helidon.common.Weight;
-import io.helidon.common.Weighted;
-import io.helidon.service.registry.ServiceRegistryManager;
-import io.helidon.spi.HelidonShutdownHandler;
-import io.helidon.spi.HelidonStartupProvider;
-
-/**
- * {@link java.util.ServiceLoader} implementation of a Helidon startup provider for Helidon Service Inject based
- * applications.
- */
-@Weight(Weighted.DEFAULT_WEIGHT) // explicit default weight, this should be the "default" startup class
-public class InjectStartupProvider extends InjectionMain implements HelidonStartupProvider {
-    /**
-     * Default constructor required by {@link java.util.ServiceLoader}.
-     *
-     * @deprecated please do not use directly
-     */
-    @Deprecated
-    public InjectStartupProvider() {
-    }
-
-    /**
-     * Register a shutdown handler.
-     * The handler is registered, and never de-registered. This method should only be used by main classes of applications.
-     * If a custom shutdown is desired, please use
-     * {@link io.helidon.Main#addShutdownHandler(io.helidon.spi.HelidonShutdownHandler)} directly.
-     *
-     * @param registryManager registry manager
-     */
-    public static void registerShutdownHandler(ServiceRegistryManager registryManager) {
-        System.Logger logger = System.getLogger(InjectStartupProvider.class.getName());
-        Main.addShutdownHandler(new InjectShutdownHandler(logger, registryManager));
-    }
-
-    @Override
-    public void start(String[] arguments) {
-        super.start(arguments);
-    }
-
-    @Override
-    protected void serviceDescriptors(InjectConfig.Builder configBuilder) {
-        // service descriptors are discovered when startup provider is used - see below discoverServices() method
-    }
-
-    @Override
-    protected boolean discoverServices() {
-        return true;
-    }
-
-    // higher than default, so we stop server as a service, not through shutdown
-    @Weight(Weighted.DEFAULT_WEIGHT + 10)
-    private static final class InjectShutdownHandler implements HelidonShutdownHandler {
-        private final System.Logger logger;
-        private final ServiceRegistryManager registryManager;
-
-        private InjectShutdownHandler(System.Logger logger, ServiceRegistryManager registryManager) {
-            this.logger = logger;
-            this.registryManager = registryManager;
-        }
-
-        @Override
-        public void shutdown() {
-            try {
-                registryManager.shutdown();
-            } catch (Exception e) {
-                logger.log(Level.ERROR,
-                           "Failed to shutdown Helidon Inject registry",
-                           e);
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "Helidon Inject shutdown handler";
-        }
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
deleted file mode 100644
index ac153fe9516..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject;
-
-import java.lang.System.Logger.Level;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Supplier;
-
-import io.helidon.common.config.Config;
-import io.helidon.common.config.GlobalConfig;
-import io.helidon.common.types.TypeName;
-import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.registry.GlobalServiceRegistry;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
-
-/**
- * Common ancestor for generated main classes.
- * <p>
- * The following methods are code generated to the {@code ApplicationMain} class by the Maven plugin.
- * If you do not want the generated code to be used, simply implement those methods in your custom Main class,
- * and they will NOT be generated.
- * When not using Maven plugin, the generated class will have no-op implementations nad service discovery will be enabled.
- * <ul>
- *     <li>{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} - registers all service descriptors
- *      in the current application; to customize the config builder, you can use
- *      {@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} and
- *      {@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} methods</li>
- *     <li>{@link #discoverServices()} - set to {@code false} when using Maven plugin, to avoid all reflection</li>
- * </ul>
- */
-public abstract class InjectionMain {
-    /*
-    A change in this class requires change in ApplicationMainGenerator!
-     */
-
-    private static final System.Logger LOGGER = System.getLogger(InjectionMain.class.getName());
-
-    static {
-        LogConfig.initClass();
-    }
-
-    /**
-     * Default constructor with no side effects.
-     */
-    protected InjectionMain() {
-        LogConfig.configureRuntime();
-    }
-
-    /**
-     * Create a service descriptor for a Java {@link java.util.ServiceLoader} based service.
-     *
-     * @param providerInterface provider interface of the service
-     * @param implType          provider implementation
-     * @param instanceSupplier  supplier of a new instance of the service implementation (to allow avoiding reflection)
-     * @param weight            weight assigned to the service
-     * @param <T>               type of the service implementation
-     * @return a new service descriptor of the service
-     */
-    protected static <T> ServiceDescriptor<?> serviceLoader(TypeName providerInterface,
-                                                            Class<T> implType,
-                                                            Supplier<T> instanceSupplier,
-                                                            double weight) {
-        return ServiceLoader__ServiceDescriptor.create(providerInterface, implType, instanceSupplier, weight);
-    }
-
-    /**
-     * Method that handles the startup sequence of an application.
-     * This method is expected to be code generated.
-     * <p>
-     * The following sequence is implemented:
-     * <ol>
-     *     <li>{@link #configBuilder(String[])} to prepare the configuration builder from
-     *              {@link io.helidon.common.config.Config}</li>
-     *     <li>{@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder</li>
-     *     <li>{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} for code generated setup</li>
-     *     <li>{@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder</li>
-     *     <li>{@link #init(InjectConfig)} to initialize the service registry</li>
-     * </ol>
-     *
-     * @param arguments command line arguments
-     */
-    protected void start(String[] arguments) {
-        var config = configBuilder(arguments);
-        beforeServiceDescriptors(config);
-        serviceDescriptors(config);
-        afterServiceDescriptors(config);
-        var registry = init(config.build());
-        afterInit(registry);
-    }
-
-    /**
-     * Method that registers all service descriptors.
-     * This method is expected to be code generated.
-     *
-     * @param configBuilder in progress config builder
-     */
-    protected abstract void serviceDescriptors(InjectConfig.Builder configBuilder);
-
-    /**
-     * Create a config builder from command line arguments.
-     * This method will create default configuration (but not register it as a global config, so we still use the registry
-     * to create a config instance), configure the {@link io.helidon.service.inject.InjectConfig.Builder} from it,
-     * then disable discovery of services.
-     *
-     * @param arguments command line arguments
-     * @return a new config builder
-     */
-    protected InjectConfig.Builder configBuilder(String[] arguments) {
-        Config config;
-        if (GlobalConfig.configured()) {
-            config = GlobalConfig.config();
-        } else {
-            config = Config.create();
-        }
-
-        return InjectConfig.builder()
-                .config(config.get("registry"))
-                .discoverServices(discoverServices())
-                .discoverServicesFromServiceLoader(discoverServices());
-    }
-
-    /**
-     * Whether to discover services from classpath and from service loader.
-     * Defaults to {@code false}, should be overridden when
-     * {@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)}
-     * does not configure all services.
-     *
-     * @return whether to discover services
-     */
-    protected boolean discoverServices() {
-        return false;
-    }
-
-    /**
-     * Called before service descriptors are configured in the generated main class.
-     * This method is invoked from generated {@link #start(String[])}.
-     *
-     * @param configBuilder in-progress config builder
-     */
-    protected void beforeServiceDescriptors(InjectConfig.Builder configBuilder) {
-    }
-
-    /**
-     * Called after service descriptors are configured in the generated main class, before the registry is initialized.
-     * This method is invoked from generated {@link #start(String[])}
-     *
-     * @param configBuilder in-progress config builder
-     */
-    protected void afterServiceDescriptors(InjectConfig.Builder configBuilder) {
-    }
-
-    /**
-     * Initialize the service registry, register it for shutdown during process shutdown, and lookup all
-     * startup services.
-     *
-     * @param config configuration of the Inject service registry
-     * @return the inject registry created within this method
-     */
-    protected InjectRegistry init(InjectConfig config) {
-        InjectRegistryManager manager = InjectRegistryManager.create(config);
-        InjectRegistry registry = manager.registry();
-        InjectStartupProvider.registerShutdownHandler(manager);
-
-        GlobalServiceRegistry.registry(registry);
-
-        double maxRunLevel = maxRunLevel(config, registry);
-        for (double runLevel : runLevels(config, registry)) {
-            if (runLevel <= maxRunLevel) {
-                List<Object> all = registry.all(Lookup.builder()
-                                                        .addScope(Injection.Singleton.TYPE)
-                                                        .runLevel(runLevel)
-                                                        .build());
-                if (LOGGER.isLoggable(Level.TRACE)) {
-                    LOGGER.log(Level.DEBUG, "Starting services in run level: " + runLevel + ": ");
-                    for (Object o : all) {
-                        LOGGER.log(Level.DEBUG, "\t" + o);
-                    }
-                } else if (LOGGER.isLoggable(Level.DEBUG)) {
-                    LOGGER.log(Level.TRACE, "Starting services in run level: " + runLevel);
-                }
-            }
-        }
-
-        return registry;
-    }
-
-    /**
-     * Maximal run level to initialize.
-     * The default startup sequence will go through each
-     * {@link #runLevels(InjectConfig, io.helidon.service.inject.api.InjectRegistry) run level} up to (and including) the value
-     * returned by this method.
-     *
-     * @param config injection config
-     * @param registry registry instance
-     * @return maximal run level to initialize
-     */
-    protected double maxRunLevel(InjectConfig config,
-                                 InjectRegistry registry) {
-        return config.maxRunLevel();
-    }
-
-    /**
-     * Run levels that should be initialized at startup.
-     * Default implementation initializes all declared run levels (services with explicit
-     * {@link io.helidon.service.inject.api.Injection.RunLevel} annotation).
-     *
-     * @param config injection config
-     * @param registry registry instance
-     * @return array of doubles that represent run levels to initialize, will be used in the order provided here
-     */
-    protected double[] runLevels(InjectConfig config,
-                                 InjectRegistry registry) {
-        // child classes will have this method code generated at build time
-        List<Double> runLevelList = registry.lookupServices(Lookup.EMPTY)
-                .stream()
-                .map(InjectServiceInfo::runLevel)
-                .flatMap(Optional::stream)
-                .distinct()
-                .sorted()
-                .toList();
-        double[] result = new double[runLevelList.size()];
-        for (int i = 0; i < result.length; i++) {
-            result[i] = runLevelList.get(i);
-        }
-        return result;
-    }
-
-    /**
-     * Allows to query the registry after the service is started.
-     *
-     * @param registry inject service registry
-     */
-    protected void afterInit(InjectRegistry registry) {
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/package-info.java b/service/inject/inject/src/main/java/io/helidon/service/inject/package-info.java
deleted file mode 100644
index 5ba826bcc8a..00000000000
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/package-info.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Support for service registry with full injection and interception.
- *
- * @see io.helidon.service.inject.api.InjectRegistry
- * @see io.helidon.service.inject.InjectRegistryManager
- * @see io.helidon.service.inject.api.Injection
- */
-package io.helidon.service.inject;
diff --git a/service/inject/inject/src/main/java/module-info.java b/service/inject/inject/src/main/java/module-info.java
deleted file mode 100644
index 26bc2a3d01a..00000000000
--- a/service/inject/inject/src/main/java/module-info.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import io.helidon.common.features.api.Feature;
-import io.helidon.common.features.api.Preview;
-
-/**
- * Service registry with injection support API.
- */
-@Feature(value = "Injection",
-         description = "Injection, interception and config bean support for Service Registry",
-         path = {"Registry", "Injection"},
-         since = "4.2.0")
-@Preview
-module io.helidon.service.inject {
-    requires static io.helidon.common.features.api;
-
-    requires io.helidon;
-    requires io.helidon.logging.common;
-    requires io.helidon.metrics.api;
-    requires io.helidon.service.metadata;
-
-    requires transitive io.helidon.service.inject.api;
-    requires transitive io.helidon.service.registry;
-    requires transitive io.helidon.common.config;
-    requires transitive io.helidon.builder.api;
-    requires transitive io.helidon.common.types;
-    requires transitive io.helidon.common.configurable;
-
-    exports io.helidon.service.inject;
-
-    provides io.helidon.service.registry.spi.ServiceRegistryManagerProvider
-            with io.helidon.service.inject.InjectRegistryManagerProvider;
-
-    provides io.helidon.spi.HelidonStartupProvider
-            with io.helidon.service.inject.InjectStartupProvider;
-}
\ No newline at end of file
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java b/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
deleted file mode 100644
index 027b00f67a3..00000000000
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MainClassCreator.java
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.inject.maven.plugin;
-
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Collectors;
-
-import io.helidon.codegen.CodegenException;
-import io.helidon.codegen.classmodel.ClassModel;
-import io.helidon.codegen.classmodel.Method;
-import io.helidon.codegen.compiler.Compiler;
-import io.helidon.codegen.compiler.CompilerOptions;
-import io.helidon.codegen.scan.ScanContext;
-import io.helidon.codegen.scan.ScanTypeInfoFactory;
-import io.helidon.common.types.AccessModifier;
-import io.helidon.common.types.ElementSignature;
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeInfo;
-import io.helidon.common.types.TypeName;
-import io.helidon.common.types.TypeNames;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection.RunLevel;
-import io.helidon.service.inject.codegen.ApplicationMainGenerator;
-import io.helidon.service.metadata.DescriptorMetadata;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceDiscovery;
-import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
-
-import io.github.classgraph.ClassGraph;
-import io.github.classgraph.ClassInfo;
-import io.github.classgraph.ClassInfoList;
-import io.github.classgraph.ScanResult;
-
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_MAIN;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_RUN_LEVEL;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_BINDING;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
-
-class MainClassCreator {
-    private static final TypeName GENERATOR = TypeName.create(MainClassCreator.class);
-    private static final String INJECTION_MAIN_ANNOTATION = INJECTION_MAIN.packageName()
-            + "."
-            + INJECTION_MAIN.classNameWithEnclosingNames().replace('.', '$');
-
-    private final MavenCodegenContext ctx;
-    private final boolean failOnError;
-
-    MainClassCreator(MavenCodegenContext scanContext, boolean failOnError) {
-        this.ctx = scanContext;
-        this.failOnError = failOnError;
-    }
-
-    void create(MavenCodegenContext scanContext,
-                CompilerOptions compilerOptions,
-                WrappedServices services,
-                TypeName generatedType) {
-        try {
-            codegen(scanContext, compilerOptions, services, generatedType);
-        } catch (CodegenException ce) {
-            handleError(ce);
-        } catch (Throwable te) {
-            handleError(new CodegenException("Failed to code generate application main class", te));
-        }
-    }
-
-    private void codegen(ScanContext scanContext,
-                         CompilerOptions compilerOptions,
-                         WrappedServices services,
-                         TypeName generatedType) {
-        // if there is a custom main class present, we must honor it
-        Optional<TypeInfo> foundCustomMain = findCustomMain(scanContext, compilerOptions.outputDirectory());
-        Set<ElementSignature> declaredSignatures;
-        TypeName superType;
-
-        if (foundCustomMain.isPresent()) {
-            TypeInfo customMain = foundCustomMain.get();
-            ApplicationMainGenerator.validate(customMain);
-            declaredSignatures = ApplicationMainGenerator.declaredSignatures(customMain);
-            superType = customMain.typeName();
-        } else {
-            declaredSignatures = Set.of();
-            superType = INJECT_MAIN;
-        }
-
-        ClassModel classModel =
-                ApplicationMainGenerator.generate(GENERATOR,
-                                                  declaredSignatures,
-                                                  superType,
-                                                  generatedType,
-                                                  false,
-                                                  true,
-                                                  (classBuilder, methodModel, paramName) -> serviceDescriptors(classBuilder,
-                                                                                                               methodModel,
-                                                                                                               paramName,
-                                                                                                               services),
-                                                  (classBuilder, methodModel, paramName) -> runLevels(
-                                                          methodModel,
-                                                          services))
-                        .build();
-
-        Path generated = ctx.filer()
-                .writeSourceFile(classModel);
-
-        Compiler.compile(compilerOptions, generated);
-    }
-
-    private Optional<TypeInfo> findCustomMain(ScanContext scanContext, Path targetPath) {
-        // we do not want to search the whole application, just the current module. Main class MUST be in the module that
-        // uses the maven plugin
-        try (ScanResult scan = new ClassGraph()
-                .overrideClasspath(Set.of(targetPath))
-                .enableAllInfo()
-                .scan()) {
-            ClassInfoList customMainClasses = scan.getClassesWithAnnotation(INJECTION_MAIN_ANNOTATION);
-            if (customMainClasses.isEmpty()) {
-                return Optional.empty();
-            }
-            if (customMainClasses.size() > 1) {
-                String names = customMainClasses.stream()
-                        .map(ClassInfo::getName)
-                        .collect(Collectors.joining(", "));
-                throw new CodegenException("There can only be one class annotated with " + INJECTION_MAIN.fqName() + ", "
-                                                   + "but discovered more than one: " + names);
-            }
-            return ScanTypeInfoFactory.create(scanContext, customMainClasses.getFirst());
-        }
-    }
-
-    private void runLevels(Method.Builder method,
-                           WrappedServices services) {
-        Set<Double> runLevels = new TreeSet<>();
-
-        for (InjectServiceInfo serviceInfo : services.all()) {
-            if (serviceInfo.runLevel().isPresent()) {
-                runLevels.add(serviceInfo.runLevel().get());
-            }
-        }
-
-        List<Double> runLevelList = List.copyOf(runLevels);
-
-        for (int i = 0; i < runLevelList.size(); i++) {
-            double current = runLevelList.get(i);
-            if (Double.compare(RunLevel.STARTUP, current) == 0) {
-                method.addContent(INJECTION_RUN_LEVEL)
-                        .addContent(".STARTUP");
-            } else if (Double.compare(RunLevel.SERVER, current) == 0) {
-                method.addContent(INJECTION_RUN_LEVEL)
-                        .addContent(".SERVER");
-            } else if (Double.compare(RunLevel.NORMAL, current) == 0) {
-                method.addContent(INJECTION_RUN_LEVEL)
-                        .addContent(".NORMAL");
-            } else {
-                method.addContent(String.valueOf(current))
-                        .addContent("D");
-            }
-            if (i == runLevelList.size() - 1) {
-                method.addContentLine("");
-            } else {
-                method.addContentLine(",");
-            }
-        }
-    }
-
-    private void serviceDescriptors(ClassModel.Builder classModel,
-                                    Method.Builder method,
-                                    String paramName,
-                                    WrappedServices services) {
-        List<ServiceLoader__ServiceDescriptor> serviceLoaded = new ArrayList<>();
-        List<TypeName> serviceDescriptors = new ArrayList<>();
-
-        // bindings must be added directly from service discovery, as they are not part of the registry
-        addBindings(serviceDescriptors);
-
-        // for each discovered service, add it to the configuration
-        for (InjectServiceInfo serviceInfo : services.all()) {
-            if (serviceInfo.coreInfo() instanceof ServiceLoader__ServiceDescriptor sl) {
-                serviceLoaded.add(sl);
-            } else {
-                serviceDescriptors.add(serviceInfo.descriptorType());
-            }
-        }
-
-        Map<TypeName, String> providerConstants = new HashMap<>();
-        AtomicInteger constantCounter = new AtomicInteger();
-
-        serviceLoaded.stream()
-                .sorted(serviceLoaderComparator())
-                .forEach(it -> addServiceLoader(classModel, method, providerConstants, constantCounter, it));
-
-        if (!serviceLoaded.isEmpty() && !serviceDescriptors.isEmpty()) {
-            // visually separate service loaded services from service descriptors
-            method.addContentLine("");
-        }
-
-        // config.addServiceDescriptor(ImperativeFeature__ServiceDescriptor.INSTANCE);
-        serviceDescriptors.stream().sorted()
-                .forEach(it -> method.addContent(paramName)
-                        .addContent(".addServiceDescriptor(")
-                        .addContent(it)
-                        .addContentLine(".INSTANCE);"));
-    }
-
-    private void addBindings(List<TypeName> serviceDescriptors) {
-        ResolvedType binding = ResolvedType.create(INJECT_BINDING);
-
-        ServiceDiscovery.create()
-                .allMetadata()
-                .stream()
-                .filter(it -> it.contracts().contains(binding))
-                .map(DescriptorMetadata::descriptorType)
-                .forEach(serviceDescriptors::add);
-    }
-
-    private void addServiceLoader(ClassModel.Builder classModel,
-                                  Method.Builder main,
-                                  Map<TypeName, String> providerConstants,
-                                  AtomicInteger constantCounter,
-                                  ServiceLoader__ServiceDescriptor sl) {
-        // Generated code:
-        // config.addServiceDescriptor(serviceLoader(PROVIDER_1,
-        //                                           YamlConfigParser.class,
-        //                                           () -> new io.helidon.config.yaml.YamlConfigParser(),
-        //                                           90.0));
-        TypeName providerInterface = sl.providerInterface();
-        String constantName = providerConstants.computeIfAbsent(providerInterface, it -> {
-            int i = constantCounter.getAndIncrement();
-            String constant = "PROVIDER_" + i;
-            classModel.addField(field -> field
-                    .accessModifier(AccessModifier.PRIVATE)
-                    .isStatic(true)
-                    .isFinal(true)
-                    .type(TypeNames.TYPE_NAME)
-                    .name(constant)
-                    .addContentCreate(providerInterface));
-            return constant;
-        });
-
-        main.addContent("config")
-                .addContent(".addServiceDescriptor(serviceLoader(")
-                .addContent(constantName)
-                .addContentLine(",")
-                .increaseContentPadding()
-                .increaseContentPadding()
-                .increaseContentPadding()
-                .addContent(sl.serviceType()).addContentLine(".class,")
-                .addContent("() -> new ").addContent(sl.serviceType()).addContentLine("(),")
-                .addContent(String.valueOf(sl.weight()))
-                .addContentLine("));")
-                .decreaseContentPadding()
-                .decreaseContentPadding()
-                .decreaseContentPadding();
-    }
-
-    private Comparator<ServiceLoader__ServiceDescriptor> serviceLoaderComparator() {
-        return Comparator.comparing(ServiceLoader__ServiceDescriptor::providerInterface)
-                .thenComparing(ServiceDescriptor::serviceType);
-    }
-
-    private void handleError(CodegenException ce) {
-        if (failOnError) {
-            throw ce;
-        } else {
-            ctx.logger().log(ce.toEvent(System.Logger.Level.WARNING));
-        }
-    }
-}
diff --git a/service/inject/pom.xml b/service/inject/pom.xml
deleted file mode 100644
index 1d863c4a322..00000000000
--- a/service/inject/pom.xml
+++ /dev/null
@@ -1,45 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service</groupId>
-        <artifactId>helidon-service-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>io.helidon.service.inject</groupId>
-    <artifactId>helidon-service-inject-project</artifactId>
-    <name>Helidon Service Inject Project</name>
-    <packaging>pom</packaging>
-    <description>
-        Full injection support on top of service registry, and API to declare injection in services
-    </description>
-
-    <modules>
-        <module>codegen</module>
-        <module>api</module>
-        <module>inject</module>
-        <module>maven-plugin</module>
-    </modules>
-</project>
diff --git a/service/inject/maven-plugin/README.md b/service/maven-plugin/README.md
similarity index 95%
rename from service/inject/maven-plugin/README.md
rename to service/maven-plugin/README.md
index ca14faba7bc..fc8a79d5955 100644
--- a/service/inject/maven-plugin/README.md
+++ b/service/maven-plugin/README.md
@@ -15,7 +15,7 @@ This goal generates:
 
 Usage of this plugin goal is not required, yet it is recommended for final application module, it will add
 - binding for injection points, to avoid runtime lookups
-- explicit registration of all services into `InjectConfig`, to avoid resource lookup and reflection at runtime
+- explicit registration of all services into `ServiceRegistryConfig`, to avoid resource lookup and reflection at runtime
 - overall speedup of bootstrapping, as all the required tasks to start a service registry are code generated
 
 This goal should not be used for library modules (i.e. modules that do not have a Main class that bootstraps registry).
@@ -47,7 +47,7 @@ Configuration example in `pom.xml`:
 ```xml
 
 <plugin>
-    <groupId>io.helidon.service.inject</groupId>
+    <groupId>io.helidon.service.registry</groupId>
     <artifactId>helidon-service-inject-maven-plugin</artifactId>
     <executions>
         <execution>
diff --git a/service/inject/maven-plugin/etc/spotbugs/exclude.xml b/service/maven-plugin/etc/spotbugs/exclude.xml
similarity index 83%
rename from service/inject/maven-plugin/etc/spotbugs/exclude.xml
rename to service/maven-plugin/etc/spotbugs/exclude.xml
index e672fbdf494..f31710372a3 100644
--- a/service/inject/maven-plugin/etc/spotbugs/exclude.xml
+++ b/service/maven-plugin/etc/spotbugs/exclude.xml
@@ -24,18 +24,18 @@
 
     <Match>
         <!-- Path comes from config or code -->
-        <Class name="io.helidon.service.inject.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Class name="io.helidon.service.registry.maven.plugin.CreateApplicationAbstractMojo"/>
         <Bug pattern="PATH_TRAVERSAL_IN"/>
     </Match>
     <Match>
         <!-- Classpath is constructed from maven classpath -->
-        <Class name="io.helidon.service.inject.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Class name="io.helidon.service.registry.maven.plugin.CreateApplicationAbstractMojo"/>
         <Bug pattern="DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED"/>
     </Match>
 
     <Match>
         <!-- Path comes from config or code -->
-        <Class name="io.helidon.service.inject.maven.plugin.CreateTestApplicationMojo"/>
+        <Class name="io.helidon.service.maven.plugin.CreateTestApplicationMojo"/>
         <Bug pattern="PATH_TRAVERSAL_IN"/>
     </Match>
 </FindBugsFilter>
diff --git a/service/inject/maven-plugin/pom.xml b/service/maven-plugin/pom.xml
similarity index 91%
rename from service/inject/maven-plugin/pom.xml
rename to service/maven-plugin/pom.xml
index 7e320213b06..7ba10c76e78 100644
--- a/service/inject/maven-plugin/pom.xml
+++ b/service/maven-plugin/pom.xml
@@ -20,14 +20,14 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.inject</groupId>
-        <artifactId>helidon-service-inject-project</artifactId>
+        <groupId>io.helidon.service</groupId>
+        <artifactId>helidon-service-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-inject-maven-plugin</artifactId>
+    <artifactId>helidon-service-maven-plugin</artifactId>
     <name>Helidon Service Maven Plugin</name>
     <packaging>maven-plugin</packaging>
 
@@ -85,16 +85,16 @@
             <artifactId>helidon-service-codegen</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-codegen</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-codegen</artifactId>
         </dependency>
         <dependency>
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-metadata</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
         </dependency>
         <dependency>
             <groupId>io.helidon.codegen</groupId>
@@ -142,7 +142,7 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-plugin-plugin</artifactId>
                 <configuration>
-                    <goalPrefix>helidon-inject</goalPrefix>
+                    <goalPrefix>helidon-service</goalPrefix>
                     <skipErrorNoDescriptorsFound>false</skipErrorNoDescriptorsFound>
                 </configuration>
                 <executions>
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/ApplicationValidator.java
similarity index 87%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/ApplicationValidator.java
index e5545f21777..e2ad4699d7f 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/ApplicationValidator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/ApplicationValidator.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.lang.System.Logger.Level;
 import java.util.HashMap;
@@ -28,10 +28,10 @@
 import io.helidon.common.Errors;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.Dependency;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceInfo;
 
 class ApplicationValidator {
     private final MavenCodegenContext scanContext;
@@ -65,13 +65,13 @@ void validate(WrappedServices services) {
 
     private void validate(WrappedServices services, Errors.Collector collector) {
         // check all singletons, that they only contain injection points that are singletons, or have a supplier
-        List<InjectServiceInfo> requestScopedServices = services.all(Lookup.builder()
-                                                                             .addScope(Injection.PerRequest.TYPE)
-                                                                             .build());
+        List<ServiceInfo> requestScopedServices = services.all(Lookup.builder()
+                                                                       .addScope(Service.PerRequest.TYPE)
+                                                                       .build());
         Set<ResolvedType> requestScopedContracts = new HashSet<>();
         Map<ResolvedType, Set<TypeName>> requestScopedByContracts = new HashMap<>();
 
-        for (InjectServiceInfo requestScoped : requestScopedServices) {
+        for (ServiceInfo requestScoped : requestScopedServices) {
             TypeName serviceType = requestScoped.serviceType();
             Set<ResolvedType> contracts = requestScoped.contracts();
 
@@ -87,14 +87,14 @@ private void validate(WrappedServices services, Errors.Collector collector) {
             }
         }
 
-        List<InjectServiceInfo> singletons = services.all(Lookup.builder()
-                                                                  .addScope(Injection.Singleton.TYPE)
+        List<ServiceInfo> singletons = services.all(Lookup.builder()
+                                                                  .addScope(Service.Singleton.TYPE)
                                                                   .build());
 
         boolean requestScopeHinted = false;
 
-        for (InjectServiceInfo singleton : singletons) {
-            for (Ip dependency : singleton.dependencies()) {
+        for (ServiceInfo singleton : singletons) {
+            for (Dependency dependency : singleton.dependencies()) {
                 ResolvedType contract = ResolvedType.create(dependency.contract());
                 if (requestScopedContracts.contains(contract)) {
                     // this is an injection of request scope service into a singleton
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
similarity index 86%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
index 93f3ea286a6..abe97250e62 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/BindingGenerator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -42,23 +42,23 @@
 import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeName;
 import io.helidon.service.codegen.DescriptorClassCode;
-import io.helidon.service.codegen.GenerateServiceDescriptor;
 import io.helidon.service.codegen.HelidonMetaInfServices;
 import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.codegen.ServiceDescriptorCodegen;
 import io.helidon.service.metadata.DescriptorMetadata;
+import io.helidon.service.registry.Dependency;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.ServiceInfo;
 import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
 
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_CONTRACT;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_POINT_FACTORY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_BINDING;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_PLAN_BINDER;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_INSTANCE;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_BINDING;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_INJECTION_POINT_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_PLAN_BINDER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_SERVICE_INSTANCE;
 
 /**
  * The default implementation for {@link BindingGenerator}.
@@ -75,7 +75,7 @@ class BindingGenerator {
     }
 
     /**
-     * Generates the source and class file for {@code io.helidon.inject.Binding} using the current classpath.
+     * Generates the source and class file for {@code Binding} using the current classpath.
      *
      * @param injectionServices injection services to use
      * @param serviceTypes      types to process
@@ -117,7 +117,7 @@ void codegen(WrappedServices injectionServices,
                                                                typeName,
                                                                "1",
                                                                ""))
-                .addInterface(INJECT_BINDING);
+                .addInterface(SERVICE_BINDING);
 
         // deprecated default constructor - binding should always be service loaded
         classModel.addConstructor(ctr -> ctr
@@ -138,7 +138,7 @@ void codegen(WrappedServices injectionServices,
                 .addAnnotation(Annotation.create(SuppressWarnings.class, "deprecation"))
                 .addParameter(binderParam -> binderParam
                         .name("binder")
-                        .type(INJECT_PLAN_BINDER))
+                        .type(SERVICE_PLAN_BINDER))
                 .update(it -> createConfigureMethodBody(injectionServices,
                                                         serviceTypes,
                                                         it)));
@@ -149,11 +149,11 @@ void codegen(WrappedServices injectionServices,
         TypeInfo appTypeInfo = createAppTypeInfo(typeName);
         RegistryCodegenContext registryCodegenContext = RegistryCodegenContext.create(ctx);
         MavenRoundContext roundContext = new MavenRoundContext(ctx);
-        GenerateServiceDescriptor.generate(GENERATOR,
-                                           registryCodegenContext,
-                                           roundContext,
-                                           List.of(appTypeInfo),
-                                           appTypeInfo);
+        ServiceDescriptorCodegen descriptorCodegen = ServiceDescriptorCodegen.create(registryCodegenContext);
+        descriptorCodegen.service(GENERATOR,
+                                  roundContext,
+                                  List.of(appTypeInfo),
+                                  appTypeInfo);
 
         List<Path> toCompile = new ArrayList<>();
         toCompile.add(generated);
@@ -180,24 +180,24 @@ BindingPlan bindingPlan(WrappedServices services,
                             TypeName serviceTypeName) {
 
         Lookup lookup = toLookup(serviceTypeName);
-        InjectServiceInfo sp = services.get(lookup);
+        ServiceInfo sp = services.get(lookup);
         TypeName serviceDescriptorType = sp.descriptorType();
 
         if (!isQualifiedInjectionTarget(sp)) {
             return new BindingPlan(serviceDescriptorType, Set.of());
         }
 
-        List<Ip> dependencies = sp.dependencies();
+        List<Dependency> dependencies = sp.dependencies();
         if (dependencies.isEmpty()) {
             return new BindingPlan(serviceDescriptorType, Set.of());
         }
 
         Set<Binding> bindings = new LinkedHashSet<>();
-        for (Ip dependency : dependencies) {
+        for (Dependency dependency : dependencies) {
             InjectionPlan iPlan = injectionPlan(services, sp, dependency);
-            List<InjectServiceInfo> qualified = iPlan.qualifiedProviders();
-            List<InjectServiceInfo> unqualified = iPlan.unqualifiedProviders();
-            List<InjectServiceInfo> usedList;
+            List<ServiceInfo> qualified = iPlan.qualifiedProviders();
+            List<ServiceInfo> unqualified = iPlan.unqualifiedProviders();
+            List<ServiceInfo> usedList;
 
             if (qualified.isEmpty() && !unqualified.isEmpty()) {
                 usedList = unqualified;
@@ -212,8 +212,8 @@ BindingPlan bindingPlan(WrappedServices services,
         return new BindingPlan(serviceDescriptorType, bindings);
     }
 
-    private static Consumer<ContentBuilder<?>> toContentBuilder(InjectServiceInfo serviceInfo) {
-        if (serviceInfo.coreInfo() instanceof ServiceLoader__ServiceDescriptor sl) {
+    private static Consumer<ContentBuilder<?>> toContentBuilder(ServiceInfo serviceInfo) {
+        if (serviceInfo instanceof ServiceLoader__ServiceDescriptor sl) {
             // we need to create a specific descriptor for interface and implementation
             TypeName providerInterface = sl.providerInterface();
             TypeName providerImpl = sl.serviceType();
@@ -246,11 +246,11 @@ private static Lookup toLookup(TypeName typeName) {
      * @param sp the service provider
      * @return true if the service provider can receive injection
      */
-    private static boolean isQualifiedInjectionTarget(InjectServiceInfo sp) {
+    private static boolean isQualifiedInjectionTarget(ServiceInfo sp) {
         Set<ResolvedType> contractsImplemented = sp.contracts();
-        List<Ip> dependencies = sp.dependencies();
+        List<Dependency> dependencies = sp.dependencies();
 
-        if (contractsImplemented.contains(ResolvedType.create(INJECT_BINDING))) {
+        if (contractsImplemented.contains(ResolvedType.create(SERVICE_BINDING))) {
             return false;
         }
         boolean hasDependencies = !dependencies.isEmpty();
@@ -267,7 +267,7 @@ private TypeInfo createAppTypeInfo(TypeName typeName) {
                 .addAnnotation(Annotation.create(SERVICE_ANNOTATION_PROVIDER))
                 .addInterfaceTypeInfo(TypeInfo.builder()
                                               .kind(ElementKind.INTERFACE)
-                                              .typeName(INJECT_BINDING)
+                                              .typeName(SERVICE_BINDING)
                                               .addAnnotation(Annotation.create(SERVICE_ANNOTATION_CONTRACT))
                                               .build())
                 .build();
@@ -282,8 +282,8 @@ private void handleError(CodegenException ce) {
     }
 
     private InjectionPlan injectionPlan(WrappedServices services,
-                                        InjectServiceInfo self,
-                                        Ip dependency) {
+                                        ServiceInfo self,
+                                        Dependency dependency) {
         /*
          very similar code is used in ServiceManager.planForIp
          make sure this is kept in sync!
@@ -312,8 +312,8 @@ private InjectionPlan injectionPlan(WrappedServices services,
         4. an InjectionResolver, where the method resolve returns an information if this type can be resolved (config driven)
         */
 
-        List<InjectServiceInfo> qualifiedProviders = services.all(dependencyTo);
-        List<InjectServiceInfo> unqualifiedProviders;
+        List<ServiceInfo> qualifiedProviders = services.all(dependencyTo);
+        List<ServiceInfo> unqualifiedProviders;
 
         if (qualifiedProviders.isEmpty()) {
             unqualifiedProviders = injectionPointProvidersFor(services, dependency)
@@ -333,22 +333,22 @@ private InjectionPlan injectionPlan(WrappedServices services,
         return new InjectionPlan(unqualifiedProviders, qualifiedProviders);
     }
 
-    private List<InjectServiceInfo> injectionPointProvidersFor(WrappedServices services, Ip injectionPoint) {
+    private List<ServiceInfo> injectionPointProvidersFor(WrappedServices services, Dependency injectionPoint) {
         if (injectionPoint.qualifiers().isEmpty()) {
             return List.of();
         }
-        Lookup criteria = Lookup.builder(Lookup.create(injectionPoint))
+        Lookup lookup = Lookup.builder(Lookup.create(injectionPoint))
                 .qualifiers(Set.of()) // remove qualifier from lookup
-                .addContract(INJECTION_POINT_FACTORY) // only search for injection point providers
+                .addContract(SERVICE_INJECTION_POINT_FACTORY) // only search for injection point providers
                 .build();
-        return services.all(criteria);
+        return services.all(lookup);
     }
 
     private void createConfigureMethodBody(WrappedServices services,
                                            Set<TypeName> serviceTypes,
                                            Method.Builder method) {
         // find all interceptors and bind them
-        List<InjectServiceInfo> interceptors =
+        List<ServiceInfo> interceptors =
                 services.all(Lookup.builder()
                                      .addContract(Interception.Interceptor.class)
                                      .addQualifier(Qualifier.WILDCARD_NAMED)
@@ -360,7 +360,7 @@ private void createConfigureMethodBody(WrappedServices services,
                     .increaseContentPadding();
         }
 
-        Iterator<InjectServiceInfo> interceptorIterator = interceptors.iterator();
+        Iterator<ServiceInfo> interceptorIterator = interceptors.iterator();
         while (interceptorIterator.hasNext()) {
             method.addContent(interceptorIterator.next().descriptorType())
                     .addContent(".INSTANCE");
@@ -400,9 +400,9 @@ private void createConfigureMethodBody(WrappedServices services,
 
             for (Binding binding : bindings) {
                 Consumer<ContentBuilder<?>> ipId = content -> content
-                        .addContent(binding.injectionPoint().descriptor().genericTypeName())
+                        .addContent(binding.dependency().descriptor().genericTypeName())
                         .addContent(".")
-                        .addContent(binding.injectionPoint.descriptorConstant());
+                        .addContent(binding.dependency.descriptorConstant());
 
                 buildTimeBinding(method, binding, ipId, supportNulls);
             }
@@ -426,8 +426,8 @@ private void buildTimeBinding(Method.Builder method,
                                   Consumer<ContentBuilder<?>> ipId,
                                   boolean supportNulls) {
 
-        Ip injectionPoint = binding.injectionPoint();
-        List<InjectServiceInfo> discovered = binding.descriptors();
+        Dependency injectionPoint = binding.dependency();
+        List<ServiceInfo> discovered = binding.descriptors();
         Iterator<Consumer<ContentBuilder<?>>> descriptors = discovered.stream()
                 .map(BindingGenerator::toContentBuilder)
                 .iterator();
@@ -440,7 +440,7 @@ private void buildTimeBinding(Method.Builder method,
             if (typeOfList.isSupplier()) {
                 // inject List<Supplier<Contract>>
                 method.addContent(".bindListOfSuppliers(");
-            } else if (typeOfList.equals(INJECT_SERVICE_INSTANCE)) {
+            } else if (typeOfList.equals(SERVICE_SERVICE_INSTANCE)) {
                 method.addContent(".bindServiceInstanceList(");
             } else {
                 // inject List<Contract>
@@ -467,7 +467,7 @@ private void buildTimeBinding(Method.Builder method,
             if (typeOfOptional.isSupplier()) {
                 // inject Optional<Supplier<Contract>>
                 method.addContent(".bindOptionalOfSupplier(");
-            } else if (typeOfOptional.equals(INJECT_SERVICE_INSTANCE)) {
+            } else if (typeOfOptional.equals(SERVICE_SERVICE_INSTANCE)) {
                 // inject Optional<ServiceInstance<Contract>>
                 method.addContent(".bindOptionalOfServiceInstance(");
             } else {
@@ -530,7 +530,7 @@ private void buildTimeBinding(Method.Builder method,
                 descriptors.next().accept(method);
                 method.addContentLine(")");
             }
-        } else if (ipType.equals(INJECT_SERVICE_INSTANCE)) {
+        } else if (ipType.equals(SERVICE_SERVICE_INSTANCE)) {
             // inject Contract
             if (discovered.isEmpty()) {
                 if (supportNulls) {
@@ -571,8 +571,8 @@ private void buildTimeBinding(Method.Builder method,
         }
     }
 
-    record InjectionPlan(List<InjectServiceInfo> unqualifiedProviders,
-                         List<InjectServiceInfo> qualifiedProviders) {
+    record InjectionPlan(List<ServiceInfo> unqualifiedProviders,
+                         List<ServiceInfo> qualifiedProviders) {
     }
 
     record BindingPlan(TypeName descriptorType,
@@ -580,10 +580,10 @@ record BindingPlan(TypeName descriptorType,
     }
 
     /**
-     * @param injectionPoint to bind to
+     * @param dependency to bind to
      * @param descriptors    matching descriptors
      */
-    record Binding(Ip injectionPoint,
-                   List<InjectServiceInfo> descriptors) {
+    record Binding(Dependency dependency,
+                   List<ServiceInfo> descriptors) {
     }
 }
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CodegenAbstractMojo.java
similarity index 96%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CodegenAbstractMojo.java
index 2a1ac7f0f59..96aff4c867d 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CodegenAbstractMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CodegenAbstractMojo.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.util.List;
 import java.util.Optional;
@@ -34,12 +34,12 @@ abstract class CodegenAbstractMojo extends AbstractMojo {
     /**
      * Tag controlling whether we fail on error.
      */
-    static final String TAG_FAIL_ON_ERROR = "helidon.inject.fail-on-error";
+    static final String TAG_FAIL_ON_ERROR = "helidon.service.registry.fail-on-error";
 
     /**
      * Tag controlling whether we fail on warnings.
      */
-    static final String TAG_FAIL_ON_WARNING = "helidon.inject.fail-on-warning";
+    static final String TAG_FAIL_ON_WARNING = "helidon.service.registry.fail-on-warning";
 
     // ----------------------------------------------------------------------
     // Configurables
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
similarity index 87%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
index 144e26b9d24..0b1f348c1de 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationAbstractMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.IOException;
 import java.net.MalformedURLException;
@@ -44,8 +44,7 @@
 import io.helidon.codegen.ModuleInfoSourceParser;
 import io.helidon.codegen.compiler.CompilerOptions;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.codegen.ApplicationMainGenerator;
+import io.helidon.service.registry.ServiceInfo;
 
 import io.github.classgraph.ClassGraph;
 import io.github.classgraph.ScanResult;
@@ -62,12 +61,6 @@ abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
      * Class name of the binding class generated by Maven plugin (for end user application).
      */
     protected static final String BINDING_CLASS_NAME = "Injection__Binding";
-    /**
-     * Name of the generated main class.
-     */
-    @Parameter(property = "helidon.inject.application.main.class.name",
-               defaultValue = ApplicationMainGenerator.CLASS_NAME)
-    private String mainClassName;
     /**
      * The -source argument for the Java compiler.
      * Note: using the same as maven-compiler for convenience and least astonishment.
@@ -78,13 +71,13 @@ abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
     /**
      * Whether to validate the application when creating its bindings.
      */
-    @Parameter(property = "helidon.inject.application.validate",
+    @Parameter(property = "helidon.service.registry.validate",
                defaultValue = "true")
     private boolean validate;
     /**
      * Whether to generate binding class (provides generated injection plan for all services).
      */
-    @Parameter(property = "helidon.inject.application.binding.generate",
+    @Parameter(property = "helidon.service.registry.binding.generate",
                defaultValue = "true")
     private boolean generateBinding;
 
@@ -151,38 +144,11 @@ void innerExecute() {
                                compilerOptions,
                                moduleName,
                                packageName);
-
-            if (createMain()) {
-                // we need to re-create the classloader, as we have created new classes for binding
-                loader = createClassLoader(classpath, prev);
-                createMain(loader,
-                           mavenLogger,
-                           scanContext,
-                           compilerOptions,
-                           packageName);
-            }
         } finally {
             Thread.currentThread().setContextClassLoader(prev);
         }
     }
 
-    void createMain(ClassLoader loader,
-                    MavenLogger mavenLogger,
-                    MavenCodegenContext scanContext,
-                    CompilerOptions compilerOptions,
-                    String packageName) {
-        try (WrappedServices services = WrappedServices.create(loader, mavenLogger, false)) {
-            createMainClass(compilerOptions,
-                            scanContext,
-                            services,
-                            packageName);
-        } catch (CodegenException e) {
-            throw e;
-        } catch (Exception e) {
-            throw new CodegenException("An error occurred creating the main class in " + getClass().getName(), e);
-        }
-    }
-
     void applicationBinding(ClassLoader loader,
                             MavenLogger mavenLogger,
                             MavenCodegenContext scanContext,
@@ -202,21 +168,6 @@ void applicationBinding(ClassLoader loader,
         }
     }
 
-    void createMainClass(CompilerOptions compilerOptions,
-                         MavenCodegenContext scanContext,
-                         WrappedServices services,
-                         String packageName) {
-        TypeName generatedType = TypeName.builder()
-                .packageName(packageName)
-                .className(mainClassName)
-                .build();
-
-        getLog().info("Generating application main class: " + generatedType.fqName());
-
-        MainClassCreator creator = new MainClassCreator(scanContext, failOnError());
-        creator.create(scanContext, compilerOptions, services, generatedType);
-    }
-
     void applicationBinding(MavenCodegenContext scanContext,
                             WrappedServices services,
                             CompilerOptions compilerOptions,
@@ -226,7 +177,7 @@ void applicationBinding(MavenCodegenContext scanContext,
         // retrieves all the services in the registry
         Set<TypeName> allServices = services.all()
                 .stream()
-                .map(InjectServiceInfo::serviceType)
+                .map(ServiceInfo::serviceType)
                 .collect(Collectors.toCollection(TreeSet::new));
 
         if (allServices.isEmpty()) {
@@ -281,8 +232,6 @@ void applicationBinding(MavenCodegenContext scanContext,
      */
     abstract Path outputDirectory();
 
-    abstract boolean createMain();
-
     /**
      * Source roots for this {@link #scope()}.
      *
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationMojo.java
similarity index 83%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationMojo.java
index a6bedc507cc..3f3ad8c07b1 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateApplicationMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationMojo.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.File;
 import java.nio.file.Path;
@@ -48,18 +48,10 @@ public class CreateApplicationMojo extends CreateApplicationAbstractMojo {
     @Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
     private File outputDirectory;
 
-    /**
-     * Whether to generate main class. Default name is {@code ApplicationMain} in the same package as
-     * the generated application.
-     */
-    @Parameter(property = "helidon.inject.application.main.generate",
-               defaultValue = "true")
-    private boolean generateMain;
-
     /**
      * Name of the generated binding class.
      */
-    @Parameter(property = "helidon.inject.application.binding.class.name",
+    @Parameter(property = "helidon.service.registry.binding.class.name",
                defaultValue = BINDING_CLASS_NAME)
     private String bindingClassName;
 
@@ -88,9 +80,4 @@ protected CodegenScope scope() {
     String bindingClassName() {
         return bindingClassName;
     }
-
-    @Override
-    boolean createMain() {
-        return generateMain;
-    }
 }
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
similarity index 94%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
index 637ef1f1ea3..23c067462b3 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/CreateTestApplicationMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.File;
 import java.nio.file.Path;
@@ -42,7 +42,7 @@ public class CreateTestApplicationMojo extends CreateApplicationAbstractMojo {
     /**
      * Name of the generated binding class.
      */
-    @Parameter(property = "helidon.inject.application.binding.classname",
+    @Parameter(property = "helidon.service.registry.binding.classname",
                defaultValue = "Test" + BINDING_CLASS_NAME)
     private String bindingClassName;
 
@@ -106,9 +106,4 @@ protected String bindingClassName() {
     protected CodegenScope scope() {
         return new CodegenScope("test");
     }
-
-    @Override
-    boolean createMain() {
-        return false;
-    }
 }
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenCodegenContext.java
similarity index 98%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenCodegenContext.java
index f5bffbf0b37..96463aa4a43 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenCodegenContext.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenCodegenContext.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.nio.file.Path;
 import java.util.Optional;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFiler.java
similarity index 99%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFiler.java
index 1de4e40a56b..9ac6aaa9dc1 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFiler.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFiler.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.IOException;
 import java.io.OutputStream;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerResource.java
similarity index 97%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerResource.java
index 284ea4ab585..80069be6d2c 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerResource.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerResource.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.IOException;
 import java.nio.file.Files;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerTextResource.java
similarity index 97%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerTextResource.java
index 14a0cbcf7ca..dfbf50157c7 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenFilerTextResource.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenFilerTextResource.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.io.IOException;
 import java.nio.file.Files;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenLogger.java
similarity index 98%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenLogger.java
index 334cbb958ad..723ab07eb0c 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenLogger.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenLogger.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.util.List;
 import java.util.Optional;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenOptions.java
similarity index 98%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenOptions.java
index eb393e30fa0..3c1b1ff1f64 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenOptions.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenOptions.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
similarity index 98%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
index 23cfa7802ee..0f54f311245 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/MavenRoundContext.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/WrappedServices.java
similarity index 79%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/WrappedServices.java
index 20bebf70b01..c09ff4d92be 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/WrappedServices.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/WrappedServices.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
 
 import java.lang.System.Logger.Level;
 import java.util.List;
@@ -22,13 +22,13 @@
 import io.helidon.codegen.CodegenEvent;
 import io.helidon.codegen.CodegenException;
 import io.helidon.codegen.CodegenLogger;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.ActivationPhase;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.ServiceInfo;
 
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY;
-import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY_MANAGER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_CONFIG;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_REGISTRY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_REGISTRY_MANAGER;
 
 class WrappedServices implements AutoCloseable {
     private final ClassLoader classLoader;
@@ -58,31 +58,31 @@ static WrappedServices create(ClassLoader classLoader, CodegenLogger logger, boo
             Phase.GATHERING_DEPENDENCIES
              */
 
-            Activator.Phase limitPhase = Activator.Phase.ACTIVATION_STARTING;
+            ActivationPhase limitPhase = ActivationPhase.ACTIVATION_STARTING;
 
             /*
             InjectionConfig.builder()....build();
              */
-            Class<?> injectConfigType = classLoader.loadClass(INJECT_CONFIG.fqName());
+            Class<?> injectConfigType = classLoader.loadClass(SERVICE_CONFIG.fqName());
             Object injectConfigBuilder = injectConfigType.getMethod("builder")
                     .invoke(null);
             Class<?> injectConfigBuilderType = injectConfigBuilder.getClass();
 
             injectConfigBuilderType.getMethod("useBinding", boolean.class)
                     .invoke(injectConfigBuilder, useBindings);
-            injectConfigBuilderType.getMethod("limitRuntimePhase", Activator.Phase.class)
+            injectConfigBuilderType.getMethod("limitActivationPhase", ActivationPhase.class)
                     .invoke(injectConfigBuilder, limitPhase);
             Object injectionConfig = injectConfigBuilderType.getMethod("build")
                     .invoke(injectConfigBuilder);
 
             /*
-            InjectRegistryManager registryManager = InjectRegistryManager.create(injectionConfig)
-            InjectRegistry services = injectionServices.registry();
+            ServiceRegistryManager registryManager = ServiceRegistryManager.create(injectionConfig)
+            ServiceRegistry services = injectionServices.registry();
              */
-            Class<?> injectionServicesType = classLoader.loadClass(INJECT_REGISTRY_MANAGER.fqName());
+            Class<?> injectionServicesType = classLoader.loadClass(SERVICE_REGISTRY_MANAGER.fqName());
             Object injectionServices = injectionServicesType.getMethod("create", injectConfigType)
                     .invoke(null, injectionConfig);
-            Class<?> servicesType = classLoader.loadClass(INJECT_REGISTRY.fqName());
+            Class<?> servicesType = classLoader.loadClass(SERVICE_REGISTRY.fqName());
             Object services = injectionServicesType.getMethod("registry")
                     .invoke(injectionServices);
 
@@ -113,23 +113,23 @@ public void close() {
         }
     }
 
-    List<InjectServiceInfo> all() {
+    List<ServiceInfo> all() {
         return all(Lookup.EMPTY);
     }
 
     @SuppressWarnings("unchecked")
-    List<InjectServiceInfo> all(Lookup lookup) {
+    List<ServiceInfo> all(Lookup lookup) {
         try {
             // retrieves all the services in the registry
-            return (List<InjectServiceInfo>) servicesType.getMethod("lookupServices", Lookup.class)
+            return (List<ServiceInfo>) servicesType.getMethod("lookupServices", Lookup.class)
                     .invoke(services, lookup);
         } catch (ReflectiveOperationException e) {
             throw new CodegenException("Failed to get providers from service registry using reflection", e);
         }
     }
 
-    InjectServiceInfo get(Lookup lookup) {
-        List<InjectServiceInfo> services = all(lookup);
+    ServiceInfo get(Lookup lookup) {
+        List<ServiceInfo> services = all(lookup);
         if (services.size() == 1) {
             return services.getFirst();
         }
diff --git a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/package-info.java
similarity index 95%
rename from service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java
rename to service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/package-info.java
index 1f616eb568e..4fc38922107 100644
--- a/service/inject/maven-plugin/src/main/java/io/helidon/service/inject/maven/plugin/package-info.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/package-info.java
@@ -23,4 +23,4 @@
  * The plugin generates application binding (mapping of services to injection points they satisfy), and application main class
  * to avoid lookups (binding), and reflection and resources discovery from classpath (main class).
  */
-package io.helidon.service.inject.maven.plugin;
+package io.helidon.service.maven.plugin;
diff --git a/service/inject/maven-plugin/src/main/java/module-info.java b/service/maven-plugin/src/main/java/module-info.java
similarity index 75%
rename from service/inject/maven-plugin/src/main/java/module-info.java
rename to service/maven-plugin/src/main/java/module-info.java
index 2922be8f334..3df603e438f 100644
--- a/service/inject/maven-plugin/src/main/java/module-info.java
+++ b/service/maven-plugin/src/main/java/module-info.java
@@ -15,19 +15,14 @@
  */
 
 /**
- * Injection maven-plugin module.
+ * Maven-plugin module for code generating service registry components that require full runtime classpath.
  */
-module io.helidon.service.inject.maven.plugin {
+module io.helidon.service.maven.plugin {
 
-    requires io.helidon.builder.api;
-    requires io.helidon.common;
-    requires io.helidon.common.config;
     requires io.helidon.codegen;
     requires io.helidon.codegen.scan;
     requires io.helidon.codegen.compiler;
     requires io.helidon.service.codegen;
-    requires io.helidon.service.inject.codegen;
-    requires io.helidon.service.inject.api;
 
     requires maven.artifact;
     requires maven.model;
@@ -36,7 +31,8 @@
     requires maven.project;
     requires java.xml;
     requires io.github.classgraph;
+    requires io.helidon.service.registry;
     requires io.helidon.service.metadata;
 
-    exports io.helidon.service.inject.maven.plugin;
+    exports io.helidon.service.maven.plugin;
 }
diff --git a/service/pom.xml b/service/pom.xml
index dc67f7c9624..a3da5ea1e66 100644
--- a/service/pom.xml
+++ b/service/pom.xml
@@ -45,7 +45,8 @@
         <module>metadata</module>
         <module>codegen</module>
         <module>registry</module>
-        <module>inject</module>
+        <module>maven-plugin</module>
+        <module>builder</module>
     </modules>
 
     <build>
diff --git a/service/registry/pom.xml b/service/registry/pom.xml
index 3d79f5592f5..0578105289b 100644
--- a/service/registry/pom.xml
+++ b/service/registry/pom.xml
@@ -30,8 +30,8 @@
     <artifactId>helidon-service-registry</artifactId>
     <name>Helidon Service Registry</name>
     <description>
-        Service registry (a replacement for service loader that allows dependencies on other services),
-        and API necessary to declare services.
+        Service registry (a replacement for service loader that allows dependencies on other services), and API necessary to
+        declare services.
     </description>
 
     <properties>
@@ -51,10 +51,6 @@
             <groupId>io.helidon.builder</groupId>
             <artifactId>helidon-builder-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.metadata</groupId>
             <artifactId>helidon-metadata-hson</artifactId>
@@ -93,13 +89,13 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.common.features</groupId>
-                            <artifactId>helidon-common-features-processor</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.config.metadata</groupId>
-                            <artifactId>helidon-config-metadata-codegen</artifactId>
+                            <groupId>io.helidon.common.features</groupId>
+                            <artifactId>helidon-common-features-processor</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                     </annotationProcessorPaths>
@@ -126,8 +122,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.config.metadata</groupId>
-                        <artifactId>helidon-config-metadata-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                 </dependencies>
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ActivationPhase.java b/service/registry/src/main/java/io/helidon/service/registry/ActivationPhase.java
new file mode 100644
index 00000000000..8d89794a7ef
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/ActivationPhase.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.registry;
+
+/**
+ * Progression of activation of a managed service instance.
+ */
+public enum ActivationPhase {
+    /**
+     * Starting state before anything happens activation-wise. Service registry is aware.
+     * Initialization may be done here.
+     */
+    INIT(false),
+    /**
+     * Starting to be activated.
+     */
+    ACTIVATION_STARTING(true),
+    /**
+     * Constructing.
+     */
+    CONSTRUCTING(true),
+
+    /**
+     * Injecting (fields then methods).
+     */
+    INJECTING(true),
+
+    /**
+     * Calling any post construct method.
+     */
+    POST_CONSTRUCTING(true),
+    /**
+     * Finishing post construct method.
+     */
+    ACTIVATION_FINISHING(true),
+    /**
+     * Service is active.
+     */
+    ACTIVE(true),
+    /**
+     * About to call pre-destroy.
+     */
+    PRE_DESTROYING(true),
+    /**
+     * Destroyed (after calling any pre-destroy).
+     * This is a final state.
+     */
+    DESTROYED(false);
+    /**
+     * True if this phase is eligible for deactivation/shutdown.
+     */
+    private final boolean eligibleForDeactivation;
+
+    ActivationPhase(boolean eligibleForDeactivation) {
+        this.eligibleForDeactivation = eligibleForDeactivation;
+    }
+
+    /**
+     * Determines whether this phase passes the gate for whether deactivation (PreDestroy) can be called.
+     *
+     * @return true if this phase is eligible to be included in shutdown processing
+     * @see io.helidon.service.registry.ServiceRegistryManager#shutdown()
+     */
+    boolean eligibleForDeactivation() {
+        return eligibleForDeactivation;
+    }
+}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationRequestBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/ActivationRequestBlueprint.java
similarity index 86%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationRequestBlueprint.java
rename to service/registry/src/main/java/io/helidon/service/registry/ActivationRequestBlueprint.java
index 7469ef6515e..644bffec4f0 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationRequestBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ActivationRequestBlueprint.java
@@ -14,13 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Optional;
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
-import io.helidon.service.inject.api.Activator.Phase;
 
 /**
  * Request to activate a service.
@@ -32,16 +31,16 @@ interface ActivationRequestBlueprint {
      *
      * @return phase to start
      */
-    Optional<Phase> startingPhase();
+    Optional<ActivationPhase> startingPhase();
 
     /**
      * Ultimate target phase for activation.
      * <p>
-     * Defaults to {@link Activator.Phase#ACTIVE}, unless configured otherwise (in the registry).
+     * Defaults to {@link ActivationPhase#ACTIVE}, unless configured otherwise (in the registry).
      *
      * @return phase to target
      */
-    Phase targetPhase();
+    ActivationPhase targetPhase();
 
     /**
      * Whether to throw an exception on failure to activate, or return an error activation result on activation.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationResultBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/ActivationResultBlueprint.java
similarity index 90%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationResultBlueprint.java
rename to service/registry/src/main/java/io/helidon/service/registry/ActivationResultBlueprint.java
index 7f58f1bdd1f..bec68eb5895 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/ActivationResultBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ActivationResultBlueprint.java
@@ -14,13 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Optional;
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
-import io.helidon.service.inject.api.Activator.Phase;
 
 /**
  * Represents the result of a service activation or deactivation.
@@ -36,7 +35,7 @@ interface ActivationResultBlueprint {
      * @return the starting phase
      */
     @Option.Default("INIT")
-    Phase startingActivationPhase();
+    ActivationPhase startingActivationPhase();
 
     /**
      * The activation phase that was requested at the onset of the phase transition.
@@ -44,14 +43,14 @@ interface ActivationResultBlueprint {
      * @return the target, desired, ultimate phase requested
      */
     @Option.Default("INIT")
-    Phase targetActivationPhase();
+    ActivationPhase targetActivationPhase();
 
     /**
      * The activation phase we finished successfully on, or are otherwise currently in if not yet finished.
      *
      * @return the finishing phase
      */
-    Phase finishingActivationPhase();
+    ActivationPhase finishingActivationPhase();
 
     /**
      * Any throwable/exceptions that were observed during activation.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Activator.java b/service/registry/src/main/java/io/helidon/service/registry/Activator.java
similarity index 50%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Activator.java
rename to service/registry/src/main/java/io/helidon/service/registry/Activator.java
index 446ceefa489..ca965279bd1 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Activator.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Activator.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Optional;
@@ -30,7 +30,7 @@ public interface Activator<T> {
      *
      * @return service descriptor
      */
-    InjectServiceDescriptor<T> descriptor();
+    ServiceDescriptor<T> descriptor();
 
     /**
      * Get instances from this managed service.
@@ -39,7 +39,7 @@ public interface Activator<T> {
      * @param lookup lookup to help with narrowing down the instances
      * @return empty optional if an instance is not available, supplier of qualified instances otherwise
      */
-    Optional<List<Injection.QualifiedInstance<T>>> instances(Lookup lookup);
+    Optional<List<Service.QualifiedInstance<T>>> instances(Lookup lookup);
 
     /**
      * Activate a managed service/factory.
@@ -52,7 +52,7 @@ public interface Activator<T> {
     /**
      * Deactivate a managed service. This will trigger any {@link io.helidon.service.registry.Service.PreDestroy}
      * method on the underlying service instance. The service will reach terminal
-     * {@link Activator.Phase#DESTROYED} phase, regardless of result of this call.
+     * {@link ActivationPhase#DESTROYED} phase, regardless of result of this call.
      *
      * @return the result of deactivation
      */
@@ -63,7 +63,7 @@ public interface Activator<T> {
      *
      * @return phase of this activator
      */
-    Phase phase();
+    ActivationPhase phase();
 
     /**
      * Description of this activator, including the current phase.
@@ -71,69 +71,4 @@ public interface Activator<T> {
      * @return description of this activator
      */
     String description();
-
-    /**
-     * Progression of activation of a managed service instance (each service may have more than one managed instance, depending on
-     * its scope).
-     */
-    enum Phase {
-        /**
-         * Starting state before anything happens activation-wise. Service registry is aware.
-         * Initialization may be done here.
-         */
-        INIT(false),
-        /**
-         * Starting to be activated.
-         */
-        ACTIVATION_STARTING(true),
-        /**
-         * Constructing.
-         */
-        CONSTRUCTING(true),
-
-        /**
-         * Injecting (fields then methods).
-         */
-        INJECTING(true),
-
-        /**
-         * Calling any post construct method.
-         */
-        POST_CONSTRUCTING(true),
-        /**
-         * Finishing post construct method.
-         */
-        ACTIVATION_FINISHING(true),
-        /**
-         * Service is active.
-         */
-        ACTIVE(true),
-        /**
-         * About to call pre-destroy.
-         */
-        PRE_DESTROYING(true),
-        /**
-         * Destroyed (after calling any pre-destroy).
-         * This is a final state.
-         */
-        DESTROYED(false);
-        /**
-         * True if this phase is eligible for deactivation/shutdown.
-         */
-        private final boolean eligibleForDeactivation;
-
-        Phase(boolean eligibleForDeactivation) {
-            this.eligibleForDeactivation = eligibleForDeactivation;
-        }
-
-        /**
-         * Determines whether this phase passes the gate for whether deactivation (PreDestroy) can be called.
-         *
-         * @return true if this phase is eligible to be included in shutdown processing
-         * @see io.helidon.service.registry.ServiceRegistryManager#shutdown()
-         */
-        public boolean eligibleForDeactivation() {
-            return eligibleForDeactivation;
-        }
-    }
 }
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/Activators.java b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
similarity index 85%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/Activators.java
rename to service/registry/src/main/java/io/helidon/service/registry/Activators.java
index 85cdd416bf2..550be405da1 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/Activators.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -34,26 +34,11 @@
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
-import io.helidon.service.inject.api.ActivationRequest;
-import io.helidon.service.inject.api.ActivationResult;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.GeneratedInjectService.PerInstanceDescriptor;
-import io.helidon.service.inject.api.GeneratedInjectService.QualifiedFactoryDescriptor;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.InjectionPointFactory;
-import io.helidon.service.inject.api.Injection.QualifiedFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
+import io.helidon.service.registry.GeneratedService.PerInstanceDescriptor;
+import io.helidon.service.registry.GeneratedService.QualifiedFactoryDescriptor;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.Service.QualifiedFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
 import static java.util.function.Predicate.not;
 
@@ -64,7 +49,7 @@
 /**
  * Activator types for various types the users can implement, for real scopes (singleton, request scope).
  *
- * @see io.helidon.service.inject.ActivatorsPerLookup
+ * @see io.helidon.service.registry.ActivatorsPerLookup
  */
 @SuppressWarnings("checkstyle:VisibilityModifier") // as long as all are inner classes, this is OK
 final class Activators {
@@ -81,16 +66,16 @@ static <T> Activator<T> create(ServiceProvider<T> provider, T instance) {
                     yield new Activators.FixedActivator<>(provider, instance);
                 }
             }
-            case SERVICES -> new Activators.FixedServicesFactoryActivator<>(provider, (Injection.ServicesFactory<T>) instance);
+            case SERVICES -> new Activators.FixedServicesFactoryActivator<>(provider, (Service.ServicesFactory<T>) instance);
             case INJECTION_POINT -> new Activators.FixedIpFactoryActivator<>(provider, (InjectionPointFactory<T>) instance);
             case QUALIFIED -> new Activators.FixedQualifiedFactoryActivator<>(provider, (QualifiedFactory<T, ?>) instance);
         };
     }
 
-    static <T> Supplier<Activator<T>> create(InjectServiceRegistryImpl registry, ServiceProvider<T> provider) {
-        InjectServiceDescriptor<T> descriptor = provider.descriptor();
+    static <T> Supplier<Activator<T>> create(CoreServiceRegistry registry, ServiceProvider<T> provider) {
+        ServiceDescriptor<T> descriptor = provider.descriptor();
 
-        if (descriptor.scope().equals(Injection.PerLookup.TYPE)) {
+        if (descriptor.scope().equals(Service.PerLookup.TYPE)) {
             return switch (descriptor.factoryType()) {
                 case NONE -> new MissingDescribedActivator<>(provider);
                 case SERVICE -> {
@@ -129,7 +114,7 @@ abstract static class BaseActivator<T> implements Activator<T> {
         final ServiceProvider<T> provider;
         private final ReadWriteLock instanceLock = new ReentrantReadWriteLock();
 
-        volatile Phase currentPhase = Phase.INIT;
+        volatile ActivationPhase currentPhase = ActivationPhase.INIT;
 
         BaseActivator(ServiceProvider<T> provider) {
             this.provider = provider;
@@ -148,7 +133,7 @@ public Optional<List<QualifiedInstance<T>>> instances(Lookup lookup) {
              */
             instanceLock.readLock().lock();
             try {
-                if (currentPhase == Phase.ACTIVE) {
+                if (currentPhase == ActivationPhase.ACTIVE) {
                     return targetInstances(lookup);
                 }
             } finally {
@@ -157,7 +142,7 @@ public Optional<List<QualifiedInstance<T>>> instances(Lookup lookup) {
 
             instanceLock.writeLock().lock();
             try {
-                if (currentPhase != Phase.ACTIVE) {
+                if (currentPhase != ActivationPhase.ACTIVE) {
                     ActivationResult res = activate(provider.activationRequest());
                     if (res.failure()) {
                         return Optional.empty();
@@ -170,7 +155,7 @@ public Optional<List<QualifiedInstance<T>>> instances(Lookup lookup) {
         }
 
         @Override
-        public InjectServiceDescriptor<T> descriptor() {
+        public ServiceDescriptor<T> descriptor() {
             return provider.descriptor();
         }
 
@@ -218,18 +203,18 @@ public ActivationResult deactivate() {
                         .success(true);
 
                 if (!currentPhase.eligibleForDeactivation()) {
-                    stateTransitionStart(response, Phase.DESTROYED);
+                    stateTransitionStart(response, ActivationPhase.DESTROYED);
                     return ActivationResult.builder()
-                            .targetActivationPhase(Phase.DESTROYED)
+                            .targetActivationPhase(ActivationPhase.DESTROYED)
                             .finishingActivationPhase(currentPhase)
                             .success(true)
                             .build();
                 }
 
                 response.startingActivationPhase(this.currentPhase);
-                stateTransitionStart(response, Phase.PRE_DESTROYING);
+                stateTransitionStart(response, ActivationPhase.PRE_DESTROYING);
                 preDestroy(response);
-                stateTransitionStart(response, Phase.DESTROYED);
+                stateTransitionStart(response, ActivationPhase.DESTROYED);
 
                 return response.build();
             } finally {
@@ -238,7 +223,7 @@ public ActivationResult deactivate() {
         }
 
         @Override
-        public Phase phase() {
+        public ActivationPhase phase() {
             return currentPhase;
         }
 
@@ -309,17 +294,17 @@ protected boolean requestedProvider(Lookup lookup, FactoryType providerType) {
             return false;
         }
 
-        private void stateTransitionStart(ActivationResult.Builder res, Phase phase) {
+        private void stateTransitionStart(ActivationResult.Builder res, ActivationPhase phase) {
             res.finishingActivationPhase(phase);
             this.currentPhase = phase;
         }
 
         private ActivationResult doActivate(ActivationRequest request) {
-            Phase initialPhase = this.currentPhase;
-            Phase startingPhase = request.startingPhase().orElse(initialPhase);
-            Phase targetPhase = request.targetPhase();
+            ActivationPhase initialPhase = this.currentPhase;
+            ActivationPhase startingPhase = request.startingPhase().orElse(initialPhase);
+            ActivationPhase targetPhase = request.targetPhase();
             this.currentPhase = startingPhase;
-            Phase finishingPhase = startingPhase;
+            ActivationPhase finishingPhase = startingPhase;
 
             ActivationResult.Builder response = ActivationResult.builder()
                     .startingActivationPhase(initialPhase)
@@ -327,48 +312,48 @@ private ActivationResult doActivate(ActivationRequest request) {
                     .targetActivationPhase(targetPhase)
                     .success(true);
 
-            if (targetPhase.ordinal() > Phase.ACTIVATION_STARTING.ordinal()
-                    && initialPhase == Phase.INIT) {
-                if (Phase.INIT == startingPhase
-                        || Phase.ACTIVATION_STARTING == startingPhase
-                        || Phase.DESTROYED == startingPhase) {
-                    stateTransitionStart(response, Phase.ACTIVATION_STARTING);
+            if (targetPhase.ordinal() > ActivationPhase.ACTIVATION_STARTING.ordinal()
+                    && initialPhase == ActivationPhase.INIT) {
+                if (ActivationPhase.INIT == startingPhase
+                        || ActivationPhase.ACTIVATION_STARTING == startingPhase
+                        || ActivationPhase.DESTROYED == startingPhase) {
+                    stateTransitionStart(response, ActivationPhase.ACTIVATION_STARTING);
                 }
             }
 
             finishingPhase = response.finishingActivationPhase().orElse(finishingPhase);
-            if (response.targetActivationPhase().ordinal() >= Phase.CONSTRUCTING.ordinal()) {
-                stateTransitionStart(response, Phase.CONSTRUCTING);
+            if (response.targetActivationPhase().ordinal() >= ActivationPhase.CONSTRUCTING.ordinal()) {
+                stateTransitionStart(response, ActivationPhase.CONSTRUCTING);
                 construct(response);
             }
 
             finishingPhase = response.finishingActivationPhase().orElse(finishingPhase);
-            if (response.targetActivationPhase().ordinal() >= Phase.INJECTING.ordinal()
-                    && (Phase.CONSTRUCTING == finishingPhase)) {
-                stateTransitionStart(response, Phase.INJECTING);
+            if (response.targetActivationPhase().ordinal() >= ActivationPhase.INJECTING.ordinal()
+                    && (ActivationPhase.CONSTRUCTING == finishingPhase)) {
+                stateTransitionStart(response, ActivationPhase.INJECTING);
                 inject(response);
             }
 
             finishingPhase = response.finishingActivationPhase().orElse(finishingPhase);
-            if (response.targetActivationPhase().ordinal() >= Phase.POST_CONSTRUCTING.ordinal()
-                    && (Phase.INJECTING == finishingPhase)) {
-                stateTransitionStart(response, Phase.POST_CONSTRUCTING);
+            if (response.targetActivationPhase().ordinal() >= ActivationPhase.POST_CONSTRUCTING.ordinal()
+                    && (ActivationPhase.INJECTING == finishingPhase)) {
+                stateTransitionStart(response, ActivationPhase.POST_CONSTRUCTING);
                 postConstruct(response);
             }
             finishingPhase = response.finishingActivationPhase().orElse(finishingPhase);
-            if (response.targetActivationPhase().ordinal() >= Phase.ACTIVATION_FINISHING.ordinal()
-                    && (Phase.POST_CONSTRUCTING == finishingPhase)) {
-                stateTransitionStart(response, Phase.ACTIVATION_FINISHING);
+            if (response.targetActivationPhase().ordinal() >= ActivationPhase.ACTIVATION_FINISHING.ordinal()
+                    && (ActivationPhase.POST_CONSTRUCTING == finishingPhase)) {
+                stateTransitionStart(response, ActivationPhase.ACTIVATION_FINISHING);
                 finishActivation(response);
             }
             finishingPhase = response.finishingActivationPhase().orElse(finishingPhase);
-            if (response.targetActivationPhase().ordinal() >= Phase.ACTIVE.ordinal()
-                    && (Phase.ACTIVATION_FINISHING == finishingPhase)) {
-                stateTransitionStart(response, Phase.ACTIVE);
+            if (response.targetActivationPhase().ordinal() >= ActivationPhase.ACTIVE.ordinal()
+                    && (ActivationPhase.ACTIVATION_FINISHING == finishingPhase)) {
+                stateTransitionStart(response, ActivationPhase.ACTIVE);
             }
 
-            if (startingPhase.ordinal() < Phase.CONSTRUCTING.ordinal()
-                    && currentPhase.ordinal() >= Phase.CONSTRUCTING.ordinal()) {
+            if (startingPhase.ordinal() < ActivationPhase.CONSTRUCTING.ordinal()
+                    && currentPhase.ordinal() >= ActivationPhase.CONSTRUCTING.ordinal()) {
                 setTargetInstances();
             }
 
@@ -423,7 +408,7 @@ static class FixedIpFactoryActivator<T> extends IpFactoryActivator<T> {
 
     static class FixedServicesFactoryActivator<T> extends ServicesFactoryActivator<T> {
         FixedServicesFactoryActivator(ServiceProvider<T> provider,
-                                      Injection.ServicesFactory<T> factory) {
+                                      Service.ServicesFactory<T> factory) {
             super(provider);
             serviceInstance = InstanceHolder.create(factory);
         }
@@ -431,7 +416,7 @@ static class FixedServicesFactoryActivator<T> extends ServicesFactoryActivator<T
 
     static class FixedQualifiedFactoryActivator<T> extends QualifiedFactoryActivator<T> {
         FixedQualifiedFactoryActivator(ServiceProvider<T> provider,
-                                       Injection.QualifiedFactory<T, ?> factory) {
+                                       QualifiedFactory<T, ?> factory) {
             super(provider, (QualifiedFactoryDescriptor) provider.descriptor());
             serviceInstance = InstanceHolder.create(factory);
         }
@@ -542,8 +527,6 @@ protected void setTargetInstances() {
      * {@code MyService implements QualifiedProvider}.
      */
     static class QualifiedFactoryActivator<T> extends SingleServiceActivator<T> {
-        static final GenericType<?> OBJECT_GENERIC_TYPE = GenericType.create(Object.class);
-
         private final TypeName supportedQualifier;
         private final Set<ResolvedType> supportedContracts;
         private final boolean anyMatch;
@@ -581,11 +564,11 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
         private Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup, Qualifier qualifier) {
             if (lookup.contracts().size() == 1) {
                 if (anyMatch || this.supportedContracts.containsAll(lookup.contracts())) {
-                    Optional<GenericType<?>> genericType = lookup.injectionPoint()
-                            .map(Ip::contractType);
+                    Optional<GenericType<?>> genericType = lookup.dependency()
+                            .map(Dependency::contractType);
                     GenericType contract = genericType
                             .or(lookup::contractType)
-                            .orElse(OBJECT_GENERIC_TYPE);
+                            .orElse(GenericType.OBJECT);
 
                     return Optional.of(targetInstances(lookup, qualifier, contract));
                 }
@@ -657,7 +640,7 @@ protected void setTargetInstances() {
                 return;
             }
             // the instance list is created just once, hardcoded to the instance we have just created
-            Injection.ServicesFactory<T> instanceSupplier = (Injection.ServicesFactory<T>) serviceInstance.get();
+            Service.ServicesFactory<T> instanceSupplier = (Service.ServicesFactory<T>) serviceInstance.get();
             targetInstances = instanceSupplier.services();
         }
 
@@ -683,16 +666,16 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
     }
 
     /**
-     * Service annotated {@link io.helidon.service.inject.api.Injection.PerInstance}.
+     * Service annotated {@link Service.PerInstance}.
      */
     static class PerInstanceActivator<T> extends BaseActivator<T> {
-        private final InjectServiceRegistryImpl registry;
+        private final CoreServiceRegistry registry;
         private final ResolvedType createFor;
         private final Lookup createForLookup;
         private List<QualifiedServiceInstance<T>> serviceInstances;
         private List<QualifiedInstance<T>> targetInstances;
 
-        PerInstanceActivator(InjectServiceRegistryImpl registry, ServiceProvider<T> provider, PerInstanceDescriptor dbd) {
+        PerInstanceActivator(CoreServiceRegistry registry, ServiceProvider<T> provider, PerInstanceDescriptor dbd) {
             super(provider);
 
             this.registry = registry;
@@ -713,27 +696,26 @@ static Map<Dependency, IpPlan<?>> updatePlan(Map<Dependency, IpPlan<?>> injectio
             Map<Dependency, IpPlan<?>> updatedPlan = new HashMap<>(injectionPlan);
 
             for (Dependency dependency : ips) {
-                Ip ip = Ip.create(dependency);
                 // injection point for the driving instance
-                if (contracts.contains(ResolvedType.create(ip.contract()))
-                        && ip.qualifiers().isEmpty()) {
-                    if (ServiceInstance.TYPE.equals(ip.typeName())) {
+                if (contracts.contains(ResolvedType.create(dependency.contract()))
+                        && dependency.qualifiers().isEmpty()) {
+                    if (ServiceInstance.TYPE.equals(dependency.typeName())) {
                         // if the injection point has the same contract, no qualifiers, then it is the driving instance
-                        updatedPlan.put(ip, new IpPlan<>(() -> driver, injectionPlan.get(ip).descriptors()));
+                        updatedPlan.put(dependency, new IpPlan<>(() -> driver, injectionPlan.get(dependency).descriptors()));
                     } else {
                         // if the injection point has the same contract, no qualifiers, then it is the driving instance
-                        updatedPlan.put(ip, new IpPlan<>(driver, injectionPlan.get(ip).descriptors()));
+                        updatedPlan.put(dependency, new IpPlan<>(driver, injectionPlan.get(dependency).descriptors()));
                     }
                 }
                 // injection point for the service name
-                if (TypeNames.STRING.equals(ip.contract())) {
+                if (TypeNames.STRING.equals(dependency.contract())) {
                     // @InstanceName String name
-                    if (ip.qualifiers()
+                    if (dependency.qualifiers()
                             .stream()
-                            .anyMatch(it -> Injection.InstanceName.TYPE.equals(it.typeName()))) {
-                        updatedPlan.put(ip,
-                                        new IpPlan<>(() -> name.value().orElse(Injection.Named.DEFAULT_NAME),
-                                                     injectionPlan.get(ip).descriptors()));
+                            .anyMatch(it -> Service.InstanceName.TYPE.equals(it.typeName()))) {
+                        updatedPlan.put(dependency,
+                                        new IpPlan<>(() -> name.value().orElse(Service.Named.DEFAULT_NAME),
+                                                     injectionPlan.get(dependency).descriptors()));
                     }
                 }
             }
@@ -817,10 +799,9 @@ private List<ServiceInfo> driversFromPlan(Map<Dependency, IpPlan<?>> ipSupplierM
             // I need the list of descriptors from the injection plan
             for (Map.Entry<Dependency, IpPlan<?>> entry : ipSupplierMap.entrySet()) {
                 Dependency dependency = entry.getKey();
-                Ip ip = Ip.create(dependency);
-                if (createFor.equals(ip.contract())
-                        && ip.qualifiers().size() == 1
-                        && ip.qualifiers().contains(Qualifier.WILDCARD_NAMED)) {
+                if (createFor.equals(dependency.contract())
+                        && dependency.qualifiers().size() == 1
+                        && dependency.qualifiers().contains(Qualifier.WILDCARD_NAMED)) {
                     return List.of(entry.getValue().descriptors());
                 }
             }
@@ -834,7 +815,7 @@ static <T> QualifiedServiceInstance<T> create(ServiceProvider<T> provider, Servi
                 Set<Qualifier> qualifiers = driver.qualifiers();
                 Qualifier name = qualifiers.stream()
                         .filter(not(Qualifier.WILDCARD_NAMED::equals))
-                        .filter(it -> Injection.Named.TYPE.equals(it.typeName()))
+                        .filter(it -> Service.Named.TYPE.equals(it.typeName()))
                         .findFirst()
                         .orElse(Qualifier.DEFAULT_NAMED);
                 Set<Qualifier> newQualifiers = provider.descriptor().qualifiers()
@@ -896,13 +877,13 @@ public T get() {
     private static class InstanceHolderImpl<T> implements InstanceHolder<T> {
         private final DependencyContext ctx;
         private final InterceptionMetadata interceptionMetadata;
-        private final InjectServiceDescriptor<T> source;
+        private final ServiceDescriptor<T> source;
 
         private volatile T instance;
 
         private InstanceHolderImpl(DependencyContext ctx,
                                InterceptionMetadata interceptionMetadata,
-                               InjectServiceDescriptor<T> source) {
+                               ServiceDescriptor<T> source) {
             this.ctx = ctx;
             this.interceptionMetadata = interceptionMetadata;
             this.source = source;
@@ -949,7 +930,7 @@ private MissingDescribedActivator(ServiceProvider<T> provider) {
             if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
                 LOGGER.log(System.Logger.Level.DEBUG,
                            "The registry knows of a descriptor that was generated on demand "
-                                   + "(@" + Injection.Describe.class.getName() + "), which expects an instance configured for "
+                                   + "(@" + Service.Describe.class.getName() + "), which expects an instance configured for "
                                    + "it, either"
                                    + " when creating the registry through configuration, or when creating a scope. "
                                    + "Service that does not have an instance registered: "
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ActivatorsPerLookup.java b/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
similarity index 84%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ActivatorsPerLookup.java
rename to service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
index af78852d9b0..299962a0fde 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ActivatorsPerLookup.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
@@ -30,26 +30,10 @@
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
-import io.helidon.service.inject.api.ActivationResult;
-import io.helidon.service.inject.api.Activator.Phase;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.GeneratedInjectService;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Injection.ServicesFactory;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
-
-import static io.helidon.service.inject.Activators.QualifiedFactoryActivator.OBJECT_GENERIC_TYPE;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.Service.QualifiedFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
+
 import static java.util.function.Predicate.not;
 
 /*
@@ -58,11 +42,11 @@
 
 /**
  * Activator types for various types the users can implement, for services without scope
- * (with {@link io.helidon.service.inject.api.Injection.PerLookup} as its scope in descriptor).
+ * (with {@link io.helidon.service.registry.Service.PerLookup} as its scope in descriptor).
  * <p>
  * Activators in this type create an instance per injection, or per call to {@link java.util.function.Supplier#get()}.
  *
- * @see io.helidon.service.inject.Activators
+ * @see io.helidon.service.registry.Activators
  */
 @SuppressWarnings("checkstyle:VisibilityModifier") // as long as all are inner classes, this is OK
 final class ActivatorsPerLookup {
@@ -123,14 +107,20 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
             return targetInstances();
         }
 
-        @SuppressWarnings("unchecked")
+        @SuppressWarnings({"unchecked", "rawtypes"})
         @Override
         protected Optional<List<QualifiedInstance<T>>> targetInstances() {
             if (serviceInstance == null) {
                 return Optional.empty();
             }
             Supplier<T> instanceSupplier = (Supplier<T>) serviceInstance.get(currentPhase);
-            return Optional.of(List.of(QualifiedInstance.create(instanceSupplier.get(),
+            T x = instanceSupplier.get();
+            if (x instanceof Optional opt) {
+                // a small optimization here - create an activator for Supplier<Optional<T>>, this is a bit hackish
+                return opt.map(value -> List.of(QualifiedInstance.create(value,
+                                                                         provider.descriptor().qualifiers())));
+            }
+            return Optional.of(List.of(QualifiedInstance.create(x,
                                                                 provider.descriptor().qualifiers())));
         }
     }
@@ -143,7 +133,7 @@ static class QualifiedFactoryActivator<T> extends SingleServiceActivator<T> {
         private final Set<ResolvedType> supportedContracts;
         private final boolean anyMatch;
 
-        QualifiedFactoryActivator(ServiceProvider<T> provider, GeneratedInjectService.QualifiedFactoryDescriptor qpd) {
+        QualifiedFactoryActivator(ServiceProvider<T> provider, GeneratedService.QualifiedFactoryDescriptor qpd) {
             super(provider);
             this.supportedQualifier = qpd.qualifierType();
             this.supportedContracts = provider.descriptor().contracts()
@@ -170,11 +160,11 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
         private Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup, Qualifier qualifier) {
             if (lookup.contracts().size() == 1) {
                 if (anyMatch || this.supportedContracts.containsAll(lookup.contracts())) {
-                    Optional<GenericType<?>> genericType = lookup.injectionPoint()
-                            .map(Ip::contractType);
+                    Optional<GenericType<?>> genericType = lookup.dependency()
+                            .map(Dependency::contractType);
                     GenericType contract = genericType
                             .or(lookup::contractType)
-                            .orElse(OBJECT_GENERIC_TYPE);
+                            .orElse(GenericType.OBJECT);
 
                     return Optional.of(targetInstances(lookup, qualifier, contract));
                 }
@@ -204,7 +194,7 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
             if (serviceInstance == null) {
                 return Optional.empty();
             }
-            var ipProvider = (Injection.InjectionPointFactory<T>) serviceInstance.get(currentPhase);
+            var ipProvider = (InjectionPointFactory<T>) serviceInstance.get(currentPhase);
 
             if (requestedProvider(lookup, FactoryType.INJECTION_POINT)) {
                 // the user requested the provider, not the provided
@@ -232,7 +222,7 @@ static class ServicesFactoryActivator<T> extends SingleServiceActivator<T> {
         @SuppressWarnings("unchecked")
         @Override
         protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
-            ServicesFactory<T> instanceSupplier = (Injection.ServicesFactory<T>) serviceInstance.get(currentPhase);
+            Service.ServicesFactory<T> instanceSupplier = (Service.ServicesFactory<T>) serviceInstance.get(currentPhase);
 
             if (requestedProvider(lookup, FactoryType.SERVICES)) {
                 return Optional.of(List.of(QualifiedInstance.create((T) instanceSupplier, descriptor().qualifiers())));
@@ -250,17 +240,17 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
     }
 
     /**
-     * Service annotated {@link io.helidon.service.inject.api.Injection.PerInstance}.
+     * Service annotated {@link Service.PerInstance}.
      */
     static class PerInstanceActivator<T> extends Activators.BaseActivator<T> {
-        private final InjectServiceRegistryImpl registry;
+        private final CoreServiceRegistry registry;
         private final ResolvedType createFor;
 
         private List<QualifiedOnDemandInstance<T>> serviceInstances;
 
-        PerInstanceActivator(InjectServiceRegistryImpl registry,
+        PerInstanceActivator(CoreServiceRegistry registry,
                              ServiceProvider<T> provider,
-                             GeneratedInjectService.PerInstanceDescriptor dbd) {
+                             GeneratedService.PerInstanceDescriptor dbd) {
             super(provider);
 
             this.registry = registry;
@@ -305,7 +295,7 @@ static <T> QualifiedOnDemandInstance<T> create(ServiceProvider<T> provider,
             Set<Qualifier> qualifiers = driver.qualifiers();
             Qualifier name = qualifiers.stream()
                     .filter(not(Qualifier.WILDCARD_NAMED::equals))
-                    .filter(it -> Injection.Named.TYPE.equals(it.typeName()))
+                    .filter(it -> Service.Named.TYPE.equals(it.typeName()))
                     .findFirst()
                     .orElse(Qualifier.DEFAULT_NAMED);
             Set<Qualifier> newQualifiers = provider.descriptor().qualifiers()
@@ -329,18 +319,18 @@ static class OnDemandInstance<T> {
         private final ReentrantLock lock = new ReentrantLock();
         private final DependencyContext ctx;
         private final InterceptionMetadata interceptionMetadata;
-        private final InjectServiceDescriptor<T> source;
+        private final ServiceDescriptor<T> source;
 
         OnDemandInstance(DependencyContext ctx,
                          InterceptionMetadata interceptionMetadata,
-                         InjectServiceDescriptor<T> source) {
+                         ServiceDescriptor<T> source) {
             this.ctx = ctx;
             this.interceptionMetadata = interceptionMetadata;
             this.source = source;
         }
 
         @SuppressWarnings("unchecked")
-        T get(Phase phase) {
+        T get(ActivationPhase phase) {
             if (lock.isHeldByCurrentThread()) {
                 throw new ServiceRegistryException("Cyclic dependency, attempting to obtain an instance of "
                                                            + source.serviceType().fqName()
@@ -348,13 +338,13 @@ T get(Phase phase) {
             }
             try {
                 lock.lock();
-                if (phase.ordinal() >= Phase.CONSTRUCTING.ordinal()) {
+                if (phase.ordinal() >= ActivationPhase.CONSTRUCTING.ordinal()) {
                     T instance = (T) source.instantiate(ctx, interceptionMetadata);
-                    if (phase.ordinal() >= Phase.INJECTING.ordinal()) {
+                    if (phase.ordinal() >= ActivationPhase.INJECTING.ordinal()) {
                         Set<String> injected = new LinkedHashSet<>();
                         source.inject(ctx, interceptionMetadata, injected, instance);
                     }
-                    if (phase.ordinal() >= Phase.POST_CONSTRUCTING.ordinal()) {
+                    if (phase.ordinal() >= ActivationPhase.POST_CONSTRUCTING.ordinal()) {
                         source.postConstruct(instance);
                     }
                     return instance;
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/Binding.java b/service/registry/src/main/java/io/helidon/service/registry/Binding.java
similarity index 92%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/Binding.java
rename to service/registry/src/main/java/io/helidon/service/registry/Binding.java
index 6151718818d..445ce4f89ce 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/Binding.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Binding.java
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Service;
 
 /**
  * A binding instance, if available at runtime, will be expected to provide a plan for all service provider's injection
@@ -47,5 +46,5 @@ public interface Binding {
      *
      * @param binder the binder used to register the service provider injection plans
      */
-    void configure(InjectionPlanBinder binder);
+    void configure(DependencyPlanBinder binder);
 }
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/Contracts.java b/service/registry/src/main/java/io/helidon/service/registry/Contracts.java
similarity index 91%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/Contracts.java
rename to service/registry/src/main/java/io/helidon/service/registry/Contracts.java
index 939f9fc81be..6750a9a1504 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/Contracts.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Contracts.java
@@ -14,13 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.Set;
 
 import io.helidon.common.types.ResolvedType;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
 
 /*
 Management of contracts, to return correct contracts for services created from other services,
@@ -30,7 +28,7 @@ final class Contracts {
     private Contracts() {
     }
 
-    static ContractLookup create(InjectServiceInfo descriptor) {
+    static ContractLookup create(ServiceInfo descriptor) {
         Set<ResolvedType> contracts = descriptor.contracts();
 
         return switch (descriptor.factoryType()) {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
index e45ea60acc1..fffd510b4b7 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
@@ -16,407 +16,643 @@
 
 package io.helidon.service.registry;
 
-import java.lang.System.Logger.Level;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 import io.helidon.common.LazyValue;
+import io.helidon.common.LruCache;
+import io.helidon.common.Weighted;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupplyList;
+
+import static io.helidon.service.registry.LookupTrace.traceLookup;
+import static io.helidon.service.registry.ServiceRegistryManager.SERVICE_INFO_COMPARATOR;
 
 /**
  * Basic implementation of the service registry with simple dependency support.
  */
-class CoreServiceRegistry implements ServiceRegistry {
-    private static final System.Logger LOGGER = System.getLogger(CoreServiceRegistry.class.getName());
-
-    private static final Comparator<ServiceProvider> PROVIDER_COMPARATOR =
-            Comparator.comparing(ServiceProvider::weight).reversed()
-                    .thenComparing(ServiceProvider::descriptorType);
-
-    private final Map<ResolvedType, List<ServiceProvider>> providersByContract;
-    private final Map<ServiceInfo, ServiceProvider> providersByService;
-    private final List<ServiceProvider> allProviders;
-
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    CoreServiceRegistry(ServiceRegistryConfig config, ServiceDiscovery serviceDiscovery) {
-        List<ServiceProvider> allProviders = new ArrayList<>();
-        Map<ResolvedType, List<ServiceProvider>> providers = new HashMap<>();
-        Map<ServiceInfo, ServiceProvider> providersByService = new IdentityHashMap<>();
-
-        // each just once
-        Set<TypeName> processedDescriptorTypes = new HashSet<>();
-
-        // add me
-        ServiceRegistry__ServiceDescriptor registryDescriptor = ServiceRegistry__ServiceDescriptor.INSTANCE;
-        processedDescriptorTypes.add(registryDescriptor.descriptorType());
-        addContracts(providers, registryDescriptor.contracts(), new BoundInstance(registryDescriptor, Optional.of(this)));
-
-        // add explicit instances
-        config.serviceInstances().forEach((descriptor, instance) -> {
-            if (processedDescriptorTypes.add(descriptor.descriptorType())) {
-                BoundInstance bi = new BoundInstance(descriptor, Optional.of(instance));
-                allProviders.add(bi);
-                providersByService.put(descriptor, bi);
-                addContracts(providers, descriptor.contracts(), bi);
+class CoreServiceRegistry implements ServiceRegistry, Scopes {
+    private static final AtomicInteger COUNTER = new AtomicInteger();
+
+    private final String id = String.valueOf(COUNTER.incrementAndGet());
+
+    private final RegistryMetricsImpl metrics = new RegistryMetricsImpl();
+    private final ReadWriteLock stateLock = new ReentrantReadWriteLock();
+    private final Lock stateReadLock = stateLock.readLock();
+    private final Lock stateWriteLock = stateLock.writeLock();
+
+    // map of scope annotation to service info
+    private final Map<TypeName, ServiceInfo> scopeHandlerServices;
+    // map of service implementation class to service info
+    private final Map<TypeName, ServiceInfo> servicesByType;
+    // map of provided contracts to service info(s)
+    private final Map<ResolvedType, Set<ServiceInfo>> servicesByContract;
+    // map of qualifier annotations to service info(s)
+    private final Map<TypeName, Set<ServiceInfo>> qualifiedProvidersByQualifier;
+    // map of qualifier annotations and resolved type combination to service info(s)
+    private final Map<ServiceRegistryManager.TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders;
+    private final Map<ResolvedType, AtomicBoolean> accessedContracts;
+
+    private final boolean cacheEnabled;
+    private final LruCache<Lookup, List<ServiceInfo>> cache;
+
+    private final LazyValue<Scope> singletonScope = LazyValue
+            .create(() -> createScope(Service.Singleton.TYPE, Optional::empty, id, Map.of()));
+
+    private final LazyValue<Scope> perLookupScope = LazyValue
+            .create(() -> createScope(Service.PerLookup.TYPE, Optional::empty, id, Map.of()));
+    private final Map<TypeName, Service.ScopeHandler> scopeHandlerInstances = new HashMap<>();
+    private final Lock scopeHandlerInstancesLock = new ReentrantLock();
+    private final boolean interceptionEnabled;
+    private final InterceptionMetadata interceptionMetadata;
+
+    // runtime fields (to obtain actual service instances)
+    // service descriptor to its manager
+    private final Map<ServiceInfo, ServiceManager<?>> servicesByDescriptor = new IdentityHashMap<>();
+    private final ActivationRequest activationRequest;
+    private Map<ServiceInfo, ServiceManager<Interception.Interceptor>> interceptors;
+
+    @SuppressWarnings("unchecked")
+    CoreServiceRegistry(ServiceRegistryConfig config,
+                        Set<ServiceDescriptor<?>> descriptors,
+                        Map<TypeName, ServiceInfo> scopeHandlers,
+                        Map<ServiceInfo, Object> explicitInstances,
+                        Map<TypeName, ServiceInfo> servicesByType,
+                        Map<ResolvedType, Set<ServiceInfo>> servicesByContract,
+                        Map<TypeName, Set<ServiceInfo>> qualifiedProvidersByQualifier,
+                        Map<ServiceRegistryManager.TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders,
+                        Map<ResolvedType, AtomicBoolean> accessedContracts) {
+        this.accessedContracts = Map.copyOf(accessedContracts);
+        this.interceptionEnabled = config.interceptionEnabled();
+        // this is a bit tricky - we are leaking our instance that is not yet finished, so it must
+        // not be accessed in the constructor!
+        this.interceptionMetadata = interceptionEnabled
+                ? InterceptionMetadataImpl.create(this)
+                : InterceptionMetadataImpl.noop();
+
+        // these must be bound here, as the instance exists now
+        // (and we do not want to allow post-constructor binding)
+        explicitInstances.put(Scopes__ServiceDescriptor.INSTANCE, this);
+        explicitInstances.put(ServiceRegistry__ServiceDescriptor.INSTANCE, this);
+        explicitInstances.put(InterceptionMetadata__ServiceDescriptor.INSTANCE, interceptionMetadata);
+        // nobody can replace these
+        accessed(Scopes__ServiceDescriptor.INSTANCE);
+        accessed(ServiceRegistry__ServiceDescriptor.INSTANCE);
+        accessed(InterceptionMetadata__ServiceDescriptor.INSTANCE);
+
+        this.cacheEnabled = config.lookupCacheEnabled();
+        this.cache = cacheEnabled ? LruCache.create(config.lookupCacheSize()) : null;
+
+        this.scopeHandlerServices = scopeHandlers;
+        this.servicesByType = new HashMap<>(servicesByType);
+        this.servicesByContract = new HashMap<>(servicesByContract);
+        this.qualifiedProvidersByQualifier = qualifiedProvidersByQualifier;
+        this.typedQualifiedProviders = typedQualifiedProviders;
+        this.activationRequest = ActivationRequest.builder()
+                .targetPhase(config.limitActivationPhase())
+                .build();
+
+        /*
+        For each known service descriptor, create an appropriate service manager
+         */
+        descriptors.forEach(descriptor -> {
+            Object instance = explicitInstances.get(descriptor);
+            ServiceProvider<Object> provider = new ServiceProvider<>(
+                    this,
+                    (ServiceDescriptor<Object>) descriptor);
+
+            if (instance != null) {
+                Activator<Object> activator = Activators.create(provider, instance);
+                servicesByDescriptor.put(descriptor,
+                                         new ServiceManager<>(scopeSupplier(descriptor),
+                                                              provider,
+                                                              true,
+                                                              () -> activator));
+            } else {
+                // we must always prefer explicit instances - so if specified, we will never override it
+                servicesByDescriptor.putIfAbsent(descriptor,
+                                                 new ServiceManager<>(scopeSupplier(descriptor),
+                                                                      provider,
+                                                                      false,
+                                                                      Activators.create(this, provider)));
             }
         });
+    }
 
-        // add configured descriptors
-        for (ServiceDescriptor descriptor : config.serviceDescriptors()) {
-            BoundDescriptor bd = new BoundDescriptor(this, descriptor, LazyValue.create(() -> {
-                var instance = instance(descriptor);
-                instance.ifPresent(descriptor::postConstruct);
-                return instance;
-            }));
-            allProviders.add(bd);
-            providersByService.put(descriptor, bd);
-            addContracts(providers, descriptor.contracts(), bd);
-        }
-
-        boolean logUnsupported = LOGGER.isLoggable(Level.TRACE);
-
-        // and finally add discovered instances
-        for (DescriptorHandler descriptorMeta : serviceDiscovery.allMetadata()) {
-            if (!descriptorMeta.registryType().equals(DescriptorHandler.REGISTRY_TYPE_CORE)) {
-                // we can only support core services, others should be handled by other registry implementations
-                if (logUnsupported) {
-                    LOGGER.log(Level.TRACE,
-                               "Ignoring service of type \"" + descriptorMeta.registryType() + "\": " + descriptorMeta);
-                }
-                continue;
-            }
-            if (processedDescriptorTypes.add(descriptorMeta.descriptor().serviceType())) {
-                DiscoveredDescriptor dd = new DiscoveredDescriptor(this,
-                                                                   descriptorMeta,
-                                                                   instanceSupplier(descriptorMeta));
-                allProviders.add(dd);
-                providersByService.put(descriptorMeta.descriptor(), dd);
-                addContracts(providers, descriptorMeta.contracts(), dd);
-            }
-        }
-        // sort all the providers
-        providers.values()
-                .forEach(it -> it.sort(PROVIDER_COMPARATOR));
-        allProviders.sort(PROVIDER_COMPARATOR);
-        allProviders.reversed();
+    @Override
+    public <T> T get(TypeName contract) {
+        return get(Lookup.create(contract));
+    }
 
-        this.providersByContract = Map.copyOf(providers);
-        this.providersByService = providersByService;
-        this.allProviders = List.copyOf(allProviders);
+    @Override
+    public <T> T get(Lookup lookup) {
+        return this.<T>supply(lookup).get();
     }
 
     @Override
-    public <T> T get(TypeName contract) {
-        return this.<T>first(contract)
-                .orElseThrow(() -> new ServiceRegistryException("Contract " + contract.fqName()
-                                                                        + " is not supported, there are no service "
-                                                                        + "descriptors in this registry that can satisfy it."));
+    public <T> Supplier<T> supply(TypeName contract) {
+        return supply(Lookup.create(contract));
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    public <T> Optional<T> first(TypeName contract) {
-        return allProviders(contract)
-                .stream()
-                .flatMap(it -> it.instance().stream())
-                .findFirst()
-                .map(it -> (T) it);
+    public <T> Supplier<T> supply(Lookup lookup) {
+        List<ServiceManager<T>> managers = lookupManagers(lookup);
+
+        if (managers.isEmpty()) {
+            throw new ServiceRegistryException("There is no service in registry that matches this lookup: " + lookup);
+        }
+        return new ServiceSupplies.ServiceSupply<>(lookup, managers);
     }
 
     @SuppressWarnings("unchecked")
     @Override
-    public <T> List<T> all(TypeName contract) {
-        return allProviders(contract)
-                .stream()
-                .flatMap(it -> it.instance().stream())
-                .map(it -> (T) it)
-                .collect(Collectors.toList());
+    public <T> Optional<T> get(ServiceInfo serviceInfo) {
+        ServiceManager<?> serviceManager = servicesByDescriptor.get(serviceInfo);
+        if (serviceManager == null) {
+            return Optional.empty();
+        }
+        return (Optional<T>) new ServiceSupplies.ServiceSupplyOptional<>(Lookup.EMPTY, List.of(serviceManager(serviceInfo)))
+                .get();
     }
 
     @Override
-    public <T> Supplier<T> supply(TypeName contract) {
-        return () -> get(contract);
+    public <T> Optional<T> first(TypeName contract) {
+        return first(Lookup.create(contract));
     }
 
     @Override
-    public <T> Supplier<Optional<T>> supplyFirst(TypeName contract) {
-        return () -> first(contract);
+    public <T> Optional<T> first(Lookup lookup) {
+        return this.<T>supplyFirst(lookup).get();
     }
 
     @Override
-    public <T> Supplier<List<T>> supplyAll(TypeName contract) {
-        return () -> all(contract);
+    public <T> Supplier<Optional<T>> supplyFirst(TypeName contract) {
+        return supplyFirst(Lookup.create(contract));
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    public <T> Optional<T> get(ServiceInfo serviceInfo) {
-        return Optional.ofNullable(providersByService.get(serviceInfo))
-                .flatMap(ServiceProvider::instance)
-                .map(it -> (T) it);
+    public <T> Supplier<Optional<T>> supplyFirst(Lookup lookup) {
+        List<ServiceManager<T>> managers = lookupManagers(lookup);
+
+        if (managers.isEmpty()) {
+            return Optional::empty;
+        }
+        return new ServiceSupplies.ServiceSupplyOptional<>(lookup, managers);
     }
 
     @Override
-    public List<ServiceInfo> allServices(TypeName contract) {
-        return Optional.ofNullable(providersByContract.get(ResolvedType.create(contract)))
-                .orElseGet(List::of)
-                .stream()
-                .map(ServiceProvider::descriptor)
-                .collect(Collectors.toUnmodifiableList());
-
+    public <T> List<T> all(TypeName contract) {
+        return all(Lookup.create(contract));
     }
 
-    void shutdown() {
-        allProviders.forEach(ServiceProvider::close);
+    @Override
+    public <T> List<T> all(Lookup lookup) {
+        return this.<T>supplyAll(lookup).get();
     }
 
-    private static void addContracts(Map<ResolvedType, List<ServiceProvider>> providers,
-                                     Set<ResolvedType> contracts,
-                                     ServiceProvider provider) {
-        for (ResolvedType contract : contracts) {
-            providers.computeIfAbsent(contract, it -> new ArrayList<>())
-                    .add(provider);
-        }
+    @Override
+    public <T> Supplier<List<T>> supplyAll(TypeName contract) {
+        return supplyAll(Lookup.create(contract));
     }
 
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    private ServiceAndInstance instanceSupplier(DescriptorHandler descriptorMeta) {
-        LazyValue<Optional<Object>> serviceInstance = LazyValue.create(() -> {
-            ServiceDescriptor descriptor = descriptorMeta.descriptor();
-            var instance = instance(descriptor);
-            instance.ifPresent(descriptor::postConstruct);
-            return instance;
-        });
+    @Override
+    public <T> Supplier<List<T>> supplyAll(Lookup lookup) {
+        List<ServiceManager<T>> managers = lookupManagers(lookup);
 
-        if (descriptorMeta.factoryContracts().isEmpty()) {
-            return new ServiceAndInstance(serviceInstance);
-        } else {
-            return new ServiceAndInstance(serviceInstance,
-                                          () -> instanceFromSupplier(descriptorMeta.descriptor(), serviceInstance));
+        if (managers.isEmpty()) {
+            return List::of;
         }
+        return new ServiceSupplyList<>(lookup, managers);
     }
 
-    private List<ServiceProvider> allProviders(TypeName contract) {
-        List<ServiceProvider> serviceProviders = providersByContract.get(ResolvedType.create(contract));
-        if (serviceProviders == null) {
-            return List.of();
-        }
-
-        return List.copyOf(serviceProviders);
+    @Override
+    public List<ServiceInfo> allServices(TypeName contract) {
+        return lookupServices(Lookup.create(contract));
     }
 
-    private Optional<Object> instanceFromSupplier(ServiceDescriptor<?> descriptor,
-                                                  LazyValue<Optional<Object>> serviceInstanceSupplier) {
-        Optional<Object> serviceInstance = serviceInstanceSupplier.get();
-        if (serviceInstance.isEmpty()) {
-            return Optional.empty();
-        }
-        Object actualInstance = serviceInstance.get();
+    @Override
+    public List<ServiceInfo> lookupServices(Lookup lookup) {
+        try {
+            stateReadLock.lock();
+            // a very special lookup
+            if (lookup.qualifiers().contains(Qualifier.CREATE_FOR_NAME)) {
+                checkCreateForName(lookup);
+                return List.of(InstanceName__ServiceDescriptor.INSTANCE);
+            }
 
-        // the service has a Supplier contract, so its instance should implement a supplier
-        // services are always singleton for us, but the supplier returned value should be requested each time
-        // we use it, to support non-thread-safe instances
-        if (actualInstance instanceof Supplier<?> supplier) {
-            return fromSupplierValue(supplier.get());
-        } else {
-            throw new ServiceRegistryException("Service " + descriptor.serviceType().fqName()
-                                                       + " exposes Supplier as an interface, yet it does not"
-                                                       + " implement it.");
-        }
-    }
+            metrics.lookup();
+            traceLookup(lookup, "start: {0}", lookup);
+
+            if (cacheEnabled) {
+                List<ServiceInfo> cacheResult = cache.get(lookup)
+                        .orElse(null);
+                metrics.cacheAccess();
+                if (cacheResult != null) {
+                    traceLookup(lookup, "from cache", cacheResult);
+                    metrics.cacheHit();
+                    return cacheResult;
+                }
+            }
 
-    private Optional<Object> instance(ServiceDescriptor<?> descriptor) {
-        var dependencyContext = collectDependencies(descriptor);
+            List<ServiceInfo> result = new ArrayList<>();
 
-        Object serviceInstance = descriptor.instantiate(dependencyContext);
-        return Optional.of(serviceInstance);
-    }
+            if (lookup.serviceType().isPresent()) {
+                // when a specific service type is requested, we go for it
+                ServiceInfo exact = servicesByType.get(lookup.serviceType().get());
+                if (exact != null) {
+                    traceLookup(lookup, "by service type", result);
+                    result.add(exact);
+                    return result;
+                }
+            }
 
-    private DependencyContext collectDependencies(ServiceDescriptor<?> descriptor) {
-        List<? extends Dependency> dependencies = descriptor.dependencies();
-        Map<Dependency, Object> collectedDependencies = new HashMap<>();
+            if (1 == lookup.contracts().size()) {
+                // a single contract is requested, we are ready for this ("indexed by contract")
+                ResolvedType theOnlyContractRequested = lookup.contracts().iterator().next();
+                Set<ServiceInfo> subsetOfMatches = servicesByContract.get(theOnlyContractRequested);
+                if (subsetOfMatches != null) {
+                    // the subset is ordered, cannot use parallel, also no need to re-order
+                    subsetOfMatches.stream()
+                            .filter(lookup::matches)
+                            .forEach(result::add);
+                    if (!result.isEmpty()) {
+                        traceLookup(lookup, "by single contract", result);
+                        if (cacheEnabled) {
+                            cacheAndAccess(lookup, result);
+                        } else {
+                            result.forEach(this::accessed);
+                        }
+                        return result;
+                    }
+                }
+            }
 
-        for (Dependency dependency : dependencies) {
-            TypeName contract = dependency.contract();
-            TypeName dependencyType = dependency.typeName();
+            // table scan :-(
+            metrics.fullScan();
+            servicesByType.values()
+                    .stream()
+                    .filter(lookup::matches)
+                    .sorted(SERVICE_INFO_COMPARATOR)
+                    .forEach(result::add);
+            traceLookup(lookup, "from full table scan", result);
+
+            if (result.isEmpty() && !lookup.qualifiers().isEmpty()) {
+                // check qualified providers
+                if (lookup.contracts().size() == 1) {
+                    ResolvedType contract = lookup.contracts().iterator().next();
+                    for (Qualifier qualifier : lookup.qualifiers()) {
+                        TypeName qualifierType = qualifier.typeName();
+                        Set<ServiceInfo> found = typedQualifiedProviders.get(new ServiceRegistryManager.TypedQualifiedProviderKey(
+                                qualifierType,
+                                contract));
+                        if (found != null) {
+                            traceLookup(lookup, "from typed qualified providers", found);
+                            result.addAll(found);
+                        }
+                        found = qualifiedProvidersByQualifier.get(qualifierType);
+                        if (found != null) {
+                            traceLookup(lookup, "from typed qualified providers", found);
+                            result.addAll(found);
+                        }
+                    }
+                }
+            }
 
-            if (dependencyType.isSupplier()) {
-                TypeName first = dependencyType.typeArguments().getFirst();
-                collectedDependencies.put(dependency, (Supplier<Object>) () -> dependencyNoSupplier(first, contract));
+            if (cacheEnabled) {
+                cacheAndAccess(lookup, result);
             } else {
-                collectedDependencies.put(dependency, dependencyNoSupplier(dependencyType, contract));
+                result.forEach(this::accessed);
             }
+
+            traceLookup(lookup, "full result", result);
+            return result;
+        } finally {
+            stateReadLock.unlock();
         }
+    }
 
-        return DependencyContext.create(collectedDependencies);
+    @Override
+    public Scope createScope(TypeName scopeType, String id, Map<ServiceDescriptor<?>, Object> initialBindings) {
+        return createScope(scopeType,
+                           scopeHandler(scopeType),
+                           id,
+                           initialBindings);
     }
 
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    private Optional<Object> fromSupplierValue(Object value) {
-        if (value instanceof Optional optValue) {
-            return optValue;
-        }
-        return Optional.of(value);
+    @Override
+    public RegistryMetrics metrics() {
+        return metrics;
     }
 
-    private Object dependencyNoSupplier(TypeName dependencyType, TypeName contract) {
-        if (dependencyType.isList()) {
-            return all(contract);
-        } else if (dependencyType.isOptional()) {
-            return first(contract);
-        } else {
-            // contract dependency
-            return get(contract);
+    <T> void add(Class<T> contract, double weight, T instance) {
+        stateWriteLock.lock();
+        try {
+            ResolvedType contractType = ResolvedType.create(contract);
+            checkValidContract(contractType);
+            ServiceInfo serviceInfo = servicesByType.get(contractType.type());
+            if (serviceInfo == null) {
+                Set<ServiceInfo> serviceInfos = new TreeSet<>(SERVICE_INFO_COMPARATOR);
+                serviceInfos.addAll(servicesByContract.get(contractType));
+
+                // each instance will have its own descriptor
+                VirtualDescriptor vt = new VirtualDescriptor(contractType.type(), weight, instance);
+                ServiceProvider<Object> provider = new ServiceProvider<>(this,
+                                                                         vt);
+                Activator<Object> activator = Activators.create(provider, instance);
+
+                servicesByDescriptor.put(vt, new ServiceManager<>(scopeSupplier(vt),
+                                                                  provider,
+                                                                  true,
+                                                                  () -> activator));
+                serviceInfos.add(vt);
+
+                // replace the instances
+                servicesByContract.put(contractType, serviceInfos);
+            } else {
+                throw new ServiceRegistryException("Cannot add a service instance for service implementation: "
+                                                           + contract.getName());
+            }
+        } finally {
+            stateWriteLock.unlock();
         }
     }
 
-    private interface ServiceProvider {
-        ServiceDescriptor<?> descriptor();
-
-        Optional<Object> instance();
-
-        double weight();
+    @SuppressWarnings("unchecked")
+    <T> void set(Class<T> contract, T[] instances) {
+        stateWriteLock.lock();
+        try {
+            ResolvedType contractType = ResolvedType.create(contract);
+            checkValidContract(contractType);
+            ServiceInfo serviceInfo = servicesByType.get(contractType.type());
+            if (serviceInfo == null) {
+                Set<ServiceInfo> serviceInfos = new TreeSet<>(SERVICE_INFO_COMPARATOR);
+
+                // we need to keep order of the instances; if somebody calls set, and then add, it may be tricky
+                double currentWeight = Weighted.DEFAULT_WEIGHT;
+                for (T instance : instances) {
+                    // each instance will have its own descriptor
+                    VirtualDescriptor vt = new VirtualDescriptor(contractType.type(), currentWeight, instance);
+                    ServiceProvider<Object> provider = new ServiceProvider<>(this,
+                                                                             vt);
+                    Activator<Object> activator = Activators.create(provider, instance);
+
+                    servicesByDescriptor.put(vt, new ServiceManager<>(scopeSupplier(vt),
+                                                                      provider,
+                                                                      true,
+                                                                      () -> activator));
+                    serviceInfos.add(vt);
+                    // reduce by a small number, so other things behave as expected
+                    currentWeight -= 0.001;
+                }
+                // replace the instances
+                servicesByContract.put(contractType, serviceInfos);
+            } else {
+                // this is a service instance, not contract implementation (i.e. the contract is actual service class)
+                ServiceProvider<Object> provider = new ServiceProvider<>(this,
+                                                                         (ServiceDescriptor<Object>) serviceInfo);
+                if (instances.length != 1) {
+                    throw new ServiceRegistryException("Attempting to set a service provider with wrong number of instances. "
+                                                               + "A service provider must have exactly one instance.");
+                }
+                Activator<Object> activator = Activators.create(provider, instances[0]);
+                servicesByDescriptor.put(serviceInfo, new ServiceManager<>(scopeSupplier(serviceInfo),
+                                                                           provider,
+                                                                           true,
+                                                                           () -> activator));
+            }
+        } finally {
+            stateWriteLock.unlock();
+        }
+    }
 
-        TypeName descriptorType();
+    InterceptionMetadata interceptionMetadata() {
+        return interceptionMetadata;
+    }
 
-        void close();
+    ActivationRequest activationRequest() {
+        return activationRequest;
     }
 
-    private record ServiceAndInstance(LazyValue<Optional<Object>> serviceSupplier,
-                                      Supplier<Optional<Object>> instanceSupplier) {
-        ServiceAndInstance(LazyValue<Optional<Object>> serviceSupplier) {
-            this(serviceSupplier, serviceSupplier);
+    List<ServiceInfo> servicesByContract(ResolvedType contract) {
+        Set<ServiceInfo> serviceInfos = servicesByContract.get(contract);
+        if (serviceInfos == null) {
+            return List.of();
         }
+        return serviceInfos.stream()
+                .collect(Collectors.toList());
     }
 
-    private record BoundInstance(ServiceDescriptor<?> descriptor, Optional<Object> instance) implements ServiceProvider {
-        @Override
-        public double weight() {
-            return descriptor.weight();
+    @SuppressWarnings("unchecked")
+    <T> ServiceManager<T> serviceManager(ServiceInfo info) {
+        ServiceManager<T> result = (ServiceManager<T>) servicesByDescriptor.get(info);
+        if (result == null) {
+            throw new ServiceRegistryException("Attempt to use service info not managed by this registry: " + info);
         }
+        return result;
+    }
 
-        @Override
-        public TypeName descriptorType() {
-            return descriptor.descriptorType();
+    void interceptors(ServiceInfo... serviceInfos) {
+        if (!interceptionEnabled) {
+            return;
         }
+        try {
+            stateWriteLock.lock();
+            if (this.interceptors == null) {
+                this.interceptors = new LinkedHashMap<>();
+            }
+            Set<ServiceInfo> ordered = new TreeSet<>(SERVICE_INFO_COMPARATOR);
+            for (ServiceInfo serviceInfo : serviceInfos) {
+                ServiceManager<Object> serviceManager = this.serviceManager(serviceInfo);
+                ordered.add(serviceManager.injectDescriptor());
+            }
 
-        @Override
-        public void close() {
-            // as the instance was provided from outside, we do not call pre-destroy
+            // there may be more than one application, we need to add to existing
+            for (ServiceInfo serviceInfo : ordered) {
+                this.interceptors.computeIfAbsent(serviceInfo,
+                                                  this::serviceManager);
+            }
+        } finally {
+            stateWriteLock.unlock();
         }
     }
 
-    private record BoundDescriptor(CoreServiceRegistry registry,
-                                   ServiceDescriptor<?> descriptor,
-                                   LazyValue<Optional<Object>> lazyInstance,
-                                   ReentrantLock lock) implements ServiceProvider {
+    void shutdown() {
+        singletonScope.get()
+                .close();
+    }
+
+    <T> List<ServiceManager<T>> lookupManagers(Lookup lookup) {
+        List<ServiceManager<T>> result = new ArrayList<>();
 
-        private BoundDescriptor(CoreServiceRegistry registry,
-                                ServiceDescriptor<?> descriptor,
-                                LazyValue<Optional<Object>> lazyInstance) {
-            this(registry, descriptor, lazyInstance, new ReentrantLock());
+        for (ServiceInfo service : lookupServices(lookup)) {
+            result.add(serviceManager(service));
         }
 
-        @Override
-        public Optional<Object> instance() {
-            if (lazyInstance.isLoaded()) {
-                return lazyInstance.get();
-            }
+        return result;
+    }
 
-            if (lock.isHeldByCurrentThread()) {
-                throw new ServiceRegistryException("Cyclic dependency, attempting to obtain an instance of "
-                                                           + descriptor.serviceType().fqName() + " while instantiating it");
+    List<ServiceManager<Interception.Interceptor>> interceptors() {
+        try {
+            stateReadLock.lock();
+            if (interceptors != null) {
+                return List.copyOf(interceptors.values());
             }
-            try {
-                lock.lock();
-                return lazyInstance.get();
-            } finally {
-                lock.unlock();
+        } finally {
+            stateReadLock.unlock();
+        }
+        try {
+            stateWriteLock.lock();
+            if (interceptors == null) {
+                // we must preserve the order of services, as they are weight ordered!
+                this.interceptors = new LinkedHashMap<>();
+                List<ServiceManager<Interception.Interceptor>> serviceManagers =
+                        lookupManagers(Lookup.builder()
+                                               .addContract(Interception.Interceptor.class)
+                                               .addQualifier(Qualifier.WILDCARD_NAMED)
+                                               .build());
+                for (ServiceManager<Interception.Interceptor> serviceManager : serviceManagers) {
+                    this.interceptors.put(serviceManager.descriptor(), serviceManager);
+                }
             }
+            return List.copyOf(interceptors.values());
+        } finally {
+            stateWriteLock.unlock();
         }
+    }
 
-        @Override
-        public double weight() {
-            return descriptor.weight();
-        }
+    void ensureInjectionPlans() {
+        servicesByDescriptor.values()
+                .forEach(ServiceManager::ensureInjectionPlan);
+    }
 
-        @Override
-        public TypeName descriptorType() {
-            return descriptor.descriptorType();
-        }
+    private void cacheAndAccess(Lookup lookup, List<ServiceInfo> result) {
+        cache.put(lookup, result);
+        result.forEach(this::accessed);
+    }
 
-        @SuppressWarnings({"unchecked", "rawtypes"})
-        @Override
-        public void close() {
-            if (lazyInstance.isLoaded()) {
-                lazyInstance.get().ifPresent(it -> ((ServiceDescriptor) descriptor).preDestroy(it));
-            }
+    private void accessed(ServiceInfo service) {
+        stateReadLock.lock();
+        try {
+            accessedContracts.get(ResolvedType.create(service.serviceType())).set(true);
+            service.contracts()
+                    .forEach(it -> accessedContracts.get(it).set(true));
+        } finally {
+            stateReadLock.unlock();
         }
     }
 
-    private record DiscoveredDescriptor(CoreServiceRegistry registry,
-                                        DescriptorHandler metadata,
-                                        ServiceAndInstance instances,
-                                        ReentrantLock lock) implements ServiceProvider {
-
-        private DiscoveredDescriptor(CoreServiceRegistry registry,
-                                     DescriptorHandler metadata,
-                                     ServiceAndInstance instances) {
-            this(registry, metadata, instances, new ReentrantLock());
+    private void checkValidContract(ResolvedType contract) {
+        AtomicBoolean accessed = accessedContracts.get(contract);
+        if (accessed == null) {
+            throw new ServiceRegistryException("Contract " + contract.resolvedName()
+                                                       + " is not provided by any service in the registry, so it cannot have "
+                                                       + "instances configured, as no services can use it.");
+        }
+        if (accessed.get()) {
+            throw new ServiceRegistryException("Contract " + contract.resolvedName()
+                                                       + " has already been set, or accessed by a service, its instances "
+                                                       + "cannot be re-configured, as that would end up in inconsistent "
+                                                       + "state of the service registry.");
         }
+    }
 
-        @Override
-        public ServiceDescriptor<?> descriptor() {
-            return metadata.descriptor();
+    private void checkCreateForName(Lookup lookup) {
+        if (lookup.qualifiers().size() != 1) {
+            throw new ServiceRegistryException("Invalid injection lookup. @"
+                                                       + Service.InstanceName.class.getName()
+                                                       + " must be the only qualifier used.");
+        }
+        if (!lookup.contracts().contains(ResolvedType.create(TypeNames.STRING))) {
+            throw new ServiceRegistryException("Invalid injection lookup. @"
+                                                       + Service.InstanceName.class.getName()
+                                                       + " must use String contract.");
+        }
+        if (lookup.contracts().size() != 1) {
+            throw new ServiceRegistryException("Invalid injection lookup. @"
+                                                       + Service.InstanceName.class.getName()
+                                                       + " must use String as the only contract.");
         }
+    }
 
-        @Override
-        public Optional<Object> instance() {
-            var instanceSupplier = instances.instanceSupplier();
-            if ((instanceSupplier instanceof LazyValue<?> lv) && lv.isLoaded()) {
-                return instanceSupplier.get();
-            }
-            if (lock.isHeldByCurrentThread()) {
-                throw new ServiceRegistryException("Cyclic dependency, attempting to obtain an instance of "
-                                                           + metadata.descriptor().serviceType().fqName()
-                                                           + " while instantiating it");
-            }
-            try {
-                lock.lock();
-                return instanceSupplier.get();
-            } finally {
-                lock.unlock();
-            }
+    private Supplier<Scope> scopeSupplier(ServiceInfo descriptor) {
+        TypeName scope = descriptor.scope();
+        if (Service.Singleton.TYPE.equals(scope)) {
+            return singletonScope;
+        } else if (Service.PerLookup.TYPE.equals(scope)) {
+            return perLookupScope;
+        } else {
+            // must be a lazy value, as the scope handler may not be available at the time this method is called
+            LazyValue<Service.ScopeHandler> scopeHandler = LazyValue.create(() -> scopeHandler(scope));
+            return () -> scopeHandler.get()
+                    .currentScope() // must be called each time, as we must use the currently active scope, not a cached one
+                    .orElseThrow(() -> new ScopeNotActiveException("Scope not active for service: "
+                                                                           + descriptor.serviceType().fqName(),
+                                                                   scope));
         }
+    }
 
-        @Override
-        public double weight() {
-            return metadata.weight();
+    private Scope createScope(TypeName scopeType,
+                              Service.ScopeHandler scopeHandler,
+                              String id,
+                              Map<ServiceDescriptor<?>, Object> initialBindings) {
+        var registry = new ScopedRegistryImpl(this, scopeType, id, initialBindings);
+        var scope = new ScopeImpl(scopeType, scopeHandler, registry);
+        scopeHandler.activate(scope);
+        return scope;
+    }
+
+    private Service.ScopeHandler scopeHandler(TypeName scope) {
+        scopeHandlerInstancesLock.lock();
+        try {
+            return scopeHandlerInstances.computeIfAbsent(scope, it -> {
+                ServiceInfo serviceInfo = scopeHandlerServices.get(scope);
+                if (serviceInfo == null) {
+                    throw new ServiceRegistryException("There is no scope handler service registered for scope: "
+                                                               + scope.fqName());
+                }
+                ServiceManager<?> serviceManager = servicesByDescriptor.get(serviceInfo);
+                return (Service.ScopeHandler) serviceManager.activator()
+                        .instances(Lookup.EMPTY)
+                        .orElseThrow(() -> new ServiceRegistryException("Scope handler service did not return any instance for: "
+                                                                                + scope.fqName()))
+                        .getFirst() // List.getFirst() - Qualified instance
+                        .get();
+            });
+        } finally {
+            scopeHandlerInstancesLock.unlock();
         }
+    }
+
+    private record ScopeImpl(TypeName scopeType,
+                             Service.ScopeHandler handler,
+                             ScopedRegistry registry) implements Scope {
 
         @Override
-        public TypeName descriptorType() {
-            return metadata.descriptorType();
+        public void close() {
+            handler.deactivate(this);
         }
 
-        @SuppressWarnings({"unchecked", "rawtypes"})
         @Override
-        public void close() {
-            var serviceSupplier = instances.serviceSupplier();
-            if (serviceSupplier.isLoaded()) {
-                serviceSupplier.get().ifPresent(it -> ((ServiceDescriptor) metadata.descriptor()).preDestroy(it));
-            }
+        public String toString() {
+            return "Scope for " + scopeType.fqName();
         }
     }
+
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistryManager.java
deleted file mode 100644
index a6d61242da5..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistryManager.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-class CoreServiceRegistryManager implements ServiceRegistryManager {
-    private final ReentrantReadWriteLock lifecycleLock = new ReentrantReadWriteLock();
-    private final ServiceRegistryConfig config;
-    private final ServiceDiscovery discovery;
-
-    private CoreServiceRegistry registry;
-
-    CoreServiceRegistryManager(ServiceRegistryConfig config, ServiceDiscovery discovery) {
-        this.config = config;
-        this.discovery = discovery;
-    }
-
-    @Override
-    public ServiceRegistry registry() {
-        Lock readLock = lifecycleLock.readLock();
-        try {
-            readLock.lock();
-            if (registry != null) {
-                return registry;
-            }
-        } finally {
-            readLock.unlock();
-        }
-
-        Lock writeLock = lifecycleLock.writeLock();
-        try {
-            writeLock.lock();
-            if (registry != null) {
-                return registry;
-            }
-
-            registry = new CoreServiceRegistry(config, discovery);
-
-            return registry;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public void shutdown() {
-        Lock lock = lifecycleLock.writeLock();
-        try {
-            lock.lock();
-            registry.shutdown();
-            registry = null;
-        } finally {
-            lock.unlock();
-        }
-    }
-
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
index 7f9497676f7..a11d9536a37 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
@@ -16,9 +16,15 @@
 
 package io.helidon.service.registry;
 
+import java.util.Optional;
+import java.util.Set;
+
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
 import io.helidon.common.GenericType;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.TypeName;
 
 /**
@@ -86,4 +92,52 @@ interface DependencyBlueprint {
      */
     @Option.Redundant(stringValue = false)
     TypeName typeName();
+
+    /**
+     * Kind of element we inject into (constructor, field, method).
+     *
+     * @return element kind (for parameters, the containing element)
+     */
+    @Option.Default("CONSTRUCTOR")
+    ElementKind elementKind();
+
+    /**
+     * The qualifier type annotations on this element.
+     *
+     * @return the qualifier type annotations on this element
+     */
+    @Option.Singular
+    @Option.Redundant(stringValue = false)
+    // kind + service type + name is a unique identification already
+    Set<Qualifier> qualifiers();
+
+    /**
+     * The access modifier on the injection point/receiver.
+     * Defaults to {@link io.helidon.common.types.AccessModifier#PACKAGE_PRIVATE}.
+     *
+     * @return the access
+     */
+    @Option.Default("PACKAGE_PRIVATE")
+    @Option.Redundant
+    // kind + service type + name is a unique identification already
+    AccessModifier access();
+
+    /**
+     * The annotations on this element.
+     *
+     * @return the annotations on this element
+     */
+    @Option.Singular
+    @Option.Redundant
+    // kind + service type + name is a unique identification already
+    Set<Annotation> annotations();
+
+    /**
+     * Top level method that declares this method.
+     * This is to provide information about overridden methods, as we should only inject such methods once.
+     *
+     * @return unique identification of a declaring method
+     */
+    @Option.Redundant(stringValue = false)
+    Optional<String> method();
 }
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionPlanBinder.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
similarity index 93%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/InjectionPlanBinder.java
rename to service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
index 47537a53783..24a4abb3b5d 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionPlanBinder.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
-
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.ServiceInfo;
+package io.helidon.service.registry;
 
 /**
  * Responsible for registering the injection plan to the services in the service registry.
@@ -26,7 +23,7 @@
  * instances for {@link io.helidon.service.registry.ServiceInfo} parameter, as the registry depends on instance
  * equality. All generated code is done this way.
  */
-public interface InjectionPlanBinder {
+public interface DependencyPlanBinder {
 
     /**
      * Bind an injection plan to a service provider instance.
@@ -34,21 +31,21 @@ public interface InjectionPlanBinder {
      * @param descriptor the service to receive the injection plan.
      * @return the binder to use for binding the injection plan to the service provider
      */
-    Binder bindTo(io.helidon.service.registry.ServiceInfo descriptor);
+    Binder bindTo(ServiceInfo descriptor);
 
     /**
      * Bind all discovered interceptors.
      *
      * @param descriptors interceptor services
      */
-    void interceptors(io.helidon.service.registry.ServiceInfo... descriptors);
+    void interceptors(ServiceInfo... descriptors);
 
     /**
      * The binder builder for the service plan.
      * The caller must be aware of cardinality and type (whether to inject {@link java.util.function.Supplier} or instance)
      * of injections.
      *
-     * @see io.helidon.service.inject.api.Ip
+     * @see io.helidon.service.registry.Dependency
      */
     interface Binder {
 
@@ -160,7 +157,7 @@ Binder bindListOfSuppliers(Dependency dependency,
         /**
          * Bind to a list of service instances.
          *
-         * @param dependency the injection point identity
+         * @param dependency  the injection point identity
          * @param descriptors the service descriptors to bind (zero or more)
          * @return the binder builder
          */
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Event.java b/service/registry/src/main/java/io/helidon/service/registry/Event.java
similarity index 85%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Event.java
rename to service/registry/src/main/java/io/helidon/service/registry/Event.java
index 194319e7af2..5e91d91a4c8 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Event.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Event.java
@@ -14,21 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Target;
 import java.util.concurrent.CompletionStage;
 
-import io.helidon.service.registry.Service;
-
 /**
  * Injection event types.
  * <p>
- * To publish an event, inject an instance of {@link io.helidon.service.inject.api.Event.Emitter}.
+ * To publish an event, inject an instance of {@link io.helidon.service.registry.Event.Emitter}.
  * <p>
  * To receive events, implement a method (at least package private) with the event object as a parameter, annotated with
- * {@link io.helidon.service.inject.api.Event.Observer}. The method can have any name, must be {@code void},
+ * {@link io.helidon.service.registry.Event.Observer}. The method can have any name, must be {@code void},
  * and have a single parameter that defines the event type.
  */
 public final class Event {
@@ -45,8 +43,8 @@ private Event() {
     /**
      * A service method that is an event observer. The method MUST have a parameter that is the type of the event.
      * Async observers are invoked on a separate thread and will never feed information back to the
-     * {@link io.helidon.service.inject.api.Event.Emitter}
-     * (even if {@link io.helidon.service.inject.api.Event.Emitter#emitAsync(Object, Qualifier...)} is used).
+     * {@link io.helidon.service.registry.Event.Emitter}
+     * (even if {@link io.helidon.service.registry.Event.Emitter#emitAsync(Object, Qualifier...)} is used).
      */
     @Target({ElementType.METHOD, ElementType.TYPE})
     public @interface AsyncObserver {
@@ -72,7 +70,7 @@ public interface Emitter<T> {
          *
          * @param eventObject event object to deliver to the observers
          * @param qualifiers  qualifiers (zero or more) that qualify this event instance
-         * @throws io.helidon.service.inject.api.EventDispatchException if any exception is encountered, the first one is the
+         * @throws io.helidon.service.registry.EventDispatchException if any exception is encountered, the first one is the
          *                                                              cause, and all others are added as a
          *                                                              suppressed exception to the thrown exception
          */
@@ -82,7 +80,7 @@ public interface Emitter<T> {
          * Emit an event.
          * The method returns immediately with a completion stage that will get completed
          * when all observers are notified. If any observer throws an exception, an
-         * {@link io.helidon.service.inject.api.EventDispatchException} is created, all exceptions are added as suppressed to it,
+         * {@link io.helidon.service.registry.EventDispatchException} is created, all exceptions are added as suppressed to it,
          * and it is thrown, so {@link java.util.concurrent.CompletionStage#exceptionally(java.util.function.Function)}
          * is invoked on the returned stage.
          * <p>
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/EventDispatchException.java b/service/registry/src/main/java/io/helidon/service/registry/EventDispatchException.java
similarity index 96%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/EventDispatchException.java
rename to service/registry/src/main/java/io/helidon/service/registry/EventDispatchException.java
index 897c39c25f8..adfdef128d3 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/EventDispatchException.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/EventDispatchException.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Objects;
 
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/EventManager.java b/service/registry/src/main/java/io/helidon/service/registry/EventManager.java
similarity index 94%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/EventManager.java
rename to service/registry/src/main/java/io/helidon/service/registry/EventManager.java
index c777121d09f..12a5b153baf 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/EventManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/EventManager.java
@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Set;
 import java.util.concurrent.CompletionStage;
 import java.util.function.Consumer;
 
 import io.helidon.common.types.ResolvedType;
-import io.helidon.service.registry.Service;
 
 /**
  * Event manager is used by generated code to manage events and listeners.
@@ -68,7 +67,7 @@ void emit(ResolvedType eventObjectType,
      * @param <T>             type of the event object
      * @return completion stage that completes when all synchronous event observers are notified; it may end exceptionally,
      *         if any of these throws an exception - in such a case all exceptions are available through the cause, or suppressed
-     *         exceptions of {@link io.helidon.service.inject.api.EventDispatchException}
+     *         exceptions of {@link io.helidon.service.registry.EventDispatchException}
      */
     <T> CompletionStage<T> emitAsync(ResolvedType eventObjectType,
                                      T eventObject,
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/EventManagerImpl.java b/service/registry/src/main/java/io/helidon/service/registry/EventManagerImpl.java
similarity index 92%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/EventManagerImpl.java
rename to service/registry/src/main/java/io/helidon/service/registry/EventManagerImpl.java
index 90d526f0aa2..87f3cc4dee9 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/EventManagerImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/EventManagerImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -32,14 +32,9 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.types.ResolvedType;
-import io.helidon.service.inject.api.EventDispatchException;
-import io.helidon.service.inject.api.EventManager;
-import io.helidon.service.inject.api.GeneratedInjectService.EventObserverRegistration;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.registry.Service;
-
-@Injection.Singleton
+import io.helidon.service.registry.GeneratedService.EventObserverRegistration;
+
+@Service.Singleton
 class EventManagerImpl implements EventManager {
     private static final System.Logger LOGGER = System.getLogger(EventManager.class.getName());
 
@@ -49,9 +44,9 @@ class EventManagerImpl implements EventManager {
     private final ReadWriteLock listenersLock = new ReentrantReadWriteLock();
     private final ExecutorService executor;
 
-    @Injection.Inject
+    @Service.Inject
     EventManagerImpl(Supplier<List<EventObserverRegistration>> registrations,
-                     @Injection.NamedByType(EventManager.class) Optional<ExecutorService> executorService) {
+                     @Service.NamedByType(EventManager.class) Optional<ExecutorService> executorService) {
         this.registrations = registrations;
         this.executor = executorService.orElseGet(() -> Executors.newThreadPerTaskExecutor(
                 Thread.ofVirtual()
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
index b92d4692bbd..9866603eacc 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
@@ -88,7 +88,7 @@ public Set<ResolvedType> contracts() {
     }
 
     @Override
-    public Object instantiate(DependencyContext ctx) {
+    public Object instantiate(DependencyContext ctx, InterceptionMetadata metadata) {
         return instance;
     }
 
@@ -119,4 +119,9 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(instance, contracts, weight);
     }
+
+    @Override
+    public TypeName scope() {
+        return Service.Singleton.TYPE;
+    }
 }
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/FactoryType.java b/service/registry/src/main/java/io/helidon/service/registry/FactoryType.java
similarity index 81%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/FactoryType.java
rename to service/registry/src/main/java/io/helidon/service/registry/FactoryType.java
index b6a6c705603..fb1e5a3afe9 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/FactoryType.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/FactoryType.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 /**
  * Described service factory type.
@@ -39,15 +39,15 @@ public enum FactoryType {
      */
     SUPPLIER,
     /**
-     * The service implements a {@link io.helidon.service.inject.api.Injection.ServicesFactory}.
+     * The service implements a {@link io.helidon.service.registry.Service.ServicesFactory}.
      */
     SERVICES,
     /**
-     * The service implements an {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}.
+     * The service implements an {@link io.helidon.service.registry.Service.InjectionPointFactory}.
      */
     INJECTION_POINT,
     /**
-     * The service implements a {@link io.helidon.service.inject.api.Injection.QualifiedFactory}.
+     * The service implements a {@link io.helidon.service.registry.Service.QualifiedFactory}.
      */
     QUALIFIED
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/GeneratedService.java b/service/registry/src/main/java/io/helidon/service/registry/GeneratedService.java
index 85a68e2f86c..c16868db3e7 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/GeneratedService.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/GeneratedService.java
@@ -16,319 +16,264 @@
 
 package io.helidon.service.registry;
 
+import java.lang.annotation.Annotation;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
-import io.helidon.builder.api.Prototype;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.ConfiguredProvider;
-import io.helidon.common.config.NamedService;
+import io.helidon.common.GenericType;
+import io.helidon.common.types.ElementKind;
+import io.helidon.common.types.TypeName;
 
 /**
  * All types in this class are used from generated code for services.
  */
 public final class GeneratedService {
-    private static final System.Logger PROVIDER_LOGGER = System.getLogger(Prototype.class.getName() + ".provider");
+    private GeneratedService() {
+    }
 
     /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * the mapping to a provider.
-     * Type of service, used to map to {@link io.helidon.common.config.ConfiguredProvider#configKey()}, which is the
-     * default "type" of a configured provider. It is then used in {@link io.helidon.common.config.NamedService#type()},
-     * to allow multiple instances of the same "type" with different "name".
+     * Each descriptor for s service that is implements {@link Service.QualifiedFactory}
+     * implements this interface to provide information about the qualifier it supports.
      */
-    private static final String KEY_SERVICE_TYPE = "type";
+    public interface QualifiedFactoryDescriptor {
+        /**
+         * Type of qualifier a {@link Service.QualifiedFactory} provides.
+         *
+         * @return type name of the qualifier this qualified factory can provide instances for
+         */
+        TypeName qualifierType();
+    }
+
     /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * the name of an instance.
-     * It is then used in {@link io.helidon.common.config.NamedService#name()}
-     * to allow multiple instances of the same "type" with different "name".
-     * In case of object type configurations, name is taken from the configuration node name.
+     * Each descriptor for s service that is annotated with {@link Service.PerInstance}
+     * implements this interface to provide information about the type that drives it.
      */
-    private static final String KEY_SERVICE_NAME = "name";
+    public interface PerInstanceDescriptor {
+        /**
+         * Service instances may be created for instances of another service.
+         * If a type is created for another type, it inherits ALL qualifiers of the type that it is based on.
+         *
+         * @return create for service type
+         */
+        TypeName createFor();
+    }
+
     /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * whether a service provider of the type is enabled.
-     * Each service from a {@link io.helidon.common.config.ConfiguredProvider} can be enabled/disabled through
-     * configuration. If marked as {@code enabled = false}, the service will be ignored and not added.
+     * Each descriptor for a service that implements {@link Service.ScopeHandler}
+     * implements this interface to provide information about the scope it handles.
      */
-    private static final String KEY_SERVICE_ENABLED = "enabled";
-
-    private GeneratedService() {
+    public interface ScopeHandlerDescriptor {
+        /**
+         * Scope handled by the scope handler service.
+         *
+         * @return type of the scope handled (annotation)
+         */
+        TypeName handledScope();
     }
 
     /**
-     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
-     *
-     * @param config configuration of the option
-     * @param configKey configuration key associated with this option
-     * @param serviceRegistry service registry instance
-     * @param providerType type of the service provider (contract)
-     * @param configType type of the configuration
-     * @param allFromRegistry whether to use all services from the registry
-     * @param existingValues existing values that was explicitly configured by the user
-     * @return instances from the user augmented with instances from the registry
-     * @param <T> type of the service
+     * For event observers an observer registration is generated, so it can be picked-up by the
+     * {@link EventManager} implementation at runtime.
      */
-    public static <T extends NamedService> List<T> discoverServices(Config config,
-                                                                    String configKey,
-                                                                    ServiceRegistry serviceRegistry,
-                                                                    Class<? extends ConfiguredProvider<T>> providerType,
-                                                                    Class<T> configType,
-                                                                    boolean allFromRegistry,
-                                                                    List<T> existingValues) {
-
-        // type and name is a unique identification of a service - for services already defined on the builder
-        // do not add them from configuration (as this would duplicate service instances)
-        Set<TypeAndName> ignoredServices = new HashSet<>();
-        existingValues.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
-
-        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromRegistry);
-        Config providersConfig = config.get(configKey);
-
-        List<ConfiguredService> configuredServices = new ArrayList<>();
-
-        // all child nodes of the current node
-        List<Config> serviceConfigList = providersConfig.asNodeList()
-                .orElseGet(List::of);
-        boolean isList = providersConfig.isList();
+    @Service.Contract
+    public interface EventObserverRegistration {
+        /**
+         * Register with the event manager.
+         *
+         * @param manager event manager
+         */
+        void register(EventManager manager);
+    }
 
-        for (Config serviceConfig : serviceConfigList) {
-            configuredServices.add(configuredService(serviceConfig, isList));
+    /**
+     * Utility type to provide method to combine injection point information for inheritance support.
+     */
+    public static final class DependencySupport {
+        private DependencySupport() {
         }
 
-        // now we have all service configurations, we can start building up instances
-        if (providersConfig.isList()) {
-            // driven by order of declaration in config
-            return servicesFromList(serviceRegistry,
-                                    providerType,
-                                    configType,
-                                    configuredServices,
-                                    discoverServices,
-                                    ignoredServices);
-        } else {
-            // driven by service loader order
-            return servicesFromObject(providersConfig,
-                                      serviceRegistry,
-                                      providerType,
-                                      configType,
-                                      configuredServices,
-                                      discoverServices,
-                                      ignoredServices);
+        /**
+         * Combine dependencies from this type with dependencies from supertype.
+         * This is a utility for code generated types.
+         *
+         * @param myType    this type's dependencies
+         * @param superType super type's dependencies
+         * @return a new list without constructor dependencies from super type
+         */
+        public static List<Dependency> combineDependencies(List<Dependency> myType, List<Dependency> superType) {
+            List<Dependency> result = new ArrayList<>(myType);
+
+            // always inject all fields
+            result.addAll(superType.stream()
+                                  .filter(it -> it.elementKind() == ElementKind.FIELD)
+                                  .toList());
+            // ignore constructors, as we only need to inject constructor on the instantiated type
+
+            // and only add methods that are not already injected on existing type
+            Set<String> injectedMethods = myType.stream()
+                    .filter(it -> it.elementKind() == ElementKind.METHOD)
+                    .map(Dependency::method)
+                    .flatMap(Optional::stream)
+                    .collect(Collectors.toSet());
+
+            result.addAll(superType.stream()
+                                  .filter(it -> it.elementKind() == ElementKind.METHOD)
+                                  .filter(it -> it.method().isPresent())
+                                  .filter(it -> injectedMethods.add(it.method().get())) // we check presence above
+                                  .toList());
+
+            return List.copyOf(result);
         }
     }
 
     /**
-     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     * Intercepted wrapper for generated interception delegates.
      *
-     * @param config configuration of the option
-     * @param configKey configuration key associated with this option
-     * @param serviceRegistry service registry instance
-     * @param providerType type of the service provider (contract)
-     * @param configType type of the configuration
-     * @param discoverServices whether to discover services from registry
-     * @param existingValue existing value that was explicitly configured by the user
-     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
-     * @param <T> type of the service
+     * @param <T> type of the provided contratc
      */
-    public static <T extends NamedService> Optional<T>
-    discoverService(Config config,
-                    String configKey,
-                    ServiceRegistry serviceRegistry,
-                    Class<? extends ConfiguredProvider<T>> providerType,
-                    Class<T> configType,
-                    boolean discoverServices,
-                    Optional<T> existingValue) {
-
-        // there is an explicit configuration for this service, ignore configuration
-        if (existingValue.isPresent()) {
-            return Optional.empty();
+    abstract static class InterceptionWrapper<T> {
+        /**
+         * Wrap a qualified instance so the actual instance is correctly intercepted.
+         *
+         * @param qualifiedInstance qualified instance created by appropriate factory
+         * @return qualified instance with wrapped instance
+         */
+        protected Service.QualifiedInstance<T> wrapQualifiedInstance(Service.QualifiedInstance<T> qualifiedInstance) {
+            return Service.QualifiedInstance.create(wrap(qualifiedInstance.get()), qualifiedInstance.qualifiers());
         }
 
-        // all child nodes of the current node
-        List<Config> serviceConfigList = config.get(configKey).asNodeList()
-                .orElseGet(List::of);
+        /**
+         * Wrap the instance for interception.
+         * This method is code generated.
+         *
+         * @param originalInstance instance to wrap
+         * @return wrapped instance
+         */
+        protected abstract T wrap(T originalInstance);
+    }
 
-        // if more than one is configured in config, fail
-        // if more than one exists in service loader, use the first one
-        if (serviceConfigList.size() > 1) {
-            throw new ConfigException("There can only be one provider configured for " + config.key());
+    /**
+     * Wrapper for generated Service factories that implement a {@link java.util.function.Supplier} of a service.
+     *
+     * @param <T> type of the provided contract
+     */
+    public abstract static class SupplierFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
+            implements Supplier<T> {
+        private final Supplier<T> delegate;
+
+        /**
+         * Creates a new instance delegating service instantiation to the provided supplier.
+         *
+         * @param delegate used to obtain service instance that will be {@link #wrap(Object) wrapped} for interception
+         */
+        protected SupplierFactoryInterceptionWrapper(Supplier<T> delegate) {
+            this.delegate = delegate;
         }
 
-        List<T> services = discoverServices(config,
-                                            configKey,
-                                            serviceRegistry,
-                                            providerType,
-                                            configType,
-                                            discoverServices,
-                                            List.of());
-
-        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
+        @Override
+        public T get() {
+            return wrap(delegate.get());
+        }
     }
 
-    private static ConfiguredService configuredService(Config serviceConfig, boolean isList) {
-        if (isList) {
-            // order is significant
-            String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(null);
-            String name = serviceConfig.get(KEY_SERVICE_NAME).asString().orElse(type);
-            boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
-
-            Config usedConfig = serviceConfig;
-            if (type == null) {
-                // nested approach (we are on the first node of the list, we need to go deeper)
-                List<Config> configs = serviceConfig.asNodeList().orElseGet(List::of);
-                if (configs.size() != 1) {
-                    throw new ConfigException(
-                            "Service provider configuration defined as a list must have a single node that is the type, "
-                                    + "with children containing the provider configuration. Failed on: " + serviceConfig.key());
-                }
-                usedConfig = configs.getFirst();
-                name = usedConfig.name();
-                type = usedConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
-                enabled = usedConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(enabled);
-            }
-            return new ConfiguredService(new TypeAndName(type, name), usedConfig, enabled);
+    /**
+     * Wrapper for generated Service factories that implement a
+     * {@link Service.ServicesFactory}.
+     *
+     * @param <T> type of the provided contract
+     */
+    public abstract static class ServicesFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
+            implements Service.ServicesFactory<T> {
+        private final Service.ServicesFactory<T> delegate;
+
+        /**
+         * Creates a new instance delegating service instantiation to the provided services factory.
+         *
+         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
+         */
+        protected ServicesFactoryInterceptionWrapper(Service.ServicesFactory<T> delegate) {
+            this.delegate = delegate;
         }
-        // just collect each node, order will be determined by weight
 
-        String name = serviceConfig.name(); // name is the config node name for object types
-        String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
-        boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
-
-        return new ConfiguredService(new TypeAndName(type, name), serviceConfig, enabled);
+        @Override
+        public List<Service.QualifiedInstance<T>> services() {
+            return delegate.services()
+                    .stream()
+                    .map(this::wrapQualifiedInstance)
+                    .collect(Collectors.toUnmodifiableList());
+        }
     }
 
-    private static <T extends NamedService> List<T>
-    servicesFromList(ServiceRegistry serviceRegistry,
-                     Class<? extends ConfiguredProvider<T>> providerType,
-                     Class<T> configType,
-                     List<ConfiguredService> configuredServices,
-                     boolean allFromServiceLoader,
-                     Set<TypeAndName> ignoredServices) {
-        Map<String, ConfiguredProvider<T>> allProvidersByType = new HashMap<>();
-        Map<String, ConfiguredProvider<T>> unusedProvidersByType = new LinkedHashMap<>();
-
-        serviceRegistry.all(providerType)
-                .forEach(provider -> {
-                    allProvidersByType.put(provider.configKey(), provider);
-                    unusedProvidersByType.put(provider.configKey(), provider);
-                });
-
-        List<T> result = new ArrayList<>();
-
-        // first add all configured
-        for (ConfiguredService service : configuredServices) {
-            TypeAndName typeAndName = service.typeAndName();
-            if (!ignoredServices.add(typeAndName)) {
-                unusedProvidersByType.remove(typeAndName.type());
-
-                if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                    PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + typeAndName
-                            + " is already added in builder, ignoring configured one.");
-                }
-
-                continue;
-            }
-            ConfiguredProvider<T> provider = allProvidersByType.get(typeAndName.type());
-            if (provider == null) {
-                throw new ConfigException("Unknown provider configured. Expecting a provider with type \"" + typeAndName.type()
-                                                  + "\", but only the following providers are supported: "
-                                                  + allProvidersByType.keySet() + ", "
-                                                  + "provider interface: " + providerType.getName()
-                                                  + ", configured service: " + configType.getName());
-            }
-            unusedProvidersByType.remove(typeAndName.type());
-            if (service.enabled()) {
-                result.add(provider.create(service.serviceConfig(), typeAndName.name()));
-            }
+    /**
+     * Wrapper for generated Service factories that implement a
+     * {@link Service.InjectionPointFactory}.
+     *
+     * @param <T> type of the provided contract
+     */
+    public abstract static class IpFactoryInterceptionWrapper<T> extends InterceptionWrapper<T>
+            implements Service.InjectionPointFactory<T> {
+        private final Service.InjectionPointFactory<T> delegate;
+
+        /**
+         * Creates a new instance delegating service instantiation to the provided injection point factory.
+         *
+         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
+         */
+        protected IpFactoryInterceptionWrapper(Service.InjectionPointFactory<T> delegate) {
+            this.delegate = delegate;
         }
 
-        // then (if desired) add the rest
-        if (allFromServiceLoader) {
-            unusedProvidersByType.forEach((type, provider) -> {
-                if (ignoredServices.add(new TypeAndName(type, type))) {
-                    result.add(provider.create(Config.empty(), type));
-                }
-            });
+        @Override
+        public List<Service.QualifiedInstance<T>> list(Lookup lookup) {
+            return delegate.first(lookup)
+                    .stream()
+                    .map(this::wrapQualifiedInstance)
+                    .collect(Collectors.toUnmodifiableList());
         }
 
-        return result;
+        @Override
+        public Optional<Service.QualifiedInstance<T>> first(Lookup lookup) {
+            return delegate.first(lookup)
+                    .map(this::wrapQualifiedInstance);
+        }
     }
 
-    private static <T extends NamedService> List<T>
-    servicesFromObject(Config providersConfig,
-                       ServiceRegistry serviceRegistry,
-                       Class<? extends ConfiguredProvider<T>> providerType,
-                       Class<T> configType,
-                       List<ConfiguredService> configuredServices,
-                       boolean allFromServiceLoader,
-                       Set<TypeAndName> ignoredServices) {
-        // order is determined by service loader
-        Set<String> availableProviders = new HashSet<>();
-        Map<String, ConfiguredService> allConfigs = new HashMap<>();
-        configuredServices.forEach(it -> allConfigs.put(it.typeAndName().type, it));
-        Set<String> unusedConfigs = new HashSet<>(allConfigs.keySet());
-
-        List<T> result = new ArrayList<>();
-
-        List<? extends ConfiguredProvider<T>> all = serviceRegistry.all(providerType);
-        for (ConfiguredProvider<T> provider : all) {
-            ConfiguredService configuredService = allConfigs.get(provider.configKey());
-            availableProviders.add(provider.configKey());
-            unusedConfigs.remove(provider.configKey());
-            if (configuredService == null) {
-                if (allFromServiceLoader) {
-                    // even though the specific key does not exist, we want to have the real config tree, so we can get to the
-                    // root of it
-                    // when there is no configuration, the name defaults to the type
-                    String type = provider.configKey();
-                    if (ignoredServices.add(new TypeAndName(type, type))) {
-                        result.add(provider.create(providersConfig.get(type), type));
-                    } else {
-                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + new TypeAndName(type, type)
-                                    + " is already added in builder, ignoring configured one.");
-                        }
-                    }
-                }
-            } else {
-                if (configuredService.enabled()) {
-                    if (ignoredServices.add(configuredService.typeAndName())) {
-                        result.add(provider.create(configuredService.serviceConfig(),
-                                                   configuredService.typeAndName().name()));
-                    } else {
-                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + configuredService.typeAndName()
-                                    + " is already added in builder, ignoring configured one.");
-                        }
-                    }
-                }
-            }
+    /**
+     * Wrapper for generated Service factories that implement a
+     * {@link Service.QualifiedFactory}.
+     *
+     * @param <T> type of the provided contract
+     * @param <A> type of the qualifier annotation
+     */
+    public abstract static class QualifiedFactoryInterceptionWrapper<T, A extends Annotation> extends InterceptionWrapper<T>
+            implements Service.QualifiedFactory<T, A> {
+        private final Service.QualifiedFactory<T, A> delegate;
+
+        /**
+         * Creates a new instance delegating service instantiation to the provided qualified factory.
+         *
+         * @param delegate used to obtain service instances that will be {@link #wrap(Object) wrapped} for interception
+         */
+        protected QualifiedFactoryInterceptionWrapper(Service.QualifiedFactory<T, A> delegate) {
+            this.delegate = delegate;
         }
 
-        if (!unusedConfigs.isEmpty()) {
-            throw new ConfigException("Unknown provider configured. Expected providers with types: " + unusedConfigs
-                                              + ", but only the following providers are supported: " + availableProviders
-                                              + ", provider interface: " + providerType.getName()
-                                              + ", configured service: " + configType.getName());
+        @Override
+        public List<Service.QualifiedInstance<T>> list(Qualifier qualifier, Lookup lookup, GenericType<T> type) {
+            return delegate.list(qualifier, lookup, type)
+                    .stream()
+                    .map(this::wrapQualifiedInstance)
+                    .collect(Collectors.toUnmodifiableList());
         }
-        return result;
-    }
 
-    private record TypeAndName(String type, String name) {
-    }
-
-    private record ConfiguredService(TypeAndName typeAndName, Config serviceConfig, boolean enabled) {
+        @Override
+        public Optional<Service.QualifiedInstance<T>> first(Qualifier qualifier, Lookup lookup, GenericType<T> type) {
+            return delegate.first(qualifier, lookup, type)
+                    .map(this::wrapQualifiedInstance);
+        }
     }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/GlobalServiceRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/GlobalServiceRegistry.java
index 33e4982f209..1f687282314 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/GlobalServiceRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/GlobalServiceRegistry.java
@@ -21,8 +21,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 
-import io.helidon.common.config.GlobalConfig;
-
 /**
  * A global singleton manager for a service registry.
  * <p>
@@ -62,12 +60,7 @@ public static ServiceRegistry registry() {
         }
         try {
             RW_LOCK.writeLock().lock();
-            ServiceRegistryConfig config;
-            if (GlobalConfig.configured()) {
-                config = ServiceRegistryConfig.create(GlobalConfig.config().get("registry"));
-            } else {
-                config = ServiceRegistryConfig.create();
-            }
+            ServiceRegistryConfig config = ServiceRegistryConfig.create();
             ServiceRegistry newInstance = ServiceRegistryManager.create(config).registry();
             INSTANCE.set(newInstance);
             return newInstance;
@@ -115,4 +108,5 @@ public static ServiceRegistry registry(ServiceRegistry newGlobalRegistry) {
         INSTANCE.set(newGlobalRegistry);
         return newGlobalRegistry;
     }
+
 }
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionContext.java b/service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
similarity index 92%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/InjectionContext.java
rename to service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
index 6424d128bd3..1ca996e9bb8 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionContext.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
@@ -14,14 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.Map;
 import java.util.NoSuchElementException;
 
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.DependencyContext;
-
 class InjectionContext implements DependencyContext {
     private final Map<Dependency, IpPlan<?>> injectionPlan;
 
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InstanceName__ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
similarity index 85%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/InstanceName__ServiceDescriptor.java
rename to service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
index 12e6d8a0844..ec60f656069 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InstanceName__ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Set;
 
@@ -23,14 +23,14 @@
 import io.helidon.common.types.TypeNames;
 
 /**
- * Service descriptor to enable injection of String name of a {@link io.helidon.service.inject.api.Injection.PerInstance}
- * service (using qualifier {@link io.helidon.service.inject.api.Injection.InstanceName}).
+ * Service descriptor to enable injection of String name of a {@link Service.PerInstance}
+ * service (using qualifier {@link Service.InstanceName}).
  * <p>
  * Not intended for direct use by users, implementation detail of the service registry, must be public,
  * as it may be used in generated binding.
  */
 @SuppressWarnings({"checkstyle:TypeName"}) // matches pattern of generated descriptors
-public class InstanceName__ServiceDescriptor implements InjectServiceDescriptor<String> {
+public class InstanceName__ServiceDescriptor implements ServiceDescriptor<String> {
     /**
      * Singleton instance to be referenced when building bindings.
      */
@@ -59,7 +59,7 @@ public Set<ResolvedType> contracts() {
 
     @Override
     public TypeName scope() {
-        return Injection.Singleton.TYPE;
+        return Service.Singleton.TYPE;
     }
 
     @Override
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Interception.java b/service/registry/src/main/java/io/helidon/service/registry/Interception.java
similarity index 90%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Interception.java
rename to service/registry/src/main/java/io/helidon/service/registry/Interception.java
index 6a524b83285..4926b361521 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Interception.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Interception.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -23,8 +23,6 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.registry.Service;
-
 /**
  * Interception annotations and types.
  * This is the entry point for any annotation and type related to interception in Helidon Inject.
@@ -53,7 +51,7 @@ private Interception() {
      * annotated with interception trigger(s).
      * <p>
      * Classes are by default not good candidates for interception, so they MUST be annotated either with
-     * this annotation, or referenced via {@link io.helidon.service.inject.api.Interception.ExternalDelegate}.
+     * this annotation, or referenced via {@link Interception.ExternalDelegate}.
      * <p>
      * Implementing a delegate for a class introduces several problems, the biggest one being
      * construction side-effects.
@@ -78,7 +76,7 @@ private Interception() {
      * <p>
      * If the factory provides an interface, this annotation is not needed, as interfaces are safe to delegate.
      *
-     * @see io.helidon.service.inject.api.Interception.Delegate
+     * @see Interception.Delegate
      */
     @Documented
     @Retention(RetentionPolicy.CLASS)
@@ -87,14 +85,14 @@ private Interception() {
         /**
          * Type provided by this service factory that is a class and should support interception.
          *
-         * @return type that should be intercepted, see {@link io.helidon.service.inject.api.Interception.Delegate}
+         * @return type that should be intercepted, see {@link Interception.Delegate}
          */
         Class<?> value();
     }
 
     /**
-     * Implementors of this contract must be {@link io.helidon.service.inject.api.Injection.Named}
-     * according to the {@link io.helidon.service.inject.api.Interception.Intercepted} annotation they support.
+     * Implementors of this contract must be {@link io.helidon.service.registry.Service.Named}
+     * according to the {@link Interception.Intercepted} annotation they support.
      */
     @Service.Contract
     public interface Interceptor {
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionContextBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionContextBlueprint.java
similarity index 92%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionContextBlueprint.java
rename to service/registry/src/main/java/io/helidon/service/registry/InterceptionContextBlueprint.java
index 05a24115879..3134f7ec653 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionContextBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionContextBlueprint.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Optional;
@@ -25,7 +25,7 @@
 
 /**
  * Invocation context provides metadata about the invoked element to an interceptor.
- * Used by {@link io.helidon.service.inject.api.Interception.Interceptor}.
+ * Used by {@link Interception.Interceptor}.
  */
 @Prototype.Blueprint
 interface InterceptionContextBlueprint {
@@ -43,7 +43,7 @@ interface InterceptionContextBlueprint {
      *
      * @return the service being intercepted
      */
-    InjectServiceInfo serviceInfo();
+    ServiceInfo serviceInfo();
 
     /**
      * Annotations on the enclosing type.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionException.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionException.java
similarity index 93%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionException.java
rename to service/registry/src/main/java/io/helidon/service/registry/InterceptionException.java
index b16618b9b5d..e0084dce333 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionException.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionException.java
@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
-
-import io.helidon.service.registry.ServiceRegistryException;
+package io.helidon.service.registry;
 
 /**
- * Wraps any checked exceptions that are thrown during the {@link io.helidon.service.inject.api.Interception.Interceptor}
+ * Wraps any checked exceptions that are thrown during the {@link Interception.Interceptor}
  * invocations.
  */
 public class InterceptionException extends ServiceRegistryException {
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionInvoker.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionInvoker.java
similarity index 96%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionInvoker.java
rename to service/registry/src/main/java/io/helidon/service/registry/InterceptionInvoker.java
index a829c9363ea..287118fdccd 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionInvoker.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionInvoker.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 /**
  * Invocation of an element that has parameters, and may throw checked exceptions.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionMetadata.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadata.java
similarity index 90%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionMetadata.java
rename to service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadata.java
index f5cc8bad771..05bac5b6629 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/InterceptionMetadata.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadata.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Set;
@@ -28,13 +28,13 @@
  * <p>
  * Used (mostly) by generated code (passed as a parameter to
  * {@link
- * InjectServiceDescriptor#inject(io.helidon.service.registry.DependencyContext,
+ * ServiceDescriptor#inject(io.helidon.service.registry.DependencyContext,
  * InterceptionMetadata, java.util.Set, Object)}, and
  * {@link
- * InjectServiceDescriptor#instantiate(io.helidon.service.registry.DependencyContext,
+ * ServiceDescriptor#instantiate(io.helidon.service.registry.DependencyContext,
  * InterceptionMetadata)}).
  */
-@Injection.Describe
+@Service.Describe
 public interface InterceptionMetadata {
     /**
      * Create an invoker that handles interception if needed, for constructors.
@@ -50,7 +50,7 @@ public interface InterceptionMetadata {
      *         will
      *         be re-thrown, any runtime exception will be re-thrown
      */
-    <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
+    <T> InterceptionInvoker<T> createInvoker(ServiceInfo descriptor,
                                              Set<Qualifier> typeQualifiers,
                                              List<Annotation> typeAnnotations,
                                              TypedElementInfo element,
@@ -73,7 +73,7 @@ <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
      *         be re-thrown, any runtime exception will be re-thrown
      */
     <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
-                                             InjectServiceInfo descriptor,
+                                             ServiceInfo descriptor,
                                              Set<Qualifier> typeQualifiers,
                                              List<Annotation> typeAnnotations,
                                              TypedElementInfo element,
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InterceptionMetadataImpl.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
similarity index 86%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/InterceptionMetadataImpl.java
rename to service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
index a6daff7e5d4..ad76cbc0c66 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InterceptionMetadataImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -24,23 +24,16 @@
 
 import io.helidon.common.types.Annotation;
 import io.helidon.common.types.TypedElementInfo;
-import io.helidon.service.inject.ServiceSupplies.ServiceSupply;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
-import io.helidon.service.inject.api.InterceptionInvoker;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupply;
 
 class InterceptionMetadataImpl implements InterceptionMetadata {
-    private final InjectServiceRegistryImpl registry;
+    private final CoreServiceRegistry registry;
 
-    private InterceptionMetadataImpl(InjectServiceRegistryImpl registry) {
+    private InterceptionMetadataImpl(CoreServiceRegistry registry) {
         this.registry = registry;
     }
 
-    static InterceptionMetadata create(InjectServiceRegistryImpl registry) {
+    static InterceptionMetadata create(CoreServiceRegistry registry) {
         return new InterceptionMetadataImpl(registry);
     }
 
@@ -49,7 +42,7 @@ static InterceptionMetadata noop() {
     }
 
     @Override
-    public <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
+    public <T> InterceptionInvoker<T> createInvoker(ServiceInfo descriptor,
                                                     Set<Qualifier> typeQualifiers,
                                                     List<Annotation> typeAnnotations,
                                                     TypedElementInfo element,
@@ -80,7 +73,7 @@ public <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
 
     @Override
     public <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
-                                                    InjectServiceInfo descriptor,
+                                                    ServiceInfo descriptor,
                                                     Set<Qualifier> typeQualifiers,
                                                     List<Annotation> typeAnnotations,
                                                     TypedElementInfo element,
@@ -111,8 +104,8 @@ public <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
         }
     }
 
-    private List<Supplier<io.helidon.service.inject.api.Interception.Interceptor>> interceptors(List<Annotation> typeAnnotations,
-                                                                                                TypedElementInfo element) {
+    private List<Supplier<Interception.Interceptor>> interceptors(List<Annotation> typeAnnotations,
+                                                                  TypedElementInfo element) {
         // need to find all interceptors for the providers (ordered by weight)
         List<ServiceManager<Interception.Interceptor>> allInterceptors = registry.interceptors();
 
@@ -131,7 +124,7 @@ private List<Supplier<io.helidon.service.inject.api.Interception.Interceptor>> i
         return result;
     }
 
-    private boolean applicable(List<Annotation> typeAnnotations, InjectServiceInfo serviceInfo) {
+    private boolean applicable(List<Annotation> typeAnnotations, ServiceInfo serviceInfo) {
         for (Annotation typeAnnotation : typeAnnotations) {
             if (serviceInfo.qualifiers().contains(Qualifier.createNamed(typeAnnotation.typeName().fqName()))) {
                 return true;
@@ -142,7 +135,7 @@ private boolean applicable(List<Annotation> typeAnnotations, InjectServiceInfo s
 
     private static class NoopMetadata implements InterceptionMetadata {
         @Override
-        public <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
+        public <T> InterceptionInvoker<T> createInvoker(ServiceInfo descriptor,
                                                         Set<Qualifier> typeQualifiers,
                                                         List<Annotation> typeAnnotations,
                                                         TypedElementInfo element,
@@ -160,7 +153,7 @@ public <T> InterceptionInvoker<T> createInvoker(InjectServiceInfo descriptor,
 
         @Override
         public <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
-                                                        InjectServiceInfo descriptor,
+                                                        ServiceInfo descriptor,
                                                         Set<Qualifier> typeQualifiers,
                                                         List<Annotation> typeAnnotations,
                                                         TypedElementInfo element,
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/Invocation.java b/service/registry/src/main/java/io/helidon/service/registry/Invocation.java
similarity index 87%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/Invocation.java
rename to service/registry/src/main/java/io/helidon/service/registry/Invocation.java
index 63add61c4cf..96155477d6f 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/Invocation.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Invocation.java
@@ -14,26 +14,21 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
-import io.helidon.service.inject.api.InterceptionException;
-import io.helidon.service.inject.api.InterceptionInvoker;
-
 /**
- * Handles the invocation of {@link io.helidon.service.inject.api.Interception.Interceptor} methods.
+ * Handles the invocation of {@link Interception.Interceptor} methods.
  * Note that upon a successful call to the
- * {@link io.helidon.service.inject.api.Interception.Interceptor.Chain#proceed(Object[])}
+ * {@link Interception.Interceptor.Chain#proceed(Object[])}
  * or to the ultimate target, the invocation will be prevented from being executed again.
  *
  * @param <V> the invocation type
- * @see io.helidon.service.inject.api.InterceptionContext
+ * @see io.helidon.service.registry.InterceptionContext
  */
 class Invocation<V> implements Interception.Interceptor.Chain<V> {
     private final InterceptionContext ctx;
@@ -53,7 +48,7 @@ private Invocation(InterceptionContext ctx,
     }
 
     /**
-     * Creates an instance of {@link io.helidon.service.inject.Invocation} and invokes it in this context.
+     * Creates an instance of {@link Invocation} and invokes it in this context.
      *
      * @param ctx               the invocation context
      * @param call              the call to the base service provider's method
@@ -61,8 +56,8 @@ private Invocation(InterceptionContext ctx,
      * @param checkedExceptions expected exception types
      * @param <V>               the type returned from the method element
      * @return the invocation instance
-     * @throws io.helidon.service.inject.api.InterceptionException if there are errors during invocation chain processing
-     * @throws Exception                                           any checked exception declared by the method itself
+     * @throws io.helidon.service.registry.InterceptionException if there are errors during invocation chain processing
+     * @throws Exception                                         any checked exception declared by the method itself
      */
     @SuppressWarnings({"unchecked", "rawtypes"})
     static <V> V invokeInterception(InterceptionContext ctx,
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/IpPlan.java b/service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
similarity index 92%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/IpPlan.java
rename to service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
index 64a6e436eb1..8aed49ffe23 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/IpPlan.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.registry.ServiceInfo;
-
 /**
  * Injection point plan of injection.
  *
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/LookupBlueprint.java
similarity index 91%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/LookupBlueprint.java
rename to service/registry/src/main/java/io/helidon/service/registry/LookupBlueprint.java
index 24cd5dc10fe..6526ed1eb00 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/LookupBlueprint.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Objects;
 import java.util.Optional;
@@ -68,7 +68,7 @@ interface LookupBlueprint {
 
     /**
      * A single {@link io.helidon.common.GenericType} can be defined if the lookup should also honor
-     * {@link io.helidon.service.inject.api.Injection.QualifiedFactory} services that can handle any type.
+     * {@link Service.QualifiedFactory} services that can handle any type.
      * This would be the target type to convert to. If not specified, Object will be used.
      *
      * @return generic type of the contract, if only one contract is desired
@@ -77,7 +77,7 @@ interface LookupBlueprint {
     Optional<GenericType<?>> contractType();
 
     /**
-     * The optional {@link Injection.RunLevel} ascribed to the service.
+     * The optional {@link Service.RunLevel} ascribed to the service.
      *
      * @return the service's run level
      */
@@ -101,7 +101,7 @@ interface LookupBlueprint {
     /**
      * Optionally, the injection point search applies to.
      * There are some service factories (such as
-     * {@link io.helidon.service.inject.api.Injection.InjectionPointFactory}) that
+     * {@link Service.InjectionPointFactory}) that
      * provide instances for a specific injection point.
      * Such factories may require an injection point to be present, and may fail otherwise.
      * <p>
@@ -109,8 +109,8 @@ interface LookupBlueprint {
      *
      * @return the optional injection point context info
      */
-    @Option.Decorator(LookupSupport.IpDecorator.class)
-    Optional<Ip> injectionPoint();
+    @Option.Decorator(LookupSupport.DependencyDecorator.class)
+    Optional<Dependency> dependency();
 
     /**
      * If configured, the lookup will return service factories of the
@@ -124,11 +124,11 @@ interface LookupBlueprint {
      *     <li>{@link FactoryType#SUPPLIER} - only that are {@link java.util.function.Supplier}
      *     of the contract</li>
      *     <li>{@link FactoryType#QUALIFIED} - services that are
-     *     {@link io.helidon.service.inject.api.Injection.QualifiedFactory} of the contract</li>
+     *     {@link Service.QualifiedFactory} of the contract</li>
      *     <li>{@link FactoryType#SERVICES} - services that are
-     *     {@link io.helidon.service.inject.api.Injection.ServicesFactory} of the contract</li>
+     *     {@link Service.ServicesFactory} of the contract</li>
      *     <li>{@link FactoryType#INJECTION_POINT} - services that are
-     *     {@link io.helidon.service.inject.api.Injection.InjectionPointFactory} of the contract</li>
+     *     {@link Service.InjectionPointFactory} of the contract</li>
      *     <li>{@link FactoryType#NONE} - this has no effect and will not modify the lookup</li>
      * </ul>
      *
@@ -161,7 +161,7 @@ && matchesTypes(scopes(), criteria.scopes())
      * @param serviceInfo to compare with
      * @return true if this criteria matches the service descriptor
      */
-    default boolean matches(InjectServiceInfo serviceInfo) {
+    default boolean matches(ServiceInfo serviceInfo) {
         if (this == LookupSupport.CustomMethods.EMPTY) {
             return !serviceInfo.isAbstract();
         }
@@ -210,7 +210,7 @@ default boolean matchesQualifiers(Set<Qualifier> qualifiers) {
         return Qualifiers.matchesQualifiers(qualifiers, qualifiers());
     }
 
-    private static boolean matchesWeight(InjectServiceInfo src,
+    private static boolean matchesWeight(ServiceInfo src,
                                          LookupBlueprint criteria) {
         if (criteria.weight().isEmpty()) {
             return true;
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java b/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
similarity index 78%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
rename to service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
index 6dad1fc703e..e6e9adcd34f 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
@@ -14,17 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Optional;
 import java.util.Set;
 
 import io.helidon.builder.api.Prototype;
 import io.helidon.common.GenericType;
-import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Dependency;
 
 final class LookupSupport {
     private LookupSupport() {
@@ -43,32 +41,13 @@ private CustomMethods() {
         /**
          * Create service lookup from this injection point information.
          *
-         * @param injectionPoint injection point to create lookup for
+         * @param dependency injection point to create lookup for
          * @return lookup to match injection point
          */
         @Prototype.FactoryMethod
-        static Lookup create(Ip injectionPoint) {
-            return Lookup.builder()
-                    .injectionPoint(injectionPoint)
-                    .build();
-        }
-
-        /**
-         * Create lookup from a specific dependency.
-         *
-         * @param dependency dependency to create lookup for
-         * @return lookup for the dependency
-         */
-        @Prototype.FactoryMethod
         static Lookup create(Dependency dependency) {
-            if (dependency instanceof Ip ip) {
-                return create(ip);
-            }
             return Lookup.builder()
-                    .injectionPoint(Ip.builder()
-                                            .from(dependency)
-                                            .elementKind(ElementKind.CONSTRUCTOR)
-                                            .build())
+                    .dependency(dependency)
                     .build();
         }
 
@@ -138,11 +117,11 @@ private static Lookup createEmpty() {
         }
     }
 
-    static final class IpDecorator implements Prototype.OptionDecorator<Lookup.BuilderBase<?, ?>, Optional<Ip>> {
+    static final class DependencyDecorator implements Prototype.OptionDecorator<Lookup.BuilderBase<?, ?>, Optional<Dependency>> {
         @Override
-        public void decorate(Lookup.BuilderBase<?, ?> builder, Optional<Ip> injectionPoint) {
-            if (injectionPoint.isPresent()) {
-                Ip value = injectionPoint.get();
+        public void decorate(Lookup.BuilderBase<?, ?> builder, Optional<Dependency> dependency) {
+            if (dependency.isPresent()) {
+                Dependency value = dependency.get();
                 builder.qualifiers(value.qualifiers())
                         .addContract(ResolvedType.create(value.contract()));
 
@@ -150,15 +129,16 @@ public void decorate(Lookup.BuilderBase<?, ?> builder, Optional<Ip> injectionPoi
                     builder.contractType(value.contractType());
                 }
             } else {
-                builder.injectionPoint().ifPresent(existing -> {
+                builder.dependency().ifPresent(existing -> {
                     // clear if contained only IP stuff
                     boolean shouldClear = true;
                     if (!builder.qualifiers().equals(existing.qualifiers())) {
                         shouldClear = false;
 
                     }
-                    if (!(builder.contracts().contains(ResolvedType.create(existing.contract()))
-                                  && builder.contracts().size() == 1)) {
+                    if (!(
+                            builder.contracts().contains(ResolvedType.create(existing.contract()))
+                                    && builder.contracts().size() == 1)) {
                         shouldClear = false;
                     }
 
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/LookupTrace.java b/service/registry/src/main/java/io/helidon/service/registry/LookupTrace.java
similarity index 91%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/LookupTrace.java
rename to service/registry/src/main/java/io/helidon/service/registry/LookupTrace.java
index 89499f92822..6424a5a0930 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/LookupTrace.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/LookupTrace.java
@@ -14,17 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
 
 import static java.lang.System.Logger.Level.DEBUG;
 import static java.lang.System.Logger.Level.TRACE;
@@ -70,13 +66,13 @@ static <T> void traceLookupInstances(Lookup lookup,
         }
     }
 
-    static void traceLookup(Lookup lookup, String message, List<InjectServiceInfo> services) {
+    static void traceLookup(Lookup lookup, String message, List<ServiceInfo> services) {
         if (LOGGER.isLoggable(DEBUG)) {
             LOGGER.log(DEBUG, "{0}matching service providers {1}: {2}",
                        prefix(lookup),
                        message,
                        services.stream()
-                               .map(InjectServiceInfo::serviceType)
+                               .map(ServiceInfo::serviceType)
                                .map(TypeName::fqName)
                                .collect(Collectors.toUnmodifiableList()));
         }
@@ -98,7 +94,7 @@ private static String instanceInfo(ServiceInstance<?> instance) {
     }
 
     private static String scope(TypeName typeName) {
-        if (typeName.packageName().startsWith("io.helidon.service.inject")) {
+        if (typeName.packageName().startsWith("io.helidon.service.registry")) {
             return typeName.classNameWithEnclosingNames();
         }
         return typeName.fqName();
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/PerRequestScopeHandler.java b/service/registry/src/main/java/io/helidon/service/registry/PerRequestScopeHandler.java
similarity index 89%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/PerRequestScopeHandler.java
rename to service/registry/src/main/java/io/helidon/service/registry/PerRequestScopeHandler.java
index 0cce53fd9ae..ab4645c5ed8 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/PerRequestScopeHandler.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/PerRequestScopeHandler.java
@@ -14,16 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.Optional;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Scope;
-
-@Injection.Singleton
-@Injection.NamedByType(Injection.PerRequest.class)
-class PerRequestScopeHandler implements Injection.ScopeHandler {
+@Service.Singleton
+@Service.NamedByType(Service.PerRequest.class)
+class PerRequestScopeHandler implements Service.ScopeHandler {
     private static final ThreadLocal<ScopeInfo> REQUEST_SCOPES = new ThreadLocal<>();
 
     @Override
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifiedInstanceImpl.java b/service/registry/src/main/java/io/helidon/service/registry/QualifiedInstanceImpl.java
similarity index 89%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/QualifiedInstanceImpl.java
rename to service/registry/src/main/java/io/helidon/service/registry/QualifiedInstanceImpl.java
index 4d37aeb76a2..3a9f4c4834e 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifiedInstanceImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/QualifiedInstanceImpl.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Set;
 
-record QualifiedInstanceImpl<T>(T instance, Set<Qualifier> qualifiers) implements Injection.QualifiedInstance<T> {
+record QualifiedInstanceImpl<T>(T instance, Set<Qualifier> qualifiers) implements Service.QualifiedInstance<T> {
     @Override
     public T get() {
         return instance;
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/QualifierBlueprint.java
similarity index 86%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierBlueprint.java
rename to service/registry/src/main/java/io/helidon/service/registry/QualifierBlueprint.java
index 8d8a9fff5e3..9d8cb9ff529 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/QualifierBlueprint.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import io.helidon.builder.api.Prototype;
 import io.helidon.common.types.Annotation;
 
 /**
  * Represents a qualifier annotation (a specific case of annotations, annotated with
- * {@link Injection.Qualifier}).
+ * {@link io.helidon.service.registry.Service.Qualifier}).
  *
- * @see Injection.Qualifier
+ * @see io.helidon.service.registry.Service.Qualifier
  */
 @Prototype.Blueprint
 @Prototype.CustomMethods(QualifierSupport.CustomMethods.class)
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierSupport.java b/service/registry/src/main/java/io/helidon/service/registry/QualifierSupport.java
similarity index 84%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierSupport.java
rename to service/registry/src/main/java/io/helidon/service/registry/QualifierSupport.java
index b60a22127f2..099e6717b13 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/QualifierSupport.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/QualifierSupport.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -30,23 +30,23 @@
 class QualifierSupport {
     static final class CustomMethods {
         /**
-         * Represents a wildcard {@link Injection.Named} qualifier.
+         * Represents a wildcard {@link io.helidon.service.registry.Service.Named} qualifier.
          */
         @Prototype.Constant
-        static final Qualifier WILDCARD_NAMED = createNamed(Injection.Named.WILDCARD_NAME);
+        static final Qualifier WILDCARD_NAMED = createNamed(Service.Named.WILDCARD_NAME);
 
         /**
-         * Represents an instance named with the default name: {@value Injection.Named#DEFAULT_NAME}.
+         * Represents an instance named with the default name: {@value Service.Named#DEFAULT_NAME}.
          */
         @Prototype.Constant
-        static final Qualifier DEFAULT_NAMED = createNamed(Injection.Named.DEFAULT_NAME);
+        static final Qualifier DEFAULT_NAMED = createNamed(Service.Named.DEFAULT_NAME);
 
         /**
-         * Represents a qualifier used for injecting name of {@link io.helidon.service.inject.api.Injection.PerInstance}
+         * Represents a qualifier used for injecting name of {@link io.helidon.service.registry.Service.PerInstance}
          * instances.
          */
         @Prototype.Constant
-        static final Qualifier CREATE_FOR_NAME = create(Injection.InstanceName.class);
+        static final Qualifier CREATE_FOR_NAME = create(Service.InstanceName.class);
 
         private CustomMethods() {
         }
@@ -132,7 +132,7 @@ static Qualifier create(Annotation annotation) {
         }
 
         /**
-         * Creates a {@link Injection.Named} qualifier.
+         * Creates a {@link Service.Named} qualifier.
          *
          * @param name the name
          * @return named qualifier
@@ -141,22 +141,22 @@ static Qualifier create(Annotation annotation) {
         static Qualifier createNamed(String name) {
             Objects.requireNonNull(name);
             return Qualifier.builder()
-                    .typeName(Injection.Named.TYPE)
+                    .typeName(Service.Named.TYPE)
                     .value(name)
                     .build();
         }
 
         /**
-         * Creates a {@link Injection.Named} qualifier.
+         * Creates a {@link Service.Named} qualifier.
          *
          * @param name the name
          * @return named qualifier
          */
         @Prototype.FactoryMethod
-        static Qualifier createNamed(Injection.Named name) {
+        static Qualifier createNamed(Service.Named name) {
             Objects.requireNonNull(name);
             Qualifier.Builder builder = Qualifier.builder()
-                    .typeName(Injection.Named.TYPE);
+                    .typeName(Service.Named.TYPE);
             if (!name.value().isEmpty()) {
                 builder.value(name.value());
             }
@@ -164,22 +164,22 @@ static Qualifier createNamed(Injection.Named name) {
         }
 
         /**
-         * Creates a {@link Injection.Named} qualifier.
+         * Creates a {@link Service.Named} qualifier.
          *
          * @param name the name
          * @return named qualifier
          */
         @Prototype.FactoryMethod
-        static Qualifier createNamed(Injection.NamedByType name) {
+        static Qualifier createNamed(Service.NamedByType name) {
             Objects.requireNonNull(name);
             return Qualifier.builder()
-                    .typeName(Injection.Named.TYPE)
+                    .typeName(Service.Named.TYPE)
                     .value(name.value().getName())
                     .build();
         }
 
         /**
-         * Creates a {@link Injection.Named} qualifier from a class name.
+         * Creates a {@link Service.Named} qualifier from a class name.
          *
          * @param className class whose name will be used
          * @return named qualifier
@@ -188,14 +188,14 @@ static Qualifier createNamed(Injection.NamedByType name) {
         static Qualifier createNamed(Class<?> className) {
             Objects.requireNonNull(className);
             return Qualifier.builder()
-                    .typeName(Injection.Named.TYPE)
+                    .typeName(Service.Named.TYPE)
                     .value(className.getName())
                     .build();
         }
 
         private static TypeName maybeNamed(TypeName qualifierType) {
-            if (Injection.NamedByType.TYPE.equals(qualifierType)) {
-                return Injection.Named.TYPE;
+            if (Service.NamedByType.TYPE.equals(qualifierType)) {
+                return Service.Named.TYPE;
             }
             return qualifierType;
         }
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Qualifiers.java b/service/registry/src/main/java/io/helidon/service/registry/Qualifiers.java
similarity index 93%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Qualifiers.java
rename to service/registry/src/main/java/io/helidon/service/registry/Qualifiers.java
index e242013621a..3f354238d4b 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Qualifiers.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Qualifiers.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Collection;
 import java.util.Set;
@@ -57,7 +57,7 @@ static boolean matchesQualifiers(Collection<Qualifier> src,
         if (src.contains(Qualifier.WILDCARD_NAMED)) {
             // if provider has any name, and criteria ONLY asks for named, we match
             if (criteria.stream()
-                    .allMatch(it -> it.typeName().equals(Injection.Named.TYPE))) {
+                    .allMatch(it -> it.typeName().equals(Service.Named.TYPE))) {
                 return true;
             }
         }
@@ -65,7 +65,7 @@ static boolean matchesQualifiers(Collection<Qualifier> src,
         for (Qualifier criteriaQualifier : criteria) {
             if (src.contains(criteriaQualifier)) {
                 // NOP;
-            } else if (criteriaQualifier.typeName().equals(Injection.Named.TYPE)) {
+            } else if (criteriaQualifier.typeName().equals(Service.Named.TYPE)) {
                 if (criteriaQualifier.equals(Qualifier.WILDCARD_NAMED)
                         || criteriaQualifier.value().isEmpty()) {
                     // any Named qualifier will match ...
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
new file mode 100644
index 00000000000..6f833ef683f
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
@@ -0,0 +1,8 @@
+package io.helidon.service.registry;
+
+public interface RegistryMetrics {
+    int lookupCount();
+    int fullScanCount();
+    int cacheAccessCount();
+    int cacheHitCount();
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
new file mode 100644
index 00000000000..0922e441113
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
@@ -0,0 +1,47 @@
+package io.helidon.service.registry;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class RegistryMetricsImpl implements RegistryMetrics {
+    private final AtomicInteger lookupCount = new AtomicInteger();
+    private final AtomicInteger fullScanCount = new AtomicInteger();
+    private final AtomicInteger cacheAccessCount = new AtomicInteger();
+    private final AtomicInteger cacheHitCount = new AtomicInteger();
+
+
+    @Override
+    public int lookupCount() {
+        return lookupCount.get();
+    }
+
+    @Override
+    public int fullScanCount() {
+        return fullScanCount.get();
+    }
+
+    @Override
+    public int cacheAccessCount() {
+        return cacheAccessCount.get();
+    }
+
+    @Override
+    public int cacheHitCount() {
+        return cacheHitCount.get();
+    }
+
+    void lookup() {
+        lookupCount.incrementAndGet();
+    }
+
+    void fullScan() {
+        fullScanCount.incrementAndGet();
+    }
+
+    void cacheAccess() {
+        cacheAccessCount.incrementAndGet();
+    }
+
+    void cacheHit() {
+        cacheHitCount.incrementAndGet();
+    }
+}
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Scope.java b/service/registry/src/main/java/io/helidon/service/registry/Scope.java
similarity index 96%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Scope.java
rename to service/registry/src/main/java/io/helidon/service/registry/Scope.java
index 7aed6f43ab6..83d0525496b 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Scope.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Scope.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 /**
  * A scope, such as request scope.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/ScopeNotActiveException.java b/service/registry/src/main/java/io/helidon/service/registry/ScopeNotActiveException.java
similarity index 93%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/ScopeNotActiveException.java
rename to service/registry/src/main/java/io/helidon/service/registry/ScopeNotActiveException.java
index db28fce85ff..0b5df5d34d3 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/ScopeNotActiveException.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ScopeNotActiveException.java
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Objects;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.ServiceRegistryException;
 
 /**
  * An attempt was done to get a service instance from a scope that is not active.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/ScopedRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/ScopedRegistry.java
similarity index 95%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/ScopedRegistry.java
rename to service/registry/src/main/java/io/helidon/service/registry/ScopedRegistry.java
index fd30eaee895..17b679bde1e 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/ScopedRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ScopedRegistry.java
@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.registry.ServiceInfo;
-
 /**
  * Service registry of a specific scope.
  */
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ScopedRegistryImpl.java b/service/registry/src/main/java/io/helidon/service/registry/ScopedRegistryImpl.java
similarity index 88%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ScopedRegistryImpl.java
rename to service/registry/src/main/java/io/helidon/service/registry/ScopedRegistryImpl.java
index dae5cbab816..aeef9477ff5 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ScopedRegistryImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ScopedRegistryImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.lang.System.Logger.Level;
 import java.util.ArrayList;
@@ -27,20 +27,11 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.ActivationResult;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.ScopeNotActiveException;
-import io.helidon.service.inject.api.ScopedRegistry;
-import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
 
 /**
  * Services for a specific scope.
  * This type is owned by Helidon Injection, and cannot be customized.
- * When a scope is properly accessible through its {@link io.helidon.service.inject.api.Injection.ScopeHandler},
+ * When a scope is properly accessible through its {@link Service.ScopeHandler},
  * {@link #activate()}
  * must be invoked by its control, to make sure all eager services are correctly activated.
  */
@@ -55,7 +46,7 @@ class ScopedRegistryImpl implements ScopedRegistry {
     private boolean active = false;
 
     @SuppressWarnings({"rawtypes", "unchecked"})
-    ScopedRegistryImpl(InjectServiceRegistryImpl registry,
+    ScopedRegistryImpl(CoreServiceRegistry registry,
                        TypeName scope,
                        String id,
                        Map<ServiceDescriptor<?>, Object> initialBindings) {
@@ -63,7 +54,7 @@ class ScopedRegistryImpl implements ScopedRegistry {
         this.id = id;
 
         for (Map.Entry<ServiceDescriptor<?>, Object> entry : initialBindings.entrySet()) {
-            InjectServiceDescriptor<?> key = CoreWrappers.create(entry.getKey());
+            ServiceDescriptor<?> key = entry.getKey();
             ServiceProvider provider = new ServiceProvider<>(registry,
                                                              key
             );
@@ -164,7 +155,7 @@ public <T> Activator<T> activator(ServiceInfo descriptor, Supplier<Activator<T>>
 
     private static Comparator<? super Activator<?>> shutdownComparator() {
         return Comparator
-                .<Activator<?>>comparingDouble(it -> it.descriptor().runLevel().orElse(Injection.RunLevel.NORMAL))
+                .<Activator<?>>comparingDouble(it -> it.descriptor().runLevel().orElse(Service.RunLevel.NORMAL))
                 .thenComparing(it -> it.descriptor().weight());
     }
 
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Scopes.java b/service/registry/src/main/java/io/helidon/service/registry/Scopes.java
similarity index 86%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/Scopes.java
rename to service/registry/src/main/java/io/helidon/service/registry/Scopes.java
index ed45de92dbb..906fffecbc7 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Scopes.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Scopes.java
@@ -14,19 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Map;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.registry.Service;
-import io.helidon.service.registry.ServiceDescriptor;
 
 /**
- * Service that provides support for creating {@link io.helidon.service.inject.api.Scope} instances.
+ * Service that provides support for creating {@link io.helidon.service.registry.Scope} instances.
  */
 @Service.Contract
-@Injection.Describe
+@Service.Describe
 public interface Scopes {
     /**
      * Type name of this interface.
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Service.java b/service/registry/src/main/java/io/helidon/service/registry/Service.java
index 2c42ae30cce..aaef3554eb5 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Service.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Service.java
@@ -16,13 +16,19 @@
 
 package io.helidon.service.registry;
 
+import java.lang.annotation.Annotation;
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Supplier;
 
+import io.helidon.common.GenericType;
 import io.helidon.common.Weighted;
 import io.helidon.common.types.TypeName;
 
@@ -50,7 +56,8 @@ private Service() {
      *     <li>{@code Contract} - obtain an instance of a service providing that contract</li>
      *     <li>{@code Optional<Contract>} - the other service may not be available</li>
      *     <li>{@code List<Contract>} - obtain all instances of services providing the contract</li>
-     *     <li>{@code Supplier<Contract>} - and <b>suppliers of all above</b>, to break instantiation chaining, and to support cyclic
+     *     <li>{@code Supplier<Contract>} - and <b>suppliers of all above</b>, to break instantiation chaining, and to support
+     *     cyclic
      *                  service references, just make sure you call the {@code get} method outside of the constructor</li>
      * </ul>
      *
@@ -64,11 +71,15 @@ private Service() {
      *     provided instance should be singleton-like as well, use {@link io.helidon.common.LazyValue} or
      *     similar approach to create it once and return the same instance every time</li>
      * </ul>
+     *
+     * @deprecated use one of the scope annotations instead ({@link io.helidon.service.registry.Service.Singleton},
+     *         {@link io.helidon.service.registry.Service.PerLookup}).
      */
     @Documented
     @Retention(RetentionPolicy.CLASS)
     @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
     @Inherited
+    @Deprecated(forRemoval = true, since = "4.2.0")
     public @interface Provider {
         /**
          * Type name of this annotation.
@@ -76,6 +87,99 @@ private Service() {
         TypeName TYPE = TypeName.create(Provider.class);
     }
 
+    /**
+     * Scope annotation.
+     * A scope defines the cardinality of instances. This is a meta-annotation used to define that an annotation is a scope.
+     * Note that a single service can only have one scope annotation, and that scopes are not inheritable.
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    public @interface Scope {
+    }
+
+    /**
+     * A singleton service.
+     * The service registry will only contain a single instance of this service, and all injection points will be satisfied by
+     * the same instance.
+     * <p>
+     * A singleton instance is guaranteed to have its constructor, post-construct, and pre-destroy methods invoked once within
+     * the lifecycle of the service registry.
+     * <p>
+     * Alternative to this annotation is {@link io.helidon.service.registry.Service.PerLookup}, or a custom
+     * {@link io.helidon.service.registry.Service.Scope} annotation.
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Scope
+    @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
+    public @interface Singleton {
+        /**
+         * Type name of this annotation.
+         */
+        TypeName TYPE = TypeName.create(Singleton.class);
+    }
+
+    /**
+     * A service with an instance per request.
+     * Injections to different scopes are supported, but must be through a {@link java.util.function.Supplier},
+     * as we do not provide a proxy mechanism for instances.
+     * <p>
+     * Request scope is not started by default. If you want to use request scope, you can add the following
+     * library to your classpath to add support for it:
+     * <ul>
+     *     <li>{@code io.helidon.declarative.webserver:helidon-declarative-webserver-request-scope}</li>
+     * </ul>
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Scope
+    @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE, ElementType.METHOD})
+    public @interface PerRequest {
+        /**
+         * This interface type.
+         */
+        TypeName TYPE = TypeName.create(PerRequest.class);
+    }
+
+    /**
+     * A partial scope that creates a new instance for each injection point/lookup.
+     * The "partial scope" means that the service instances are not managed. If this
+     * service gets injected, a new instance is created for each injection. The service is instantiated,
+     * post construct method (if any) is called, and then it is ignored (i.e. it never gets a pre destroy
+     * method invocation).
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
+    @Scope
+    public @interface PerLookup {
+        /**
+         * Type name of this interface.
+         */
+        TypeName TYPE = TypeName.create(PerLookup.class);
+    }
+
+    /**
+     * Method, constructor, or field marked with this annotation is considered as injectable, and its injection points
+     * will be satisfied with services from the service registry. An injection point is a field, or a single parameter.
+     * <p>
+     * An injection point may expect instance of a service, or a {@link java.util.function.Supplier} of the same.
+     * <p>
+     * Annotating an inaccessible component will always be marked as an error at compilation time
+     * (private fields, methods, constructors).
+     * <p>
+     * Annotating a final field will always be marked as an error at compilation time.
+     * <p>
+     * We recommend to use constructor injection, as field injection makes testing harder.
+     */
+    @Retention(RetentionPolicy.CLASS)
+    @Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
+    @Documented
+    public @interface Inject {
+    }
+
     /**
      * A method annotated with this annotation will be invoked after the constructor is finished
      * and all dependencies are satisfied.
@@ -106,6 +210,160 @@ private Service() {
     public @interface PreDestroy {
     }
 
+    /**
+     * Marks annotations that act as qualifiers.
+     * <p>
+     * A qualifier annotation restricts the eligible service instances that can be injected into an injection point to those
+     * qualified by the same qualifier.
+     */
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Retention(RetentionPolicy.CLASS)
+    @Documented
+    public @interface Qualifier {
+    }
+
+    /**
+     * A qualifier that can restrict injection to specifically named instances, or that qualifies services with that name.
+     */
+    @Qualifier
+    @Retention(RetentionPolicy.CLASS)
+    @Documented
+    @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.TYPE})
+    public @interface Named {
+        /**
+         * Type name of this annotation.
+         */
+        TypeName TYPE = TypeName.create(Named.class);
+        /**
+         * Represents a wildcard name (i.e., matches anything).
+         */
+        String WILDCARD_NAME = "*";
+        /**
+         * Default name to identify a default instance.
+         */
+        String DEFAULT_NAME = "@default";
+
+        /**
+         * The name.
+         *
+         * @return name this injection point requires, or this service provides, or a factory provides
+         */
+        String value();
+    }
+
+
+
+    /**
+     * This annotation is effectively the same as {@link io.helidon.service.registry.Service.Named}
+     * where the {@link io.helidon.service.registry.Service.Named#value()} is a {@link Class}
+     * name instead of a {@link String}. The name that would be used is the fully qualified name of the type.
+     */
+    @Qualifier
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    public @interface NamedByType {
+        /**
+         * Type name of this interface.
+         * {@link io.helidon.common.types.TypeName} is used in Helidon Inject APIs.
+         */
+        TypeName TYPE = TypeName.create(NamedByType.class);
+
+        /**
+         * The class used will function as the name.
+         *
+         * @return the class
+         */
+        Class<?> value();
+    }
+
+    /**
+     * Indicates the desired startup sequence for a service class. This is not used internally by Injection, but is available as a
+     * convenience to the caller in support for a specific startup sequence for service activations.
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.TYPE)
+    public @interface RunLevel {
+
+        /**
+         * Represents an eager singleton that should be started at "startup". Note, however, that callers control the actual
+         * activation for these services, not the injection framework itself, as shown below:         * <pre>
+         * {@code
+         * registry.all(Lookup.builder()
+         *     .runLevel(Service.RunLevel.STARTUP)
+         *     .build());
+         * }
+         * </pre>
+         */
+        double STARTUP = 10D;
+
+        /**
+         * Represents services that have the concept of "serving" something, such as webserver.
+         */
+        double SERVER = 50D;
+
+        /**
+         * Anything > 0 is left to the underlying provider implementation's discretion for meaning; this is just a default for
+         * something that is deemed "other than startup".
+         */
+        double NORMAL = 100D;
+
+        /**
+         * The service ranking applied when not declared explicitly.
+         *
+         * @return the startup int value, defaulting to {@link #NORMAL}
+         */
+        double value() default NORMAL;
+    }
+
+    /**
+     * A service that has instances created for each named instance of the service it is driven by.
+     * The instance created will have the same {@link Named} qualifier as the
+     * driving instance (in addition to all qualifiers defined on this service).
+     * <p>
+     * There are a few restrictions on this type of services:
+     * <ul>
+     * <li>The service MUST NOT implement {@link java.util.function.Supplier}</li>
+     * <li>The service MUST NOT implement {@link InjectionPointFactory}</li>
+     * <li>The service MUST NOT implement {@link ServicesFactory}</li>
+     * <li>All types that inherit from this service will also inherit the driven by</li>
+     * <li>There MAY be an injection point of the type defined in {@link #value()}, without any qualifiers -
+     * this injection point will be satisfied by the driving instance</li>
+     * <li>There MAY be a {@link String} injection point qualified with
+     * {@link InstanceName} - this injection point will be satisfied by the
+     * name of the driving instance</li>
+     * </ul>
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.TYPE)
+    public @interface PerInstance {
+        /**
+         * The service type driving this service. If the service provides more than one instance,
+         * the instances MUST be {@link io.helidon.service.registry.Service.Named}.
+         *
+         * @return type of the service driving instances of this service
+         */
+        Class<?> value();
+    }
+
+    /**
+     * For types that are {@link io.helidon.service.registry.Service.PerInstance}, an injection point (field, parameter) can
+     * be annotated with this annotation to receive the name qualifier associated with this instance.
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target({ElementType.PARAMETER, ElementType.FIELD})
+    @Qualifier
+    public @interface InstanceName {
+        /**
+         * Type name of this interface.
+         * {@link io.helidon.common.types.TypeName} is used in Helidon Inject APIs.
+         */
+        TypeName TYPE = TypeName.create(InstanceName.class);
+    }
+
+
     /**
      * The {@code Contract} annotation is used to relay significance to the type that it annotates. While remaining optional in
      * its use, it is typically placed on an interface definition to signify that the given type can be used for lookup in the
@@ -146,6 +404,24 @@ private Service() {
         Class<?>[] value();
     }
 
+    /**
+     * Describe the annotated type. This will generate a service descriptor that cannot create an instance.
+     * This is useful for scoped instances that are provided when the scope is activated.
+     * <p>
+     * This annotation will ignore type hierarchy (the descriptor will never have a super type).
+     */
+    @Documented
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.TYPE)
+    public @interface Describe {
+        /**
+         * Customize the scope to use, defaults to {@link Singleton}.
+         *
+         * @return scope to use for the generated service descriptor
+         */
+        Class<? extends Annotation> value() default Singleton.class;
+    }
+
     /**
      * Annotation to add a custom service descriptor.
      * <p>
@@ -154,7 +430,7 @@ private Service() {
      * The descriptor MUST follow the approach of Helidon service descriptor, and must be public,
      * provide a public constant called {@code INSTANCE}, and all its dependencies
      * ({@link io.helidon.service.registry.Dependency}
-     * must be available as public constants (and correctly described in each Ip instance).
+     * must be available as public constants (and correctly described in each Dependency instance).
      */
     @Documented
     @Retention(RetentionPolicy.CLASS)
@@ -191,4 +467,218 @@ private Service() {
          */
         Class<?>[] contracts();
     }
+
+    /**
+     * Provides an ability to create more than one service instance from a single service definition.
+     * This is useful when the cardinality can only be determined at runtime.
+     *
+     * @param <T> type of the provided services
+     */
+    public interface ServicesFactory<T> {
+        /**
+         * Type name of this interface.
+         */
+        TypeName TYPE = TypeName.create(ServicesFactory.class);
+
+        /**
+         * List of service instances.
+         * Each instance may have a different set of qualifiers.
+         * <p>
+         * The following is inherited from this factory:
+         * <ul>
+         *     <li>Set of contracts, except for {@link ServicesFactory}</li>
+         *     <li>Scope</li>
+         *     <li>Run level</li>
+         *     <li>Weight</li>
+         * </ul>
+         *
+         * @return qualified suppliers of service instances
+         */
+        List<QualifiedInstance<T>> services();
+    }
+
+    /**
+     * Provides ability to contextualize the injected service by the target receiver of the injection point dynamically
+     * at runtime. This API will provide service instances of type {@code T}.
+     * <p>
+     * The ordering of services, and the preferred service itself, is determined by the service registry implementation.
+     * <p>
+     * The service registry does not make any assumptions about qualifiers of the instances being created, though they should
+     * be either the same as the injection point factory itself, or a subset of it, so the service can be discovered through
+     * one of the lookup methods (i.e. the injection point factory may be annotated with a
+     * {@link Named} with {@link Named#WILDCARD_NAME}
+     * value, and each instance provided may use a more specific name qualifier).
+     *
+     * @param <T> the type that the factory produces
+     */
+    public interface InjectionPointFactory<T> {
+        /**
+         * Type name of this interface.
+         */
+        TypeName TYPE = TypeName.create(InjectionPointFactory.class);
+
+        /**
+         * Get (or create) an instance of this service type for the given injection point context. This is logically the same
+         * as using the first element of the result from calling {@link #list(Lookup)}.
+         *
+         * @param lookup the service query
+         * @return the best service instance matching the criteria, if any matched, with qualifiers (if any)
+         */
+        Optional<QualifiedInstance<T>> first(Lookup lookup);
+
+        /**
+         * Get (or create) a list of instances matching the criteria for the given injection point context.
+         *
+         * @param lookup the service query
+         * @return the service instances matching criteria for the lookup in order of weight, or empty if none matching
+         */
+        default List<QualifiedInstance<T>> list(Lookup lookup) {
+            return first(lookup).map(List::of).orElseGet(List::of);
+        }
+    }
+
+    /**
+     * A factory to resolve qualified injection points of any type.
+     * <p>
+     * As compared to {@link InjectionPointFactory}, this type is capable of resolving ANY injection
+     * point as long as it is annotated by the qualifier. The contract of the injection point depends on how the implementation
+     * service declares the type parameters of this interface. If you use any type other than {@link java.lang.Object}, that will
+     * be the only supported contract, otherwise any type is expected to be supported.
+     * <p>
+     * A good practice is to create an accompanying codegen extension that validates injection points at build time.
+     *
+     * @param <T> type of the provided instance, the special case is {@link java.lang.Object} - if used, we consider this
+     *            factory to be capable of handling ANY type, and will allow injection points with any type as long as it is
+     *            qualified by the qualifier
+     * @param <A> type of qualifier supported by this factory
+     */
+    public interface QualifiedFactory<T, A extends Annotation> {
+        /**
+         * Type name of this interface.
+         */
+        TypeName TYPE = TypeName.create(QualifiedFactory.class);
+
+        /**
+         * Get the first instance (if any) matching the qualifier and type.
+         *
+         * @param qualifier the qualifier this type supports (same type as the {@code A} type this type implements)
+         * @param lookup    full lookup used to obtain the value, may contain the actual injection point
+         * @param type      type to be injected (or type requested)
+         * @return the qualified instance matching the request, or an empty optional if none match
+         */
+        Optional<QualifiedInstance<T>> first(io.helidon.service.registry.Qualifier qualifier,
+                                             Lookup lookup,
+                                             GenericType<T> type);
+
+        /**
+         * Get all instances matching the qualifier and type.
+         *
+         * @param qualifier the qualifier this type supports (same type as the {@code A} type this type implements)
+         * @param lookup    full lookup used to obtain the value, may contain the actual injection point
+         * @param type      type to be injected (or type requested)
+         * @return the qualified instance matching the request, or an empty optional if none match
+         */
+        default List<QualifiedInstance<T>> list(io.helidon.service.registry.Qualifier qualifier,
+                                                Lookup lookup,
+                                                GenericType<T> type) {
+            return first(qualifier, lookup, type)
+                    .map(List::of)
+                    .orElseGet(List::of);
+        }
+    }
+
+    /**
+     * An instance with its qualifiers.
+     * Some services are allowed to create more than one instance, and there may be a need
+     * to use different qualifiers than the factory service uses.
+     *
+     * @param <T> type of instance, as provided by the service
+     * @see ServicesFactory
+     */
+    public interface QualifiedInstance<T> extends Supplier<T> {
+        /**
+         * Create a new qualified instance.
+         *
+         * @param instance   the instance
+         * @param qualifiers qualifiers to use
+         * @param <T>        type of the instance
+         * @return a new qualified instance
+         */
+        static <T> QualifiedInstance<T> create(T instance, io.helidon.service.registry.Qualifier... qualifiers) {
+            return new QualifiedInstanceImpl<>(instance, Set.of(qualifiers));
+        }
+
+        /**
+         * Create a new qualified instance.
+         *
+         * @param instance   the instance
+         * @param qualifiers qualifiers to use
+         * @param <T>        type of the instance
+         * @return a new qualified instance
+         */
+        static <T> QualifiedInstance<T> create(T instance, Set<io.helidon.service.registry.Qualifier> qualifiers) {
+            return new QualifiedInstanceImpl<>(instance, qualifiers);
+        }
+
+        /**
+         * Get the instance that the registry manages (or an instance that is unmanaged, if the provider is in
+         * {@link PerLookup}, or if the instance is created by a factory).
+         * The instance must be guaranteed to be constructed and if managed by the registry, and activation scope is not limited,
+         * then injected as well.
+         *
+         * @return instance
+         */
+        @Override
+        T get();
+
+        /**
+         * Qualifiers of the instance.
+         *
+         * @return qualifiers of the service instance
+         */
+        Set<io.helidon.service.registry.Qualifier> qualifiers();
+    }
+
+    /**
+     * Extension point for the service registry to support new scopes.
+     * <p>
+     * Implementation must be qualified with the fully qualified name of the corresponding scope annotation class.
+     *
+     * @see Named
+     * @see NamedByType
+     */
+    @Service.Contract
+    public interface ScopeHandler {
+        /**
+         * Type name of this interface.
+         * Service registry uses {@link io.helidon.common.types.TypeName} in its APIs.
+         */
+        TypeName TYPE = TypeName.create(ScopeHandler.class);
+
+        /**
+         * Get the current scope if available.
+         *
+         * @return current scope instance, or empty if the scope is not active
+         */
+        Optional<io.helidon.service.registry.Scope> currentScope();
+
+
+        /**
+         * Activate the given scope.
+         *
+         * @param scope scope to activate
+         */
+        default void activate(io.helidon.service.registry.Scope scope) {
+            scope.registry().activate();
+        }
+
+        /**
+         * De-activate the given scope.
+         *
+         * @param scope scope to de-activate
+         */
+        default void deactivate(io.helidon.service.registry.Scope scope) {
+            scope.registry().deactivate();
+        }
+    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
index e066bebff64..d29b24bacd2 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
@@ -16,6 +16,10 @@
 
 package io.helidon.service.registry;
 
+import java.util.Set;
+
+import io.helidon.common.types.TypeName;
+
 /**
  * A descriptor of a service. In addition to providing service metadata, this also allows instantiation
  * of the service instance, with dependent services as parameters.
@@ -30,11 +34,25 @@ public interface ServiceDescriptor<T> extends ServiceInfo {
      * @return a new instance, must be of the type T or a subclass
      */
     // we cannot return T, as it does not allow us to correctly handle inheritance
-    default Object instantiate(DependencyContext ctx) {
+    default Object instantiate(DependencyContext ctx, InterceptionMetadata interceptionMetadata) {
         throw new IllegalStateException("Cannot instantiate type " + serviceType().fqName() + ", as it is either abstract,"
                                                 + " or an interface.");
     }
 
+    /**
+     * Inject fields and methods.
+     *
+     * @param ctx                  injection context
+     * @param interceptionMetadata interception metadata to support interception of field injection
+     * @param injected             mutable set of already injected methods from subtypes
+     * @param instance             instance to update
+     */
+    default void inject(DependencyContext ctx,
+                        InterceptionMetadata interceptionMetadata,
+                        Set<String> injected,
+                        T instance) {
+    }
+
     /**
      * Invoke {@link io.helidon.service.registry.Service.PostConstruct} annotated method(s).
      *
@@ -50,4 +68,13 @@ default void postConstruct(T instance) {
      */
     default void preDestroy(T instance) {
     }
+
+    /**
+     * Scope of this service.
+     *
+     * @return scope of the service
+     */
+    default TypeName scope() {
+        return Service.Singleton.TYPE;
+    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceInfo.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceInfo.java
index 8fed8b99701..55e591c5bd8 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceInfo.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceInfo.java
@@ -17,6 +17,7 @@
 package io.helidon.service.registry;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 import io.helidon.common.Weighted;
@@ -62,12 +63,11 @@ default Set<ResolvedType> factoryContracts() {
 
     /**
      * List of dependencies required by this service.
-     * Each dependency is a point of injection of a dependency into
-     * a constructor.
+     * These may be injection points as constructor parameters, fields, or setter methods.
      *
      * @return required dependencies
      */
-    default List<? extends Dependency> dependencies() {
+    default List<Dependency> dependencies() {
         return List.of();
     }
 
@@ -80,4 +80,39 @@ default List<? extends Dependency> dependencies() {
     default boolean isAbstract() {
         return false;
     }
+
+    /**
+     * Service qualifiers.
+     *
+     * @return qualifiers
+     */
+    default Set<Qualifier> qualifiers() {
+        return Set.of();
+    }
+
+    /**
+     * Run level of this service.
+     *
+     * @return run level
+     */
+    default Optional<Double> runLevel() {
+        return Optional.empty();
+    }
+
+    /**
+     * Scope of this service.
+     *
+     * @return scope of the service
+     */
+    TypeName scope();
+
+    /**
+     * What factory type is the described service.
+     * Inject services can be any of the types in the {@link FactoryType enum}.
+     *
+     * @return factory type
+     */
+    default FactoryType factoryType() {
+        return FactoryType.SERVICE;
+    }
 }
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/ServiceInstance.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceInstance.java
similarity index 88%
rename from service/inject/api/src/main/java/io/helidon/service/inject/api/ServiceInstance.java
rename to service/registry/src/main/java/io/helidon/service/registry/ServiceInstance.java
index e14fae124c9..73a9b5d9769 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/ServiceInstance.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceInstance.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.api;
+package io.helidon.service.registry;
 
 import java.util.Set;
 
@@ -27,7 +27,7 @@
  *
  * @param <T> type of the instance
  */
-public interface ServiceInstance<T> extends Injection.QualifiedInstance<T> {
+public interface ServiceInstance<T> extends Service.QualifiedInstance<T> {
     /**
      * Type name of this interface. {@link io.helidon.common.types.TypeName} is used in various APIs of service registry.
      */
@@ -42,8 +42,8 @@ public interface ServiceInstance<T> extends Injection.QualifiedInstance<T> {
 
     /**
      * Scope this instance was created in. Always the same as the scope of the associated service descriptor
-     * ({@link InjectServiceDescriptor#scope()}.
-     * This method may return {@link io.helidon.service.inject.api.Injection.PerLookup} in case no scope is
+     * ({@link ServiceDescriptor#scope()}.
+     * This method may return {@link io.helidon.service.registry.Service.PerLookup} in case no scope is
      * defined ("Dependent" scope is not a real scope, as the instances cannot be managed, so each time an instance is injected,
      * it is constructed, injected, post constructed, and then forgotten by the registry).
      *
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
index 8117fc5e977..8b77ea676cd 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
@@ -134,7 +134,12 @@ public Set<ResolvedType> contracts() {
         }
 
         @Override
-        public Object instantiate(DependencyContext ctx) {
+        public TypeName scope() {
+            return Service.Singleton.TYPE;
+        }
+
+        @Override
+        public Object instantiate(DependencyContext ctx, InterceptionMetadata metadata) {
             return instance.get();
         }
 
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
similarity index 82%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ServiceManager.java
rename to service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
index a82aa1c9639..7abd5a5d6d0 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
@@ -14,22 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.Set;
 import java.util.function.Supplier;
 
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.Scope;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
 /*
 Manager of a single service. There is one instance per service provider (and per service descriptor).
@@ -69,15 +61,15 @@ ServiceInstance<T> registryInstance(Lookup lookup, QualifiedInstance<T> instance
                                          instance);
     }
 
-    InjectionPlanBinder.Binder servicePlanBinder() {
+    DependencyPlanBinder.Binder servicePlanBinder() {
         return provider.servicePlanBinder();
     }
 
     ServiceInfo descriptor() {
-        return provider.descriptor().coreInfo();
+        return provider.descriptor();
     }
 
-    InjectServiceInfo injectDescriptor() {
+    ServiceInfo injectDescriptor() {
         return provider.descriptor();
     }
 
@@ -89,16 +81,16 @@ Activator<T> activator() {
         return scopeSupplier
                 .get()
                 .registry()
-                .activator(provider.descriptor().coreInfo(),
+                .activator(provider.descriptor(),
                            activatorSupplier);
     }
 
     private static final class ServiceInstanceImpl<T> implements ServiceInstance<T> {
-        private final InjectServiceDescriptor<T> descriptor;
+        private final ServiceDescriptor<T> descriptor;
         private final QualifiedInstance<T> qualifiedInstance;
         private final Set<ResolvedType> contracts;
 
-        private ServiceInstanceImpl(InjectServiceDescriptor<T> descriptor,
+        private ServiceInstanceImpl(ServiceDescriptor<T> descriptor,
                                     Set<ResolvedType> contracts,
                                     QualifiedInstance<T> qualifiedInstance) {
             this.descriptor = descriptor;
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ServicePlanBinder.java b/service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
similarity index 70%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ServicePlanBinder.java
rename to service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
index 8103429b1dc..dddad478bad 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ServicePlanBinder.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -25,43 +25,36 @@
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
-import io.helidon.service.inject.ServiceSupplies.ServiceInstanceSupply;
-import io.helidon.service.inject.ServiceSupplies.ServiceInstanceSupplyList;
-import io.helidon.service.inject.ServiceSupplies.ServiceInstanceSupplyOptional;
-import io.helidon.service.inject.ServiceSupplies.ServiceSupply;
-import io.helidon.service.inject.ServiceSupplies.ServiceSupplyList;
-import io.helidon.service.inject.ServiceSupplies.ServiceSupplyOptional;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InstanceName__ServiceDescriptor;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
-
-class ServicePlanBinder implements InjectionPlanBinder.Binder {
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupply;
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyList;
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyOptional;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupply;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupplyList;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupplyOptional;
+
+class ServicePlanBinder implements DependencyPlanBinder.Binder {
     private final Map<Dependency, IpPlan<?>> injectionPlan = new LinkedHashMap<>();
 
-    private final InjectServiceDescriptor<?> self;
+    private final ServiceDescriptor<?> self;
     private final Consumer<Map<Dependency, IpPlan<?>>> injectionPlanConsumer;
-    private final InjectServiceRegistryImpl registry;
+    private final CoreServiceRegistry registry;
 
-    private ServicePlanBinder(InjectServiceRegistryImpl registry,
-                              InjectServiceDescriptor<?> self,
+    private ServicePlanBinder(CoreServiceRegistry registry,
+                              ServiceDescriptor<?> self,
                               Consumer<Map<Dependency, IpPlan<?>>> injectionPlanConsumer) {
         this.registry = registry;
         this.self = self;
         this.injectionPlanConsumer = injectionPlanConsumer;
     }
 
-    static <T> InjectionPlanBinder.Binder create(InjectServiceRegistryImpl registry,
-                                                 InjectServiceDescriptor<T> descriptor,
-                                                 Consumer<Map<Dependency, IpPlan<?>>> planConsumer) {
+    static <T> DependencyPlanBinder.Binder create(CoreServiceRegistry registry,
+                                                  ServiceDescriptor<T> descriptor,
+                                                  Consumer<Map<Dependency, IpPlan<?>>> planConsumer) {
         return new ServicePlanBinder(registry, descriptor, planConsumer);
     }
 
     @Override
-    public InjectionPlanBinder.Binder bind(Dependency dependency, ServiceInfo descriptor) {
+    public DependencyPlanBinder.Binder bind(Dependency dependency, ServiceInfo descriptor) {
         if (descriptor == InstanceName__ServiceDescriptor.INSTANCE) {
             injectionPlan.put(dependency, new IpPlan<>(new InstanceNameFailingSupplier(dependency), descriptor));
         } else {
@@ -74,7 +67,7 @@ public InjectionPlanBinder.Binder bind(Dependency dependency, ServiceInfo descri
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindServiceInstance(Dependency dependency, ServiceInfo descriptor) {
+    public DependencyPlanBinder.Binder bindServiceInstance(Dependency dependency, ServiceInfo descriptor) {
         var supply = new ServiceInstanceSupply<>(Lookup.create(dependency), List.of(registry.serviceManager(descriptor)));
         injectionPlan.put(dependency, new IpPlan<>(supply, descriptor));
 
@@ -82,7 +75,7 @@ public InjectionPlanBinder.Binder bindServiceInstance(Dependency dependency, Ser
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindOptional(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindOptional(Dependency dependency, ServiceInfo... descriptors) {
         ServiceSupplyOptional<?> supply = new ServiceSupplyOptional<>(Lookup.create(dependency),
                                                                       toManagers(descriptors));
 
@@ -91,7 +84,7 @@ public InjectionPlanBinder.Binder bindOptional(Dependency dependency, ServiceInf
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindOptionalOfServiceInstance(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindOptionalOfServiceInstance(Dependency dependency, ServiceInfo... descriptors) {
         var supply = new ServiceInstanceSupplyOptional<>(Lookup.create(dependency),
                                                          toManagers(descriptors));
 
@@ -100,7 +93,7 @@ public InjectionPlanBinder.Binder bindOptionalOfServiceInstance(Dependency depen
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindList(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindList(Dependency dependency, ServiceInfo... descriptors) {
         ServiceSupplyList<?> supply = new ServiceSupplyList<>(Lookup.create(dependency),
                                                               toManagers(descriptors));
 
@@ -109,7 +102,7 @@ public InjectionPlanBinder.Binder bindList(Dependency dependency, ServiceInfo...
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindServiceInstanceList(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindServiceInstanceList(Dependency dependency, ServiceInfo... descriptors) {
         var supply = new ServiceInstanceSupplyList<>(Lookup.create(dependency),
                                                      toManagers(descriptors));
 
@@ -118,7 +111,7 @@ public InjectionPlanBinder.Binder bindServiceInstanceList(Dependency dependency,
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindSupplier(Dependency dependency, ServiceInfo descriptor) {
+    public DependencyPlanBinder.Binder bindSupplier(Dependency dependency, ServiceInfo descriptor) {
         ServiceSupply<?> supply = new ServiceSupply<>(Lookup.create(dependency),
                                                       toManagers(descriptor));
 
@@ -127,7 +120,7 @@ public InjectionPlanBinder.Binder bindSupplier(Dependency dependency, ServiceInf
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindSupplierOfOptional(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindSupplierOfOptional(Dependency dependency, ServiceInfo... descriptors) {
         ServiceSupplyOptional<?> supply = new ServiceSupplyOptional<>(Lookup.create(dependency),
                                                                       toManagers(descriptors));
 
@@ -136,7 +129,7 @@ public InjectionPlanBinder.Binder bindSupplierOfOptional(Dependency dependency,
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindSupplierOfList(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindSupplierOfList(Dependency dependency, ServiceInfo... descriptors) {
         ServiceSupplyList<?> supply = new ServiceSupplyList<>(Lookup.create(dependency),
                                                               toManagers(descriptors));
 
@@ -145,7 +138,7 @@ public InjectionPlanBinder.Binder bindSupplierOfList(Dependency dependency, Serv
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindOptionalOfSupplier(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindOptionalOfSupplier(Dependency dependency, ServiceInfo... descriptors) {
         // we must resolve this right now, so we just use the first descriptor, and hope the user did not inject
         // this in a wrong scope
         ServiceSupply<?> supply = new ServiceSupply<>(Lookup.create(dependency),
@@ -155,7 +148,7 @@ public InjectionPlanBinder.Binder bindOptionalOfSupplier(Dependency dependency,
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindListOfSuppliers(Dependency dependency, ServiceInfo... descriptors) {
+    public DependencyPlanBinder.Binder bindListOfSuppliers(Dependency dependency, ServiceInfo... descriptors) {
         Lookup lookup = Lookup.create(dependency);
         // we must resolve the list right now (one for each descriptor)
         List<ServiceSupply<Object>> supplies = Stream.of(descriptors)
@@ -168,7 +161,7 @@ public InjectionPlanBinder.Binder bindListOfSuppliers(Dependency dependency, Ser
     }
 
     @Override
-    public InjectionPlanBinder.Binder bindNull(Dependency dependency) {
+    public DependencyPlanBinder.Binder bindNull(Dependency dependency) {
         injectionPlan.put(dependency, new IpPlan<>(() -> null));
         return this;
     }
@@ -201,7 +194,7 @@ private InstanceNameFailingSupplier(Dependency dependency) {
         @Override
         public Object get() {
             throw new ServiceRegistryException(
-                    "@" + Injection.InstanceName.class.getName()
+                    "@" + Service.InstanceName.class.getName()
                             + "should have been resolved to correct name during lookup for "
                             + dependency);
         }
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceProvider.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
similarity index 85%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ServiceProvider.java
rename to service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
index acca78b1fae..bf2d5a25c13 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceProvider.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.List;
 import java.util.Map;
@@ -24,15 +24,6 @@
 
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.ActivationRequest;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.registry.Dependency;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
 
 /**
  * Takes care of a single service descriptor.
@@ -40,17 +31,17 @@
  * @param <T> type of the provided service
  */
 class ServiceProvider<T> {
-    private final InjectServiceRegistryImpl registry;
-    private final InjectServiceInfo serviceInfo;
-    private final InjectServiceDescriptor<T> descriptor;
+    private final CoreServiceRegistry registry;
+    private final ServiceInfo serviceInfo;
+    private final ServiceDescriptor<T> descriptor;
 
     private final ActivationRequest activationRequest;
     private final InterceptionMetadata interceptionMetadata;
     private final Contracts.ContractLookup contracts;
     private volatile Map<Dependency, IpPlan<?>> injectionPlan = null;
 
-    ServiceProvider(InjectServiceRegistryImpl serviceRegistry,
-                    InjectServiceDescriptor<T> descriptor) {
+    ServiceProvider(CoreServiceRegistry serviceRegistry,
+                    ServiceDescriptor<T> descriptor) {
 
         Objects.requireNonNull(serviceRegistry);
         Objects.requireNonNull(descriptor);
@@ -69,15 +60,15 @@ public String toString() {
         return "ServiceProvider for " + serviceInfo.serviceType().fqName();
     }
 
-    InjectServiceInfo serviceInfo() {
+    ServiceInfo serviceInfo() {
         return serviceInfo;
     }
 
-    InjectServiceDescriptor<T> descriptor() {
+    ServiceDescriptor<T> descriptor() {
         return descriptor;
     }
 
-    InjectionPlanBinder.Binder servicePlanBinder() {
+    DependencyPlanBinder.Binder servicePlanBinder() {
         return ServicePlanBinder.create(registry, descriptor, it -> this.injectionPlan = it);
     }
 
@@ -104,8 +95,8 @@ ActivationRequest activationRequest() {
     }
 
     private Map<Dependency, IpPlan<?>> createInjectionPlan() {
-        // for core services, we must use Dependency, for inject services, we must use Ip
-        List<? extends Dependency> dependencies = descriptor.coreInfo().dependencies();
+        // for core services, we must use Dependency, for inject services, we must use Dependency
+        List<? extends Dependency> dependencies = descriptor.dependencies();
 
         if (dependencies.isEmpty()) {
             return Map.of();
@@ -113,9 +104,9 @@ private Map<Dependency, IpPlan<?>> createInjectionPlan() {
 
         AtomicReference<Map<Dependency, IpPlan<?>>> injectionPlan = new AtomicReference<>();
 
-        InjectionPlanBinder.Binder binder = ServicePlanBinder.create(registry,
-                                                                     descriptor,
-                                                                     injectionPlan::set);
+        DependencyPlanBinder.Binder binder = ServicePlanBinder.create(registry,
+                                                                      descriptor,
+                                                                      injectionPlan::set);
         for (Dependency injectionPoint : dependencies) {
             planForIp(binder, injectionPoint);
         }
@@ -125,7 +116,7 @@ private Map<Dependency, IpPlan<?>> createInjectionPlan() {
         return injectionPlan.get();
     }
 
-    private void planForIp(InjectionPlanBinder.Binder injectionPlan,
+    private void planForIp(DependencyPlanBinder.Binder injectionPlan,
                            Dependency injectionPoint) {
         /*
          very similar code is used in ApplicationCreator.buildTimeBinding
@@ -146,7 +137,6 @@ private void planForIp(InjectionPlanBinder.Binder injectionPlan,
         List<ServiceInfo> discovered = registry.lookupServices(lookup)
                 .stream()
                 .filter(it -> it != descriptor)
-                .map(InjectServiceInfo::coreInfo)
                 .toList();
 
         /*
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry.java
index 2bf35bf26fb..cabce35cd50 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry.java
@@ -28,6 +28,7 @@
  * The service registry has knowledge about all the services within your application.
  */
 @Service.Contract
+@Service.Describe
 public interface ServiceRegistry {
     /**
      * Type name of this interface.
@@ -179,11 +180,12 @@ default <T> Supplier<List<T>> supplyAll(Class<T> contract) {
      * from the service descriptor, or instances provided by {@link #allServices(Class)}.
      *
      * @param serviceInfo service info instance
+     * @param <T>         type of the expected instance, we just cast to it, so this may cause runtime issues if assigned to
+     *                    invalid
+     *                    type
      * @return value of the service described by the service info provided (always a single value), as there is support
-     *          for providers that are {@link java.util.function.Supplier} of an instance, and that may return
-     *          {@link java.util.Optional}, we may not get a value, hence we return {@link java.util.Optional} as well
-     * @param <T> type of the expected instance, we just cast to it, so this may cause runtime issues if assigned to invalid
-     *            type
+     *         for providers that are {@link java.util.function.Supplier} of an instance, and that may return
+     *         {@link java.util.Optional}, we may not get a value, hence we return {@link java.util.Optional} as well
      */
     <T> Optional<T> get(ServiceInfo serviceInfo);
 
@@ -206,4 +208,97 @@ default List<ServiceInfo> allServices(Class<?> contract) {
      * @return list of service metadata of services that satisfy the provided contract
      */
     List<ServiceInfo> allServices(TypeName contract);
+
+    /**
+     * Get the first service instance matching the lookup with the expectation that there is a match available.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return the best service instance matching the lookup, cast to the expected type; please use a {@code Object} as the type
+     *         if the result may contain an unknown instance
+     * @throws io.helidon.service.registry.ServiceRegistryException if there is no service that could satisfy the lookup, or the
+     *                                                              resolution to instance failed
+     */
+    <T> T get(Lookup lookup);
+
+    /**
+     * Get the first service instance matching the contract with the expectation that there may not be a match available.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return the best service instance matching the lookup, cast to the expected type; please use a {@code Object} as the type
+     *         if the result may contain an unknown instance
+     */
+    <T> Optional<T> first(Lookup lookup);
+
+    /**
+     * Get all service instances matching the lookup with the expectation that there may not be a match available.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return list of services matching the criteria, may be empty if none matched, or no instances were provided
+     */
+    <T> List<T> all(Lookup lookup);
+
+    /**
+     * Get the first service supplier matching the lookup with the expectation that there is a match available.
+     * The provided {@link java.util.function.Supplier#get()} may throw an
+     * {@link io.helidon.service.registry.ServiceRegistryException} in case the matching service cannot provide a value (either
+     * because
+     * of scope mismatch, or because there is no available instance, and we use a runtime resolution through
+     * {@link io.helidon.service.registry.Service.ServicesFactory},
+     * {@link io.helidon.service.registry.Service.InjectionPointFactory}, or similar).
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return the best service supplier matching the lookup, cast to the expected type; please use a {@code Object} as the type
+     *         if the result may contain an unknown instance
+     * @throws io.helidon.service.registry.ServiceRegistryException if there is no service that could satisfy the lookup
+     */
+    <T> Supplier<T> supply(Lookup lookup);
+
+    /**
+     * Find the first service matching the lookup with the expectation that there may not be a match available.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return the best service matching the lookup, cast to the expected type; please use a {@code Object} as the type
+     *         if the result may contain an unknown instance
+     */
+    <T> Supplier<Optional<T>> supplyFirst(Lookup lookup);
+
+    /**
+     * Lookup a supplier of all services matching the lookup with the expectation that there may not be a match available.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @param <T>    type of the service, if you use any other than {@link java.lang.Object}, make sure
+     *               you have configured appropriate contracts in the lookup, as we cannot infer this
+     * @return supplier of list of services ordered, may be empty if there is no match
+     */
+    <T> Supplier<List<T>> supplyAll(Lookup lookup);
+
+    /**
+     * A lookup method operating on the service descriptors, rather than service instances.
+     * This is useful for tools that need to analyze the structure of the registry,
+     * for testing etc.
+     * <p>
+     * The registry is optimized for look-ups based on service type and service contracts, all other
+     * lookups trigger a full registry scan.
+     *
+     * @param lookup lookup criteria to find matching services
+     * @return a list of service descriptors that match the lookup criteria
+     */
+    List<ServiceInfo> lookupServices(Lookup lookup);
+
+    /**
+     * Provides registry metrics information.
+     *
+     * @return registry metrics
+     */
+    RegistryMetrics metrics();
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
index 85565221179..2332aa1a11f 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
@@ -18,17 +18,14 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
-import io.helidon.common.config.Config;
 
 /**
  * Helidon service registry configuration.
  */
 @Prototype.Blueprint
-@Prototype.Configured("registry")
 @Prototype.CustomMethods(ServiceRegistryConfigSupport.CustomMethods.class)
 interface ServiceRegistryConfigBlueprint {
     /**
@@ -38,7 +35,6 @@ interface ServiceRegistryConfigBlueprint {
      *
      * @return whether to discover services from classpath, defaults to {@code true}
      */
-    @Option.Configured
     @Option.DefaultBoolean(true)
     boolean discoverServices();
 
@@ -49,10 +45,18 @@ interface ServiceRegistryConfigBlueprint {
      * @return whether to discover Java {@link java.util.ServiceLoader} services from classpath (a curated list only),
      *         defaults to {@code true}
      */
-    @Option.Configured
     @Option.DefaultBoolean(true)
     boolean discoverServicesFromServiceLoader();
 
+    /**
+     * Whether to allow binding via methods, such as {@link io.helidon.service.registry.Services#set(Class, Object[])}.
+     * When disabled, attempts at late binding will throw an exception.
+     *
+     * @return whether late binding is enabled, defaults to {@code true}
+     */
+    @Option.DefaultBoolean(true)
+    boolean allowLateBinding();
+
     /**
      * Manually registered service descriptors to add to the registry.
      * This is useful when {@link #discoverServices()} is set to {@code false}, to register only hand-picked services
@@ -76,10 +80,50 @@ interface ServiceRegistryConfigBlueprint {
     Map<ServiceDescriptor<?>, Object> serviceInstances();
 
     /**
-     * Config instance used to configure this registry configuration.
-     * DO NOT USE for application configuration!
+     * Flag indicating whether service lookups
+     * (i.e., via {@link io.helidon.service.registry.ServiceRegistry#first(io.helidon.service.registry.Lookup)}) are cached.
+     *
+     * @return the flag indicating whether service lookups are cached, defaults to {@code false}
+     */
+    boolean lookupCacheEnabled();
+
+    /**
+     * Size of the lookup cache when {@link #lookupCacheEnabled()} is set to {@code true}.
+     *
+     * @return cache size
+     */
+    @Option.DefaultInt(10000)
+    int lookupCacheSize();
+
+    /**
+     * Flag indicating whether runtime interception is enabled.
+     * If set to {@code false}, methods will be invoked without any interceptors, even if interceptors are available.
+     *
+     * @return whether to intercept calls at runtime, defaults to {@code true}
+     */
+    @Option.DefaultBoolean(true)
+    boolean interceptionEnabled();
+
+    /**
+     * In certain conditions Injection services should be initialized but not started (i.e., avoiding calls to
+     * {@code PostConstruct}
+     * etc.). This can be used in special cases where the normal Injection startup should limit lifecycle up to a given phase.
      *
-     * @return config node used to configure this service registry config instance (if any)
+     * @return the phase to stop at during lifecycle
      */
-    Optional<Config> config();
+    @Option.Default("ACTIVE")
+    ActivationPhase limitActivationPhase();
+
+    /**
+     * Flag indicating whether compile-time generated {@link io.helidon.service.registry.Binding}'s
+     * should be used at initialization.
+     * Even if set to {@code true}, this is effective only if an {@link io.helidon.service.registry.Binding}
+     * was generated using Helidon Service Maven Plugin.
+     *
+     * @return the flag indicating whether the provider is permitted to use binding generated code from compile-time,
+     *         defaults to {@code true}
+     * @see io.helidon.service.registry.Binding
+     */
+    @Option.DefaultBoolean(true)
+    boolean useBinding();
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 6dcd436db72..7e0cc93daf4 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -16,6 +16,28 @@
 
 package io.helidon.service.registry;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.ResolvedType;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+import io.helidon.common.types.TypedElementInfo;
+import io.helidon.service.metadata.DescriptorMetadata;
+
 /**
  * Manager is responsible for managing the state of a {@link io.helidon.service.registry.ServiceRegistry}.
  * Each manager instances owns a single service registry.
@@ -23,13 +45,43 @@
  * To use a singleton service across application, either pass it through parameters, or use
  * {@link io.helidon.service.registry.GlobalServiceRegistry}.
  */
-public interface ServiceRegistryManager {
+public final class ServiceRegistryManager {
+    static final Comparator<ServiceInfo> SERVICE_INFO_COMPARATOR = Comparator
+            .comparingDouble(ServiceInfo::weight)
+            .reversed()
+            .thenComparing((f, s) -> {
+                if (f.qualifiers().isEmpty() && s.qualifiers().isEmpty()) {
+                    return 0;
+                }
+                if (f.qualifiers().isEmpty()) {
+                    return -1;
+                }
+                if (s.qualifiers().isEmpty()) {
+                    return 1;
+                }
+                return 0;
+            })
+            .thenComparing(ServiceInfo::serviceType);
+    private static final System.Logger LOGGER = System.getLogger(ServiceRegistryManager.class.getName());
+    private static final InterceptionMetadata NO_OP_INTERCEPT_META = new NoOpInterceptMeta();
+
+    private final ReentrantReadWriteLock lifecycleLock = new ReentrantReadWriteLock();
+    private final ServiceRegistryConfig config;
+    private final ServiceDiscovery discovery;
+
+    private CoreServiceRegistry registry;
+
+    ServiceRegistryManager(ServiceRegistryConfig config, ServiceDiscovery serviceDiscovery) {
+        this.config = config;
+        this.discovery = serviceDiscovery;
+    }
+
     /**
      * Create a new service registry manager with default configuration.
      *
      * @return a new service registry manager
      */
-    static ServiceRegistryManager create() {
+    public static ServiceRegistryManager create() {
         return create(ServiceRegistryConfig.create());
     }
 
@@ -39,8 +91,12 @@ static ServiceRegistryManager create() {
      * @param config configuration of this registry manager
      * @return a new configured service registry manager
      */
-    static ServiceRegistryManager create(ServiceRegistryConfig config) {
-        return ServiceRegistryManagerDiscovery.create(config);
+    public static ServiceRegistryManager create(ServiceRegistryConfig config) {
+        ServiceDiscovery discovery = config.discoverServices() || config.discoverServicesFromServiceLoader()
+                ? CoreServiceDiscovery.create(config)
+                : CoreServiceDiscovery.noop();
+
+        return new ServiceRegistryManager(config, discovery);
     }
 
     /**
@@ -48,10 +104,367 @@ static ServiceRegistryManager create(ServiceRegistryConfig config) {
      *
      * @return service registry ready to be used
      */
-    ServiceRegistry registry();
+    public ServiceRegistry registry() {
+        Lock readLock = lifecycleLock.readLock();
+        try {
+            readLock.lock();
+            if (registry != null) {
+                return registry;
+            }
+        } finally {
+            readLock.unlock();
+        }
+
+        Lock writeLock = lifecycleLock.writeLock();
+        try {
+            writeLock.lock();
+            if (registry != null) {
+                return registry;
+            }
+            // all descriptors
+            Set<ServiceDescriptor<?>> descriptors = Collections.newSetFromMap(new IdentityHashMap<>());
+            // scope handlers (scope type to service)
+            Map<TypeName, ServiceInfo> scopeHandlers = new HashMap<>();
+            // service descriptor singleton instance to its explicit value
+            Map<io.helidon.service.registry.ServiceInfo, Object> explicitInstances = new IdentityHashMap<>();
+            // implementation type to its manager
+            Map<TypeName, ServiceInfo> servicesByType = new HashMap<>();
+            // implemented contracts to their manager(s)
+            Map<ResolvedType, Set<ServiceInfo>> servicesByContract = new HashMap<>();
+            // map of qualifier type to a service info that can provide instances for it
+            Map<TypeName, Set<ServiceInfo>> qualifiedProvidersByQualifier = new HashMap<>();
+            // map of a qualifier type and contract to a service info
+            Map<TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders =
+                    new HashMap<>();
+
+            List<ServiceDescriptor<Binding>> bindings = new ArrayList<>();
+
+            config.serviceInstances()
+                    .forEach((desc, instance) -> {
+                        var descriptor = desc;
+                        if (descriptor instanceof VirtualDescriptor) {
+                            // maybe we have a real descriptor for this type
+                            descriptor = virtualDescriptor(config, discovery, descriptor);
+                        }
+
+                        descriptors.add(descriptor);
+                        bind(bindings,
+                             scopeHandlers,
+                             servicesByType,
+                             servicesByContract,
+                             qualifiedProvidersByQualifier,
+                             typedQualifiedProviders,
+                             descriptor);
+                        explicitInstances.putIfAbsent(descriptor, instance);
+                    });
+
+            for (var descriptor : config.serviceDescriptors()) {
+                descriptors.add(descriptor);
+                bind(bindings,
+                     scopeHandlers,
+                     servicesByType,
+                     servicesByContract,
+                     qualifiedProvidersByQualifier,
+                     typedQualifiedProviders,
+                     descriptor);
+            }
+
+            boolean logUnsupported = LOGGER.isLoggable(System.Logger.Level.TRACE);
+
+            for (var descriptorMeta : discovery.allMetadata()) {
+                String registryType = descriptorMeta.registryType();
+                if (!(DescriptorMetadata.REGISTRY_TYPE_CORE.equals(registryType) || "inject".equals(registryType))) {
+                    // we support only core and inject
+                    if (logUnsupported) {
+                        LOGGER.log(System.Logger.Level.TRACE,
+                                   "Ignoring service of type \"" + descriptorMeta.registryType() + "\": " + descriptorMeta);
+                    }
+                    continue;
+                }
+
+                ServiceDescriptor<?> descriptor = descriptorMeta.descriptor();
+                if (contains(descriptor.contracts(), Binding.TYPE)) {
+                    bindings.add((ServiceDescriptor<Binding>) descriptor);
+                    // applications are not bound to the registry
+                } else {
+                    descriptors.add(descriptor);
+                    bind(bindings,
+                         scopeHandlers,
+                         servicesByType,
+                         servicesByContract,
+                         qualifiedProvidersByQualifier,
+                         typedQualifiedProviders,
+                         descriptor);
+                }
+            }
+
+            // add service registry information (service registry cannot be overridden in any way)
+            ServiceDescriptor<?> scopesDescriptor = Scopes__ServiceDescriptor.INSTANCE;
+            ServiceDescriptor<?> registryDescriptor = ServiceRegistry__ServiceDescriptor.INSTANCE;
+
+            descriptors.add(scopesDescriptor);
+            descriptors.add(registryDescriptor);
+
+            bind(bindings,
+                 scopeHandlers,
+                 servicesByType,
+                 servicesByContract,
+                 qualifiedProvidersByQualifier,
+                 typedQualifiedProviders,
+                 registryDescriptor);
+            // add injection metadata information
+            ServiceDescriptor<?> interceptDescriptor = InterceptionMetadata__ServiceDescriptor.INSTANCE;
+            descriptors.add(interceptDescriptor);
+
+            bind(bindings,
+                 scopeHandlers,
+                 servicesByType,
+                 servicesByContract,
+                 qualifiedProvidersByQualifier,
+                 typedQualifiedProviders,
+                 interceptDescriptor);
+
+            Map<ResolvedType, AtomicBoolean> accessedContracts = new HashMap<>();
+
+            // we may create a few more atomic booleans than strictly necessary,
+            // but cheaper than using putIfAbsent
+            descriptors.stream()
+                    .forEach(descriptor -> {
+                        accessedContracts.put(ResolvedType.create(descriptor.serviceType()), new AtomicBoolean());
+                        descriptor.contracts()
+                                .forEach(contract -> accessedContracts.put(contract, new AtomicBoolean()));
+                    });
+
+            registry = new CoreServiceRegistry(config,
+                                               descriptors,
+                                               scopeHandlers,
+                                               explicitInstances,
+                                               servicesByType,
+                                               servicesByContract,
+                                               qualifiedProvidersByQualifier,
+                                               typedQualifiedProviders,
+                                               accessedContracts);
+
+            // now check if we have an application, and if so, apply it
+            if (config.useBinding()) {
+                for (ServiceDescriptor<Binding> binding : bindings) {
+                    // applications cannot have dependencies
+                    Binding bindingInstance = (Binding) binding.instantiate(DependencyContext.create(Map.of()),
+                                                                            NO_OP_INTERCEPT_META);
+                    bindingInstance.configure(new ApplicationPlanBinder(bindingInstance, registry));
+                }
+            }
+
+            // and if application was not bound using binding(s), we need to create the bindings now
+            registry.ensureInjectionPlans();
+
+            return registry;
+        } finally {
+            writeLock.unlock();
+        }
+    }
 
     /**
      * Shutdown the managed service registry.
      */
-    void shutdown();
+    public void shutdown() {
+        Lock lock = lifecycleLock.writeLock();
+        try {
+            lock.lock();
+            if (registry == null) {
+                // registry was never requested,
+                return;
+            }
+
+            registry.shutdown();
+            registry = null;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static ServiceDescriptor<?> virtualDescriptor(ServiceRegistryConfig config,
+                                                          ServiceDiscovery discovery,
+                                                          ServiceDescriptor<?> descriptor) {
+        TypeName serviceType = descriptor.serviceType();
+        var fromConfig = config.serviceDescriptors()
+                .stream()
+                .filter(registered -> registered.serviceType().equals(serviceType))
+                .findFirst();
+        if (fromConfig.isPresent()) {
+            return fromConfig.get();
+        }
+
+        return discovery.allMetadata()
+                .stream()
+                .filter(handler -> contains(handler.contracts(), serviceType))
+                .map(DescriptorHandler::descriptor)
+                .filter(desc -> desc.serviceType().equals(serviceType))
+                .findFirst()
+                .map(it -> (ServiceDescriptor) it)
+                .orElse(descriptor);
+    }
+
+    private static boolean contains(Set<ResolvedType> contracts, TypeName type) {
+        return contracts.stream().anyMatch(it -> it.type().equals(type));
+    }
+
+    @SuppressWarnings("unchecked")
+    private void bind(List<ServiceDescriptor<Binding>> bindings,
+                      Map<TypeName, ServiceInfo> scopeHandlers,
+                      Map<TypeName, ServiceInfo> servicesByType,
+                      Map<ResolvedType, Set<ServiceInfo>> servicesByContract,
+                      Map<TypeName, Set<ServiceInfo>> qualifiedProvidersByQualifier,
+                      Map<TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders,
+                      ServiceDescriptor<?> descriptor) {
+
+        if (contains(descriptor.contracts(), Binding.TYPE)) {
+            bindings.add((ServiceDescriptor<Binding>) descriptor);
+            // application is not bound to the registry
+            return;
+        }
+
+        if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
+            if (descriptor instanceof ServiceLoader__ServiceDescriptor sl) {
+                LOGGER.log(System.Logger.Level.TRACE,
+                           "Binding service loader descriptor: " + sl + ")");
+            } else {
+                LOGGER.log(System.Logger.Level.TRACE, "Binding service descriptor: " + descriptor.descriptorType()
+                        .fqName());
+            }
+        }
+
+        // by service type
+        servicesByType.putIfAbsent(descriptor.serviceType(), descriptor);
+        // service type is a contract as well (to make lookup easier)
+        servicesByContract.computeIfAbsent(ResolvedType.create(descriptor.serviceType()),
+                                           it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
+                .add(descriptor);
+
+        Set<ResolvedType> contracts = descriptor.contracts();
+        // by contract
+        for (ResolvedType contract : contracts) {
+            servicesByContract.computeIfAbsent(contract,
+                                               it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
+                    .add(descriptor);
+        }
+
+        // scope handlers have a very specific meaning
+        if (contains(contracts, Service.ScopeHandler.TYPE)) {
+            if (!Service.Singleton.TYPE.equals(descriptor.scope())) {
+                throw new ServiceRegistryException("Services that provide ScopeHandler contract MUST be in Singleton scope, but "
+                                                           + descriptor.serviceType().fqName() + " is in "
+                                                           + descriptor.scope().fqName() + " scope.");
+            }
+            if (descriptor instanceof GeneratedService.ScopeHandlerDescriptor shd) {
+                scopeHandlers.putIfAbsent(shd.handledScope(), descriptor);
+            } else {
+                throw new ServiceRegistryException("Service descriptors of services that implement ScopeHandler MUST"
+                                                           + " implement ScopeHandlerDescriptor. Service "
+                                                           + descriptor.descriptorType().fqName() + " does not.");
+            }
+        }
+
+        if (descriptor.factoryType() == FactoryType.QUALIFIED) {
+            // a special kind of service that matches ANY qualifier instance of a specific type, and also may match
+            // a specific contract, or ANY contract
+            if (descriptor instanceof GeneratedService.QualifiedFactoryDescriptor qpd) {
+                TypeName qualifierType = qpd.qualifierType();
+                if (contains(contracts, TypeNames.OBJECT)) {
+                    // matches any contract
+                    qualifiedProvidersByQualifier.computeIfAbsent(qualifierType, it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
+                            .add(descriptor);
+                } else {
+                    // contract specific
+                    Set<TypeName> realContracts = contracts.stream()
+                            .map(ResolvedType::type)
+                            .filter(Predicate.not(Service.QualifiedFactory.TYPE::equals))
+                            .collect(Collectors.toSet());
+                    for (TypeName realContract : realContracts) {
+                        TypedQualifiedProviderKey key = new TypedQualifiedProviderKey(qualifierType,
+                                                                                      ResolvedType.create(realContract));
+                        typedQualifiedProviders.computeIfAbsent(key, it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
+                                .add(descriptor);
+                    }
+                }
+            } else {
+                throw new ServiceRegistryException("Service descriptors of services that implement QualifiedProvider MUST"
+                                                           + " implement QualifiedProviderDescriptor. Service "
+                                                           + descriptor.descriptorType().fqName() + " does not.");
+            }
+        }
+
+        // and bind factory types, as we can also lookup factories, but only types that are not provided by contracts
+        // as otherwise we would return a factory instance instead of constructed instance
+        // there are cases where the structure can "trick" us into thinking something is a factory contract, such as
+        // when an actual contract of the factory extends a Supplier that provides the same type as the factory itself
+        var factoryContracts = descriptor.factoryContracts();
+        for (ResolvedType factoryContract : factoryContracts) {
+            if (!contracts.contains(factoryContract)) {
+                servicesByContract.computeIfAbsent(factoryContract,
+                                                   it -> new TreeSet<>(SERVICE_INFO_COMPARATOR))
+                        .add(descriptor);
+            }
+        }
+    }
+
+    record TypedQualifiedProviderKey(TypeName qualifier, ResolvedType contract) {
+    }
+
+    private static class ApplicationPlanBinder implements DependencyPlanBinder {
+        private static final System.Logger LOGGER = System.getLogger(ApplicationPlanBinder.class.getName());
+
+        private final Binding appInstance;
+        private final CoreServiceRegistry registry;
+
+        private ApplicationPlanBinder(Binding appInstance, CoreServiceRegistry registry) {
+            this.appInstance = appInstance;
+            this.registry = registry;
+        }
+
+        @Override
+        public Binder bindTo(ServiceInfo descriptor) {
+            ServiceManager<Object> serviceManager = registry.serviceManager(descriptor);
+
+            if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                LOGGER.log(System.Logger.Level.DEBUG, "binding injection plan to " + serviceManager);
+            }
+
+            return serviceManager.servicePlanBinder();
+        }
+
+        @Override
+        public void interceptors(ServiceInfo... descriptors) {
+            registry.interceptors(descriptors);
+        }
+
+        @Override
+        public String toString() {
+            return "Service binder for application: " + appInstance.name();
+        }
+    }
+
+    private static class NoOpInterceptMeta implements InterceptionMetadata {
+        @Override
+        public <T> InterceptionInvoker<T> createInvoker(ServiceInfo descriptor,
+                                                        Set<Qualifier> typeQualifiers,
+                                                        List<Annotation> typeAnnotations,
+                                                        TypedElementInfo element,
+                                                        InterceptionInvoker<T> targetInvoker,
+                                                        Set<Class<? extends Throwable>> checkedExceptions) {
+            return targetInvoker;
+        }
+
+        @Override
+        public <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
+                                                        ServiceInfo descriptor,
+                                                        Set<Qualifier> typeQualifiers,
+                                                        List<Annotation> typeAnnotations,
+                                                        TypedElementInfo element,
+                                                        InterceptionInvoker<T> targetInvoker,
+                                                        Set<Class<? extends Throwable>> checkedExceptions) {
+            return targetInvoker;
+        }
+    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManagerDiscovery.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManagerDiscovery.java
deleted file mode 100644
index 94ea9c0d035..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManagerDiscovery.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.Optional;
-import java.util.ServiceLoader;
-
-import io.helidon.common.HelidonServiceLoader;
-import io.helidon.common.LazyValue;
-import io.helidon.service.registry.spi.ServiceRegistryManagerProvider;
-
-final class ServiceRegistryManagerDiscovery {
-    private static final Optional<ServiceRegistryManagerProvider> REGISTRY_MANAGER_PROVIDER =
-            HelidonServiceLoader.builder(ServiceLoader.load(ServiceRegistryManagerProvider.class))
-                    .build()
-                    .stream()
-                    .findFirst();
-
-    private ServiceRegistryManagerDiscovery() {
-    }
-
-    static ServiceRegistryManager create(ServiceRegistryConfig config) {
-        ServiceDiscovery discovery = config.discoverServices() || config.discoverServicesFromServiceLoader()
-                ? CoreServiceDiscovery.create(config)
-                : CoreServiceDiscovery.noop();
-
-        LazyValue<ServiceRegistryManager> coreManager = LazyValue.create(() -> new CoreServiceRegistryManager(config, discovery));
-
-        return REGISTRY_MANAGER_PROVIDER.map(it -> it.create(config, discovery, coreManager))
-                .orElseGet(coreManager);
-    }
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry__ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry__ServiceDescriptor.java
deleted file mode 100644
index 826d37299f7..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistry__ServiceDescriptor.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.Set;
-
-import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeName;
-
-/**
- * Service descriptor to enable dependency on {@link io.helidon.service.registry.ServiceRegistry}.
- */
-@SuppressWarnings("checkstyle:TypeName") // matches pattern of generated descriptors
-public class ServiceRegistry__ServiceDescriptor implements ServiceDescriptor<ServiceRegistry> {
-    /**
-     * Singleton instance to be referenced when building applications.
-     */
-    public static final ServiceRegistry__ServiceDescriptor INSTANCE = new ServiceRegistry__ServiceDescriptor();
-
-    private static final TypeName DESCRIPTOR_TYPE = TypeName.create(ServiceRegistry__ServiceDescriptor.class);
-    private static final Set<ResolvedType> CONTRACTS = Set.of(ResolvedType.create(ServiceRegistry.TYPE));
-
-    private ServiceRegistry__ServiceDescriptor() {
-    }
-
-    @Override
-    public TypeName serviceType() {
-        return ServiceRegistry.TYPE;
-    }
-
-    @Override
-    public TypeName descriptorType() {
-        return DESCRIPTOR_TYPE;
-    }
-
-    @Override
-    public Set<ResolvedType> contracts() {
-        return CONTRACTS;
-    }
-}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceSupplies.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
similarity index 94%
rename from service/inject/inject/src/main/java/io/helidon/service/inject/ServiceSupplies.java
rename to service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
index 8034d61b36f..7d0977a4cee 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/ServiceSupplies.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject;
+package io.helidon.service.registry;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -25,15 +25,10 @@
 import java.util.stream.Stream;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.registry.ServiceInfo;
-import io.helidon.service.registry.ServiceRegistryException;
-
-import static io.helidon.service.inject.LookupTrace.traceLookup;
-import static io.helidon.service.inject.LookupTrace.traceLookupInstance;
-import static io.helidon.service.inject.LookupTrace.traceLookupInstances;
+
+import static io.helidon.service.registry.LookupTrace.traceLookup;
+import static io.helidon.service.registry.LookupTrace.traceLookupInstance;
+import static io.helidon.service.registry.LookupTrace.traceLookupInstances;
 
 final class ServiceSupplies {
     private ServiceSupplies() {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Services.java b/service/registry/src/main/java/io/helidon/service/registry/Services.java
new file mode 100644
index 00000000000..d6441e25997
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/Services.java
@@ -0,0 +1,140 @@
+package io.helidon.service.registry;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Static access to the service registry.
+ * <p>
+ * There is always a single instance of a registry available within an application that can be access through
+ * methods on this class.
+ * <p>
+ * This instance can be explicitly configured using {@link #registry(ServiceRegistry)} in case you want to setup a
+ * registry instance yourself.
+ * <p>
+ * We support "late binding" of services using this class, such as by using {@link #set(Class, Object[])}.
+ * These methods allow setting an explicit instance for a service normally built by the registry.
+ * <p>
+ * The set methods have the following limitations:
+ * <ul>
+ *     <li>The {@code contract} parameter must be of one of the supported contracts by the service registry</li>
+ *     <li>The method MUST be called before the contract is used by any other service, to achieve consistency (i.e. calling
+ *     {@link io.helidon.service.registry.ServiceRegistry#get(Class)} must yield the same instance if the service is a
+ *     singleton</li>
+ * </ul>
+ */
+public final class Services {
+    private Services() {
+    }
+
+    /**
+     * Configure the application wide registry to be used by components that require static lookup of required
+     * services.
+     * <p>
+     * Note that this method MUST be called as one of the first things in your application, as all Helidon components
+     * that use other services require it (except for Helidon Logging and Common Config).
+     *
+     * @param registry registry instance to use
+     * @throws java.lang.NullPointerException in case the registry is null
+     */
+    public static void registry(ServiceRegistry registry) {
+        GlobalServiceRegistry.registry(registry);
+    }
+
+    /**
+     * Configure an explicit instance (explicit instances) for the specified service contract. This method
+     * replaces all existing service providers and the registry will only use the provided instances.
+     * <p>
+     * This method must be called before the contract is requested from the registry for the first time.
+     * <p>
+     * This method only accepts contracts that are provided by one of the services in this registry.
+     * <p>
+     * This method will only work if the underlying implementation of the service registry is provided by Helidon
+     * (i.e. it will not work on mocked types, and custom implementations).
+     *
+     * @param contract  contract to bind the instance under
+     * @param instances instances to use
+     * @param <T>       type of the contract
+     * @throws io.helidon.service.registry.ServiceRegistryException in case the service contract was already used and cannot be
+     *                                                              re-bound
+     * @throws java.lang.NullPointerException                       if either of the parameters is null
+     */
+    @SafeVarargs
+    public static <T> void set(Class<T> contract, T... instances) {
+        Objects.requireNonNull(contract);
+        Objects.requireNonNull(instances);
+        for (T instance : instances) {
+            Objects.requireNonNull(instance, "All instances must be non-null");
+        }
+        ServiceRegistry registry = GlobalServiceRegistry.registry();
+        if (registry instanceof CoreServiceRegistry csr) {
+            csr.set(contract, instances);
+        }
+    }
+
+    /**
+     * Add an explicit instance for the specified service contract.
+     * <p>
+     * This method has similar contract to {@link #set(Class, Object[])} except it adds the implementation,
+     * where the {@code set} method replaces all implementations.
+     *
+     * @param contract  contract to bind the instance under
+     * @param weight weight of the instance (use {@link io.helidon.common.Weighted#DEFAULT_WEIGHT} for default)
+     * @param instance instance to add
+     * @param <T>       type of the contract
+     * @throws io.helidon.service.registry.ServiceRegistryException in case the service contract was already used and cannot be
+     *                                                              re-bound
+     * @throws java.lang.NullPointerException                       if either of the parameters is null
+     */
+    public static <T> void add(Class<T> contract, double weight, T instance) {
+        Objects.requireNonNull(contract);
+        Objects.requireNonNull(instance);
+
+        ServiceRegistry registry = GlobalServiceRegistry.registry();
+        if (registry instanceof CoreServiceRegistry csr) {
+            csr.add(contract, weight, instance);
+        }
+    }
+
+    /**
+     * Get the first instance of the contract, expecting the contract is available.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return an instance of the contract, never {@code null}
+     * @throws io.helidon.service.registry.ServiceRegistryException in case the contract is not available in the registry
+     * @throws java.lang.NullPointerException                       if either of the parameters is null
+     * @see #first(Class)
+     */
+    public static <T> T get(Class<T> contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().get(contract);
+    }
+
+    /**
+     * Get all instances of the contract.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return all instances in the registry, may be empty
+     * @throws java.lang.NullPointerException if either of the parameters is null
+     */
+    public static <T> List<T> all(Class<T> contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().all(contract);
+    }
+
+    /**
+     * Get first instance of the contract from the registry, all an empty optional if none exist.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return first instance, or an empty optional
+     * @throws java.lang.NullPointerException if either of the parameters is null
+     */
+    public static <T> Optional<T> first(Class<T> contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().first(contract);
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
index 014e49939d4..90865b20ad0 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
@@ -31,13 +31,22 @@ public class VirtualDescriptor implements ServiceDescriptor<Object> {
     private final Set<ResolvedType> contracts;
     private final TypeName serviceType;
     private final TypeName descriptorType;
+    private final double weight;
+    private final Object instance;
 
     VirtualDescriptor(TypeName contract) {
+        // explicit instances configured through config have a very high weight, to be used first
+        this(contract, Weighted.DEFAULT_WEIGHT + 1000, TYPE);
+    }
+
+    VirtualDescriptor(TypeName contract, double weight, Object instance) {
         this.contracts = Set.of(ResolvedType.create(contract));
         this.serviceType = contract;
         this.descriptorType = TypeName.builder(TYPE)
                 .className(TYPE.className() + "_" + contract.className() + "__VirtualDescriptor")
                 .build();
+        this.weight = weight;
+        this.instance = instance;
     }
 
     @Override
@@ -57,7 +66,7 @@ public Set<ResolvedType> contracts() {
 
     @Override
     public double weight() {
-        return Weighted.DEFAULT_WEIGHT + 1000;
+        return weight;
     }
 
     @Override
@@ -73,6 +82,18 @@ public boolean equals(Object o) {
         if (!(o instanceof VirtualDescriptor that)) {
             return false;
         }
-        return Objects.equals(serviceType, that.serviceType);
+        // if this represents the same instance, it is equal, otherwise not
+        return Objects.equals(serviceType, that.serviceType)
+                && (instance == that.instance);
+    }
+
+    @Override
+    public TypeName scope() {
+        return Service.Singleton.TYPE;
+    }
+
+    @Override
+    public String toString() {
+        return "VirtualDescriptor for contract " + serviceType + " (" + weight + ")";
     }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/spi/ServiceRegistryManagerProvider.java b/service/registry/src/main/java/io/helidon/service/registry/spi/ServiceRegistryManagerProvider.java
deleted file mode 100644
index 6ffed28d3ca..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/spi/ServiceRegistryManagerProvider.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry.spi;
-
-import java.util.function.Supplier;
-
-import io.helidon.service.registry.ServiceDiscovery;
-import io.helidon.service.registry.ServiceRegistryConfig;
-import io.helidon.service.registry.ServiceRegistryManager;
-
-/**
- * A {@link java.util.ServiceLoader} provider that enables a different type of service registry.
- * In Helidon this could be a service registry with full injection support.
- */
-public interface ServiceRegistryManagerProvider {
-    /**
-     * Create a new registry manager.
-     *
-     * @param config              configuration as provided to {@link io.helidon.service.registry.ServiceRegistryManager}
-     * @param serviceDiscovery    service discovery to load service instances
-     * @param coreRegistryManager core service registry manager, if it would be used as a backing one for the one provided by this
-     *                            service (lazy loaded)
-     * @return a new service registry manager
-     */
-    ServiceRegistryManager create(ServiceRegistryConfig config,
-                                  ServiceDiscovery serviceDiscovery,
-                                  Supplier<ServiceRegistryManager> coreRegistryManager);
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/spi/package-info.java b/service/registry/src/main/java/io/helidon/service/registry/spi/package-info.java
deleted file mode 100644
index e583f20e3b8..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/spi/package-info.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Service registry SPI provides extension points for the service registry.
- */
-package io.helidon.service.registry.spi;
diff --git a/service/registry/src/main/java/module-info.java b/service/registry/src/main/java/module-info.java
index 3ef1a44825e..c3e620f291a 100644
--- a/service/registry/src/main/java/module-info.java
+++ b/service/registry/src/main/java/module-info.java
@@ -33,12 +33,8 @@
     requires io.helidon.service.metadata;
     requires io.helidon.metadata.hson;
 
-    requires transitive io.helidon.common.config;
     requires transitive io.helidon.builder.api;
     requires transitive io.helidon.common.types;
 
     exports io.helidon.service.registry;
-    exports io.helidon.service.registry.spi;
-
-    uses io.helidon.service.registry.spi.ServiceRegistryManagerProvider;
 }
\ No newline at end of file
diff --git a/service/tests/codegen/pom.xml b/service/tests/codegen/pom.xml
index f0ac014576d..e2a51fe3d51 100644
--- a/service/tests/codegen/pom.xml
+++ b/service/tests/codegen/pom.xml
@@ -24,6 +24,7 @@
         <groupId>io.helidon.service.tests</groupId>
         <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -40,14 +41,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config-metadata</artifactId>
diff --git a/service/tests/codegen/src/main/java/module-info.java b/service/tests/codegen/src/main/java/module-info.java
index ad35b9206ee..6dfc02fed59 100644
--- a/service/tests/codegen/src/main/java/module-info.java
+++ b/service/tests/codegen/src/main/java/module-info.java
@@ -16,8 +16,6 @@
 
 module io.helidon.service.tests.codegen {
     requires io.helidon.service.registry;
-    requires io.helidon.service.inject;
-    requires io.helidon.service.inject.api;
     requires io.helidon.service.codegen;
     requires io.helidon.config.metadata;
 }
\ No newline at end of file
diff --git a/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java b/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
index 89c0c9d35dd..923c13cfaf1 100644
--- a/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
+++ b/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
@@ -20,19 +20,37 @@
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import io.helidon.builder.api.Prototype;
 import io.helidon.common.Generated;
+import io.helidon.common.GenericType;
+import io.helidon.common.types.Annotation;
+import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
 import io.helidon.service.codegen.ServiceCodegenTypes;
+import io.helidon.service.registry.Binding;
 import io.helidon.service.registry.Dependency;
 import io.helidon.service.registry.DependencyContext;
+import io.helidon.service.registry.DependencyPlanBinder;
+import io.helidon.service.registry.Event;
+import io.helidon.service.registry.EventManager;
+import io.helidon.service.registry.FactoryType;
 import io.helidon.service.registry.GeneratedService;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionException;
+import io.helidon.service.registry.InterceptionInvoker;
+import io.helidon.service.registry.InterceptionMetadata;
+import io.helidon.service.registry.Qualifier;
 import io.helidon.service.registry.Service;
 import io.helidon.service.registry.ServiceDescriptor;
-import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceInstance;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.collection.IsEmptyCollection;
@@ -79,11 +97,124 @@ void testTypes() {
         checkField(toCheck, checked, fields, "BUILDER_BLUEPRINT", Prototype.Blueprint.class);
         checkField(toCheck, checked, fields, "GENERATED_ANNOTATION", Generated.class);
 
+        // api.Service.*
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_INJECT", Service.Inject.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_SINGLETON", Service.Singleton.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_NAMED", Service.Named.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_NAMED_BY_TYPE", Service.NamedByType.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_QUALIFIER", Service.Qualifier.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_DESCRIBE", Service.Describe.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_SCOPE", Service.Scope.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_PER_LOOKUP", Service.PerLookup.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_PER_INSTANCE", Service.PerInstance.class);
+        checkField(toCheck, checked, fields, "SERVICE_ANNOTATION_RUN_LEVEL", Service.RunLevel.class);
+        checkField(toCheck, checked, fields, "SERVICE_INJECTION_POINT_FACTORY", Service.InjectionPointFactory.class);
+        checkField(toCheck, checked, fields, "SERVICE_SCOPE_HANDLER", Service.ScopeHandler.class);
+        checkField(toCheck, checked, fields, "SERVICE_SERVICES_FACTORY", Service.ServicesFactory.class);
+        checkField(toCheck, checked, fields, "SERVICE_QUALIFIED_FACTORY", Service.QualifiedFactory.class);
+
+        checkField(toCheck, checked, fields, "SERVICE_CONFIG", ServiceRegistryConfig.class);
+        checkField(toCheck, checked, fields, "SERVICE_REGISTRY", ServiceRegistry.class);
+        checkField(toCheck, checked, fields, "SERVICE_REGISTRY_MANAGER", ServiceRegistryManager.class);
+
+        // api.Interception.*
+        checkField(toCheck, checked, fields, "INTERCEPTION_INTERCEPTED", Interception.Intercepted.class);
+        checkField(toCheck, checked, fields, "INTERCEPTION_DELEGATE", Interception.Delegate.class);
+        checkField(toCheck, checked, fields, "INTERCEPTION_EXTERNAL_DELEGATE", Interception.ExternalDelegate.class);
+
+        // api.* except for interception types
+        checkField(toCheck, checked, fields, "SERVICE_FACTORY_TYPE", FactoryType.class);
+        checkField(toCheck, checked, fields, "SERVICE_QUALIFIER", Qualifier.class);
+        checkField(toCheck, checked, fields, "SERVICE_SERVICE_INSTANCE", ServiceInstance.class);
+        checkField(toCheck, checked, fields, "SERVICE_BINDING", Binding.class);
+        checkField(toCheck, checked, fields, "SERVICE_PLAN_BINDER", DependencyPlanBinder.class);
+
+        // api.* interception types
+        checkField(toCheck, checked, fields, "INTERCEPT_EXCEPTION", InterceptionException.class);
+        checkField(toCheck, checked, fields, "INTERCEPT_METADATA", InterceptionMetadata.class);
+        checkField(toCheck, checked, fields, "INTERCEPT_INVOKER", InterceptionInvoker.class);
+
+        // api.* event types
+        checkField(toCheck, checked, fields, "EVENT_OBSERVER", Event.Observer.class);
+        checkField(toCheck, checked, fields, "EVENT_OBSERVER_ASYNC", Event.AsyncObserver.class);
+        checkField(toCheck, checked, fields, "EVENT_EMITTER", Event.Emitter.class);
+        checkField(toCheck, checked, fields, "EVENT_MANAGER", EventManager.class);
+
+        // generated inject service types
+        checkField(toCheck, checked, fields, "SERVICE_G_PER_INSTANCE_DESCRIPTOR",
+                   GeneratedService.PerInstanceDescriptor.class);
+        checkField(toCheck, checked, fields, "SERVICE_G_QUALIFIED_FACTORY_DESCRIPTOR",
+                   GeneratedService.QualifiedFactoryDescriptor.class);
+        checkField(toCheck, checked, fields, "SERVICE_G_SCOPE_HANDLER_DESCRIPTOR",
+                   GeneratedService.ScopeHandlerDescriptor.class);
+        checkField(toCheck, checked, fields, "SERVICE_G_DEPENDENCY_SUPPORT",
+                   GeneratedService.DependencySupport.class);
+        checkField(toCheck, checked, fields, "SERVICE_G_EVENT_OBSERVER_REGISTRATION",
+                   GeneratedService.EventObserverRegistration.class);
+
+        // generated interception types
+        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY",
+                   GeneratedService.SupplierFactoryInterceptionWrapper.class);
+        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_SERVICES_FACTORY",
+                   GeneratedService.ServicesFactoryInterceptionWrapper.class);
+        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_IP_FACTORY",
+                   GeneratedService.IpFactoryInterceptionWrapper.class);
+        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY",
+                   GeneratedService.QualifiedFactoryInterceptionWrapper.class);
+        checkField(toCheck, checked, fields, "ANY_GENERIC_TYPE", TypeName.builder()
+                .type(GenericType.class)
+                .addTypeArgument(TypeNames.WILDCARD)
+                .build());
+        checkField(toCheck, checked, fields, "LIST_OF_DEPENDENCIES", TypeName.builder()
+                .type(List.class)
+                .addTypeArgument(TypeName.create(Dependency.class))
+                .build());
+        checkField(toCheck, checked, fields, "SET_OF_QUALIFIERS", TypeName.builder()
+                .type(Set.class)
+                .addTypeArgument(TypeName.create(Qualifier.class))
+                .build());
+        checkField(toCheck, checked, fields, "LIST_OF_ANNOTATIONS", TypeName.builder()
+                .type(List.class)
+                .addTypeArgument(TypeName.create(Annotation.class))
+                .build());
+        checkField(toCheck, checked, fields, "SET_OF_STRINGS", TypeName.builder()
+                .type(Set.class)
+                .addTypeArgument(TypeName.create(String.class))
+                .build());
+        checkField(toCheck, checked, fields, "SET_OF_RESOLVED_TYPES", TypeName.builder()
+                .type(Set.class)
+                .addTypeArgument(TypeName.create(ResolvedType.class))
+                .build());
+        checkField(toCheck, checked, fields, "GENERIC_T_TYPE", TypeName.builder()
+                .className("T")
+                .generic(true)
+                .build());
+
         assertThat("If the collection is not empty, please add appropriate checkField line to this test",
                    toCheck,
                    IsEmptyCollection.empty());
     }
 
+    private void checkField(Set<String> namesToCheck,
+                            Set<String> checkedNames,
+                            Map<String, Field> namesToFields,
+                            String name,
+                            TypeName expectedType) {
+        Field field = namesToFields.get(name);
+        assertThat("Field " + name + " does not exist in the class", field, notNullValue());
+        try {
+            namesToCheck.remove(name);
+            if (checkedNames.add(name)) {
+                TypeName value = (TypeName) field.get(null);
+                assertThat("Field " + name, value.resolvedName(), is(expectedType.resolvedName()));
+            } else {
+                fail("Field " + name + " is checked more than once");
+            }
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     private void checkField(Set<String> namesToCheck,
                             Set<String> checkedNames,
                             Map<String, Field> namesToFields,
diff --git a/service/tests/codegen/src/test/java/module-info.java b/service/tests/codegen/src/test/java/module-info.java
index ab0295c357e..e150ae14fb1 100644
--- a/service/tests/codegen/src/test/java/module-info.java
+++ b/service/tests/codegen/src/test/java/module-info.java
@@ -18,8 +18,6 @@
     exports io.helidon.service.tests.codegen;
 
     requires io.helidon.service.registry;
-    requires io.helidon.service.inject;
-    requires io.helidon.service.inject.api;
     requires io.helidon.service.codegen;
     requires io.helidon.config.metadata;
 
diff --git a/service/tests/inject/events/pom.xml b/service/tests/events/pom.xml
similarity index 83%
rename from service/tests/inject/events/pom.xml
rename to service/tests/events/pom.xml
index 966d87120c6..b962340d51a 100644
--- a/service/tests/inject/events/pom.xml
+++ b/service/tests/events/pom.xml
@@ -21,30 +21,22 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-events</artifactId>
-    <name>Helidon Service Tests Inject Events</name>
-    <description>Tests for injection events</description>
+    <artifactId>helidon-service-tests-events</artifactId>
+    <name>Helidon Service Tests Events</name>
+    <description>Tests for service registry events</description>
 
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config</artifactId>
@@ -80,8 +72,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -98,8 +90,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/AsyncEventTypes.java b/service/tests/events/src/main/java/io/helidon/service/tests/events/AsyncEventTypes.java
similarity index 91%
rename from service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/AsyncEventTypes.java
rename to service/tests/events/src/main/java/io/helidon/service/tests/events/AsyncEventTypes.java
index 7e426061fa5..1c3113030c2 100644
--- a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/AsyncEventTypes.java
+++ b/service/tests/events/src/main/java/io/helidon/service/tests/events/AsyncEventTypes.java
@@ -14,24 +14,24 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.events;
+package io.helidon.service.tests.events;
 
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import io.helidon.service.inject.api.Event;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Event;
+import io.helidon.service.registry.Service;
 
 class AsyncEventTypes {
     private AsyncEventTypes() {
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventEmitter {
         private final Event.Emitter<EventObject> event;
 
-        @Injection.Inject
+        @Service.Inject
         EventEmitter(Event.Emitter<EventObject> event) {
             this.event = event;
         }
@@ -53,7 +53,7 @@ String message() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class SyncEventObserver {
         private volatile String threadName;
         private volatile EventObject eventObject;
@@ -77,7 +77,7 @@ String threadName() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventObserver {
         private volatile String threadName;
         private volatile EventObject eventObject;
diff --git a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/EventTypes.java b/service/tests/events/src/main/java/io/helidon/service/tests/events/EventTypes.java
similarity index 86%
rename from service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/EventTypes.java
rename to service/tests/events/src/main/java/io/helidon/service/tests/events/EventTypes.java
index 89f3c2d5258..e1c11045d65 100644
--- a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/EventTypes.java
+++ b/service/tests/events/src/main/java/io/helidon/service/tests/events/EventTypes.java
@@ -14,20 +14,20 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.events;
+package io.helidon.service.tests.events;
 
-import io.helidon.service.inject.api.Event;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Event;
+import io.helidon.service.registry.Service;
 
 class EventTypes {
     private EventTypes() {
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventEmitter {
         private final Event.Emitter<EventObject> event;
 
-        @Injection.Inject
+        @Service.Inject
         EventEmitter(Event.Emitter<EventObject> event) {
             this.event = event;
         }
@@ -37,11 +37,11 @@ void emit(EventObject eventObject) {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventEmitter2 {
         private final Event.Emitter<EventObject> event;
 
-        @Injection.Inject
+        @Service.Inject
         EventEmitter2(Event.Emitter<EventObject> event) {
             this.event = event;
         }
@@ -63,7 +63,7 @@ String message() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventObserver {
         private volatile EventObject eventObject;
 
diff --git a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/QualifiedEventTypes.java b/service/tests/events/src/main/java/io/helidon/service/tests/events/QualifiedEventTypes.java
similarity index 89%
rename from service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/QualifiedEventTypes.java
rename to service/tests/events/src/main/java/io/helidon/service/tests/events/QualifiedEventTypes.java
index d2f0e7d2a82..b5b728058af 100644
--- a/service/tests/inject/events/src/main/java/io/helidon/service/tests/inject/events/QualifiedEventTypes.java
+++ b/service/tests/events/src/main/java/io/helidon/service/tests/events/QualifiedEventTypes.java
@@ -14,26 +14,25 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.events;
+package io.helidon.service.tests.events;
 
-import io.helidon.service.inject.api.Event;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Event;
+import io.helidon.service.registry.Service;
 
 class QualifiedEventTypes {
     private QualifiedEventTypes() {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface EventQualifier {
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventEmitter {
         private final Event.Emitter<EventObject> unqualifiedEvent;
         private final Event.Emitter<EventObject> event;
 
-
-        @Injection.Inject
+        @Service.Inject
         EventEmitter(@EventQualifier Event.Emitter<EventObject> event,
                      Event.Emitter<EventObject> unqualifiedEvent) {
             this.event = event;
@@ -58,7 +57,7 @@ String message() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class EventObserver {
         private volatile EventObject eventObject;
         private volatile EventObject unqualifiedEventObject;
diff --git a/service/tests/inject/service-lifecycle/src/main/java/module-info.java b/service/tests/events/src/main/java/module-info.java
similarity index 85%
rename from service/tests/inject/service-lifecycle/src/main/java/module-info.java
rename to service/tests/events/src/main/java/module-info.java
index 9494710f2c0..ee2b140b16d 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/module-info.java
+++ b/service/tests/events/src/main/java/module-info.java
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-open module io.helidon.service.inject.tests.service.lifecycle {
+module io.helidon.service.tests.events {
     requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
 
+    exports io.helidon.service.tests.events;
 }
\ No newline at end of file
diff --git a/service/tests/inject/events/src/test/java/io/helidon/service/tests/inject/events/EventTest.java b/service/tests/events/src/test/java/io/helidon/service/tests/events/EventTest.java
similarity index 92%
rename from service/tests/inject/events/src/test/java/io/helidon/service/tests/inject/events/EventTest.java
rename to service/tests/events/src/test/java/io/helidon/service/tests/events/EventTest.java
index f2e16b49eaf..70b1b958c5f 100644
--- a/service/tests/inject/events/src/test/java/io/helidon/service/tests/inject/events/EventTest.java
+++ b/service/tests/events/src/test/java/io/helidon/service/tests/events/EventTest.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.events;
+package io.helidon.service.tests.events;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -35,12 +35,12 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 class EventTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     static void initRegistry() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/codegen/pom.xml b/service/tests/inject/codegen/pom.xml
deleted file mode 100644
index 6b9d124bafd..00000000000
--- a/service/tests/inject/codegen/pom.xml
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>helidon-service-tests-inject-codegen</artifactId>
-    <name>Helidon Service Tests Inject Codegen</name>
-    <description>Tests for injection codegen</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-codegen</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-all</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common.testing</groupId>
-            <artifactId>helidon-common-testing-junit5</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>
diff --git a/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java b/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
deleted file mode 100644
index 5856b589df5..00000000000
--- a/service/tests/inject/codegen/src/test/java/io/helidon/service/tests/inject/codegen/InjectCodegenTypesTest.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.tests.inject.codegen;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.Binding;
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.InjectionMain;
-import io.helidon.service.inject.InjectionPlanBinder;
-import io.helidon.service.inject.api.Event;
-import io.helidon.service.inject.api.EventManager;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.GeneratedInjectService;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionException;
-import io.helidon.service.inject.api.InterceptionInvoker;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
-import io.helidon.service.inject.codegen.InjectCodegenTypes;
-
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.collection.IsEmptyCollection;
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
-class InjectCodegenTypesTest {
-    @Test
-    void testTypes() {
-        // it is really important to test ALL constants on the class, so let's use reflection
-        Field[] declaredFields = InjectCodegenTypes.class.getDeclaredFields();
-
-        Set<String> toCheck = new HashSet<>();
-        Set<String> checked = new HashSet<>();
-        Map<String, Field> fields = new HashMap<>();
-
-        for (Field declaredField : declaredFields) {
-            String name = declaredField.getName();
-
-            assertThat(name + " must be a TypeName", declaredField.getType(), CoreMatchers.sameInstance(TypeName.class));
-            assertThat(name + " must be static", Modifier.isStatic(declaredField.getModifiers()), is(true));
-            assertThat(name + " must be public", Modifier.isPublic(declaredField.getModifiers()), is(true));
-            assertThat(name + " must be final", Modifier.isFinal(declaredField.getModifiers()), is(true));
-
-            toCheck.add(name);
-            fields.put(name, declaredField);
-        }
-
-        // api.Injection.*
-        checkField(toCheck, checked, fields, "INJECTION_INJECT", Injection.Inject.class);
-        checkField(toCheck, checked, fields, "INJECTION_SINGLETON", Injection.Singleton.class);
-        checkField(toCheck, checked, fields, "INJECTION_NAMED", Injection.Named.class);
-        checkField(toCheck, checked, fields, "INJECTION_NAMED_BY_TYPE", Injection.NamedByType.class);
-        checkField(toCheck, checked, fields, "INJECTION_QUALIFIER", Injection.Qualifier.class);
-        checkField(toCheck, checked, fields, "INJECTION_DESCRIBE", Injection.Describe.class);
-        checkField(toCheck, checked, fields, "INJECTION_SCOPE", Injection.Scope.class);
-        checkField(toCheck, checked, fields, "INJECTION_PER_LOOKUP", Injection.PerLookup.class);
-        checkField(toCheck, checked, fields, "INJECTION_PER_INSTANCE", Injection.PerInstance.class);
-        checkField(toCheck, checked, fields, "INJECTION_RUN_LEVEL", Injection.RunLevel.class);
-        checkField(toCheck, checked, fields, "INJECTION_POINT_FACTORY", Injection.InjectionPointFactory.class);
-        checkField(toCheck, checked, fields, "INJECTION_SCOPE_HANDLER", Injection.ScopeHandler.class);
-        checkField(toCheck, checked, fields, "INJECTION_SERVICES_FACTORY", Injection.ServicesFactory.class);
-        checkField(toCheck, checked, fields, "INJECTION_QUALIFIED_FACTORY", Injection.QualifiedFactory.class);
-        checkField(toCheck, checked, fields, "INJECTION_MAIN", Injection.Main.class);
-
-        // api.Interception.*
-        checkField(toCheck, checked, fields, "INTERCEPTION_INTERCEPTED", Interception.Intercepted.class);
-        checkField(toCheck, checked, fields, "INTERCEPTION_DELEGATE", Interception.Delegate.class);
-        checkField(toCheck, checked, fields, "INTERCEPTION_EXTERNAL_DELEGATE", Interception.ExternalDelegate.class);
-
-        // api.* except for interception types
-        checkField(toCheck, checked, fields, "INJECT_FACTORY_TYPE", FactoryType.class);
-        checkField(toCheck, checked, fields, "INJECT_QUALIFIER", Qualifier.class);
-        checkField(toCheck, checked, fields, "INJECT_INJECTION_POINT", Ip.class);
-        checkField(toCheck, checked, fields, "INJECT_SERVICE_INSTANCE", ServiceInstance.class);
-        checkField(toCheck, checked, fields, "INJECT_SERVICE_DESCRIPTOR", InjectServiceDescriptor.class);
-        checkField(toCheck, checked, fields, "INJECT_CONFIG", InjectConfig.class);
-        checkField(toCheck, checked, fields, "INJECT_CONFIG_BUILDER", InjectConfig.Builder.class);
-        checkField(toCheck, checked, fields, "INJECT_MAIN", InjectionMain.class);
-        checkField(toCheck, checked, fields, "INJECT_BINDING", Binding.class);
-        checkField(toCheck, checked, fields, "INJECT_REGISTRY", InjectRegistry.class);
-        checkField(toCheck, checked, fields, "INJECT_REGISTRY_MANAGER", InjectRegistryManager.class);
-        checkField(toCheck, checked, fields, "INJECT_PLAN_BINDER", InjectionPlanBinder.class);
-
-        // api.* interception types
-        checkField(toCheck, checked, fields, "INTERCEPT_EXCEPTION", InterceptionException.class);
-        checkField(toCheck, checked, fields, "INTERCEPT_METADATA", InterceptionMetadata.class);
-        checkField(toCheck, checked, fields, "INTERCEPT_INVOKER", InterceptionInvoker.class);
-
-        // api.* event types
-        checkField(toCheck, checked, fields, "EVENT_OBSERVER", Event.Observer.class);
-        checkField(toCheck, checked, fields, "EVENT_OBSERVER_ASYNC", Event.AsyncObserver.class);
-        checkField(toCheck, checked, fields, "EVENT_EMITTER", Event.Emitter.class);
-        checkField(toCheck, checked, fields, "EVENT_MANAGER", EventManager.class);
-
-
-        // generated inject service types
-        checkField(toCheck, checked, fields, "INJECT_G_PER_INSTANCE_DESCRIPTOR",
-                   GeneratedInjectService.PerInstanceDescriptor.class);
-        checkField(toCheck, checked, fields, "INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR",
-                   GeneratedInjectService.QualifiedFactoryDescriptor.class);
-        checkField(toCheck, checked, fields, "INJECT_G_SCOPE_HANDLER_DESCRIPTOR",
-                   GeneratedInjectService.ScopeHandlerDescriptor.class);
-        checkField(toCheck, checked, fields, "INJECT_G_IP_SUPPORT",
-                   GeneratedInjectService.IpSupport.class);
-        checkField(toCheck, checked, fields, "INJECT_G_EVENT_OBSERVER_REGISTRATION",
-                   GeneratedInjectService.EventObserverRegistration.class);
-
-        // generated interception types
-        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_SUPPLIER_FACTORY",
-                   GeneratedInjectService.SupplierFactoryInterceptionWrapper.class);
-        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_SERVICES_FACTORY",
-                   GeneratedInjectService.ServicesFactoryInterceptionWrapper.class);
-        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_IP_FACTORY",
-                   GeneratedInjectService.IpFactoryInterceptionWrapper.class);
-        checkField(toCheck, checked, fields, "INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY",
-                   GeneratedInjectService.QualifiedFactoryInterceptionWrapper.class);
-
-        checkField(toCheck, checked, fields, "STRING_ARRAY", String[].class);
-        checkField(toCheck, checked, fields, "DOUBLE_ARRAY", double[].class);
-
-        assertThat("If the collection is not empty, please add appropriate checkField line to this test",
-                   toCheck,
-                   IsEmptyCollection.empty());
-    }
-
-    private void checkField(Set<String> namesToCheck,
-                            Set<String> checkedNames,
-                            Map<String, Field> namesToFields,
-                            String name,
-                            Class<?> expectedType) {
-        Field field = namesToFields.get(name);
-        assertThat("Field " + name + " does not exist in the class", field, notNullValue());
-        try {
-            namesToCheck.remove(name);
-            if (checkedNames.add(name)) {
-                TypeName value = (TypeName) field.get(null);
-                assertThat("Field " + name, value.fqName(), is(expectedType.getCanonicalName()));
-            } else {
-                fail("Field " + name + " is checked more than once");
-            }
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        }
-    }
-}
\ No newline at end of file
diff --git a/service/tests/inject/events/src/main/java/module-info.java b/service/tests/inject/events/src/main/java/module-info.java
deleted file mode 100644
index 3d96521bd0e..00000000000
--- a/service/tests/inject/events/src/main/java/module-info.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.tests.inject.events {
-    requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
-    requires java.logging;
-
-    exports io.helidon.service.tests.inject.events;
-}
\ No newline at end of file
diff --git a/service/tests/inject/inject/pom.xml b/service/tests/inject/inject/pom.xml
deleted file mode 100644
index ca0630caaa7..00000000000
--- a/service/tests/inject/inject/pom.xml
+++ /dev/null
@@ -1,165 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-        <relativePath>../pom.xml</relativePath>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>helidon-service-tests-inject</artifactId>
-    <name>Helidon Service Tests Inject</name>
-    <description>Tests for injection operations</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-registry</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.config</groupId>
-            <artifactId>helidon-config</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-all</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.common.testing</groupId>
-            <artifactId>helidon-common-testing-junit5</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.logging</groupId>
-            <artifactId>helidon-logging-jul</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-apt</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                        <path>
-                            <groupId>io.helidon.codegen</groupId>
-                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                            <version>${helidon.version}</version>
-                        </path>
-                    </annotationProcessorPaths>
-                </configuration>
-                <dependencies>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-apt</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                </dependencies>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-enforcer-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>enforce-jakarta-not-included</id>
-                        <goals>
-                            <goal>enforce</goal>
-                        </goals>
-                        <configuration>
-                            <rules>
-                                <bannedDependencies>
-                                    <excludes>
-                                        <exclude>jakarta.inject:jakarta.inject-api</exclude>
-                                        <exclude>jakarta.annotation:jakarta.annotation-api</exclude>
-                                    </excludes>
-                                </bannedDependencies>
-                            </rules>
-                            <fail>true</fail>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
-                <version>${helidon.version}</version>
-                <executions>
-                    <execution>
-                        <id>create-application</id>
-                        <goals>
-                            <goal>create-application</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <dependencies>
-                    <dependency>
-                        <groupId>io.helidon.codegen</groupId>
-                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
-                        <version>${helidon.version}</version>
-                    </dependency>
-                </dependencies>
-                <configuration>
-                    <failOnWarning>true</failOnWarning>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java b/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
deleted file mode 100644
index 41fff4325b6..00000000000
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/CustomMain.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.tests.inject;
-
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectionMain;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.Injection;
-
-/**
- * Example of a custom main class.
- * This class is here to make sure this does not get broken.
- */
-@Injection.Main
-public abstract class CustomMain extends InjectionMain {
-    /*
-    Important note:
-    DO NOT change the signature of methods in this class, as that would cause a backward incompatible change
-    for our users.
-    The subtype is code generated. Any changes in the
-    Helidon APIs would cause older generated code to stop working.
-    The only exception is major version updates, but it would still be better if this stays compatible.
-     */
-
-    @Override
-    protected void beforeServiceDescriptors(InjectConfig.Builder configBuilder) {
-        System.out.println("Before service descriptors");
-    }
-
-    @Override
-    protected void afterServiceDescriptors(InjectConfig.Builder configBuilder) {
-        System.out.println("After service descriptors");
-    }
-
-    @Override
-    protected InjectRegistry init(InjectConfig config) {
-        System.out.println("Before init method");
-        try {
-            return super.init(config);
-        } finally {
-            System.out.println("After init method");
-        }
-    }
-
-    @Override
-    protected void start(String[] arguments) {
-        super.start(arguments);
-    }
-
-    @Override
-    protected InjectConfig.Builder configBuilder(String[] arguments) {
-        return super.configBuilder(arguments);
-    }
-}
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java b/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
deleted file mode 100644
index 9dfe1bf53a6..00000000000
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.tests.inject;
-
-import java.util.List;
-import java.util.Map;
-
-import io.helidon.common.configurable.LruCache;
-import io.helidon.config.Config;
-import io.helidon.config.ConfigSources;
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.api.Activator;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
-
-import org.junit.jupiter.api.Test;
-
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalEmpty;
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalPresent;
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalValue;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.sameInstance;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.collection.IsEmptyCollection.empty;
-
-public class InjectRegistryConfigTest {
-    @Test
-    void testDefaults() {
-        InjectConfig cfg = InjectConfig.create();
-        // service registry config
-        assertThat(cfg.config(), is(optionalEmpty()));
-        assertThat(cfg.discoverServices(), is(true));
-        assertThat(cfg.serviceDescriptors(), is(empty()));
-        assertThat(cfg.serviceInstances().size(), is(0));
-        // injection specific config
-        assertThat(cfg.interceptionEnabled(), is(true));
-        assertThat(cfg.limitRuntimePhase(), is(Activator.Phase.ACTIVE));
-        assertThat(cfg.lookupCacheEnabled(), is(false));
-        assertThat(cfg.lookupCache(), is(optionalEmpty()));
-        assertThat(cfg.useBinding(), is(true));
-    }
-
-    @Test
-    void testFromConfig() {
-        Config config = Config.builder(
-                        ConfigSources.create(
-                                Map.of("inject.discover-services", "false",
-                                       "inject.interception-enabled", "false",
-                                       "inject.limit-runtime-phase", "CONSTRUCTING",
-                                       "inject.lookup-cache-enabled", "true",
-                                       "inject.lookup-cache.capacity", "200",
-                                       "inject.use-binding", "false"
-                                ), "config-1"))
-                .disableEnvironmentVariablesSource()
-                .disableSystemPropertiesSource()
-                .build();
-        Config injectConfig = config.get("inject");
-        InjectConfig cfg = InjectConfig.create(injectConfig);
-
-        // service registry config
-        assertThat(cfg.config(), optionalValue(sameInstance(injectConfig)));
-        assertThat(cfg.discoverServices(), is(false));
-        assertThat(cfg.serviceDescriptors(), is(empty()));
-        assertThat(cfg.serviceInstances().size(), is(0));
-        // injection specific config
-        assertThat(cfg.interceptionEnabled(), is(false));
-        assertThat(cfg.limitRuntimePhase(), is(Activator.Phase.CONSTRUCTING));
-        assertThat(cfg.lookupCacheEnabled(), is(true));
-        assertThat(cfg.lookupCache(), is(optionalPresent()));
-        LruCache<Lookup, List<InjectServiceInfo>> cache = cfg.lookupCache().get();
-        assertThat(cache.capacity(), is(200));
-        assertThat(cfg.useBinding(), is(false));
-    }
-}
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java b/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java
deleted file mode 100644
index 82cc105a13c..00000000000
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MainClassTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.tests.inject;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-
-import io.helidon.service.inject.InjectConfig;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-// test that the generated main class exists and works as expected
-public class MainClassTest {
-    @Test
-    public void testMain() throws NoSuchMethodException {
-        // this class is expected to be code generated based on CustomMain @Injection.Main annotation
-        ApplicationMain appMain = new ApplicationMain();
-
-        assertThat(appMain, instanceOf(CustomMain.class));
-
-        Class<ApplicationMain> theClass = ApplicationMain.class;
-
-        assertThat("The class must be public, to be a candidate for Main class",
-                   Modifier.isPublic(theClass.getModifiers()));
-
-        // the class must have the following two methods (when not using the maven plugin):
-        // public static void main(String[] args) {}
-        // protected void serviceDescriptors(InjectConfig.Builder config) {}
-        Method mainMethod = theClass.getMethod("main", String[].class);
-        assertThat("The main method must be public", Modifier.isPublic(mainMethod.getModifiers()));
-        assertThat("The main method must be static", Modifier.isStatic(mainMethod.getModifiers()));
-        assertThat("The main method must return void", mainMethod.getReturnType(), equalTo(void.class));
-
-        Method serviceDescriptorMethod = theClass.getDeclaredMethod("serviceDescriptors", InjectConfig.Builder.class);
-        assertThat("The service descriptors method must be protected",
-                   Modifier.isProtected(serviceDescriptorMethod.getModifiers()));
-        assertThat("The service descriptors method must not be static",
-                   !Modifier.isStatic(serviceDescriptorMethod.getModifiers()));
-        assertThat("The service descriptors method must return void",
-                   serviceDescriptorMethod.getReturnType(),
-                   equalTo(void.class));
-    }
-}
diff --git a/service/tests/inject/interception/src/main/java/module-info.java b/service/tests/inject/interception/src/main/java/module-info.java
deleted file mode 100644
index cce16042ec4..00000000000
--- a/service/tests/inject/interception/src/main/java/module-info.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.tests.inject.interception {
-    requires io.helidon.service.inject.api;
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
-
-    exports io.helidon.service.tests.inject.interception;
-}
\ No newline at end of file
diff --git a/service/tests/inject/pom.xml b/service/tests/inject/pom.xml
index 65a3bf6683b..fe35f268209 100644
--- a/service/tests/inject/pom.xml
+++ b/service/tests/inject/pom.xml
@@ -28,24 +28,130 @@
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>io.helidon.service.tests.inject</groupId>
-    <artifactId>helidon-service-tests-inject-project</artifactId>
-    <name>Helidon Service Tests Inject Project</name>
+    <artifactId>helidon-service-tests-inject</artifactId>
+    <name>Helidon Service Tests Inject</name>
     <description>Tests for injection operations</description>
 
-    <packaging>pom</packaging>
-
-    <modules>
-        <module>codegen</module>
-        <module>inject</module>
-        <module>lookup</module>
-        <module>service-lifecycle</module>
-        <module>scopes</module>
-        <module>interception</module>
-        <module>qualified-providers</module>
-        <module>stacking</module>
-        <module>toolbox</module>
-        <module>events</module>
-        <module>maven-plugin</module>
-    </modules>
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.config</groupId>
+            <artifactId>helidon-config</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-all</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.common.testing</groupId>
+            <artifactId>helidon-common-testing-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.logging</groupId>
+            <artifactId>helidon-logging-jul</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-apt</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>enforce-jakarta-not-included</id>
+                        <goals>
+                            <goal>enforce</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <bannedDependencies>
+                                    <excludes>
+                                        <exclude>jakarta.inject:jakarta.inject-api</exclude>
+                                        <exclude>jakarta.annotation:jakarta.annotation-api</exclude>
+                                    </excludes>
+                                </bannedDependencies>
+                            </rules>
+                            <fail>true</fail>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
+                <version>${helidon.version}</version>
+                <executions>
+                    <execution>
+                        <id>create-application</id>
+                        <goals>
+                            <goal>create-application</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                </dependencies>
+                <configuration>
+                    <failOnWarning>true</failOnWarning>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 </project>
diff --git a/service/tests/inject/qualified-providers/src/main/java/module-info.java b/service/tests/inject/qualified-providers/src/main/java/module-info.java
deleted file mode 100644
index bd6e8292e08..00000000000
--- a/service/tests/inject/qualified-providers/src/main/java/module-info.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.tests.qualified.providers {
-    requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-    // we use Application
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
-
-    exports io.helidon.service.tests.inject.qualified.providers;
-}
\ No newline at end of file
diff --git a/service/tests/inject/scopes/src/main/java/module-info.java b/service/tests/inject/scopes/src/main/java/module-info.java
deleted file mode 100644
index 2c0e5e6f0cf..00000000000
--- a/service/tests/inject/scopes/src/main/java/module-info.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.inject.tests.scopes {
-    requires io.helidon.service.inject.api;
-
-    // we use Application
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires java.net.http;
-    requires io.helidon.common.context;
-
-    exports io.helidon.service.tests.inject.scopes;
-}
\ No newline at end of file
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/AContract.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/AContract.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/AContract.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/AContract.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java
index 42cca575fcf..cc1e0c6585f 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/AContractSupplier.java
@@ -18,9 +18,9 @@
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class AContractSupplier implements Supplier<AContract> {
     @Override
     public AContract get() {
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ContractOfNamed.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ContractOfNamed.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ContractOfNamed.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ContractOfNamed.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ContractOfQualified.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ContractOfQualified.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ContractOfQualified.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ContractOfQualified.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java
similarity index 93%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java
index 5b831665ece..bd74cb0916c 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/DescribeTypes.java
@@ -16,7 +16,6 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 
 final class DescribeTypes {
@@ -26,7 +25,7 @@ private DescribeTypes() {
     /**
      * A greeting that needs to be described separately.
      */
-    @Injection.Describe
+    @Service.Describe
     @Service.Contract
     interface DescribedContract {
         String sayHello();
@@ -48,9 +47,8 @@ public String sayHello() {
      *
      * @param myContract myContract
      */
-    @Injection.Singleton
+    @Service.Singleton
     record DescribedReceiver(DescribedContract myContract) {
     }
 
-
 }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java
similarity index 94%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java
index 8c13b82fd92..d6122144aba 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/FactoryIsAServiceTypes.java
@@ -18,7 +18,7 @@
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 final class FactoryIsAServiceTypes {
     private FactoryIsAServiceTypes() {
@@ -32,7 +32,7 @@ interface TargetType {
         String name();
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class MyFactory implements FactoryContract, Supplier<TargetType> {
         @Override
         public String name() {
@@ -45,12 +45,12 @@ public TargetType get() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class InjectionReceiver {
         private final FactoryContract factoryContract;
         private final TargetType targetType;
 
-        @Injection.Inject
+        @Service.Inject
         InjectionReceiver(FactoryContract factoryContract,
                           TargetType targetType) {
             this.factoryContract = factoryContract;
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java
similarity index 94%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java
index f2dc69e0eea..c5a245d7008 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/InnerTypes.java
@@ -18,7 +18,6 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 
 /*
@@ -29,7 +28,7 @@ class InnerTypes {
     interface InnerContract {
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class InnerService implements InnerContract {
         static final AtomicInteger postConstructCount = new AtomicInteger();
 
diff --git a/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
new file mode 100644
index 00000000000..c83d69aacdb
--- /dev/null
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
@@ -0,0 +1,28 @@
+package io.helidon.service.tests.inject;
+
+import io.helidon.service.registry.Service;
+
+class LateBindingTypes {
+    interface Contract {
+        String message();
+    }
+
+    @Service.Singleton
+    static class ServiceProvider implements Contract {
+        private final String message;
+
+        @Service.Inject
+        ServiceProvider() {
+            this.message = "injected";
+        }
+
+        ServiceProvider(String message) {
+            this.message = message;
+        }
+
+        @Override
+        public String message() {
+            return message;
+        }
+    }
+}
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java
similarity index 94%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java
index a3731da6ac2..a209891971c 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LifecycleReceiver.java
@@ -16,10 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class LifecycleReceiver {
     private boolean postConstructCalled;
     private boolean preDestroyCalled;
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutableService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutableService.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutableService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutableService.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java
similarity index 91%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java
index 711c3ddbcea..0f96ff5f8fc 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorA.java
@@ -19,14 +19,14 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(10)
 class MutatorA implements Supplier<MutableService> {
     private final MutableService m;
 
-    @Injection.Inject
+    @Service.Inject
     MutatorA(MutableService m) {
         this.m = m;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java
similarity index 91%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java
index 935afe7441e..bff0cf7d0b1 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorB.java
@@ -19,14 +19,14 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(20)
 class MutatorB implements Supplier<MutableService> {
     private final MutableService m;
 
-    @Injection.Inject
+    @Service.Inject
     MutatorB(MutableService m) {
         this.m = m;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java
similarity index 91%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java
index 6e53e52a5ba..07149b1acf9 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorC.java
@@ -19,14 +19,14 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(50)
 class MutatorC implements Supplier<MutableService> {
     private final MutableService m;
 
-    @Injection.Inject
+    @Service.Inject
     MutatorC(MutableService m) {
         this.m = m;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java
similarity index 90%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java
index db0ffb16d6e..dae38015f99 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MutatorReceiver.java
@@ -17,14 +17,14 @@
 package io.helidon.service.tests.inject;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(100)
 class MutatorReceiver {
     private final MutableService m;
 
-    @Injection.Inject
+    @Service.Inject
     MutatorReceiver(MutableService m) {
         this.m = m;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyContract.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyContract.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyContract.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyContract.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService.java
index e24e2e50dde..5c0887ba6e4 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class MyService implements MyContract {
     static int instances = 0;
 
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java
index d5df2af2daf..ecdd4f6b948 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService2.java
@@ -17,16 +17,16 @@
 package io.helidon.service.tests.inject;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(102)
 class MyService2 implements MyContract {
     static int instances;
 
     private final MyService service;
 
-    @Injection.Inject
+    @Service.Inject
     MyService2(MyService service) {
         instances++;
         this.service = service;
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java
similarity index 90%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java
index 716c204f7b8..e5df81a7ed1 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/MyService3.java
@@ -17,12 +17,12 @@
 package io.helidon.service.tests.inject;
 
 import io.helidon.common.Weight;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(90)
 class MyService3 extends MyService2 {
-    @Injection.Inject
+    @Service.Inject
     MyService3(MyService service) {
         super(service, false);
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java
similarity index 83%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java
index 1400f7dcd49..ac55fccbd4a 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedReceiver.java
@@ -16,14 +16,14 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class NamedReceiver {
     private final ContractOfNamed named;
 
-    @Injection.Inject
-    NamedReceiver(@Injection.Named("named") ContractOfNamed named) {
+    @Service.Inject
+    NamedReceiver(@Service.Named("named") ContractOfNamed named) {
         this.named = named;
     }
 
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java
similarity index 89%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java
index e61ea0ece86..d23dfaa5cd2 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NamedService.java
@@ -16,10 +16,10 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Named("named")
-@Injection.Singleton
+@Service.Named("named")
+@Service.Singleton
 class NamedService implements ContractOfNamed {
     @Override
     public String name() {
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java
similarity index 90%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java
index 049668e70ce..6ac6361c67a 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/NonSingletonService.java
@@ -16,13 +16,13 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerLookup
+@Service.PerLookup
 class NonSingletonService {
     private final SingletonService singleton;
 
-    @Injection.Inject
+    @Service.Inject
     NonSingletonService(SingletonService singleton) {
         this.singleton = singleton;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java
index 11b0956e8db..b1b4898a79d 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ParameterizedTypes.java
@@ -21,7 +21,6 @@
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 
 final class ParameterizedTypes {
@@ -42,7 +41,7 @@ interface Type<T> {
         T type();
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class Blue implements Color {
         @Override
         public String name() {
@@ -50,7 +49,7 @@ public String name() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class Green implements Color {
         @Override
         public String name() {
@@ -58,7 +57,7 @@ public String name() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     @Weight(Weighted.DEFAULT_WEIGHT + 10)
     record BlueCircle(Blue color) implements Circle<Blue>, Type<String> {
         @Override
@@ -67,7 +66,7 @@ public String type() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     record GreenCircle(Green color) implements Circle<Green>, Type<Integer> {
         @Override
         public Integer type() {
@@ -75,13 +74,13 @@ public Integer type() {
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class ColorReceiver {
         private final List<Circle<Color>> circles;
         private final List<Circle<?>> allCircles;
         private final List<Type<?>> types;
 
-        @Injection.Inject
+        @Service.Inject
         ColorReceiver(List<Circle<Color>> circles, List<Circle<?>> allCircles, List<Type<?>> types) {
             this.circles = circles;
             this.allCircles = allCircles;
@@ -98,18 +97,18 @@ String getString() {
         boolean allCirclesValid() {
             return this.circles.equals(this.allCircles);
         }
-        
+
         List<Type<?>> types() {
             return types;
         }
     }
 
-    @Injection.Singleton
+    @Service.Singleton
     static class ColorsReceiver {
         private final Circle<Green> greenCircle;
         private final Circle<Blue> blueCircle;
 
-        @Injection.Inject
+        @Service.Inject
         ColorsReceiver(Circle<Green> greenCircle,
                        Circle<Blue> blueCircle) {
             this.greenCircle = greenCircle;
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java
similarity index 95%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java
index 59af08bdca9..f8747d06676 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ProviderReceiver.java
@@ -20,16 +20,16 @@
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class ProviderReceiver {
     private final Supplier<NonSingletonService> provider;
     private final Supplier<List<NonSingletonService>> listOfProviders;
     private final Supplier<Optional<NonSingletonService>> optionalProvider;
     private final AContract contract;
 
-    @Injection.Inject
+    @Service.Inject
     ProviderReceiver(Supplier<NonSingletonService> provider,
                      Supplier<List<NonSingletonService>> listOfProviders,
                      Supplier<Optional<NonSingletonService>> optionalProvider,
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java
similarity index 91%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java
index d1707bb5ef6..fa2a80d7748 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedReceiver.java
@@ -16,13 +16,13 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class QualifiedReceiver {
     private final ContractOfQualified qualified;
 
-    @Injection.Inject
+    @Service.Inject
     QualifiedReceiver(@QualifierAnnotation("qualified") ContractOfQualified qualified) {
         this.qualified = qualified;
     }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java
index 158c197aec3..32515f63148 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifiedService.java
@@ -16,10 +16,10 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 @QualifierAnnotation("qualified")
-@Injection.Singleton
+@Service.Singleton
 class QualifiedService implements ContractOfQualified {
     @Override
     public String qualifier() {
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java
similarity index 93%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java
index 49bc6d62692..a3ff3769c24 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/QualifierAnnotation.java
@@ -20,12 +20,12 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 /**
  * Custom qualifier.
  */
-@Injection.Qualifier
+@Service.Qualifier
 @Documented
 @Retention(RetentionPolicy.CLASS)
 @interface QualifierAnnotation {
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ServiceSupplier.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ServiceSupplier.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ServiceSupplier.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ServiceSupplier.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java
similarity index 78%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java
index 979a806e957..a8b31b6b4a6 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/ServicesFactoryTypes.java
@@ -19,9 +19,9 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.inject.api.ServiceInstance;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceInstance;
 
 final class ServicesFactoryTypes {
     private ServicesFactoryTypes() {
@@ -35,11 +35,11 @@ interface TargetType {
         NamedConfig config();
     }
 
-    @Injection.Singleton
-    static class ConfigFactory implements Injection.ServicesFactory<NamedConfig> {
+    @Service.Singleton
+    static class ConfigFactory implements Service.ServicesFactory<NamedConfig> {
         private final List<NamedConfig> configs;
 
-        @Injection.Inject
+        @Service.Inject
         ConfigFactory() {
             configs = List.of(new NamedConfigImpl("first"),
                               new NamedConfigImpl("second"),
@@ -51,20 +51,20 @@ static class ConfigFactory implements Injection.ServicesFactory<NamedConfig> {
         }
 
         @Override
-        public List<Injection.QualifiedInstance<NamedConfig>> services() {
+        public List<Service.QualifiedInstance<NamedConfig>> services() {
             return configs.stream()
-                    .map(it -> Injection.QualifiedInstance.create(it, Qualifier.createNamed(it.name())))
+                    .map(it -> Service.QualifiedInstance.create(it, Qualifier.createNamed(it.name())))
                     .collect(Collectors.toUnmodifiableList());
         }
     }
 
-    @Injection.Singleton
-    @Injection.PerInstance(NamedConfig.class)
+    @Service.Singleton
+    @Service.PerInstance(NamedConfig.class)
     static class TargetTypeProvider implements TargetType {
         private final NamedConfig config;
 
-        @Injection.Inject
-        TargetTypeProvider(@Injection.InstanceName String name,
+        @Service.Inject
+        TargetTypeProvider(@Service.InstanceName String name,
                            NamedConfig config,
                            List<ServiceInstance<CharSequence>> emptyList) {
             this.config = config;
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java
similarity index 90%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java
index 874d90d0082..781100e42b2 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/SingletonService.java
@@ -16,8 +16,8 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class SingletonService {
 }
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/SuppliedContract.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/SuppliedContract.java
similarity index 100%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/SuppliedContract.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/SuppliedContract.java
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java
similarity index 92%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java
index 4e7b2401d5f..3571f0b9221 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnQualifiedService.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class UnQualifiedService implements ContractOfQualified {
     @Override
     public String qualifier() {
diff --git a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java
similarity index 91%
rename from service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java
rename to service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java
index 3c7ac74394d..50921399921 100644
--- a/service/tests/inject/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/UnnamedService.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class UnnamedService implements ContractOfNamed {
     @Override
     public String name() {
diff --git a/service/tests/inject/inject/src/main/java/module-info.java b/service/tests/inject/src/main/java/module-info.java
similarity index 82%
rename from service/tests/inject/inject/src/main/java/module-info.java
rename to service/tests/inject/src/main/java/module-info.java
index 03cb3e4a205..48bed2c8c33 100644
--- a/service/tests/inject/inject/src/main/java/module-info.java
+++ b/service/tests/inject/src/main/java/module-info.java
@@ -16,10 +16,6 @@
 
 module io.helidon.service.tests.inject {
     requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
 
     exports io.helidon.service.tests.inject;
 }
\ No newline at end of file
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java
similarity index 91%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java
index 90682e16be7..ed381c04fdd 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyCoreTest.java
@@ -23,12 +23,10 @@
 import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
 import io.helidon.service.registry.Dependency;
 import io.helidon.service.registry.DependencyContext;
+import io.helidon.service.registry.InterceptionMetadata;
+import io.helidon.service.registry.Service;
 import io.helidon.service.registry.ServiceDescriptor;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.ServiceRegistryConfig;
@@ -88,7 +86,7 @@ private static class Descriptor1 implements ServiceDescriptor<Service1> {
                 .build();
 
         @Override
-        public Object instantiate(DependencyContext ctx) {
+        public Object instantiate(DependencyContext ctx, InterceptionMetadata metadata) {
             return new Service1(ctx.dependency(DEP));
         }
 
@@ -113,10 +111,10 @@ public Set<ResolvedType> contracts() {
         }
     }
 
-    private static class Descriptor2 implements InjectServiceDescriptor<Service2> {
+    private static class Descriptor2 implements ServiceDescriptor<Service2> {
         private static final TypeName TYPE = TypeName.create(Descriptor2.class);
 
-        private static final Ip DEP = Ip.builder()
+        private static final Dependency DEP = Dependency.builder()
                 .elementKind(ElementKind.CONSTRUCTOR)
                 .contract(SERVICE_1)
                 .descriptor(TYPE)
@@ -144,11 +142,11 @@ public TypeName descriptorType() {
 
         @Override
         public TypeName scope() {
-            return Injection.Singleton.TYPE;
+            return Service.Singleton.TYPE;
         }
 
         @Override
-        public List<Ip> dependencies() {
+        public List<Dependency> dependencies() {
             return List.of(DEP);
         }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java
similarity index 88%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java
index 9051f0bf4df..1941b5d3fb0 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/CyclicDependencyInjectTest.java
@@ -23,11 +23,11 @@
 import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.InjectServiceDescriptor;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.InterceptionMetadata;
-import io.helidon.service.inject.api.Ip;
+import io.helidon.service.registry.Dependency;
 import io.helidon.service.registry.DependencyContext;
+import io.helidon.service.registry.InterceptionMetadata;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceDescriptor;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.ServiceRegistryConfig;
 import io.helidon.service.registry.ServiceRegistryException;
@@ -72,10 +72,10 @@ private static class Service2 {
         }
     }
 
-    private static class Descriptor1 implements InjectServiceDescriptor<Service1> {
+    private static class Descriptor1 implements ServiceDescriptor<Service1> {
         private static final TypeName TYPE = TypeName.create(Descriptor1.class);
 
-        private static final Ip DEP = Ip.builder()
+        private static final Dependency DEP = Dependency.builder()
                 .elementKind(ElementKind.CONSTRUCTOR)
                 .contract(SERVICE_2)
                 .descriptor(TYPE)
@@ -102,7 +102,7 @@ public TypeName descriptorType() {
         }
 
         @Override
-        public List<Ip> dependencies() {
+        public List<Dependency> dependencies() {
             return List.of(DEP);
         }
 
@@ -113,14 +113,14 @@ public Set<ResolvedType> contracts() {
 
         @Override
         public TypeName scope() {
-            return Injection.Singleton.TYPE;
+            return Service.Singleton.TYPE;
         }
     }
 
-    private static class Descriptor2 implements InjectServiceDescriptor<Service2> {
+    private static class Descriptor2 implements ServiceDescriptor<Service2> {
         private static final TypeName TYPE = TypeName.create(Descriptor2.class);
 
-        private static final Ip DEP = Ip.builder()
+        private static final Dependency DEP = Dependency.builder()
                 .elementKind(ElementKind.CONSTRUCTOR)
                 .contract(SERVICE_1)
                 .descriptor(TYPE)
@@ -147,7 +147,7 @@ public TypeName descriptorType() {
         }
 
         @Override
-        public List<Ip> dependencies() {
+        public List<Dependency> dependencies() {
             return List.of(DEP);
         }
 
@@ -158,7 +158,7 @@ public Set<ResolvedType> contracts() {
 
         @Override
         public TypeName scope() {
-            return Injection.Singleton.TYPE;
+            return Service.Singleton.TYPE;
         }
     }
 }
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java
similarity index 82%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java
index 7813254b49d..009df6f364b 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/DescribeTest.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -30,18 +30,18 @@
 class DescribeTest {
     private static final DescribeTypes.DescribedContract INSTANCE = new DescribeTypes.DescribedContractImpl();
 
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void initRegistry() {
-        var injectConfig = InjectConfig.builder()
+        var injectConfig = ServiceRegistryConfig.builder()
                 .putContractInstance(DescribeTypes.DescribedContract.class, INSTANCE)
                 .addServiceDescriptor(DescribeTypes_DescribedReceiver__ServiceDescriptor.INSTANCE)
                 .discoverServices(false)
                 .discoverServicesFromServiceLoader(false)
                 .build();
-        registryManager = InjectRegistryManager.create(injectConfig);
+        registryManager = ServiceRegistryManager.create(injectConfig);
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java
similarity index 82%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java
index 24baa2e0fd2..377e4483465 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/FactoryIsAServiceTest.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 import io.helidon.service.tests.inject.FactoryIsAServiceTypes.InjectionReceiver;
 
 import org.junit.jupiter.api.AfterAll;
@@ -29,18 +29,18 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 public class FactoryIsAServiceTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void initRegistry() {
-        var injectConfig = InjectConfig.builder()
+        var injectConfig = ServiceRegistryConfig.builder()
                 .addServiceDescriptor(FactoryIsAServiceTypes_MyFactory__ServiceDescriptor.INSTANCE)
                 .addServiceDescriptor(FactoryIsAServiceTypes_InjectionReceiver__ServiceDescriptor.INSTANCE)
                 .discoverServices(false)
                 .discoverServicesFromServiceLoader(false)
                 .build();
-        registryManager = InjectRegistryManager.create(injectConfig);
+        registryManager = ServiceRegistryManager.create(injectConfig);
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
new file mode 100644
index 00000000000..5cd69cce947
--- /dev/null
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryConfigTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.tests.inject;
+
+import io.helidon.service.registry.ActivationPhase;
+import io.helidon.service.registry.ServiceRegistryConfig;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+
+public class InjectRegistryConfigTest {
+    @Test
+    void testDefaults() {
+        ServiceRegistryConfig cfg = ServiceRegistryConfig.create();
+        // service registry config
+        assertThat(cfg.discoverServices(), is(true));
+        assertThat(cfg.serviceDescriptors(), is(empty()));
+        assertThat(cfg.serviceInstances().size(), is(0));
+        // injection specific config
+        assertThat(cfg.interceptionEnabled(), is(true));
+        assertThat(cfg.limitActivationPhase(), is(ActivationPhase.ACTIVE));
+        assertThat(cfg.lookupCacheEnabled(), is(false));
+        assertThat(cfg.lookupCacheSize(), is(10000));
+        assertThat(cfg.useBinding(), is(true));
+    }
+}
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java
similarity index 93%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java
index 2376988cd59..7ec7962e304 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectRegistryTest.java
@@ -19,8 +19,8 @@
 import java.util.List;
 
 import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.InjectRegistryManager;
 import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -32,15 +32,16 @@
 import static org.hamcrest.Matchers.hasSize;
 
 public class InjectRegistryTest {
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
+
     static {
         LogConfig.initClass();
     }
-    private static InjectRegistryManager registryManager;
-    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java
similarity index 95%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java
index 1046b67b61b..b41321b5c37 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/InjectionTest.java
@@ -18,8 +18,8 @@
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -42,13 +42,13 @@
  */
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 public class InjectionTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
     private static LifecycleReceiver lifecycleReceiver;
 
     @BeforeAll
     public static void initRegistry() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
new file mode 100644
index 00000000000..5c236973006
--- /dev/null
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
@@ -0,0 +1,180 @@
+package io.helidon.service.tests.inject;
+
+import java.util.List;
+
+import io.helidon.common.Weighted;
+import io.helidon.service.registry.GlobalServiceRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryException;
+import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.service.registry.Services;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class LateBindingTest {
+    @Test
+    void testLateBindingFailsPostUseContract() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(1));
+            assertThat(contracts.getFirst().message(), is("injected"));
+
+            assertThrows(ServiceRegistryException.class,
+                         () -> Services.add(LateBindingTypes.Contract.class,
+                                            Weighted.DEFAULT_WEIGHT - 10,
+                                            new LateBindingTypes.ServiceProvider("custom")));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingFailsPostUseService() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            List<LateBindingTypes.ServiceProvider> contracts = registry.all(LateBindingTypes.ServiceProvider.class);
+            assertThat(contracts, hasSize(1));
+            assertThat(contracts.getFirst().message(), is("injected"));
+
+            assertThrows(ServiceRegistryException.class,
+                         () -> Services.set(LateBindingTypes.Contract.class,
+                                            new LateBindingTypes.ServiceProvider("custom")));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingContractSingleSet() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            Services.set(LateBindingTypes.Contract.class, new LateBindingTypes.ServiceProvider("custom"));
+
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(1));
+            assertThat(contracts.getFirst().message(), is("custom"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingContractMultiSet() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            Services.set(LateBindingTypes.Contract.class,
+                         new LateBindingTypes.ServiceProvider("custom1"),
+                         new LateBindingTypes.ServiceProvider("custom2"));
+
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(2));
+            assertThat(contracts.get(0).message(), is("custom1"));
+            assertThat(contracts.get(1).message(), is("custom2"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingServiceSingleSet() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            Services.set(LateBindingTypes.ServiceProvider.class, new LateBindingTypes.ServiceProvider("custom"));
+
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(1));
+            assertThat(contracts.getFirst().message(), is("custom"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingServiceMultiSet() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            ServiceRegistryException e = assertThrows(ServiceRegistryException.class,
+                                                      () -> Services.set(LateBindingTypes.ServiceProvider.class,
+                                                                         new LateBindingTypes.ServiceProvider("custom1"),
+                                                                         new LateBindingTypes.ServiceProvider("custom2")));
+            assertThat(e.getMessage(), containsString("exactly one instance"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingContractSingleAdd() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            Services.add(LateBindingTypes.Contract.class,
+                         Weighted.DEFAULT_WEIGHT - 10,
+                         new LateBindingTypes.ServiceProvider("custom"));
+
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(2));
+            assertThat(contracts.get(0).message(), is("injected"));
+            assertThat(contracts.get(1).message(), is("custom"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingContractMultiAdd() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        GlobalServiceRegistry.registry(registry);
+        try {
+            Services.add(LateBindingTypes.Contract.class,
+                         Weighted.DEFAULT_WEIGHT + 10,
+                         new LateBindingTypes.ServiceProvider("custom1"));
+            Services.add(LateBindingTypes.Contract.class,
+                         Weighted.DEFAULT_WEIGHT - 10,
+                         new LateBindingTypes.ServiceProvider("custom2"));
+
+            List<LateBindingTypes.Contract> contracts = registry.all(LateBindingTypes.Contract.class);
+            assertThat(contracts, hasSize(3));
+            assertThat(contracts.get(0).message(), is("custom1"));
+            assertThat(contracts.get(1).message(), is("injected"));
+            assertThat(contracts.get(2).message(), is("custom2"));
+        } finally {
+            manager.shutdown();
+        }
+    }
+
+    @Test
+    void testLateBindingServiceSingleAdd() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        GlobalServiceRegistry.registry(manager.registry());
+        try {
+            ServiceRegistryException e = assertThrows(ServiceRegistryException.class,
+                                                      () -> Services.add(LateBindingTypes.ServiceProvider.class,
+                                                                         Weighted.DEFAULT_WEIGHT,
+                                                                         new LateBindingTypes.ServiceProvider("custom")));
+        } finally {
+            manager.shutdown();
+        }
+    }
+}
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java
similarity index 90%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java
index 14ac1e5bce0..3bb638b68d3 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/MutationTest.java
@@ -16,8 +16,8 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.InjectRegistryManager;
 import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -27,12 +27,12 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 public class MutationTest {
-    private static InjectRegistryManager registryManager;
+    private static ServiceRegistryManager registryManager;
     private static ServiceRegistry registry;
 
     @BeforeAll
     public static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java
similarity index 86%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java
index 105fdf2d546..27ee3f4475c 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ParameterizedTypesTest.java
@@ -16,9 +16,9 @@
 
 package io.helidon.service.tests.inject;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -29,12 +29,12 @@
 import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
 
 public class ParameterizedTypesTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void initRegistry() {
-        var injectConfig = InjectConfig.builder()
+        var injectConfig = ServiceRegistryConfig.builder()
                 .addServiceDescriptor(ParameterizedTypes_Blue__ServiceDescriptor.INSTANCE)
                 .addServiceDescriptor(ParameterizedTypes_Green__ServiceDescriptor.INSTANCE)
                 .addServiceDescriptor(ParameterizedTypes_BlueCircle__ServiceDescriptor.INSTANCE)
@@ -44,7 +44,7 @@ public static void initRegistry() {
                 .discoverServices(false)
                 .discoverServicesFromServiceLoader(false)
                 .build();
-        registryManager = InjectRegistryManager.create(injectConfig);
+        registryManager = ServiceRegistryManager.create(injectConfig);
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java
similarity index 80%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java
index 637cc2febf6..63ed0744ba0 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryProvidedInstancesTest.java
@@ -19,11 +19,11 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -34,20 +34,21 @@
 import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
 
 public class ServicesFactoryProvidedInstancesTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void initRegistry() {
-        var injectConfig = InjectConfig.builder()
+        var injectConfig = ServiceRegistryConfig.builder()
                 .addServiceDescriptor(ServicesFactoryTypes_TargetTypeProvider__ServiceDescriptor.INSTANCE)
                 .addServiceDescriptor(ServicesFactoryTypes_ConfigFactory__ServiceDescriptor.INSTANCE)
                 .putServiceInstance(ServicesFactoryTypes_ConfigFactory__ServiceDescriptor.INSTANCE,
-                                    new ServicesFactoryTypes.ConfigFactory(List.of(new ServicesFactoryTypes.NamedConfigImpl("custom"))))
+                                    new ServicesFactoryTypes.ConfigFactory(List.of(new ServicesFactoryTypes.NamedConfigImpl(
+                                            "custom"))))
                 .discoverServices(false)
                 .discoverServicesFromServiceLoader(false)
                 .build();
-        registryManager = InjectRegistryManager.create(injectConfig);
+        registryManager = ServiceRegistryManager.create(injectConfig);
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java
similarity index 82%
rename from service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java
rename to service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java
index 9c2c658be4f..c996e28ba3f 100644
--- a/service/tests/inject/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/ServicesFactoryTest.java
@@ -19,11 +19,11 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -34,18 +34,18 @@
 import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
 
 public class ServicesFactoryTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     public static void initRegistry() {
-        var injectConfig = InjectConfig.builder()
+        var injectConfig = ServiceRegistryConfig.builder()
                 .addServiceDescriptor(ServicesFactoryTypes_TargetTypeProvider__ServiceDescriptor.INSTANCE)
                 .addServiceDescriptor(ServicesFactoryTypes_ConfigFactory__ServiceDescriptor.INSTANCE)
                 .discoverServices(false)
                 .discoverServicesFromServiceLoader(false)
                 .build();
-        registryManager = InjectRegistryManager.create(injectConfig);
+        registryManager = ServiceRegistryManager.create(injectConfig);
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/inject/src/test/resources/logging.properties b/service/tests/inject/src/test/resources/logging.properties
similarity index 94%
rename from service/tests/inject/inject/src/test/resources/logging.properties
rename to service/tests/inject/src/test/resources/logging.properties
index 5190b108e32..563562ef136 100644
--- a/service/tests/inject/inject/src/test/resources/logging.properties
+++ b/service/tests/inject/src/test/resources/logging.properties
@@ -13,10 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 handlers=io.helidon.logging.jul.HelidonConsoleHandler
 java.util.logging.SimpleFormatter.format=%1$tY.%1$tm.%1$td %1$tH:%1$tM:%1$tS.%1$tL %4$s %5$s%6$s%n
-
 # Global logging level. Can be overridden by specific loggers
 .level=INFO
-io.helidon.service.inject.LookupTrace.level=ALL
+io.helidon.service.registry.LookupTrace.level=ALL
diff --git a/service/tests/inject/stacking/src/main/java/module-info.java b/service/tests/inject/stacking/src/main/java/module-info.java
deleted file mode 100644
index da29fb5efd5..00000000000
--- a/service/tests/inject/stacking/src/main/java/module-info.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.tests.inject.stacking {
-    requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-
-    // we use Application
-    requires io.helidon.service.inject;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
-
-    exports io.helidon.service.tests.inject.stacking;
-}
\ No newline at end of file
diff --git a/service/tests/inject/toolbox/src/main/java/module-info.java b/service/tests/inject/toolbox/src/main/java/module-info.java
deleted file mode 100644
index 983e668d0e5..00000000000
--- a/service/tests/inject/toolbox/src/main/java/module-info.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-module io.helidon.service.tests.inject.toolbox {
-    requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-
-    // we use Application
-    requires io.helidon.service.inject;
-    requires io.helidon.config;
-    requires io.helidon.config.yaml;
-    requires io.helidon.http;
-    requires io.helidon.common.context;
-    requires io.helidon.metrics.api;
-
-    exports io.helidon.service.tests.inject.toolbox;
-    exports io.helidon.service.tests.inject.toolbox.impl to io.helidon.service.registry;
-}
\ No newline at end of file
diff --git a/service/tests/inject/interception/pom.xml b/service/tests/interception/pom.xml
similarity index 83%
rename from service/tests/inject/interception/pom.xml
rename to service/tests/interception/pom.xml
index ec48f21a2ce..8b15b8c9834 100644
--- a/service/tests/inject/interception/pom.xml
+++ b/service/tests/interception/pom.xml
@@ -21,30 +21,22 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-interception</artifactId>
-    <name>Helidon Service Tests Inject Interception</name>
-    <description>Tests for injection operations</description>
+    <artifactId>helidon-service-tests-interception</artifactId>
+    <name>Helidon Service Tests Interception</name>
+    <description>Tests for service registry interception operations</description>
 
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -80,8 +72,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -98,8 +90,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/AbstractClassTypes.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/AbstractClassTypes.java
similarity index 87%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/AbstractClassTypes.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/AbstractClassTypes.java
index ae0c8da78ae..659c68ed4be 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/AbstractClassTypes.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/AbstractClassTypes.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Target;
@@ -22,13 +22,12 @@
 import java.util.Arrays;
 import java.util.List;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionContext;
 import io.helidon.service.registry.Service;
 
 /**
- * An example that illustrates usages of {@link io.helidon.service.inject.api.Interception.Interceptor}.
+ * An example that illustrates usages of {@link io.helidon.service.registry.Interception.Interceptor}.
  */
 class AbstractClassTypes {
 
@@ -58,8 +57,8 @@ String sayHelloDirect(String name) {
     /**
      * An interceptor implementation that supports {@link AbstractClassTypes.Traced}.
      */
-    @Injection.Singleton
-    @Injection.NamedByType(Traced.class)
+    @Service.Singleton
+    @Service.NamedByType(Traced.class)
     static class MyServiceInterceptor implements Interception.Interceptor {
         static final List<String> INVOKED = new ArrayList<>();
 
@@ -76,7 +75,7 @@ public <V> V proceed(InterceptionContext ctx, Chain<V> chain, Object... args) th
     /**
      * A service that extends an abstract class contract with an intercepted method.
      */
-    @Injection.Singleton
+    @Service.Singleton
     static class MyAbstractClassContractImpl extends MyAbstractClassContract {
 
         @Override
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Construct.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Construct.java
similarity index 89%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Construct.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/Construct.java
index af1fedd51e6..fc82e81e9e0 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Construct.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Construct.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 
 @Interception.Intercepted
 @Retention(RetentionPolicy.SOURCE)
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ConstructorInterceptor.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ConstructorInterceptor.java
similarity index 79%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ConstructorInterceptor.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/ConstructorInterceptor.java
index 7a7c033467a..df16cc44004 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ConstructorInterceptor.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ConstructorInterceptor.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.HashSet;
 import java.util.Set;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionContext;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
-@Injection.NamedByType(Construct.class)
+@Service.Singleton
+@Service.NamedByType(Construct.class)
 class ConstructorInterceptor implements Interception.Interceptor {
     static final Set<TypeName> CONSTRUCTED = new HashSet<>();
 
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClass.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClass.java
similarity index 91%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClass.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClass.java
index 30d88d36201..413d2ef222b 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClass.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClass.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 import io.helidon.service.registry.Service;
 
 @Service.Contract
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClassServiceProvider.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClassServiceProvider.java
similarity index 87%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClassServiceProvider.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClassServiceProvider.java
index 1562bad45dc..e18ba5eff48 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedClassServiceProvider.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedClassServiceProvider.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class DelegatedClassServiceProvider implements Supplier<DelegatedClass> {
     @Override
     public DelegatedClass get() {
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedContract.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedContract.java
similarity index 89%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedContract.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedContract.java
index bc29178823a..1946f8a18fd 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedContract.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedContract.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 import io.helidon.service.registry.Service;
 
 @Service.Contract
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedServiceProvider.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedServiceProvider.java
similarity index 91%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedServiceProvider.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedServiceProvider.java
index 14e583e660a..7b24f5e2399 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/DelegatedServiceProvider.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/DelegatedServiceProvider.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class DelegatedServiceProvider implements Supplier<DelegatedContract> {
     @Override
     public DelegatedContract get() {
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Invocation.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Invocation.java
similarity index 93%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Invocation.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/Invocation.java
index 9a5af3c5803..6a392306233 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Invocation.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Invocation.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.Arrays;
 
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Modify.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Modify.java
similarity index 90%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Modify.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/Modify.java
index ae05f747962..fe733de6f9c 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Modify.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Modify.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -23,7 +23,7 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 
 /**
  * Modify call.
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ModifyingInterceptor.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ModifyingInterceptor.java
similarity index 86%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ModifyingInterceptor.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/ModifyingInterceptor.java
index 803b84d1029..415acb209d6 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ModifyingInterceptor.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ModifyingInterceptor.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicReference;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionContext;
+import io.helidon.service.registry.Service;
 
-@Injection.NamedByType(Modify.class)
-@Injection.Singleton
+@Service.NamedByType(Modify.class)
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 50)
 class ModifyingInterceptor implements Interception.Interceptor {
     private static final AtomicReference<Invocation> LAST_CALL = new AtomicReference<>();
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/OtherContract.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/OtherContract.java
similarity index 95%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/OtherContract.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/OtherContract.java
index 9feaa7c72fb..8d3b9b6562f 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/OtherContract.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/OtherContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Repeat.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Repeat.java
similarity index 90%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Repeat.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/Repeat.java
index 089f3b7a192..80ceac19d56 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Repeat.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Repeat.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -23,7 +23,7 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 
 /**
  * Repeat the call twice.
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/RepeatingInterceptor.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/RepeatingInterceptor.java
similarity index 85%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/RepeatingInterceptor.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/RepeatingInterceptor.java
index 2c9bfa5d89b..4886a8f2691 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/RepeatingInterceptor.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/RepeatingInterceptor.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicReference;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
-import io.helidon.service.inject.api.InterceptionException;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionContext;
+import io.helidon.service.registry.InterceptionException;
+import io.helidon.service.registry.Service;
 
-@Injection.NamedByType(Repeat.class)
-@Injection.Singleton
+@Service.NamedByType(Repeat.class)
+@Service.Singleton
 class RepeatingInterceptor implements Interception.Interceptor {
     private static final AtomicReference<Invocation> LAST_CALL = new AtomicReference<>();
 
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Return.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Return.java
similarity index 90%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Return.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/Return.java
index 944aec677d4..9d4e461c6c4 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/Return.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/Return.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -23,7 +23,7 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Interception;
+import io.helidon.service.registry.Interception;
 
 /**
  * Return an explicit value (do not call target).
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ReturningInterceptor.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ReturningInterceptor.java
similarity index 86%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ReturningInterceptor.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/ReturningInterceptor.java
index 9e522b9ce22..942efd58beb 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/ReturningInterceptor.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/ReturningInterceptor.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicReference;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Interception;
-import io.helidon.service.inject.api.InterceptionContext;
+import io.helidon.service.registry.Interception;
+import io.helidon.service.registry.InterceptionContext;
+import io.helidon.service.registry.Service;
 
-@Injection.NamedByType(Return.class)
-@Injection.Singleton
+@Service.NamedByType(Return.class)
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 100)
 class ReturningInterceptor implements Interception.Interceptor {
     private static final AtomicReference<Invocation> LAST_CALL = new AtomicReference<>();
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheOtherService.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheOtherService.java
similarity index 93%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheOtherService.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheOtherService.java
index 88b974707a5..0c2d128383d 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheOtherService.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheOtherService.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class TheOtherService implements OtherContract {
     private boolean throwException;
 
diff --git a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheService.java b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheService.java
similarity index 93%
rename from service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheService.java
rename to service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheService.java
index 8b5144df941..32da340e254 100644
--- a/service/tests/inject/interception/src/main/java/io/helidon/service/tests/inject/interception/TheService.java
+++ b/service/tests/interception/src/main/java/io/helidon/service/tests/interception/TheService.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class TheService {
     private boolean throwException;
 
diff --git a/service/tests/interception/src/main/java/module-info.java b/service/tests/interception/src/main/java/module-info.java
new file mode 100644
index 00000000000..2b31cc556f3
--- /dev/null
+++ b/service/tests/interception/src/main/java/module-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.service.tests.interception {
+    requires io.helidon.service.registry;
+
+    exports io.helidon.service.tests.interception;
+}
\ No newline at end of file
diff --git a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/AbstractClassInterceptionTest.java b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/AbstractClassInterceptionTest.java
similarity index 76%
rename from service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/AbstractClassInterceptionTest.java
rename to service/tests/interception/src/test/java/io/helidon/service/tests/interception/AbstractClassInterceptionTest.java
index ceb30ada7cd..20ed39b58de 100644
--- a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/AbstractClassInterceptionTest.java
+++ b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/AbstractClassInterceptionTest.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import java.util.List;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.tests.inject.interception.AbstractClassTypes.MyAbstractClassContract;
-import io.helidon.service.tests.inject.interception.AbstractClassTypes.MyAbstractClassContractImpl;
-import io.helidon.service.tests.inject.interception.AbstractClassTypes.MyServiceInterceptor;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.service.tests.interception.AbstractClassTypes.MyAbstractClassContract;
+import io.helidon.service.tests.interception.AbstractClassTypes.MyAbstractClassContractImpl;
+import io.helidon.service.tests.interception.AbstractClassTypes.MyServiceInterceptor;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -33,12 +33,12 @@
 
 // test interceptor annotated on abstract method of an abstract class
 class AbstractClassInterceptionTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
diff --git a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/DelegatingInterceptionTest.java b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/DelegatingInterceptionTest.java
similarity index 94%
rename from service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/DelegatingInterceptionTest.java
rename to service/tests/interception/src/test/java/io/helidon/service/tests/interception/DelegatingInterceptionTest.java
index a1ca9b9cae4..023fd0b0c8c 100644
--- a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/DelegatingInterceptionTest.java
+++ b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/DelegatingInterceptionTest.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InterceptionException;
+import io.helidon.service.registry.InterceptionException;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -42,16 +42,17 @@
 Repeating
  */
 class DelegatingInterceptionTest {
+    private static ServiceRegistryManager registryManager;
+    private static DelegatedContract service;
+
     static {
         LogConfig.initClass();
     }
-    private static InjectRegistryManager registryManager;
-    private static DelegatedContract service;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
-        InjectRegistry registry = registryManager.registry();
+        registryManager = ServiceRegistryManager.create();
+        ServiceRegistry registry = registryManager.registry();
         service = registry.get(DelegatedContract.class);
     }
 
diff --git a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterceptionTest.java b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterceptionTest.java
similarity index 96%
rename from service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterceptionTest.java
rename to service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterceptionTest.java
index 570fafa5a63..ba57ea718ac 100644
--- a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterceptionTest.java
+++ b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterceptionTest.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InterceptionException;
+import io.helidon.service.registry.InterceptionException;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -41,13 +41,13 @@
 Repeating
  */
 class InterceptionTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
     private static TheService service;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
         service = registry.get(TheService.class);
 
diff --git a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterfaceInterceptionTest.java b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterfaceInterceptionTest.java
similarity index 96%
rename from service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterfaceInterceptionTest.java
rename to service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterfaceInterceptionTest.java
index 92d34ffc409..a18ff1dac5a 100644
--- a/service/tests/inject/interception/src/test/java/io/helidon/service/tests/inject/interception/InterfaceInterceptionTest.java
+++ b/service/tests/interception/src/test/java/io/helidon/service/tests/interception/InterfaceInterceptionTest.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.interception;
+package io.helidon.service.tests.interception;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InterceptionException;
+import io.helidon.service.registry.InterceptionException;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -43,13 +43,13 @@
 Repeating
  */
 class InterfaceInterceptionTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
     private static OtherContract service;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
         service = registry.get(OtherContract.class);
 
diff --git a/service/tests/inject/interception/src/test/resources/logging.properties b/service/tests/interception/src/test/resources/logging.properties
similarity index 94%
rename from service/tests/inject/interception/src/test/resources/logging.properties
rename to service/tests/interception/src/test/resources/logging.properties
index 5190b108e32..563562ef136 100644
--- a/service/tests/inject/interception/src/test/resources/logging.properties
+++ b/service/tests/interception/src/test/resources/logging.properties
@@ -13,10 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 handlers=io.helidon.logging.jul.HelidonConsoleHandler
 java.util.logging.SimpleFormatter.format=%1$tY.%1$tm.%1$td %1$tH:%1$tM:%1$tS.%1$tL %4$s %5$s%6$s%n
-
 # Global logging level. Can be overridden by specific loggers
 .level=INFO
-io.helidon.service.inject.LookupTrace.level=ALL
+io.helidon.service.registry.LookupTrace.level=ALL
diff --git a/service/tests/inject/lookup/pom.xml b/service/tests/lookup/pom.xml
similarity index 84%
rename from service/tests/inject/lookup/pom.xml
rename to service/tests/lookup/pom.xml
index 1d1be68d387..6a1abcda49e 100644
--- a/service/tests/inject/lookup/pom.xml
+++ b/service/tests/lookup/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-lookup</artifactId>
-    <name>Helidon Service Tests Inject Lookup</name>
+    <artifactId>helidon-service-tests-lookup</artifactId>
+    <name>Helidon Service Tests Lookup</name>
     <description>Tests for all lookup methods</description>
 
     <dependencies>
@@ -37,14 +37,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -85,8 +77,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -103,8 +95,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
@@ -138,8 +130,8 @@
                 </executions>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${helidon.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractCommon.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractCommon.java
similarity index 93%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractCommon.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractCommon.java
index f7bedc78d58..0693fa6dad3 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractCommon.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractCommon.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoIpProvider.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoIpProvider.java
similarity index 93%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoIpProvider.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoIpProvider.java
index 4ae5b3b41ea..95854eaf1cf 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoIpProvider.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoIpProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScope.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScope.java
similarity index 93%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScope.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScope.java
index d66302fcca6..be3863acb79 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScope.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScope.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScopeNoIpProvider.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScopeNoIpProvider.java
similarity index 94%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScopeNoIpProvider.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScopeNoIpProvider.java
index 5b0b27303a5..a782ab3ce40 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractNoScopeNoIpProvider.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractNoScopeNoIpProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScope.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScope.java
similarity index 93%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScope.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScope.java
index c216c91536d..8f3ae60f6fa 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScope.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScope.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScopeNoIpProvider.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScopeNoIpProvider.java
similarity index 94%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScopeNoIpProvider.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScopeNoIpProvider.java
index f6ccc0be232..a667377445c 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractRequestScopeNoIpProvider.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractRequestScopeNoIpProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingleton.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingleton.java
similarity index 93%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingleton.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingleton.java
index 4c484461ab4..502af766659 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingleton.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingleton.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingletonNoIpProvider.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingletonNoIpProvider.java
similarity index 94%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingletonNoIpProvider.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingletonNoIpProvider.java
index 365980c51a4..f0527129c48 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/ContractSingletonNoIpProvider.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/ContractSingletonNoIpProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeDirectExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeDirectExample.java
similarity index 85%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeDirectExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeDirectExample.java
index dab285f41c7..3bc0b153f0f 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeDirectExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeDirectExample.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerLookup
+@Service.PerLookup
 class NoScopeDirectExample implements ContractNoScopeNoIpProvider {
 }
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeInjectionPointProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeInjectionPointProviderExample.java
similarity index 81%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeInjectionPointProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeInjectionPointProviderExample.java
index 82b457522da..ef9b9aae810 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeInjectionPointProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeInjectionPointProviderExample.java
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.Optional;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.InjectionPointFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.PerLookup
+@Service.PerLookup
 @NoScopeInjectionPointProviderExample.FirstQuali
 @NoScopeInjectionPointProviderExample.SecondQuali
 class NoScopeInjectionPointProviderExample implements InjectionPointFactory<ContractNoScope> {
@@ -42,11 +42,11 @@ public Optional<QualifiedInstance<ContractNoScope>> first(Lookup lookup) {
         return Optional.empty();
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeServicesProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeServicesProviderExample.java
similarity index 78%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeServicesProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeServicesProviderExample.java
index 0a499217665..445ad834f41 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeServicesProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeServicesProviderExample.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.PerLookup
+@Service.PerLookup
 @NoScopeServicesProviderExample.FirstQuali
 @NoScopeServicesProviderExample.SecondQuali
-class NoScopeServicesProviderExample implements Injection.ServicesFactory<ContractNoScopeNoIpProvider> {
+class NoScopeServicesProviderExample implements Service.ServicesFactory<ContractNoScopeNoIpProvider> {
     static final Qualifier FIRST_QUALI = Qualifier.create(FirstQuali.class);
     static final Qualifier SECOND_QUALI = Qualifier.create(SecondQuali.class);
 
@@ -37,11 +37,11 @@ public List<QualifiedInstance<ContractNoScopeNoIpProvider>> services() {
         );
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeSupplierExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeSupplierExample.java
similarity index 90%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeSupplierExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeSupplierExample.java
index a7325fe7790..a0d6de47519 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/NoScopeSupplierExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/NoScopeSupplierExample.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerLookup
+@Service.PerLookup
 @Weight(Weighted.DEFAULT_WEIGHT + 1) // higher than other no-scope, lower than singleton supplier
 class NoScopeSupplierExample implements Supplier<ContractNoScopeNoIpProvider> {
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeDirectExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeDirectExample.java
similarity index 85%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeDirectExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeDirectExample.java
index 69bb9d14306..cc9a0c64143 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeDirectExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeDirectExample.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerRequest
+@Service.PerRequest
 class RequestScopeDirectExample implements ContractRequestScopeNoIpProvider {
 }
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeInjectionPointProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeInjectionPointProviderExample.java
similarity index 81%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeInjectionPointProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeInjectionPointProviderExample.java
index ccd0fce70a3..cb144e68f08 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeInjectionPointProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeInjectionPointProviderExample.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.Optional;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.PerRequest
+@Service.PerRequest
 @RequestScopeInjectionPointProviderExample.FirstQuali
 @RequestScopeInjectionPointProviderExample.SecondQuali
-class RequestScopeInjectionPointProviderExample implements Injection.InjectionPointFactory<ContractRequestScope> {
+class RequestScopeInjectionPointProviderExample implements Service.InjectionPointFactory<ContractRequestScope> {
     static final Qualifier FIRST_QUALI = Qualifier.create(RequestScopeInjectionPointProviderExample.FirstQuali.class);
     static final Qualifier SECOND_QUALI = Qualifier.create(RequestScopeInjectionPointProviderExample.SecondQuali.class);
     static final QualifiedInstance<ContractRequestScope> FIRST =
@@ -47,11 +47,11 @@ public Optional<QualifiedInstance<ContractRequestScope>> first(Lookup lookup) {
         return Optional.empty();
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeServicesProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeServicesProviderExample.java
similarity index 82%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeServicesProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeServicesProviderExample.java
index 64fe6704f78..a15d0c50ceb 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeServicesProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeServicesProviderExample.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Injection.ServicesFactory;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedInstance;
+import io.helidon.service.registry.Service.ServicesFactory;
 
-@Injection.PerRequest
+@Service.PerRequest
 @RequestScopeServicesProviderExample.FirstQuali // need to qualify, so lookups for specific qualifier match this provider
 @RequestScopeServicesProviderExample.SecondQuali
 class RequestScopeServicesProviderExample implements ServicesFactory<ContractRequestScopeNoIpProvider> {
@@ -38,11 +38,11 @@ public List<QualifiedInstance<ContractRequestScopeNoIpProvider>> services() {
         );
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeSupplierExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeSupplierExample.java
similarity index 90%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeSupplierExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeSupplierExample.java
index d01cca47abc..4c85c20b795 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/RequestScopeSupplierExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/RequestScopeSupplierExample.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerRequest
+@Service.PerRequest
 @Weight(Weighted.DEFAULT_WEIGHT + 1) // higher than other no-scope, lower than singleton supplier
 class RequestScopeSupplierExample implements Supplier<ContractRequestScopeNoIpProvider> {
     private static final ContractRequestScopeNoIpProvider FIRST = new First();
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonDirectExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonDirectExample.java
similarity index 85%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonDirectExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonDirectExample.java
index 0e553ab2892..02390d64125 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonDirectExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonDirectExample.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class SingletonDirectExample implements ContractSingletonNoIpProvider {
 }
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonInjectionPointProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonInjectionPointProviderExample.java
similarity index 82%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonInjectionPointProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonInjectionPointProviderExample.java
index 613f376cd1a..6cc0215ae72 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonInjectionPointProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonInjectionPointProviderExample.java
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.Optional;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.InjectionPointFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.Singleton
+@Service.Singleton
 @SingletonInjectionPointProviderExample.FirstQuali
 @SingletonInjectionPointProviderExample.SecondQuali
 class SingletonInjectionPointProviderExample implements InjectionPointFactory<ContractSingleton> {
@@ -44,11 +44,11 @@ public Optional<QualifiedInstance<ContractSingleton>> first(Lookup lookup) {
         return Optional.empty();
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonServicesProviderExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonServicesProviderExample.java
similarity index 79%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonServicesProviderExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonServicesProviderExample.java
index 5b552260d0d..fbba7a67b42 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonServicesProviderExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonServicesProviderExample.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.Singleton
+@Service.Singleton
 @SingletonServicesProviderExample.FirstQuali // need to qualify, so lookups for specific qualifier match this provider
 @SingletonServicesProviderExample.SecondQuali
-class SingletonServicesProviderExample implements Injection.ServicesFactory<ContractSingletonNoIpProvider> {
+class SingletonServicesProviderExample implements Service.ServicesFactory<ContractSingletonNoIpProvider> {
     static final Qualifier FIRST_QUALI = Qualifier.create(FirstQuali.class);
     static final Qualifier SECOND_QUALI = Qualifier.create(SecondQuali.class);
 
@@ -37,11 +37,11 @@ public List<QualifiedInstance<ContractSingletonNoIpProvider>> services() {
         );
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface FirstQuali {
     }
 
-    @Injection.Qualifier
+    @Service.Qualifier
     @interface SecondQuali {
     }
 
diff --git a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonSupplierExample.java b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonSupplierExample.java
similarity index 90%
rename from service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonSupplierExample.java
rename to service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonSupplierExample.java
index c0c2dc2a70d..cdb171b2072 100644
--- a/service/tests/inject/lookup/src/main/java/io/helidon/service/inject/tests/lookup/SingletonSupplierExample.java
+++ b/service/tests/lookup/src/main/java/io/helidon/service/tests/lookup/SingletonSupplierExample.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.function.Supplier;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 2) // the only weighted one, should be first
 class SingletonSupplierExample implements Supplier<ContractSingletonNoIpProvider> {
     private static final ContractSingletonNoIpProvider FIRST = new First();
diff --git a/service/tests/lookup/src/main/java/module-info.java b/service/tests/lookup/src/main/java/module-info.java
new file mode 100644
index 00000000000..6364bf7947e
--- /dev/null
+++ b/service/tests/lookup/src/main/java/module-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.service.tests.lookup {
+    requires io.helidon.service.registry;
+
+    exports io.helidon.service.tests.lookup;
+}
\ No newline at end of file
diff --git a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/AllScopesLookupTest.java b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/AllScopesLookupTest.java
similarity index 91%
rename from service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/AllScopesLookupTest.java
rename to service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/AllScopesLookupTest.java
index 2d9f63c9f77..7cf8d396000 100644
--- a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/AllScopesLookupTest.java
+++ b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/AllScopesLookupTest.java
@@ -14,20 +14,20 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Scopes;
-import io.helidon.service.inject.api.Scope;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Scope;
+import io.helidon.service.registry.Scopes;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
@@ -49,14 +49,14 @@ class AllScopesLookupTest {
     private static final Lookup LOOKUP = Lookup.create(ContractCommon.class);
     private static final Class<ContractCommon> CONTRACT = ContractCommon.class;
 
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     private Scope requestScope;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
@@ -71,7 +71,7 @@ static void shutdown() {
     void startRequestScope() {
         // we need to have request scope active, so we can access providers from everywhere
         var scopes = registry.get(Scopes.class);
-        requestScope = scopes.createScope(Injection.PerRequest.TYPE, "unit-test", Map.of());
+        requestScope = scopes.createScope(Service.PerRequest.TYPE, "unit-test", Map.of());
     }
 
     @AfterEach
@@ -167,7 +167,7 @@ void supplyAllTypeTest() {
 
     @Test
     void lookupServicesTest() {
-        List<InjectServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
+        List<ServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
 
         /*
         Order:
diff --git a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/NoScopeLookupTest.java b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/NoScopeLookupTest.java
similarity index 94%
rename from service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/NoScopeLookupTest.java
rename to service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/NoScopeLookupTest.java
index 109032dd318..9c70d6bcac5 100644
--- a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/NoScopeLookupTest.java
+++ b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/NoScopeLookupTest.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -43,12 +43,12 @@
 class NoScopeLookupTest {
     private static final Lookup LOOKUP = Lookup.create(ContractNoScope.class);
     private static final Class<ContractNoScope> CONTRACT = ContractNoScope.class;
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
@@ -194,7 +194,7 @@ void supplyFromDescriptorTest() {
 
     @Test
     void lookupServicesTest() {
-        List<InjectServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
+        List<ServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
 
         /*
         Order:
diff --git a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/RequestScopeLookupTest.java b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/RequestScopeLookupTest.java
similarity index 92%
rename from service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/RequestScopeLookupTest.java
rename to service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/RequestScopeLookupTest.java
index fff7488f7bc..fe515f66f72 100644
--- a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/RequestScopeLookupTest.java
+++ b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/RequestScopeLookupTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 import java.util.Map;
@@ -22,13 +22,13 @@
 import java.util.function.Supplier;
 
 import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Scope;
-import io.helidon.service.inject.api.Scopes;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Scope;
+import io.helidon.service.registry.Scopes;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
@@ -47,20 +47,20 @@
  * Test all lookup methods for requestScope.
  */
 class RequestScopeLookupTest {
+    private static final Lookup LOOKUP = Lookup.create(ContractRequestScope.class);
+    private static final Class<ContractRequestScope> CONTRACT = ContractRequestScope.class;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
+
     static {
         LogConfig.initClass();
     }
 
-    private static final Lookup LOOKUP = Lookup.create(ContractRequestScope.class);
-    private static final Class<ContractRequestScope> CONTRACT = ContractRequestScope.class;
-
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
     private Scope requestScope;
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
@@ -74,7 +74,7 @@ static void shutdown() {
     @BeforeEach
     void startRequestScope() {
         var scopes = registry.get(Scopes.class);
-        requestScope = scopes.createScope(Injection.PerRequest.TYPE, "unit-test", Map.of());
+        requestScope = scopes.createScope(Service.PerRequest.TYPE, "unit-test", Map.of());
     }
 
     @AfterEach
@@ -219,7 +219,7 @@ void supplyFromDescriptorTest() {
 
     @Test
     void lookupServicesTest() {
-        List<InjectServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
+        List<ServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
 
         /*
         Order:
diff --git a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/SingletonLookupTest.java b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/SingletonLookupTest.java
similarity index 93%
rename from service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/SingletonLookupTest.java
rename to service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/SingletonLookupTest.java
index e3ea0fb064f..0f54e81031d 100644
--- a/service/tests/inject/lookup/src/test/java/io/helidon/service/inject/tests/lookup/SingletonLookupTest.java
+++ b/service/tests/lookup/src/test/java/io/helidon/service/tests/lookup/SingletonLookupTest.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.inject.tests.lookup;
+package io.helidon.service.tests.lookup;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
 
 import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Injection.InjectionPointFactory;
-import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.FactoryType;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -45,8 +45,8 @@
 class SingletonLookupTest {
     private static final Lookup LOOKUP = Lookup.create(ContractSingleton.class);
     private static final Class<ContractSingleton> CONTRACT = ContractSingleton.class;
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     static {
         LogConfig.initClass();
@@ -54,7 +54,7 @@ class SingletonLookupTest {
 
     @BeforeAll
     static void init() {
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
     }
 
@@ -200,7 +200,7 @@ void supplyFromDescriptorTest() {
 
     @Test
     void lookupServicesTest() {
-        List<InjectServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
+        List<ServiceInfo> serviceDescriptors = registry.lookupServices(LOOKUP);
 
         /*
         Order:
diff --git a/service/tests/inject/lookup/src/test/resources/logging.properties b/service/tests/lookup/src/test/resources/logging.properties
similarity index 94%
rename from service/tests/inject/lookup/src/test/resources/logging.properties
rename to service/tests/lookup/src/test/resources/logging.properties
index 5190b108e32..563562ef136 100644
--- a/service/tests/inject/lookup/src/test/resources/logging.properties
+++ b/service/tests/lookup/src/test/resources/logging.properties
@@ -13,10 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 handlers=io.helidon.logging.jul.HelidonConsoleHandler
 java.util.logging.SimpleFormatter.format=%1$tY.%1$tm.%1$td %1$tH:%1$tM:%1$tS.%1$tL %4$s %5$s%6$s%n
-
 # Global logging level. Can be overridden by specific loggers
 .level=INFO
-io.helidon.service.inject.LookupTrace.level=ALL
+io.helidon.service.registry.LookupTrace.level=ALL
diff --git a/service/tests/inject/maven-plugin/pom.xml b/service/tests/maven-plugin/pom.xml
similarity index 91%
rename from service/tests/inject/maven-plugin/pom.xml
rename to service/tests/maven-plugin/pom.xml
index e4acf371362..1f847942cdc 100644
--- a/service/tests/inject/maven-plugin/pom.xml
+++ b/service/tests/maven-plugin/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-maven-plugin</artifactId>
-    <name>Helidon Service Tests Inject Maven Plugin</name>
+    <artifactId>helidon-service-tests-maven-plugin</artifactId>
+    <name>Helidon Service Tests Maven Plugin</name>
     <description>Tests for Maven Plugin</description>
 
     <dependencies>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
similarity index 80%
rename from service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml
rename to service/tests/maven-plugin/src/it/projects/test1/pom.xml
index 0692c5a56bf..5f7b01e6f61 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test1/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
@@ -22,7 +22,7 @@
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <groupId>io.helidon.service.tests.maven.plugin.test</groupId>
     <artifactId>test-1</artifactId>
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 1</name>
@@ -33,16 +33,6 @@
             <artifactId>helidon-service-registry</artifactId>
             <version>@project.version@</version>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-            <version>@project.version@</version>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-            <version>@project.version@</version>
-        </dependency>
     </dependencies>
 
     <build>
@@ -58,8 +48,8 @@
                             <version>@project.version@</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>@project.version@</version>
                         </path>
                         <path>
@@ -71,8 +61,8 @@
                 </configuration>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${project.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy b/service/tests/maven-plugin/src/it/projects/test1/postbuild.groovy
similarity index 100%
rename from service/tests/inject/maven-plugin/src/it/projects/test1/postbuild.groovy
rename to service/tests/maven-plugin/src/it/projects/test1/postbuild.groovy
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java b/service/tests/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
similarity index 90%
rename from service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
rename to service/tests/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
index 4244fb878cb..b8b54e46d79 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
+++ b/service/tests/maven-plugin/src/it/projects/test1/src/main/java/my/module/ServiceType.java
@@ -16,9 +16,9 @@
 
 package my.module;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class ServiceType {
 
 }
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
similarity index 81%
rename from service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml
rename to service/tests/maven-plugin/src/it/projects/test2/pom.xml
index 3279da678b6..4e13b33360d 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test2/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
@@ -22,7 +22,7 @@
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <groupId>io.helidon.service.tests.maven.plugin.test</groupId>
     <artifactId>test-2</artifactId>
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 2</name>
@@ -33,16 +33,6 @@
             <artifactId>helidon-service-registry</artifactId>
             <version>@project.version@</version>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-            <version>@project.version@</version>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-            <version>@project.version@</version>
-        </dependency>
     </dependencies>
 
     <build>
@@ -58,8 +48,8 @@
                             <version>@project.version@</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>@project.version@</version>
                         </path>
                         <path>
@@ -71,8 +61,8 @@
                 </configuration>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${project.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy b/service/tests/maven-plugin/src/it/projects/test2/postbuild.groovy
similarity index 100%
rename from service/tests/inject/maven-plugin/src/it/projects/test2/postbuild.groovy
rename to service/tests/maven-plugin/src/it/projects/test2/postbuild.groovy
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java b/service/tests/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
similarity index 90%
rename from service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
rename to service/tests/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
index 4244fb878cb..b8b54e46d79 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
+++ b/service/tests/maven-plugin/src/it/projects/test2/src/main/java/my/module/ServiceType.java
@@ -16,9 +16,9 @@
 
 package my.module;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class ServiceType {
 
 }
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
similarity index 81%
rename from service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml
rename to service/tests/maven-plugin/src/it/projects/test3/pom.xml
index b81874fb86d..ecb517ed452 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test3/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
@@ -22,7 +22,7 @@
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>io.helidon.service.tests.inject.maven.plugin.test</groupId>
+    <groupId>io.helidon.service.tests.maven.plugin.test</groupId>
     <artifactId>test-3</artifactId>
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 3</name>
@@ -33,16 +33,6 @@
             <artifactId>helidon-service-registry</artifactId>
             <version>@project.version@</version>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-            <version>@project.version@</version>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-            <version>@project.version@</version>
-        </dependency>
     </dependencies>
 
     <build>
@@ -58,8 +48,8 @@
                             <version>@project.version@</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>@project.version@</version>
                         </path>
                         <path>
@@ -71,8 +61,8 @@
                 </configuration>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${project.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy b/service/tests/maven-plugin/src/it/projects/test3/postbuild.groovy
similarity index 100%
rename from service/tests/inject/maven-plugin/src/it/projects/test3/postbuild.groovy
rename to service/tests/maven-plugin/src/it/projects/test3/postbuild.groovy
diff --git a/service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java b/service/tests/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
similarity index 90%
rename from service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
rename to service/tests/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
index 4244fb878cb..b8b54e46d79 100644
--- a/service/tests/inject/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
+++ b/service/tests/maven-plugin/src/it/projects/test3/src/main/java/my/module/ServiceType.java
@@ -16,9 +16,9 @@
 
 package my.module;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class ServiceType {
 
 }
\ No newline at end of file
diff --git a/service/tests/inject/maven-plugin/src/it/settings.xml b/service/tests/maven-plugin/src/it/settings.xml
similarity index 100%
rename from service/tests/inject/maven-plugin/src/it/settings.xml
rename to service/tests/maven-plugin/src/it/settings.xml
diff --git a/service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java b/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
similarity index 90%
rename from service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
rename to service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
index fb46edd1e93..e3782e06c1f 100644
--- a/service/tests/inject/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
+++ b/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
@@ -25,6 +25,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 
 import static io.helidon.build.common.test.utils.FileMatchers.fileExists;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
@@ -48,7 +49,8 @@ void test1(String basedir) {
         assertThat("Generated by the service inject codegen during compilation",
                    generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
                    fileExists());
-        assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationMain.java"), fileExists());
+        // Main class not yet ready
+        // assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationMain.java"), fileExists());
         assertThat("Not a generated type, exists in project sources only",
                    generatedSources.resolve("ServiceType.java"),
                    not(fileExists()));
@@ -60,7 +62,8 @@ void test1(String basedir) {
         assertThat("Generated by the service inject codegen during compilation",
                    compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
                    fileExists());
-        assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationMain.class"), fileExists());
+        // Main class not yet ready
+        // assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationMain.class"), fileExists());
         assertThat("Compiled service", compiledClasses.resolve("ServiceType.class"), fileExists());
 
     }
@@ -83,9 +86,10 @@ void test2(String basedir) {
         assertThat("Generated by the Maven plugin",
                    generatedCustomSources.resolve("UpdatedBinding__ServiceDescriptor.java"),
                    fileExists());
-        assertThat("Generated by the Maven plugin",
-                   generatedCustomSources.resolve("UpdatedMain.java"),
-                   fileExists());
+        // Main class not yet ready
+        //        assertThat("Generated by the Maven plugin",
+        //                   generatedCustomSources.resolve("UpdatedMain.java"),
+        //                   fileExists());
         assertThat("Generated by the service inject codegen during compilation",
                    generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
                    fileExists());
@@ -99,9 +103,10 @@ void test2(String basedir) {
         assertThat("Generated by the Maven plugin",
                    compiledCustomClasses.resolve("UpdatedBinding__ServiceDescriptor.class"),
                    fileExists());
-        assertThat("Generated by the Maven plugin",
-                   compiledCustomClasses.resolve("UpdatedMain.class"),
-                   fileExists());
+        // Main class not yet ready
+        //        assertThat("Generated by the Maven plugin",
+        //                   compiledCustomClasses.resolve("UpdatedMain.class"),
+        //                   fileExists());
         assertThat("Generated by the service inject codegen during compilation",
                    compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
                    fileExists());
diff --git a/service/tests/pom.xml b/service/tests/pom.xml
index 73e02f741c6..6c739b83e02 100644
--- a/service/tests/pom.xml
+++ b/service/tests/pom.xml
@@ -43,9 +43,18 @@
     </properties>
 
     <modules>
-        <module>registry</module>
         <module>codegen</module>
+        <module>registry</module>
         <module>inject</module>
+        <module>lookup</module>
+        <module>service-lifecycle</module>
+        <module>scopes</module>
+        <module>interception</module>
+        <module>qualified-providers</module>
+        <module>stacking</module>
+        <module>toolbox</module>
+        <module>events</module>
+        <module>maven-plugin</module>
     </modules>
 
 </project>
diff --git a/service/tests/inject/qualified-providers/pom.xml b/service/tests/qualified-providers/pom.xml
similarity index 83%
rename from service/tests/inject/qualified-providers/pom.xml
rename to service/tests/qualified-providers/pom.xml
index e00b45ef4c1..13cde8f5b2e 100644
--- a/service/tests/inject/qualified-providers/pom.xml
+++ b/service/tests/qualified-providers/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-qualified-providers</artifactId>
-    <name>Helidon Service Tests Inject Qualified Providers</name>
+    <artifactId>helidon-service-tests-qualified-providers</artifactId>
+    <name>Helidon Service Tests Qualified Providers</name>
     <description>Tests for qualified providers - both typed and untyped</description>
 
     <dependencies>
@@ -37,14 +37,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -75,8 +67,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -93,8 +85,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
@@ -128,8 +120,8 @@
                 </executions>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${helidon.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifiedProvider.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifiedProvider.java
similarity index 81%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifiedProvider.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifiedProvider.java
index a4f4ef35592..4a43ffe265a 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifiedProvider.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifiedProvider.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
 import java.util.Map;
 import java.util.Optional;
 
 import io.helidon.common.GenericType;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.Singleton
-class FirstQualifiedProvider implements Injection.QualifiedFactory<Object, FirstQualifier> {
+@Service.Singleton
+class FirstQualifiedProvider implements Service.QualifiedFactory<Object, FirstQualifier> {
     private final Map<String, String> values = Map.of("first", "first",
                                                       "second", "49");
 
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifier.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifier.java
similarity index 87%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifier.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifier.java
index 67584981a59..788a7b68635 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/FirstQualifier.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/FirstQualifier.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Qualifier
+@Service.Qualifier
 @Retention(RetentionPolicy.CLASS)
 @Target({ElementType.PARAMETER, ElementType.FIELD})
 @interface FirstQualifier {
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/QualifiedContract.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/QualifiedContract.java
similarity index 92%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/QualifiedContract.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/QualifiedContract.java
index de7c81795dc..d239c24e5be 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/QualifiedContract.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/QualifiedContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifiedProvider.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifiedProvider.java
similarity index 83%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifiedProvider.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifiedProvider.java
index 3ab6cc384a1..12108343103 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifiedProvider.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifiedProvider.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
 import java.util.Map;
 import java.util.Optional;
 
 import io.helidon.common.GenericType;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.QualifiedFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.QualifiedFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
 
-@Injection.Singleton
+@Service.Singleton
 class SecondQualifiedProvider implements QualifiedFactory<QualifiedContract, SecondQualifier> {
     private final Map<String, QualifiedContract> values = Map.of("first", new QualifiedContractImpl("first"),
                                                                  "second", new QualifiedContractImpl("second"));
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifier.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifier.java
similarity index 87%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifier.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifier.java
index a336a0902e1..fca3405fe34 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/SecondQualifier.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/SecondQualifier.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Qualifier
+@Service.Qualifier
 @Retention(RetentionPolicy.CLASS)
 @Target({ElementType.PARAMETER, ElementType.FIELD})
 @interface SecondQualifier {
diff --git a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/TheService.java b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/TheService.java
similarity index 90%
rename from service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/TheService.java
rename to service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/TheService.java
index 7fc7493d5b3..2fd51362a9c 100644
--- a/service/tests/inject/qualified-providers/src/main/java/io/helidon/service/tests/inject/qualified/providers/TheService.java
+++ b/service/tests/qualified-providers/src/main/java/io/helidon/service/tests/qualified/providers/TheService.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class TheService {
     private final String first;
     private final int second;
     private final QualifiedContract firstContract;
     private final QualifiedContract secondContract;
 
-    @Injection.Inject
+    @Service.Inject
     TheService(@FirstQualifier("first") String first,
                @FirstQualifier("second") int second,
                @SecondQualifier("first") QualifiedContract firstContract,
diff --git a/service/tests/qualified-providers/src/main/java/module-info.java b/service/tests/qualified-providers/src/main/java/module-info.java
new file mode 100644
index 00000000000..4a956c40458
--- /dev/null
+++ b/service/tests/qualified-providers/src/main/java/module-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.service.tests.qualified.providers {
+    requires io.helidon.service.registry;
+
+    exports io.helidon.service.tests.qualified.providers;
+}
\ No newline at end of file
diff --git a/service/tests/inject/qualified-providers/src/test/java/io/helidon/service/tests/inject/qualified/providers/QualifiedProvidersTest.java b/service/tests/qualified-providers/src/test/java/io/helidon/service/tests/qualified/providers/QualifiedProvidersTest.java
similarity index 83%
rename from service/tests/inject/qualified-providers/src/test/java/io/helidon/service/tests/inject/qualified/providers/QualifiedProvidersTest.java
rename to service/tests/qualified-providers/src/test/java/io/helidon/service/tests/qualified/providers/QualifiedProvidersTest.java
index fdda2504399..9db300f74c9 100644
--- a/service/tests/inject/qualified-providers/src/test/java/io/helidon/service/tests/inject/qualified/providers/QualifiedProvidersTest.java
+++ b/service/tests/qualified-providers/src/test/java/io/helidon/service/tests/qualified/providers/QualifiedProvidersTest.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.qualified.providers;
+package io.helidon.service.tests.qualified.providers;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
 import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.Test;
 
@@ -28,7 +28,7 @@
 public class QualifiedProvidersTest {
     @Test
     public void testQualifiedProvidersNoApp() {
-        InjectRegistryManager registryManager = InjectRegistryManager.create(InjectConfig.builder()
+        ServiceRegistryManager registryManager = ServiceRegistryManager.create(ServiceRegistryConfig.builder()
                                                                                      .useBinding(false)
                                                                                      .build());
 
@@ -41,7 +41,7 @@ public void testQualifiedProvidersNoApp() {
 
     @Test
     public void testQualifiedProvidersWithApp() {
-        InjectRegistryManager registryManager = InjectRegistryManager.create();
+        ServiceRegistryManager registryManager = ServiceRegistryManager.create();
 
         try {
             testServices(registryManager.registry());
diff --git a/service/tests/registry/src/test/java/io/helidon/service/test/registry/CyclicDependencyTest.java b/service/tests/registry/src/test/java/io/helidon/service/test/registry/CyclicDependencyTest.java
index a90993b3526..5f85cd58926 100644
--- a/service/tests/registry/src/test/java/io/helidon/service/test/registry/CyclicDependencyTest.java
+++ b/service/tests/registry/src/test/java/io/helidon/service/test/registry/CyclicDependencyTest.java
@@ -24,7 +24,7 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.service.registry.Dependency;
 import io.helidon.service.registry.DependencyContext;
-import io.helidon.service.registry.GeneratedService;
+import io.helidon.service.registry.InterceptionMetadata;
 import io.helidon.service.registry.ServiceDescriptor;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.ServiceRegistryConfig;
@@ -84,7 +84,7 @@ private static class Descriptor1 implements ServiceDescriptor<Service1> {
                 .build();
 
         @Override
-        public Object instantiate(DependencyContext ctx) {
+        public Object instantiate(DependencyContext ctx, InterceptionMetadata im) {
             return new Service1(ctx.dependency(DEP));
         }
 
@@ -123,7 +123,7 @@ private static class Descriptor2 implements ServiceDescriptor<Service2> {
                 .build();
 
         @Override
-        public Object instantiate(DependencyContext ctx) {
+        public Object instantiate(DependencyContext ctx, InterceptionMetadata im) {
             return new Service2(ctx.dependency(DEP));
         }
 
diff --git a/service/tests/registry/src/test/java/io/helidon/service/test/registry/RegistryConfigTest.java b/service/tests/registry/src/test/java/io/helidon/service/test/registry/RegistryConfigTest.java
deleted file mode 100644
index c9a4eb9949c..00000000000
--- a/service/tests/registry/src/test/java/io/helidon/service/test/registry/RegistryConfigTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.test.registry;
-
-import java.util.Map;
-
-import io.helidon.config.Config;
-import io.helidon.config.ConfigSources;
-import io.helidon.service.registry.ServiceRegistryConfig;
-
-import org.junit.jupiter.api.Test;
-
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalEmpty;
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalValue;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.sameInstance;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.collection.IsEmptyCollection.empty;
-
-public class RegistryConfigTest {
-    @Test
-    void testDefaults() {
-        ServiceRegistryConfig cfg = ServiceRegistryConfig.create();
-        assertThat(cfg.config(), is(optionalEmpty()));
-        assertThat(cfg.discoverServices(), is(true));
-        assertThat(cfg.serviceDescriptors(), is(empty()));
-        assertThat(cfg.serviceInstances().size(), is(0));
-    }
-
-    @Test
-    void testFromConfig() {
-        Config config = Config.builder(
-                        ConfigSources.create(
-                                Map.of("registry.discover-services", "false"
-                                ), "config-1"))
-                .disableEnvironmentVariablesSource()
-                .disableSystemPropertiesSource()
-                .build();
-        Config registryConfig = config.get("registry");
-        ServiceRegistryConfig cfg = ServiceRegistryConfig.create(registryConfig);
-
-        assertThat(cfg.config(), optionalValue(sameInstance(registryConfig)));
-        assertThat(cfg.discoverServices(), is(false));
-        assertThat(cfg.serviceDescriptors(), is(empty()));
-        assertThat(cfg.serviceInstances().size(), is(0));
-    }
-}
diff --git a/service/tests/inject/scopes/pom.xml b/service/tests/scopes/pom.xml
similarity index 78%
rename from service/tests/inject/scopes/pom.xml
rename to service/tests/scopes/pom.xml
index ad65e443cd1..d7239648ee9 100644
--- a/service/tests/inject/scopes/pom.xml
+++ b/service/tests/scopes/pom.xml
@@ -21,30 +21,22 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-scopes</artifactId>
-    <name>Helidon Service Tests Inject Scopes</name>
-    <description>Tets for injection scopes (Request scope, singleton, dependent)</description>
+    <artifactId>helidon-service-tests-scopes</artifactId>
+    <name>Helidon Service Tests Scopes</name>
+    <description>Tests for injection scopes (Request scope, singleton, dependent)</description>
 
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -75,8 +67,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -93,8 +85,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScope.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScope.java
similarity index 90%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScope.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScope.java
index ab658b566d5..75eecb0ecb4 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScope.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScope.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -23,11 +23,11 @@
 import java.lang.annotation.Target;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 @Documented
 @Retention(RetentionPolicy.CLASS)
-@Injection.Scope
+@Service.Scope
 @Target(ElementType.TYPE)
 public @interface CustomScope {
     TypeName TYPE = TypeName.create(CustomScope.class);
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContract.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContract.java
similarity index 84%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContract.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContract.java
index f0543172611..f7541bb0331 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContract.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContract.java
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 
-@Injection.Describe(CustomScope.class)
+@Service.Describe(CustomScope.class)
 @Service.Contract
 interface CustomScopeDescribedContract {
     String message();
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContractImpl.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContractImpl.java
similarity index 94%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContractImpl.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContractImpl.java
index 5f530af1f83..9a8fbec2ee7 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeDescribedContractImpl.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeDescribedContractImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 class CustomScopeDescribedContractImpl implements CustomScopeDescribedContract {
     @Override
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeHandler.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeHandler.java
similarity index 79%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeHandler.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeHandler.java
index 53835c5de13..8f6147f5aa4 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopeHandler.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopeHandler.java
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicReference;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Scope;
+import io.helidon.service.registry.Scope;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
-@Injection.NamedByType(CustomScope.class)
-public class CustomScopeHandler implements Injection.ScopeHandler {
+@Service.Singleton
+@Service.NamedByType(CustomScope.class)
+public class CustomScopeHandler implements Service.ScopeHandler {
 
     private final AtomicReference<Scope> currentScope = new AtomicReference<>();
 
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedContract.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedContract.java
similarity index 94%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedContract.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedContract.java
index 2f04c970e38..04540eecdd3 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedContract.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedContract.java
@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import io.helidon.service.registry.Service;
 
 @Service.Contract
 interface CustomScopedContract {
     int id();
+
     String message();
 }
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedProducer.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedProducer.java
similarity index 91%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedProducer.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedProducer.java
index 3ea2a47ed99..edba62a6c22 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/CustomScopedProducer.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/CustomScopedProducer.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 @CustomScope
 class CustomScopedProducer implements CustomScopedContract {
@@ -27,7 +27,7 @@ class CustomScopedProducer implements CustomScopedContract {
     private final int id = COUNTER.incrementAndGet();
     private final CustomScopeDescribedContract describedContract;
 
-    @Injection.Inject
+    @Service.Inject
     CustomScopedProducer(CustomScopeDescribedContract describedContract) {
         this.describedContract = describedContract;
     }
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedContract.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedContract.java
similarity index 93%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedContract.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedContract.java
index 7d66be8c55d..746c8fc9066 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedContract.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedProducer.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedProducer.java
similarity index 88%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedProducer.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedProducer.java
index ab2e0301d4e..0cb4088ac37 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/RequestScopedProducer.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/RequestScopedProducer.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerRequest
+@Service.PerRequest
 class RequestScopedProducer implements RequestScopedContract {
     private static final AtomicInteger COUNTER = new AtomicInteger();
 
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonContract.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonContract.java
similarity index 93%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonContract.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonContract.java
index 4dfb2b9d101..4be1a020c95 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonContract.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonService.java b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonService.java
similarity index 87%
rename from service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonService.java
rename to service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonService.java
index a79d3347a4a..4793b18808f 100644
--- a/service/tests/inject/scopes/src/main/java/io/helidon/service/tests/inject/scopes/SingletonService.java
+++ b/service/tests/scopes/src/main/java/io/helidon/service/tests/scopes/SingletonService.java
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class SingletonService implements SingletonContract {
     private final Supplier<RequestScopedContract> contract;
 
-    @Injection.Inject
+    @Service.Inject
     SingletonService(Supplier<RequestScopedContract> contract) {
         this.contract = contract;
     }
diff --git a/service/tests/scopes/src/main/java/module-info.java b/service/tests/scopes/src/main/java/module-info.java
new file mode 100644
index 00000000000..443aefb7aca
--- /dev/null
+++ b/service/tests/scopes/src/main/java/module-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.service.tests.scopes {
+    requires io.helidon.service.registry;
+
+    exports io.helidon.service.tests.scopes;
+}
\ No newline at end of file
diff --git a/service/tests/inject/scopes/src/test/java/io/helidon/service/tests/inject/scopes/TestScopes.java b/service/tests/scopes/src/test/java/io/helidon/service/tests/scopes/TestScopes.java
similarity index 80%
rename from service/tests/inject/scopes/src/test/java/io/helidon/service/tests/inject/scopes/TestScopes.java
rename to service/tests/scopes/src/test/java/io/helidon/service/tests/scopes/TestScopes.java
index fab247fee10..09fff7cdb82 100644
--- a/service/tests/inject/scopes/src/test/java/io/helidon/service/tests/inject/scopes/TestScopes.java
+++ b/service/tests/scopes/src/test/java/io/helidon/service/tests/scopes/TestScopes.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.scopes;
+package io.helidon.service.tests.scopes;
 
 import java.util.Map;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Scope;
-import io.helidon.service.inject.api.ScopeNotActiveException;
-import io.helidon.service.inject.api.Scopes;
+import io.helidon.service.registry.Scope;
+import io.helidon.service.registry.ScopeNotActiveException;
+import io.helidon.service.registry.Scopes;
+import io.helidon.service.registry.Service;
 import io.helidon.service.registry.ServiceDescriptor;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -42,12 +42,12 @@ class TestScopes {
             Map.of(CustomScopeDescribedContract__ServiceDescriptor.INSTANCE,
                    new CustomScopeDescribedContractImpl());
 
-    private InjectRegistryManager registryManager;
-    private InjectRegistry registry;
+    private ServiceRegistryManager registryManager;
+    private ServiceRegistry registry;
 
     @BeforeEach
     void init() {
-        registryManager = InjectRegistryManager.create(InjectConfig.create());
+        registryManager = ServiceRegistryManager.create(ServiceRegistryConfig.create());
         registry = registryManager.registry();
     }
 
@@ -64,7 +64,7 @@ void testScopeNotAvailable() {
         SingletonContract service = serviceProvider.get();
 
         ScopeNotActiveException scopeNotAvailableException = assertThrows(ScopeNotActiveException.class, service::id);
-        assertThat(scopeNotAvailableException.scope(), is(Injection.PerRequest.TYPE));
+        assertThat(scopeNotAvailableException.scope(), is(Service.PerRequest.TYPE));
     }
 
     @Test
@@ -75,7 +75,7 @@ void testDifferentScopeDifferentValue() {
         Scopes scopes = registry.get(Scopes.class);
 
         int id;
-        try (Scope ignored = scopes.createScope(Injection.PerRequest.TYPE, "test-1", Map.of())) {
+        try (Scope ignored = scopes.createScope(Service.PerRequest.TYPE, "test-1", Map.of())) {
             id = service.id();
             assertThat("We should get a request scope based id", id, not(-1));
         }
@@ -83,9 +83,9 @@ void testDifferentScopeDifferentValue() {
         ScopeNotActiveException scopeNotAvailableException = assertThrows(ScopeNotActiveException.class, service::id);
         assertThat("We should not be in scope when it has been closed",
                    scopeNotAvailableException.scope(),
-                   is(Injection.PerRequest.TYPE));
+                   is(Service.PerRequest.TYPE));
 
-        try (Scope ignored = scopes.createScope(Injection.PerRequest.TYPE, "test-2", Map.of())) {
+        try (Scope ignored = scopes.createScope(Service.PerRequest.TYPE, "test-2", Map.of())) {
             int nextId = service.id();
             assertThat("We should get a request scope based id", nextId, not(-1));
             assertThat("We should get a different request scope than last time", nextId, not(id));
diff --git a/service/tests/inject/service-lifecycle/pom.xml b/service/tests/service-lifecycle/pom.xml
similarity index 84%
rename from service/tests/inject/service-lifecycle/pom.xml
rename to service/tests/service-lifecycle/pom.xml
index 0e384a5a9a9..018efd67a3a 100644
--- a/service/tests/inject/service-lifecycle/pom.xml
+++ b/service/tests/service-lifecycle/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-inject-tests-service-lifecycle</artifactId>
-    <name>Helidon Service Tests Inject Service Lifecycle</name>
+    <artifactId>helidon-service-tests-service-lifecycle</artifactId>
+    <name>Helidon Service Tests Service Lifecycle</name>
     <description>
         Tests for service lifecycle. This test validates that singletons are instantiated and injected just once, and at the right
         time. This test validates that non-scoped services are instantiated for each lookup, and at the right time. This test
@@ -41,14 +41,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -79,8 +71,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -97,8 +89,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContract.java b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContract.java
similarity index 93%
rename from service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContract.java
rename to service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContract.java
index 63222df7e35..b6e509f095d 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContract.java
+++ b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContractImpl.java b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContractImpl.java
similarity index 89%
rename from service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContractImpl.java
rename to service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContractImpl.java
index 27412598ad8..9552f15f471 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/AServiceContractImpl.java
+++ b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/AServiceContractImpl.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.PerLookup
+@Service.PerLookup
 class AServiceContractImpl implements AServiceContract {
     static final AtomicInteger INSTANCES = new AtomicInteger();
     static final AtomicInteger INJECTIONS = new AtomicInteger();
@@ -36,7 +36,7 @@ public InjectedService service() {
         return injectedService;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setInjectedService(InjectedService injectedService) {
         this.injectedService = injectedService;
         INJECTIONS.incrementAndGet();
diff --git a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContract.java b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContract.java
similarity index 93%
rename from service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContract.java
rename to service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContract.java
index 967d23d0ef3..2bbda2b7ce4 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContract.java
+++ b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContractImpl.java b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContractImpl.java
similarity index 89%
rename from service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContractImpl.java
rename to service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContractImpl.java
index 4620c7e9462..4ca0c879d90 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/ASingletonContractImpl.java
+++ b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/ASingletonContractImpl.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class ASingletonContractImpl implements ASingletonContract {
     static final AtomicInteger INSTANCES = new AtomicInteger();
     static final AtomicInteger INJECTIONS = new AtomicInteger();
@@ -36,7 +36,7 @@ public InjectedService service() {
         return injectedService;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setInjectedService(InjectedService injectedService) {
         this.injectedService = injectedService;
         INJECTIONS.incrementAndGet();
diff --git a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/InjectedService.java b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/InjectedService.java
similarity index 84%
rename from service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/InjectedService.java
rename to service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/InjectedService.java
index 6ca0b8972e7..ac8d0bd13e7 100644
--- a/service/tests/inject/service-lifecycle/src/main/java/io/helidon/tests/service/inject/lifecycle/InjectedService.java
+++ b/service/tests/service-lifecycle/src/main/java/io/helidon/tests/service/lifecycle/InjectedService.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 class InjectedService {
 }
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/package-info.java b/service/tests/service-lifecycle/src/main/java/module-info.java
similarity index 85%
rename from service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/package-info.java
rename to service/tests/service-lifecycle/src/main/java/module-info.java
index 5e914a90535..11957e73c23 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/package-info.java
+++ b/service/tests/service-lifecycle/src/main/java/module-info.java
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-/**
- * Code generation for Helidon Service Injection.
- */
-package io.helidon.service.inject.codegen;
+open module io.helidon.service.tests.service.lifecycle {
+    requires io.helidon.service.registry;
+}
\ No newline at end of file
diff --git a/service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleLimitPhaseTest.java b/service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleLimitPhaseTest.java
similarity index 88%
rename from service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleLimitPhaseTest.java
rename to service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleLimitPhaseTest.java
index 4e7320b35f9..895eeb28e64 100644
--- a/service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleLimitPhaseTest.java
+++ b/service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleLimitPhaseTest.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.Activator.Phase;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ActivationPhase;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryConfig;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -35,8 +35,8 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 class ServiceLifecycleLimitPhaseTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     static void initClass() {
@@ -45,9 +45,9 @@ static void initClass() {
         AServiceContractImpl.INJECTIONS.set(0);
         AServiceContractImpl.INSTANCES.set(0);
 
-        registryManager = InjectRegistryManager.create(InjectConfig.builder()
-                                                               .limitRuntimePhase(Phase.CONSTRUCTING)
-                                                               .build());
+        registryManager = ServiceRegistryManager.create(ServiceRegistryConfig.builder()
+                                                                .limitActivationPhase(ActivationPhase.CONSTRUCTING)
+                                                                .build());
         registry = registryManager.registry();
 
         assertThat(registry, notNullValue());
diff --git a/service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleTest.java b/service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleTest.java
similarity index 94%
rename from service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleTest.java
rename to service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleTest.java
index 3d897d538d7..60e2d29ad2c 100644
--- a/service/tests/inject/service-lifecycle/src/test/java/io/helidon/tests/service/inject/lifecycle/ServiceLifecycleTest.java
+++ b/service/tests/service-lifecycle/src/test/java/io/helidon/tests/service/lifecycle/ServiceLifecycleTest.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.tests.service.inject.lifecycle;
+package io.helidon.tests.service.lifecycle;
 
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -32,8 +32,8 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 
 class ServiceLifecycleTest {
-    private static InjectRegistryManager registryManager;
-    private static InjectRegistry registry;
+    private static ServiceRegistryManager registryManager;
+    private static ServiceRegistry registry;
 
     @BeforeAll
     static void initClass() {
@@ -42,7 +42,7 @@ static void initClass() {
         AServiceContractImpl.INJECTIONS.set(0);
         AServiceContractImpl.INSTANCES.set(0);
 
-        registryManager = InjectRegistryManager.create();
+        registryManager = ServiceRegistryManager.create();
         registry = registryManager.registry();
 
         assertThat(registry, notNullValue());
diff --git a/service/tests/inject/stacking/pom.xml b/service/tests/stacking/pom.xml
similarity index 84%
rename from service/tests/inject/stacking/pom.xml
rename to service/tests/stacking/pom.xml
index 95ce2725ff3..fbb67d63442 100644
--- a/service/tests/inject/stacking/pom.xml
+++ b/service/tests/stacking/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-stacking</artifactId>
-    <name>Helidon Service Tests Inject Stacking</name>
+    <artifactId>helidon-service-tests-stacking</artifactId>
+    <name>Helidon Service Tests Stacking</name>
     <description>
         Tests for service stacking. This test validates that we can have services that implement the same contract stacked.
     </description>
@@ -39,14 +39,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config</artifactId>
@@ -82,8 +74,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -100,8 +92,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContract.java b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContract.java
similarity index 95%
rename from service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContract.java
rename to service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContract.java
index c8149f2d8d5..09966665f53 100644
--- a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContract.java
+++ b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContract.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.stacking;
+package io.helidon.service.tests.stacking;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContractImpl.java b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContractImpl.java
similarity index 88%
rename from service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContractImpl.java
rename to service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContractImpl.java
index e648e42dde7..53f800ee9a1 100644
--- a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/CommonContractImpl.java
+++ b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/CommonContractImpl.java
@@ -14,22 +14,22 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.stacking;
+package io.helidon.service.tests.stacking;
 
 import java.util.Optional;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
-@Injection.RunLevel(1)
+@Service.Singleton
+@Service.RunLevel(1)
 @Weight(Weighted.DEFAULT_WEIGHT + 1)
 public class CommonContractImpl implements CommonContract {
 
     private final CommonContract inner;
 
-    @Injection.Inject
+    @Service.Inject
     public CommonContractImpl(Optional<CommonContract> inner) {
         this.inner = inner.orElse(null);
     }
diff --git a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/MostOuterCommonContractImpl.java b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/MostOuterCommonContractImpl.java
similarity index 86%
rename from service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/MostOuterCommonContractImpl.java
rename to service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/MostOuterCommonContractImpl.java
index 3798a2889f1..faa7796c114 100644
--- a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/MostOuterCommonContractImpl.java
+++ b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/MostOuterCommonContractImpl.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.stacking;
+package io.helidon.service.tests.stacking;
 
 import java.util.Optional;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 3)
 public class MostOuterCommonContractImpl extends OuterCommonContractImpl {
 
-    @Injection.Inject
+    @Service.Inject
     public MostOuterCommonContractImpl(Optional<CommonContract> inner) {
         super(inner);
     }
diff --git a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/OuterCommonContractImpl.java b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/OuterCommonContractImpl.java
similarity index 86%
rename from service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/OuterCommonContractImpl.java
rename to service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/OuterCommonContractImpl.java
index c534b6f182f..318df2483e9 100644
--- a/service/tests/inject/stacking/src/main/java/io/helidon/service/tests/inject/stacking/OuterCommonContractImpl.java
+++ b/service/tests/stacking/src/main/java/io/helidon/service/tests/stacking/OuterCommonContractImpl.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.stacking;
+package io.helidon.service.tests.stacking;
 
 import java.util.Optional;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 2)
 public class OuterCommonContractImpl extends CommonContractImpl {
 
-    @Injection.Inject
+    @Service.Inject
     public OuterCommonContractImpl(Optional<CommonContract> inner) {
         super(inner);
     }
diff --git a/service/tests/stacking/src/main/java/module-info.java b/service/tests/stacking/src/main/java/module-info.java
new file mode 100644
index 00000000000..95259d0ad53
--- /dev/null
+++ b/service/tests/stacking/src/main/java/module-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module io.helidon.service.tests.stacking {
+    requires io.helidon.service.registry;
+
+    exports io.helidon.service.tests.stacking;
+}
\ No newline at end of file
diff --git a/service/tests/inject/toolbox/pom.xml b/service/tests/toolbox/pom.xml
similarity index 82%
rename from service/tests/inject/toolbox/pom.xml
rename to service/tests/toolbox/pom.xml
index 84c7f654273..c7489098aeb 100644
--- a/service/tests/inject/toolbox/pom.xml
+++ b/service/tests/toolbox/pom.xml
@@ -21,15 +21,15 @@
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <groupId>io.helidon.service.tests.inject</groupId>
-        <artifactId>helidon-service-tests-inject-project</artifactId>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
         <version>4.2.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>helidon-service-tests-inject-toolbox</artifactId>
-    <name>Helidon Service Tests Inject Toolbox</name>
+    <artifactId>helidon-service-tests-toolbox</artifactId>
+    <name>Helidon Service Tests Toolbox</name>
     <description>Tests for a more complex set of services</description>
 
     <dependencies>
@@ -37,14 +37,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
-        </dependency>
         <dependency>
             <!-- must be in compile scope, so we generate application for it -->
             <groupId>io.helidon.config</groupId>
@@ -69,11 +61,6 @@
             <artifactId>helidon-common-testing-junit5</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.metrics</groupId>
-            <artifactId>helidon-metrics</artifactId>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>
@@ -89,8 +76,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -107,8 +94,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
@@ -142,8 +129,8 @@
                 </executions>
             </plugin>
             <plugin>
-                <groupId>io.helidon.service.inject</groupId>
-                <artifactId>helidon-service-inject-maven-plugin</artifactId>
+                <groupId>io.helidon.service</groupId>
+                <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${helidon.version}</version>
                 <executions>
                     <execution>
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractBlade.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractBlade.java
similarity index 86%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractBlade.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractBlade.java
index 36ca0a4108d..de38ad4bd9d 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractBlade.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractBlade.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 public abstract class AbstractBlade {
 
     // intended to be a void injection point
-    @Injection.Inject
+    @Service.Inject
     protected AbstractBlade() {
     }
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractSaw.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
similarity index 82%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractSaw.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
index 4fd55c3e8a8..cbca92c23db 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/AbstractSaw.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
@@ -14,27 +14,26 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
-import io.helidon.service.tests.inject.toolbox.impl.DullBlade;
+import io.helidon.service.tests.toolbox.impl.DullBlade;
 
 @Service.Contract
 public abstract class AbstractSaw extends Verification implements Tool {
-    @Injection.Inject protected Supplier<AbstractBlade> fieldInjectedProtectedProviderInAbstractBase;
-    @Injection.Inject protected Optional<AbstractBlade> fieldInjectedProtectedOptionalInAbstractBase;
-    @Injection.Inject protected List<AbstractBlade> fieldInjectedProtectedListInAbstractBase;
-    @Injection.Inject protected List<AbstractBlade> fieldInjectedProtectedProviderListInAbstractBase;
+    @Service.Inject protected Supplier<AbstractBlade> fieldInjectedProtectedProviderInAbstractBase;
+    @Service.Inject protected Optional<AbstractBlade> fieldInjectedProtectedOptionalInAbstractBase;
+    @Service.Inject protected List<AbstractBlade> fieldInjectedProtectedListInAbstractBase;
+    @Service.Inject protected List<AbstractBlade> fieldInjectedProtectedProviderListInAbstractBase;
 
-    @Injection.Inject Supplier<AbstractBlade> fieldInjectedPkgPrivateProviderInAbstractBase;
-    @Injection.Inject Optional<AbstractBlade> fieldInjectedPkgPrivateOptionalInAbstractBase;
-    @Injection.Inject List<AbstractBlade> fieldInjectedPkgPrivateListInAbstractBase;
-    @Injection.Inject List<Supplier<AbstractBlade>> fieldInjectedPkgPrivateProviderListInAbstractBase;
+    @Service.Inject Supplier<AbstractBlade> fieldInjectedPkgPrivateProviderInAbstractBase;
+    @Service.Inject Optional<AbstractBlade> fieldInjectedPkgPrivateOptionalInAbstractBase;
+    @Service.Inject List<AbstractBlade> fieldInjectedPkgPrivateListInAbstractBase;
+    @Service.Inject List<Supplier<AbstractBlade>> fieldInjectedPkgPrivateProviderListInAbstractBase;
 
     Supplier<AbstractBlade> setterInjectedPkgPrivateProviderInAbstractBase;
     Optional<AbstractBlade> setterInjectedPkgPrivateOptionalInAbstractBase;
@@ -46,7 +45,7 @@ public abstract class AbstractSaw extends Verification implements Tool {
     int setterInjectedPkgPrivateListInAbstractBaseInjectedCount;
     int setterInjectedPkgPrivateProviderListInAbstractBaseInjectedCount;
 
-    @Injection.Inject
+    @Service.Inject
     public void setBladeProviders(List<Supplier<AbstractBlade>> blades) {
         setterInjectedPkgPrivateProviderListInAbstractBase = blades;
         setterInjectedPkgPrivateProviderListInAbstractBaseInjectedCount++;
@@ -87,19 +86,19 @@ public void verifyState() {
                 + ".fieldInjectedPkgPrivateProviderListInAbstractBase", null, 1, Supplier.class);
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeProvider(Supplier<AbstractBlade> blade) {
         setterInjectedPkgPrivateProviderInAbstractBase = blade;
         setterInjectedPkgPrivateProviderInAbstractBaseInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeOptional(Optional<AbstractBlade> blade) {
         setterInjectedPkgPrivateOptionalInAbstractBase = blade;
         setterInjectedPkgPrivateOptionalInAbstractBaseInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeList(List<AbstractBlade> blades) {
         setterInjectedPkgPrivateListInAbstractBase = blades;
         setterInjectedPkgPrivateListInAbstractBaseInjectedCount++;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Awl.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Awl.java
similarity index 93%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Awl.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Awl.java
index f4b167f3b49..4f97cef153f 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Awl.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Awl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Hammer.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Hammer.java
similarity index 93%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Hammer.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Hammer.java
index 7365bbdf0b8..49f1d6cca98 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Hammer.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Hammer.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Lubricant.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Lubricant.java
similarity index 93%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Lubricant.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Lubricant.java
index d705537d49f..b1685a94cea 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Lubricant.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Lubricant.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 /**
  * Testing.
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Preferred.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Preferred.java
similarity index 89%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Preferred.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Preferred.java
index ecb82dfffd6..9357880b045 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Preferred.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Preferred.java
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
-import io.helidon.service.inject.api.Injection;
+import io.helidon.service.registry.Service;
 
 /**
  * Custom qualifier.
  */
-@Injection.Qualifier
+@Service.Qualifier
 @Documented
 @Retention(RetentionPolicy.CLASS)
 public @interface Preferred {
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/SomeOtherLocalNonContractInterface1.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/SomeOtherLocalNonContractInterface1.java
similarity index 93%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/SomeOtherLocalNonContractInterface1.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/SomeOtherLocalNonContractInterface1.java
index a77e623c517..b1a6af41d8f 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/SomeOtherLocalNonContractInterface1.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/SomeOtherLocalNonContractInterface1.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 /**
  * Testing.
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/TableSaw.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
similarity index 88%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/TableSaw.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
index ffa48756b2d..e28160108cf 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/TableSaw.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
@@ -14,36 +14,36 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.impl.CoarseBlade;
-import io.helidon.service.tests.inject.toolbox.impl.DullBlade;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.impl.CoarseBlade;
+import io.helidon.service.tests.toolbox.impl.DullBlade;
 
 /**
  * Intentionally in the same package as {AbstractSaw}.
  */
-@Injection.Singleton
+@Service.Singleton
 class TableSaw extends AbstractSaw {
 
-    @Injection.Inject
-    @Injection.Named(CoarseBlade.NAME)
+    @Service.Inject
+    @Service.Named(CoarseBlade.NAME)
     Supplier<AbstractBlade> coarseBladeFieldInjectedPkgPrivateProviderInSubClass;
 
-    @Injection.Inject
-    @Injection.Named(CoarseBlade.NAME)
+    @Service.Inject
+    @Service.Named(CoarseBlade.NAME)
     Optional<AbstractBlade> coarseBladeFieldInjectedPkgPrivateOptionalInSubClass;
 
-    @Injection.Inject
-    @Injection.Named(CoarseBlade.NAME)
+    @Service.Inject
+    @Service.Named(CoarseBlade.NAME)
     List<AbstractBlade> coarseBladeFieldInjectedPkgPrivateListInSubClass;
 
-    @Injection.Inject
-    @Injection.Named(CoarseBlade.NAME)
+    @Service.Inject
+    @Service.Named(CoarseBlade.NAME)
     List<Supplier<AbstractBlade>> coarseBladeFieldInjectedPkgPrivateProviderListInSubClass;
 
     Supplier<AbstractBlade> setterInjectedPkgPrivateProviderInSubClass;
@@ -61,7 +61,7 @@ class TableSaw extends AbstractSaw {
     TableSaw() {
     }
 
-    @Injection.Inject
+    @Service.Inject
     public TableSaw(Optional<Lubricant> lubricant) {
         ctorInjectedLubricantInSubClass = lubricant;
     }
@@ -111,31 +111,31 @@ public void verifyState() {
         super.verifyState();
     }
 
-    @Injection.Inject
+    @Service.Inject
     protected void injectLubricant(Optional<Lubricant> lubricant) {
         setterInjectedLubricantInSubClass = lubricant;
         setterInjectedLubricantInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeProviderInSubclass(Supplier<AbstractBlade> blade) {
         setterInjectedPkgPrivateProviderInSubClass = blade;
         setterInjectedPkgPrivateProviderInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeOptionalInSubclass(Optional<AbstractBlade> blade) {
         setterInjectedPkgPrivateOptionalInSubClass = blade;
         setterInjectedPkgPrivateOptionalInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
-    void setAllBladesInSubclass(@Injection.Named("*") List<AbstractBlade> blades) {
+    @Service.Inject
+    void setAllBladesInSubclass(@Service.Named("*") List<AbstractBlade> blades) {
         setterInjectedPkgPrivateListInSubClass = blades;
         setterInjectedPkgPrivateListInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeProviderListInSubclass(List<Supplier<AbstractBlade>> blades) {
         setterInjectedPkgPrivateProviderListInSubClass = blades;
         setterInjectedPkgPrivateProviderListInSubClassInjectedCount++;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Tool.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Tool.java
similarity index 94%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Tool.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Tool.java
index 7c28f79e03d..13ade79bceb 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Tool.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Tool.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import io.helidon.service.registry.Service;
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/ToolBox.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
similarity index 95%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/ToolBox.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
index b672afa8c99..7581ca9ecfc 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/ToolBox.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.util.List;
 import java.util.function.Supplier;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Verification.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Verification.java
similarity index 99%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Verification.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Verification.java
index a77b59bbf1c..678f6a38da4 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/Verification.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/Verification.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.util.List;
 import java.util.Objects;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/AwlImpl.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/AwlImpl.java
similarity index 79%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/AwlImpl.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/AwlImpl.java
index 8de51278704..136426be2d9 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/AwlImpl.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/AwlImpl.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.Awl;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.Awl;
 
-@Injection.Singleton
+@Service.Singleton
 public class AwlImpl implements Awl {
-    @Injection.Inject
+    @Service.Inject
     AwlImpl() {
     }
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BigHammer.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BigHammer.java
similarity index 77%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BigHammer.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BigHammer.java
index ca26e078c44..2a00f633882 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BigHammer.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BigHammer.java
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.Hammer;
-import io.helidon.service.tests.inject.toolbox.Preferred;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.Hammer;
+import io.helidon.service.tests.toolbox.Preferred;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 1)
-@Injection.Named(BigHammer.NAME)
+@Service.Named(BigHammer.NAME)
 @Preferred
 public class BigHammer implements Hammer {
 
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BladeProvider.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BladeProvider.java
similarity index 86%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BladeProvider.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BladeProvider.java
index d73b65129e5..77097adacbd 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/BladeProvider.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/BladeProvider.java
@@ -14,25 +14,25 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Injection.InjectionPointFactory;
-import io.helidon.service.inject.api.Injection.QualifiedInstance;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.inject.api.Qualifier;
-import io.helidon.service.tests.inject.toolbox.AbstractBlade;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.Service.InjectionPointFactory;
+import io.helidon.service.registry.Service.QualifiedInstance;
+import io.helidon.service.tests.toolbox.AbstractBlade;
 
 /**
  * Provides contextual injection for blades.
  */
-@Injection.Singleton
-@Injection.Named("*")
+@Service.Singleton
+@Service.Named("*")
 public class BladeProvider implements InjectionPointFactory<AbstractBlade> {
 
     static final Qualifier QUALIFIER_ALL = Qualifier.WILDCARD_NAMED;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/CoarseBlade.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/CoarseBlade.java
similarity index 78%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/CoarseBlade.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/CoarseBlade.java
index 2eaf796bf69..62f5448e9aa 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/CoarseBlade.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/CoarseBlade.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.AbstractBlade;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.AbstractBlade;
 
-@Injection.Named(CoarseBlade.NAME)
+@Service.Named(CoarseBlade.NAME)
 public class CoarseBlade extends AbstractBlade {
 
     public static final String NAME = "coarse";
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/DullBlade.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/DullBlade.java
similarity index 79%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/DullBlade.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/DullBlade.java
index d2dae20cc95..17223769b5d 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/DullBlade.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/DullBlade.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.AbstractBlade;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.AbstractBlade;
 
 /**
  * When a particular blade name is not "asked for" explicitly then we give out a dull blade.
  */
-@Injection.Named("dull blade")
+@Service.Named("dull blade")
 public class DullBlade extends AbstractBlade {
 
 }
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/FineBlade.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/FineBlade.java
similarity index 78%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/FineBlade.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/FineBlade.java
index 0a4d4d4af39..b5eeabdad97 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/FineBlade.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/FineBlade.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.AbstractBlade;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.AbstractBlade;
 
-@Injection.Named(FineBlade.NAME)
+@Service.Named(FineBlade.NAME)
 public class FineBlade extends AbstractBlade {
 
     static final String NAME = "fine";
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/HandSaw.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/HandSaw.java
similarity index 84%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/HandSaw.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/HandSaw.java
index d2a12b0dd4b..cd98851fc3a 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/HandSaw.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/HandSaw.java
@@ -14,27 +14,27 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.AbstractBlade;
-import io.helidon.service.tests.inject.toolbox.AbstractSaw;
-import io.helidon.service.tests.inject.toolbox.Lubricant;
-import io.helidon.service.tests.inject.toolbox.Verification;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.AbstractBlade;
+import io.helidon.service.tests.toolbox.AbstractSaw;
+import io.helidon.service.tests.toolbox.Lubricant;
+import io.helidon.service.tests.toolbox.Verification;
 
 /**
  * Kept intentionally in a different package from {@link AbstractSaw} for testing.
  */
-@Injection.Singleton
+@Service.Singleton
 public class HandSaw extends AbstractSaw {
 
-    @Injection.Inject @Injection.Named(FineBlade.NAME) Supplier<AbstractBlade> fineBladeFieldInjectedPkgPrivateProviderInSubClass;
-    @Injection.Inject @Injection.Named(FineBlade.NAME) Optional<AbstractBlade> fineBladeFieldInjectedPkgPrivateOptionalInSubClass;
-    @Injection.Inject @Injection.Named(FineBlade.NAME) List<AbstractBlade> fineBladeFieldInjectedPkgPrivateListInSubClass;
+    @Service.Inject @Service.Named(FineBlade.NAME) Supplier<AbstractBlade> fineBladeFieldInjectedPkgPrivateProviderInSubClass;
+    @Service.Inject @Service.Named(FineBlade.NAME) Optional<AbstractBlade> fineBladeFieldInjectedPkgPrivateOptionalInSubClass;
+    @Service.Inject @Service.Named(FineBlade.NAME) List<AbstractBlade> fineBladeFieldInjectedPkgPrivateListInSubClass;
     Supplier<AbstractBlade> setterInjectedPkgPrivateProviderInSubClass;
     Optional<AbstractBlade> setterInjectedPkgPrivateOptionalInSubClass;
     List<AbstractBlade> setterInjectedPkgPrivateListInSubClass;
@@ -50,7 +50,7 @@ public class HandSaw extends AbstractSaw {
     HandSaw() {
     }
 
-    @Injection.Inject
+    @Service.Inject
     public HandSaw(Optional<Lubricant> lubricant) {
         ctorInjectedLubricantInSubClass = lubricant;
     }
@@ -98,25 +98,25 @@ public void verifyState() {
         super.verifyState();
     }
 
-    @Injection.Inject
+    @Service.Inject
     protected void injectLubricant(Optional<Lubricant> lubricant) {
         setterInjectedLubricantInSubClass = lubricant;
         setterInjectedLubricantInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeProvider(Supplier<AbstractBlade> blade) {
         setterInjectedPkgPrivateProviderInSubClass = blade;
         setterInjectedPkgPrivateProviderInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeOptional(Optional<AbstractBlade> blade) {
         setterInjectedPkgPrivateOptionalInSubClass = blade;
         setterInjectedPkgPrivateOptionalInSubClassInjectedCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setBladeList(List<AbstractBlade> blades) {
         setterInjectedPkgPrivateListInSubClass = blades;
         setterInjectedPkgPrivateListInSubClassInjectedCount++;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/LittleHammer.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/LittleHammer.java
similarity index 78%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/LittleHammer.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/LittleHammer.java
index 9e5c55253c7..820dde433a7 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/LittleHammer.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/LittleHammer.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.Hammer;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.Hammer;
 
-@Injection.Singleton
-@Injection.Named(LittleHammer.NAME)
+@Service.Singleton
+@Service.Named(LittleHammer.NAME)
 public class LittleHammer implements Hammer {
 
     public static final String NAME = "little";
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/MainToolBox.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
similarity index 82%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/MainToolBox.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
index 1c80be1e943..a8658e127f8 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/MainToolBox.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
@@ -14,21 +14,20 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Supplier;
 
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
-import io.helidon.service.tests.inject.toolbox.Hammer;
-import io.helidon.service.tests.inject.toolbox.Preferred;
-import io.helidon.service.tests.inject.toolbox.Tool;
-import io.helidon.service.tests.inject.toolbox.ToolBox;
+import io.helidon.service.tests.toolbox.Hammer;
+import io.helidon.service.tests.toolbox.Preferred;
+import io.helidon.service.tests.toolbox.Tool;
+import io.helidon.service.tests.toolbox.ToolBox;
 
 @SuppressWarnings("unused")
-@Injection.Singleton
+@Service.Singleton
 public class MainToolBox implements ToolBox {
 
     private final List<Supplier<Tool>> allTools;
@@ -38,15 +37,15 @@ public class MainToolBox implements ToolBox {
     public int postConstructCallCount;
     public int preDestroyCallCount;
     public int setterCallCount;
-    @Injection.Inject
+    @Service.Inject
     @Preferred
     Supplier<Hammer> preferredHammer;
     private Supplier<Hammer> setPreferredHammer;
 
-    @Injection.Inject
+    @Service.Inject
     MainToolBox(List<Supplier<Tool>> allTools,
                 Screwdriver screwdriver,
-                @Injection.Named("big") Supplier<Hammer> bigHammer,
+                @Service.Named("big") Supplier<Hammer> bigHammer,
                 List<Supplier<Hammer>> allHammers) {
         this.allTools = Objects.requireNonNull(allTools);
         this.screwdriver = Objects.requireNonNull(screwdriver);
@@ -76,13 +75,13 @@ public Screwdriver screwdriver() {
         return screwdriver;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setScrewdriver(Screwdriver screwdriver) {
         assert (this.screwdriver == screwdriver);
         setterCallCount++;
     }
 
-    @Injection.Inject
+    @Service.Inject
     void setPreferredHammer(@Preferred Supplier<Hammer> hammer) {
         this.setPreferredHammer = hammer;
     }
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/Screwdriver.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/Screwdriver.java
similarity index 76%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/Screwdriver.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/Screwdriver.java
index 5edba839c24..68377264e23 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/Screwdriver.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/Screwdriver.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import java.io.Serializable;
 
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.SomeOtherLocalNonContractInterface1;
-import io.helidon.service.tests.inject.toolbox.Tool;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.SomeOtherLocalNonContractInterface1;
+import io.helidon.service.tests.toolbox.Tool;
 
-@Injection.Singleton
+@Service.Singleton
 public class Screwdriver implements Tool, SomeOtherLocalNonContractInterface1, Serializable {
 
     @Override
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/SledgeHammer.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/SledgeHammer.java
similarity index 84%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/SledgeHammer.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/SledgeHammer.java
index 4358b130160..ad1762051e2 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/SledgeHammer.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/SledgeHammer.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox.impl;
 
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.tests.inject.toolbox.Hammer;
+import io.helidon.service.registry.Service;
+import io.helidon.service.tests.toolbox.Hammer;
 
-@Injection.Singleton
+@Service.Singleton
 @Weight(Weighted.DEFAULT_WEIGHT + 2)
 //@Named(SledgeHammer.NAME)
 public class SledgeHammer implements Hammer {
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/package-info.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/package-info.java
similarity index 92%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/package-info.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/package-info.java
index e895c13941c..85a5c86f61e 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/package-info.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/package-info.java
@@ -17,4 +17,4 @@
 /**
  * Testing.
  */
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox.impl;
diff --git a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/package-info.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/package-info.java
similarity index 92%
rename from service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/package-info.java
rename to service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/package-info.java
index a70d42e0eb4..eb01ed71fe0 100644
--- a/service/tests/inject/toolbox/src/main/java/io/helidon/service/tests/inject/toolbox/impl/package-info.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/package-info.java
@@ -17,4 +17,4 @@
 /**
  * Testing.
  */
-package io.helidon.service.tests.inject.toolbox.impl;
+package io.helidon.service.tests.toolbox;
diff --git a/service/tests/inject/lookup/src/main/java/module-info.java b/service/tests/toolbox/src/main/java/module-info.java
similarity index 73%
rename from service/tests/inject/lookup/src/main/java/module-info.java
rename to service/tests/toolbox/src/main/java/module-info.java
index 0dce7930575..c0b5e41d5a4 100644
--- a/service/tests/inject/lookup/src/main/java/module-info.java
+++ b/service/tests/toolbox/src/main/java/module-info.java
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
-module io.helidon.service.tests.inject.lookup {
+module io.helidon.service.tests.toolbox {
     requires io.helidon.service.registry;
-    requires io.helidon.service.inject.api;
-    requires io.helidon.service.inject;
 
-    exports io.helidon.service.inject.tests.lookup;
+    requires io.helidon.config;
+    requires io.helidon.config.yaml;
+
+    exports io.helidon.service.tests.toolbox;
+    exports io.helidon.service.tests.toolbox.impl to io.helidon.service.registry;
 }
\ No newline at end of file
diff --git a/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java b/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
similarity index 71%
rename from service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java
rename to service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
index 974c976e4c0..58b5c1f62b3 100644
--- a/service/tests/inject/toolbox/src/test/java/io/helidon/service/tests/inject/toolbox/ToolBoxTest.java
+++ b/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
@@ -14,31 +14,25 @@
  * limitations under the License.
  */
 
-package io.helidon.service.tests.inject.toolbox;
+package io.helidon.service.tests.toolbox;
 
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.function.Supplier;
 
 import io.helidon.common.types.TypeName;
-import io.helidon.metrics.api.Counter;
-import io.helidon.metrics.api.MeterRegistry;
-import io.helidon.metrics.api.Metrics;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.FactoryType;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.InjectServiceInfo;
-import io.helidon.service.inject.api.Lookup;
-import io.helidon.service.tests.inject.toolbox.impl.BigHammer;
-import io.helidon.service.tests.inject.toolbox.impl.MainToolBox;
+import io.helidon.service.registry.FactoryType;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.ServiceInfo;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.service.tests.toolbox.impl.BigHammer;
+import io.helidon.service.tests.toolbox.impl.MainToolBox;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
-import static io.helidon.common.testing.junit5.OptionalMatcher.optionalPresent;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
@@ -53,14 +47,12 @@
  * Expectation here is that the annotation processor ran, and we can use standard injection and di registry services, etc.
  */
 class ToolBoxTest {
-    private static final MeterRegistry METER_REGISTRY = Metrics.globalRegistry();
-
-    private InjectRegistryManager registryManager;
-    private InjectRegistry registry;
+    private ServiceRegistryManager registryManager;
+    private ServiceRegistry registry;
 
     @BeforeEach
     void setUp() {
-        this.registryManager = InjectRegistryManager.create();
+        this.registryManager = ServiceRegistryManager.create();
         this.registry = registryManager.registry();
     }
 
@@ -79,10 +71,10 @@ void sanity() {
 
     @Test
     void toolbox() {
-        List<InjectServiceInfo> blanks = registry.lookupServices(Lookup.create(Awl.class));
+        List<ServiceInfo> blanks = registry.lookupServices(Lookup.create(Awl.class));
         assertThat(blanks, hasSize(1));
 
-        List<InjectServiceInfo> allToolBoxes = registry.lookupServices(Lookup.create(ToolBox.class));
+        List<ServiceInfo> allToolBoxes = registry.lookupServices(Lookup.create(ToolBox.class));
         assertThat(allToolBoxes, hasSize(1));
 
         ToolBox toolBox = registry.get(ToolBox.class);
@@ -129,8 +121,9 @@ void toolbox() {
     }
 
     /**
-     * Targets {@link AbstractSaw} with derived classes of
-     * {@link io.helidon.service.tests.inject.toolbox.impl.HandSaw} and {@link TableSaw} found in different packages.
+     * Targets {@link io.helidon.service.tests.toolbox.AbstractSaw} with derived classes of
+     * {@link io.helidon.service.tests.toolbox.impl.HandSaw} and {@link io.helidon.service.tests.toolbox.TableSaw} found in
+     * different packages.
      */
     @Test
     void hierarchyOfInjections() {
@@ -150,17 +143,17 @@ void hierarchyOfInjections() {
      * This assumes the presence of module(s) + application(s) to handle all bindings, with effectively no lookups!
      */
     @Test
-    void noServiceActivationRequiresLookupWhenApplicationIsPresent() {
-        Counter counter = lookupCounter();
-        long initialCount = counter.count();
+    void noServiceActivationRequiresLookupWhenBindingIsPresent() {
+
+        int initialCount = registry.metrics().lookupCount();
 
-        List<InjectServiceInfo> allServices = registry.lookupServices(Lookup.EMPTY);
+        List<ServiceInfo> allServices = registry.lookupServices(Lookup.EMPTY);
         // one lookup on previous line
-        long postLookupCount = counter.count();
-        assertThat((postLookupCount - initialCount), is(1L));
+        int postLookupCount = registry.metrics().lookupCount();
+        assertThat((postLookupCount - initialCount), is(1));
 
         // now lookup of each service should increase the counter by exactly one (i.e. no lookups for injection points)
-        for (InjectServiceInfo service : allServices) {
+        for (ServiceInfo service : allServices) {
             postLookupCount++;
             try {
                 registry.supply(service.serviceType())
@@ -170,16 +163,16 @@ void noServiceActivationRequiresLookupWhenApplicationIsPresent() {
                 // still should not lookup
             }
             assertThat("Activation should not have triggered any lookups (for singletons): "
-                               + service.descriptorType().fqName() + " triggered lookups", counter.count(),
+                               + service.descriptorType().fqName() + " triggered lookups", registry.metrics().lookupCount(),
                        equalTo(postLookupCount));
         }
     }
 
     @Test
     void knownIpProviders() {
-        List<InjectServiceInfo> services = this.registry.lookupServices(Lookup.builder()
-                                                                                .addFactoryType(FactoryType.INJECTION_POINT)
-                                                                                .build());
+        List<ServiceInfo> services = this.registry.lookupServices(Lookup.builder()
+                                                                          .addFactoryType(FactoryType.INJECTION_POINT)
+                                                                          .build());
         List<String> desc = toSimpleTypes(services);
 
         // this list must only InjectionPointProviders
@@ -194,16 +187,10 @@ private List<String> toSimpleClassNames(List<?> listOfObjects) {
                 .toList();
     }
 
-    private List<String> toSimpleTypes(List<InjectServiceInfo> providers) {
+    private List<String> toSimpleTypes(List<ServiceInfo> providers) {
         return providers.stream()
-                .map(InjectServiceInfo::serviceType)
+                .map(ServiceInfo::serviceType)
                 .map(TypeName::className)
                 .toList();
     }
-
-    private Counter lookupCounter() {
-        Optional<Counter> counterMeter = METER_REGISTRY.counter("io.helidon.inject.lookups", List.of());
-        assertThat(counterMeter, optionalPresent());
-        return counterMeter.get();
-    }
 }
diff --git a/tests/integration/packaging/inject/pom.xml b/tests/integration/packaging/inject/pom.xml
index 8ff5638e904..233ad264b6e 100644
--- a/tests/integration/packaging/inject/pom.xml
+++ b/tests/integration/packaging/inject/pom.xml
@@ -48,12 +48,8 @@
             <artifactId>helidon-config-yaml</artifactId>
         </dependency>
         <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service.inject</groupId>
-            <artifactId>helidon-service-inject</artifactId>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
         </dependency>
         <dependency>
             <groupId>io.helidon.logging</groupId>
@@ -134,8 +130,8 @@
                             <version>${helidon.version}</version>
                         </path>
                         <path>
-                            <groupId>io.helidon.service.inject</groupId>
-                            <artifactId>helidon-service-inject-codegen</artifactId>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
                             <version>${helidon.version}</version>
                         </path>
                         <path>
@@ -152,8 +148,8 @@
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
-                        <groupId>io.helidon.service.inject</groupId>
-                        <artifactId>helidon-service-inject-codegen</artifactId>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
                         <version>${helidon.version}</version>
                     </dependency>
                     <dependency>
diff --git a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/GreetFeature.java b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/GreetFeature.java
index 04936bb8e48..dcf7d9bc0b5 100644
--- a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/GreetFeature.java
+++ b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/GreetFeature.java
@@ -16,8 +16,7 @@
 
 package io.helidon.tests.integration.packaging.inject;
 
-import io.helidon.service.inject.api.Configuration;
-import io.helidon.service.inject.api.Injection;
+import io.helidon.common.config.Config;
 import io.helidon.service.registry.Service;
 import io.helidon.webserver.http.HttpFeature;
 import io.helidon.webserver.http.HttpRouting;
@@ -28,7 +27,7 @@
 /**
  * A simple service to greet you.
  */
-@Injection.Singleton
+@Service.Singleton
 @Service.ExternalContracts(HttpFeature.class)
 class GreetFeature implements HttpFeature {
 
@@ -37,8 +36,8 @@ class GreetFeature implements HttpFeature {
      */
     private final String greeting;
 
-    GreetFeature(@Configuration.Value("app.greeting:Ciao") String greetingValue) {
-        this.greeting = greetingValue;
+    GreetFeature(Config config) {
+        this.greeting = config.get("app.greeting").asString().orElse("Ciao");
     }
 
     @Override
diff --git a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
index c778ebfdd66..13a36b89bc7 100644
--- a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
+++ b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
@@ -19,14 +19,16 @@
 import io.helidon.common.config.Config;
 import io.helidon.common.config.GlobalConfig;
 import io.helidon.logging.common.LogConfig;
-import io.helidon.service.inject.InjectRegistryManager;
-import io.helidon.service.inject.api.InjectRegistry;
-import io.helidon.service.inject.api.Injection;
-import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.Lookup;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
 
 /**
  * We must provide a main class when using modularized jar file with main class attribute,
  * as we cannot use a main class from another module (at least not easily).
+ * <p>
+ * This should be replaced once the maven plugin fully supports main classes (if..).
  */
 public class Main {
     static {
@@ -40,10 +42,10 @@ public static void main(String[] args) {
         Config config = GlobalConfig.config();
         GlobalConfig.config(() -> config);
 
-        InjectRegistry registry = InjectRegistryManager.create()
+        ServiceRegistry registry = ServiceRegistryManager.create()
                 .registry();
         registry.get(Lookup.builder()
-                             .runLevel(Injection.RunLevel.SERVER)
+                             .runLevel(Service.RunLevel.SERVER)
                              .build());
     }
 }
diff --git a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/ServerStarter.java b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/ServerStarter.java
index 810666011d0..0a61a3c413a 100644
--- a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/ServerStarter.java
+++ b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/ServerStarter.java
@@ -20,7 +20,6 @@
 import java.util.function.Supplier;
 
 import io.helidon.common.config.Config;
-import io.helidon.service.inject.api.Injection;
 import io.helidon.service.registry.Service;
 import io.helidon.webserver.WebServer;
 import io.helidon.webserver.http.HttpFeature;
@@ -28,15 +27,15 @@
 /**
  * This will eventually be part of Helidon WebServer
  */
-@Injection.Singleton
-@Injection.RunLevel(Injection.RunLevel.SERVER)
+@Service.Singleton
+@Service.RunLevel(Service.RunLevel.SERVER)
 class ServerStarter {
     private final Supplier<Config> config;
     private final Supplier<List<HttpFeature>> features;
 
     private volatile WebServer server;
 
-    @Injection.Inject
+    @Service.Inject
     ServerStarter(Supplier<Config> config, Supplier<List<HttpFeature>> features) {
         this.config = config;
         this.features = features;
diff --git a/tests/integration/packaging/inject/src/main/java/module-info.java b/tests/integration/packaging/inject/src/main/java/module-info.java
index 7fe479296d7..07302371db0 100644
--- a/tests/integration/packaging/inject/src/main/java/module-info.java
+++ b/tests/integration/packaging/inject/src/main/java/module-info.java
@@ -17,7 +17,7 @@
 module io.helidon.tests.integration.packaging.inject {
     requires io.helidon.webserver;
     requires io.helidon;
-    requires io.helidon.service.inject;
+    requires io.helidon.service.registry;
     requires io.helidon.logging.common;
 
     exports io.helidon.tests.integration.packaging.inject;

From 7497e67db10f7da799ed72a0f2aca086feee21ea Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 10 Dec 2024 15:05:24 +0100
Subject: [PATCH 12/23] Single registry. Cleaned up dependencies. Support for
 registry in builder.

---
 all/pom.xml                                   |   4 -
 bom/pom.xml                                   |   5 -
 builder/api/pom.xml                           |   5 -
 .../java/io/helidon/builder/api/Option.java   |  11 +-
 .../io/helidon/builder/api/Prototype.java     | 105 +-----
 .../io/helidon/builder/api/ProvidedUtil.java  | 328 -----------------
 builder/api/src/main/java/module-info.java    |   3 -
 .../builder/codegen/AnnotationDataOption.java |   4 +
 .../builder/codegen/BuilderCodegen.java       | 103 +-----
 .../builder/codegen/CustomMethods.java        |  34 +-
 .../codegen/GenerateAbstractBuilder.java      | 114 +++++-
 .../codegen/TypeHandlerCollection.java        |   9 +-
 .../io/helidon/builder/codegen/Types.java     |   8 +-
 .../codegen/src/main/java/module-info.java    |   1 -
 .../processor/GenerateAbstractBuilder.java    |   4 +-
 .../io/helidon/builder/processor/Types.java   |   5 +-
 builder/tests/builder/pom.xml                 |   4 -
 .../WithProviderRegistryBlueprint.java        |  10 +-
 .../builder/src/main/java/module-info.java    |   1 -
 .../builder/test/ProviderRegistryTest.java    |  15 +-
 builder/tests/codegen/pom.xml                 |   5 -
 .../io/helidon/builder/codegen/TypesTest.java |  10 +-
 .../common/types/ElementSignature.java        |  33 ++
 .../io/helidon/common/types/ResolvedType.java |   7 +
 .../common/types/ResolvedTypeImpl.java        |   5 +
 .../helidon/common/types/TypeNameSupport.java |   6 +
 .../io/helidon/common/types/TypeNames.java    |  12 +
 .../types/TypedElementInfoBlueprint.java      |   9 +
 .../helidon/codegen/apt/AptTypeFactory.java   |   5 +
 .../codegen/apt/AptTypeInfoFactory.java       |  14 +
 .../codegen/classmodel/TypeArgument.java      |  18 +
 common/config/pom.xml                         |   8 +
 .../common/config/ConfigBuilderSupport.java   | 177 +++++++++
 .../helidon/common/config/GlobalConfig.java   |  12 +-
 .../helidon/common/config/ProvidedUtil.java   | 348 +++++++++++-------
 common/config/src/main/java/module-info.java  |   1 +
 common/mapper/pom.xml                         |  67 ++++
 .../helidon/common/mapper/BuiltInMappers.java |   2 +
 .../common/mapper/DefaultMapperProvider.java  |   6 +-
 .../java/io/helidon/common/mapper/Mapper.java |  40 ++
 .../helidon/common/mapper/MapperManager.java  |  23 +-
 .../io/helidon/common/mapper/Mappers.java     |  75 ++++
 .../common/mapper/MappersConfigBlueprint.java |  53 +++
 .../common/mapper/MappersConfigSupport.java   | 221 +++++++++++
 .../helidon/common/mapper/MappersFactory.java |  29 ++
 ...apperManagerImpl.java => MappersImpl.java} |  37 +-
 .../helidon/common/mapper/OptionalValue.java  |   8 +-
 .../java/io/helidon/common/mapper/Value.java  |   4 +-
 .../io/helidon/common/mapper/ValueBacked.java |   6 +-
 .../io/helidon/common/mapper/ValueEmpty.java  |   4 +-
 common/mapper/src/main/java/module-info.java  |   5 +
 .../resources/META-INF/helidon/service.loader |   2 +
 .../helidon/common/mapper/CustomMapper.java   |  23 ++
 ....java => MapperManagerTestDeprecated.java} |  33 +-
 .../io/helidon/common/mapper/MappersTest.java | 291 +++++++++++++++
 ...rMapper1.java => ServiceLoaderMapper.java} |   2 +-
 ...apper2.java => ServiceRegistryMapper.java} |   7 +-
 ...o.helidon.common.mapper.spi.MapperProvider |   3 +-
 .../common/types/TypedElementInfo.java        |  99 ++++-
 .../types/TypedElementInfoBlueprint.java      |   9 +
 .../java/io/helidon/config/BuilderImpl.java   |   8 +
 .../main/java/io/helidon/config/Config.java   |  21 ++
 .../io/helidon/config/ConfigProvider.java     |   4 +-
 .../dbclient/DbMapperProviderImpl.java        |   3 +
 etc/checkstyle-suppressions.xml               |   2 +-
 inject/api/src/main/java/module-info.java     |   1 +
 service/builder/pom.xml                       |  53 ---
 .../builder/src/main/java/module-info.java    |   6 -
 .../codegen/ServiceCodegenAnnotations.java    |  21 +-
 .../service/codegen/ServiceContracts.java     |  35 +-
 .../codegen/ServiceDescriptorCodegen.java     |  47 +--
 service/maven-plugin/pom.xml                  |   8 -
 service/pom.xml                               |   1 -
 .../registry/RegistryBuilderSupport.java      |  94 +++++
 .../service/registry/RegistryMetrics.java     |  44 ++-
 .../service/registry/RegistryMetricsImpl.java |   2 +-
 .../service/registry/ServiceDescriptor.java   |   3 +-
 .../ServiceRegistryConfigBlueprint.java       |   3 +-
 .../registry/ServiceRegistryManager.java      |   1 +
 .../io/helidon/service/registry/Services.java |  44 +++
 80 files changed, 2004 insertions(+), 889 deletions(-)
 delete mode 100644 builder/api/src/main/java/io/helidon/builder/api/ProvidedUtil.java
 create mode 100644 common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
 rename service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java => common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java (61%)
 create mode 100644 common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
 create mode 100644 common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
 create mode 100644 common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
 create mode 100644 common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
 rename common/mapper/src/main/java/io/helidon/common/mapper/{MapperManagerImpl.java => MappersImpl.java} (91%)
 create mode 100644 common/mapper/src/main/resources/META-INF/helidon/service.loader
 create mode 100644 common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
 rename common/mapper/src/test/java/io/helidon/common/mapper/{MapperManagerTest.java => MapperManagerTestDeprecated.java} (87%)
 create mode 100644 common/mapper/src/test/java/io/helidon/common/mapper/MappersTest.java
 rename common/mapper/src/test/java/io/helidon/common/mapper/{ServiceLoaderMapper1.java => ServiceLoaderMapper.java} (95%)
 rename common/mapper/src/test/java/io/helidon/common/mapper/{ServiceLoaderMapper2.java => ServiceRegistryMapper.java} (88%)
 delete mode 100644 service/builder/pom.xml
 delete mode 100644 service/builder/src/main/java/module-info.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java

diff --git a/all/pom.xml b/all/pom.xml
index 0281de7bd2c..565604cf210 100644
--- a/all/pom.xml
+++ b/all/pom.xml
@@ -1132,10 +1132,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-maven-plugin</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-builder</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.metadata</groupId>
             <artifactId>helidon-metadata-hson</artifactId>
diff --git a/bom/pom.xml b/bom/pom.xml
index 8a52ec29605..a5b56360fa0 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -1496,11 +1496,6 @@
                 <artifactId>helidon-service-maven-plugin</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
-            <dependency>
-                <groupId>io.helidon.service</groupId>
-                <artifactId>helidon-service-builder</artifactId>
-                <version>${helidon.version}</version>
-            </dependency>
 
             <!-- Metadata -->
             <dependency>
diff --git a/builder/api/pom.xml b/builder/api/pom.xml
index 7e6a6158597..466188d9a03 100644
--- a/builder/api/pom.xml
+++ b/builder/api/pom.xml
@@ -36,11 +36,6 @@
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-config</artifactId>
-            <optional>true</optional>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/builder/api/src/main/java/io/helidon/builder/api/Option.java b/builder/api/src/main/java/io/helidon/builder/api/Option.java
index e315748b874..dc7a753ded2 100644
--- a/builder/api/src/main/java/io/helidon/builder/api/Option.java
+++ b/builder/api/src/main/java/io/helidon/builder/api/Option.java
@@ -31,7 +31,7 @@ private Option() {
     }
 
     /**
-     * Mark a prototype option as one that can be read from {@link io.helidon.common.config.Config}.
+     * Mark a prototype option as one that can be read from {@code io.helidon.common.config.Config}.
      */
     @Target(ElementType.METHOD)
     @Inherited
@@ -157,6 +157,15 @@ private Option() {
      * This annotation cannot be combined with {@link io.helidon.builder.api.Option.Configured} - if you want
      * providers configured from configuration, kindly use {@link io.helidon.builder.api.Option.Provider}.
      * <p>
+     * Behavior depends on the return type of the annotated method:
+     * <ul>
+     *     <li>A single instance - if the instance is configured on the builder by hand, registry is not used</li>
+     *     <li>An {@link java.util.Optional} instance - ditto</li>
+     *     <li>A {@link java.util.List} of instances - instances configured on the builder are combined with instances
+     *      discovered in the registry; there is a generated method that allows for disabling registry use for each
+     *      service</li>
+     * </ul>
+     *
      * Options annotated with this annotation will load the instances as the default value (before method {@code builder()})
      * returns, thus you have full control over the field, be it an Optional, single value, or a List.
      * <p>
diff --git a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
index f1efe5ad12c..93c5f946d25 100644
--- a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
+++ b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
@@ -21,13 +21,6 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-import java.util.List;
-import java.util.Optional;
-
-import io.helidon.common.HelidonServiceLoader;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfiguredProvider;
-import io.helidon.common.config.NamedService;
 
 /**
  * Prototype is generated from a prototype blueprint, and it is expected to be part of the public API of the module.
@@ -72,102 +65,6 @@ default BUILDER self() {
         }
     }
 
-    /**
-     * Extension of {@link io.helidon.builder.api.Prototype.Builder} that supports configuration.
-     * If a blueprint is marked as {@code @Configured}, build will accept configuration.
-     *
-     * @param <BUILDER>   type of the builder
-     * @param <PROTOTYPE> type of the prototype to be built
-     */
-    public interface ConfiguredBuilder<BUILDER, PROTOTYPE> extends Builder<BUILDER, PROTOTYPE> {
-        /**
-         * Update builder from configuration.
-         * Any configured option that is defined on this prototype will be checked in configuration, and if it exists,
-         * it will override current value for that option on this builder.
-         * Options that do not exist in the provided config will not impact current values.
-         * The config instance is kept and may be used in builder decorator, it is not available in prototype implementation.
-         *
-         * @param config configuration to use
-         * @return updated builder instance
-         */
-        BUILDER config(Config config);
-
-        /**
-         * Discover services from configuration.
-         * If already configured instances already contain a service of the same type and name that would be added from
-         * configuration, the configuration would be ignored (e.g. the user must make a choice whether to configure, or
-         * set using an API).
-         *
-         * @param config               configuration located at the parent node of the service providers
-         * @param configKey            configuration key of the provider list
-         *                             (either a list node, or object, where each child is one service)
-         * @param serviceLoader        helidon service loader for the expected type
-         * @param providerType         type of the service provider interface
-         * @param configType           type of the configured service
-         * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
-         *                             node
-         * @param existingInstances    already configured instances
-         * @param <S>                  type of the expected service
-         * @param <T>                  type of the configured service provider that creates instances of S
-         * @return list of discovered services, ordered by {@link io.helidon.common.Weight} (highest weight is first in the list)
-         */
-        default <S extends NamedService, T extends ConfiguredProvider<S>> List<S>
-        discoverServices(Config config,
-                         String configKey,
-                         HelidonServiceLoader<T> serviceLoader,
-                         Class<T> providerType,
-                         Class<S> configType,
-                         boolean allFromServiceLoader,
-                         List<S> existingInstances) {
-            return ProvidedUtil.discoverServices(config,
-                                                 configKey,
-                                                 serviceLoader,
-                                                 providerType,
-                                                 configType,
-                                                 allFromServiceLoader,
-                                                 existingInstances);
-        }
-
-        /**
-         * Discover service from configuration. If an instance is already configured using a builder, it will not be
-         * discovered from configuration (e.g. the user must make a choice whether to configure, or set using API).
-         *
-         * @param config               configuration located at the parent node of the service providers
-         * @param configKey            configuration key of the provider list
-         *                             (either a list node, or object, where each child is one service - this method requires
-         *                             *                             zero to one configured services)
-         * @param serviceLoader        helidon service loader for the expected type
-         * @param providerType         type of the service provider interface
-         * @param configType           type of the configured service
-         * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
-         *                             node
-         * @param existingValue        value already configured, if the name is same as discovered from configuration
-         * @param <S>                  type of the expected service
-         * @param <T>                  type of the configured service provider that creates instances of S
-         * @return the first service (ordered by {@link io.helidon.common.Weight} that is discovered, or empty optional if none
-         *         is found
-         */
-        @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-        default <S extends NamedService, T extends ConfiguredProvider<S>> Optional<S>
-        discoverService(Config config,
-                        String configKey,
-                        HelidonServiceLoader<T> serviceLoader,
-                        Class<T> providerType,
-                        Class<S> configType,
-                        boolean allFromServiceLoader,
-                        Optional<S> existingValue) {
-            return ProvidedUtil.discoverService(config,
-                                                configKey,
-                                                serviceLoader,
-                                                providerType,
-                                                configType,
-                                                allFromServiceLoader,
-                                                existingValue);
-        }
-
-
-    }
-
     /**
      * A prototype {@link Prototype.Blueprint} may extend this interface
      * to explicitly reference the associated runtime type.
@@ -262,7 +159,7 @@ public interface Factory<T> {
 
     /**
      * A blueprint annotated with this annotation will create a prototype that can be created from a
-     * {@link io.helidon.common.config.Config} instance. The builder will also have a method {@code config(Config)} that
+     * {@code io.helidon.common.config.Config} instance. The builder will also have a method {@code config(Config)} that
      * reads all options annotated with {@link io.helidon.builder.api.Option.Configured} from the config.
      */
     @Target(ElementType.TYPE)
diff --git a/builder/api/src/main/java/io/helidon/builder/api/ProvidedUtil.java b/builder/api/src/main/java/io/helidon/builder/api/ProvidedUtil.java
deleted file mode 100644
index 100c23eedd3..00000000000
--- a/builder/api/src/main/java/io/helidon/builder/api/ProvidedUtil.java
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * Copyright (c) 2023 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.builder.api;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-
-import io.helidon.common.HelidonServiceLoader;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.ConfiguredProvider;
-import io.helidon.common.config.NamedService;
-
-final class ProvidedUtil {
-    private static final System.Logger PROVIDER_LOGGER = System.getLogger(Prototype.class.getName() + ".provider");
-    /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * the mapping to a provider.
-     * Type of service, used to map to {@link io.helidon.common.config.ConfiguredProvider#configKey()}, which is the
-     * default "type" of a configured provider. It is then used in {@link io.helidon.common.config.NamedService#type()},
-     * to allow multiple instances of the same "type" with different "name".
-     */
-    private static final String KEY_SERVICE_TYPE = "type";
-    /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * the name of an instance.
-     * It is then used in {@link io.helidon.common.config.NamedService#name()}
-     * to allow multiple instances of the same "type" with different "name".
-     * In case of object type configurations, name is taken from the configuration node name.
-     */
-    private static final String KEY_SERVICE_NAME = "name";
-    /**
-     * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
-     * whether a service provider of the type is enabled.
-     * Each service from a {@link io.helidon.common.config.ConfiguredProvider} can be enabled/disabled through
-     * configuration. If marked as {@code enabled = false}, the service will be ignored and not added.
-     */
-    private static final String KEY_SERVICE_ENABLED = "enabled";
-
-    private ProvidedUtil() {
-    }
-
-    /**
-     * Discover service from configuration.
-     * This method looks for a single provider only.
-     *
-     * @param config           configuration located at the parent node of the service providers
-     * @param configKey        configuration key of the provider list
-     *                         (either a list node, or object, where each child is one service)
-     * @param serviceLoader    helidon service loader for the expected type
-     * @param providerType     service provider interface type
-     * @param configType       configured service type
-     * @param discoverServices whether all services from service loader should be used, or only the ones with configured
-     *                         node
-     * @param existingValue    value already configured, if the name is same as discovered from configuration
-     * @param <T>              type of the expected service
-     * @return first service by {@link io.helidon.common.Weight}, or empty optional
-     */
-    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-    static <T extends NamedService> Optional<T>
-    discoverService(Config config,
-                    String configKey,
-                    HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
-                    Class<? extends ConfiguredProvider<T>> providerType,
-                    Class<T> configType,
-                    boolean discoverServices,
-                    Optional<T> existingValue) {
-
-        // there is an explicit configuration for this service, ignore configuration
-        if (existingValue.isPresent()) {
-            return Optional.empty();
-        }
-
-        // all child nodes of the current node
-        List<Config> serviceConfigList = config.get(configKey).asNodeList()
-                .orElseGet(List::of);
-
-        // if more than one is configured in config, fail
-        // if more than one exists in service loader, use the first one
-        if (serviceConfigList.size() > 1) {
-            throw new ConfigException("There can only be one provider configured for " + config.key());
-        }
-
-        List<T> services = discoverServices(config,
-                                            configKey,
-                                            serviceLoader,
-                                            providerType,
-                                            configType,
-                                            discoverServices,
-                                            List.of());
-
-        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
-    }
-
-    /**
-     * Discover services from configuration.
-     *
-     * @param config               configuration located at the parent node of the service providers
-     * @param configKey            configuration key of the provider list
-     *                             (either a list node, or object, where each child is one service)
-     * @param serviceLoader        helidon service loader for the expected type
-     * @param providerType         service provider interface type
-     * @param configType           configured service type
-     * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
-     *                             node
-     * @param existingInstances    already configured instances
-     * @param <T>                  type of the expected service
-     * @return list of discovered services, ordered by {@link io.helidon.common.Weight} (highest weight first)
-     */
-    static <T extends NamedService> List<T> discoverServices(Config config,
-                                                             String configKey,
-                                                             HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
-                                                             Class<? extends ConfiguredProvider<T>> providerType,
-                                                             Class<T> configType,
-                                                             boolean allFromServiceLoader,
-                                                             List<T> existingInstances) {
-
-        // type and name is a unique identification of a service - for services already defined on the builder
-        // do not add them from configuration (as this would duplicate service instances)
-        Set<TypeAndName> ignoredServices = new HashSet<>();
-        existingInstances.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
-
-        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromServiceLoader);
-        Config providersConfig = config.get(configKey);
-
-        List<ConfiguredService> configuredServices = new ArrayList<>();
-
-        // all child nodes of the current node
-        List<Config> serviceConfigList = providersConfig.asNodeList()
-                .orElseGet(List::of);
-        boolean isList = providersConfig.isList();
-
-        for (Config serviceConfig : serviceConfigList) {
-            configuredServices.add(configuredService(serviceConfig, isList));
-        }
-
-        // now we have all service configurations, we can start building up instances
-        if (providersConfig.isList()) {
-            // driven by order of declaration in config
-            return servicesFromList(serviceLoader,
-                                    providerType,
-                                    configType,
-                                    configuredServices,
-                                    discoverServices,
-                                    ignoredServices);
-        } else {
-            // driven by service loader order
-            return servicesFromObject(providersConfig,
-                                      serviceLoader,
-                                      providerType,
-                                      configType,
-                                      configuredServices,
-                                      discoverServices,
-                                      ignoredServices);
-        }
-    }
-
-    private static <T extends NamedService> List<T>
-    servicesFromObject(Config providersConfig,
-                       HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
-                       Class<? extends ConfiguredProvider<T>> providerType,
-                       Class<T> configType,
-                       List<ConfiguredService> configuredServices,
-                       boolean allFromServiceLoader,
-                       Set<TypeAndName> ignoredServices) {
-        // order is determined by service loader
-        Set<String> availableProviders = new HashSet<>();
-        Map<String, ConfiguredService> allConfigs = new HashMap<>();
-        configuredServices.forEach(it -> allConfigs.put(it.typeAndName().type, it));
-        Set<String> unusedConfigs = new HashSet<>(allConfigs.keySet());
-
-        List<T> result = new ArrayList<>();
-
-        serviceLoader.forEach(provider -> {
-            ConfiguredService configuredService = allConfigs.get(provider.configKey());
-            availableProviders.add(provider.configKey());
-            unusedConfigs.remove(provider.configKey());
-            if (configuredService == null) {
-                if (allFromServiceLoader) {
-                    // even though the specific key does not exist, we want to have the real config tree, so we can get to the
-                    // root of it
-                    // when there is no configuration, the name defaults to the type
-                    String type = provider.configKey();
-                    if (ignoredServices.add(new TypeAndName(type, type))) {
-                        result.add(provider.create(providersConfig.get(type), type));
-                    } else {
-                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + new TypeAndName(type, type)
-                                    + " is already added in builder, ignoring configured one.");
-                        }
-                    }
-                }
-            } else {
-                if (configuredService.enabled()) {
-                    if (ignoredServices.add(configuredService.typeAndName())) {
-                        result.add(provider.create(configuredService.serviceConfig(),
-                                                   configuredService.typeAndName().name()));
-                    } else {
-                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + configuredService.typeAndName()
-                                    + " is already added in builder, ignoring configured one.");
-                        }
-                    }
-                }
-            }
-        });
-        if (!unusedConfigs.isEmpty()) {
-            throw new ConfigException("Unknown provider configured. Expected providers with types: " + unusedConfigs
-                                              + ", but only the following providers are supported: " + availableProviders
-                                              + ", provider interface: " + providerType.getName()
-                                              + ", configured service: " + configType.getName());
-        }
-        return result;
-    }
-
-    private static <T extends NamedService> List<T>
-    servicesFromList(HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
-                     Class<? extends ConfiguredProvider<T>> providerType,
-                     Class<T> configType,
-                     List<ConfiguredService> configuredServices,
-                     boolean allFromServiceLoader,
-                     Set<TypeAndName> ignoredServices) {
-        Map<String, ConfiguredProvider<T>> allProvidersByType = new HashMap<>();
-        Map<String, ConfiguredProvider<T>> unusedProvidersByType = new LinkedHashMap<>();
-        serviceLoader.forEach(it -> {
-            allProvidersByType.put(it.configKey(), it);
-            unusedProvidersByType.put(it.configKey(), it);
-        });
-
-        List<T> result = new ArrayList<>();
-
-        // first add all configured
-        for (ConfiguredService service : configuredServices) {
-            TypeAndName typeAndName = service.typeAndName();
-            if (!ignoredServices.add(typeAndName)) {
-                unusedProvidersByType.remove(typeAndName.type());
-
-                if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                    PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + typeAndName
-                            + " is already added in builder, ignoring configured one.");
-                }
-
-                continue;
-            }
-            ConfiguredProvider<T> provider = allProvidersByType.get(typeAndName.type());
-            if (provider == null) {
-                throw new ConfigException("Unknown provider configured. Expecting a provider with type \"" + typeAndName.type()
-                                                  + "\", but only the following providers are supported: "
-                                                  + allProvidersByType.keySet() + ", "
-                                                  + "provider interface: " + providerType.getName()
-                                                  + ", configured service: " + configType.getName());
-            }
-            unusedProvidersByType.remove(typeAndName.type());
-            if (service.enabled()) {
-                result.add(provider.create(service.serviceConfig(), typeAndName.name()));
-            }
-        }
-
-        // then (if desired) add the rest
-        if (allFromServiceLoader) {
-            unusedProvidersByType.forEach((type, provider) -> {
-                if (ignoredServices.add(new TypeAndName(type, type))) {
-                    result.add(provider.create(Config.empty(), type));
-                }
-            });
-        }
-
-        return result;
-    }
-
-    private static ConfiguredService configuredService(Config serviceConfig, boolean isList) {
-        if (isList) {
-            // order is significant
-            String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(null);
-            String name = serviceConfig.get(KEY_SERVICE_NAME).asString().orElse(type);
-            boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
-
-            Config usedConfig = serviceConfig;
-            if (type == null) {
-                // nested approach (we are on the first node of the list, we need to go deeper)
-                List<Config> configs = serviceConfig.asNodeList().orElseGet(List::of);
-                if (configs.size() != 1) {
-                    throw new ConfigException(
-                            "Service provider configuration defined as a list must have a single node that is the type, "
-                                    + "with children containing the provider configuration. Failed on: " + serviceConfig.key());
-                }
-                usedConfig = configs.get(0);
-                name = usedConfig.name();
-                type = usedConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
-                enabled = usedConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(enabled);
-            }
-            return new ConfiguredService(new TypeAndName(type, name), usedConfig, enabled);
-        }
-        // just collect each node, order will be determined by weight
-
-        String name = serviceConfig.name(); // name is the config node name for object types
-        String type = serviceConfig.get(KEY_SERVICE_TYPE).asString().orElse(name);
-        boolean enabled = serviceConfig.get(KEY_SERVICE_ENABLED).asBoolean().orElse(true);
-
-        return new ConfiguredService(new TypeAndName(type, name), serviceConfig, enabled);
-    }
-
-    private record TypeAndName(String type, String name) {
-    }
-
-    private record ConfiguredService(TypeAndName typeAndName, Config serviceConfig, boolean enabled) {
-    }
-}
diff --git a/builder/api/src/main/java/module-info.java b/builder/api/src/main/java/module-info.java
index 2075aeb13e0..037d6910d08 100644
--- a/builder/api/src/main/java/module-info.java
+++ b/builder/api/src/main/java/module-info.java
@@ -21,8 +21,5 @@
 
     requires transitive io.helidon.common;
 
-    requires static io.helidon.common.config;
-
     exports io.helidon.builder.api;
-	
 }
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/AnnotationDataOption.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/AnnotationDataOption.java
index 8f0576be0ae..66a64cb6f43 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/AnnotationDataOption.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/AnnotationDataOption.java
@@ -45,6 +45,7 @@
 import static io.helidon.builder.codegen.Types.OPTION_DEFAULT_METHOD;
 import static io.helidon.builder.codegen.Types.OPTION_PROVIDER;
 import static io.helidon.builder.codegen.Types.OPTION_REDUNDANT;
+import static io.helidon.builder.codegen.Types.OPTION_REGISTRY_SERVICE;
 import static io.helidon.builder.codegen.Types.OPTION_REQUIRED;
 import static io.helidon.builder.codegen.Types.OPTION_SAME_GENERIC;
 import static io.helidon.builder.codegen.Types.OPTION_SINGULAR;
@@ -60,6 +61,7 @@ record AnnotationDataOption(Javadoc javadoc,
                             AccessModifier accessModifier,
                             boolean required,
                             boolean validateNotNull,
+                            boolean registryService,
                             boolean provider,
                             TypeName providerType,
                             boolean providerDiscoverServices,
@@ -101,6 +103,7 @@ static AnnotationDataOption create(TypeHandler handler, TypedElementInfo element
                     .orElse(false);
         }
         accessModifier = accessModifier(element);
+        boolean registryService = element.hasAnnotation(OPTION_REGISTRY_SERVICE);
         if (element.hasAnnotation(OPTION_PROVIDER)) {
             Annotation annotation = element.annotation(OPTION_PROVIDER);
             providerBased = true;
@@ -171,6 +174,7 @@ static AnnotationDataOption create(TypeHandler handler, TypedElementInfo element
                                         accessModifier,
                                         required,
                                         validateNotNull,
+                                        registryService,
                                         providerBased,
                                         providerType,
                                         discoverServices,
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
index c4bb405a26f..31249dfd782 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/BuilderCodegen.java
@@ -46,7 +46,6 @@
 import io.helidon.common.types.TypeName;
 
 import static io.helidon.builder.codegen.Types.RUNTIME_PROTOTYPE;
-import static io.helidon.builder.codegen.Types.SERVICE_REGISTRY;
 
 class BuilderCodegen implements CodegenExtension {
     private static final TypeName GENERATOR = TypeName.create(BuilderCodegen.class);
@@ -197,106 +196,22 @@ private static void addCopyBuilderMethod(ClassModel.Builder classModel,
         });
     }
 
-    private static void addRegistryBuilderMethod(ClassModel.Builder classModel,
-                                                 TypeName builderTypeName,
-                                                 List<TypeArgument> typeArguments,
-                                                 String ifaceName, List<PrototypeProperty> properties) {
-        classModel.addMethod(builder -> {
-            builder.isStatic(true)
-                    .name("builder")
-                    .description("Create a new fluent API builder to customize configuration using the provided service "
-                                         + "registry.")
-                    .addParameter(registry -> registry
-                            .type(SERVICE_REGISTRY)
-                            .name("registry")
-                    )
-                    .returnType(builderTypeName, "a new builder");
-            typeArguments.forEach(builder::addGenericArgument);
-            builder.addContent(builderTypeName.genericTypeName());
-
-            if (!typeArguments.isEmpty()) {
-                builder.addContent("<");
-                builder.addContent(typeArguments.stream()
-                                           .map(TypeArgument::className)
-                                           .collect(Collectors.joining(", ")));
-                builder.addContent(">");
-            }
-
-            builder.addContent(" builder = new ")
-                    .addContent(ifaceName)
-                    .addContent(".Builder");
-
-            if (typeArguments.isEmpty()) {
-                builder.addContentLine("();");
-            } else {
-                builder.addContentLine("<>();");
-            }
-
-            // and configure the service registry, and load all @Option.RegistryService fields
-            if (properties.stream()
-                    .anyMatch(PrototypeProperty::registryService)) {
-                builder.addContentLine("");
-                builder.addContentLine("builder.serviceRegistry(registry);");
-                // now for each option that has registry, add initialization
-                for (PrototypeProperty property : properties) {
-                    if (property.registryService()) {
-                        // depends on type - Optional, List, Direct (supplier?)
-                        TypeHandler typeHandler = property.typeHandler();
-                        typeHandler.updateBuilderFromRegistry(builder, "builder", "registry");
-                    }
-                }
-                builder.addContentLine("");
-            }
-            builder.addContentLine("return builder;");
-        });
-    }
     private static void addBuilderMethod(ClassModel.Builder classModel,
                                          TypeName builderTypeName,
                                          List<TypeArgument> typeArguments,
-                                         String ifaceName,
-                                         List<PrototypeProperty> properties) {
+                                         String ifaceName) {
+
         classModel.addMethod(builder -> {
             builder.isStatic(true)
                     .name("builder")
                     .description("Create a new fluent API builder to customize configuration.")
                     .returnType(builderTypeName, "a new builder");
             typeArguments.forEach(builder::addGenericArgument);
-            builder.addContent(builderTypeName.genericTypeName());
-
-            if (!typeArguments.isEmpty()) {
-                builder.addContent("<");
-                builder.addContent(typeArguments.stream()
-                                           .map(TypeArgument::className)
-                                           .collect(Collectors.joining(", ")));
-                builder.addContent(">");
-            }
-
-            builder.addContent(" builder = new ")
-                    .addContent(ifaceName)
-                    .addContent(".Builder");
-
             if (typeArguments.isEmpty()) {
-                builder.addContentLine("();");
+                builder.addContentLine("return new " + ifaceName + ".Builder();");
             } else {
-                builder.addContentLine("<>();");
+                builder.addContentLine("return new " + ifaceName + ".Builder<>();");
             }
-
-            // and configure the service registry, and load all @Option.RegistryService fields
-            if (properties.stream()
-                    .anyMatch(PrototypeProperty::registryService)) {
-                builder.addContentLine("");
-                // now for each option that has registry, add initialization
-                for (PrototypeProperty property : properties) {
-                    if (property.registryService()) {
-                        // depends on type - Optional, List, Direct (supplier?)
-                        TypeHandler typeHandler = property.typeHandler();
-                        typeHandler.updateBuilderFromServices(builder, "builder");
-                    }
-                }
-                builder.addContentLine("");
-            }
-
-            builder.addContentLine("return builder;");
         });
     }
 
@@ -484,19 +399,11 @@ private void process(RoundContext roundContext, TypeInfo blueprint) {
                 .build();
 
         // static Builder builder()
-        addBuilderMethod(classModel, builderTypeName, typeArguments, ifaceName, typeContext.propertyData().properties());
+        addBuilderMethod(classModel, builderTypeName, typeArguments, ifaceName);
 
         // static Builder builder(T instance)
         addCopyBuilderMethod(classModel, builderTypeName, prototype, typeArguments, ifaceName, typeArgumentString);
 
-        if (typeContext.typeInfo().supportsServiceRegistry()) {
-            addRegistryBuilderMethod(classModel,
-                                     builderTypeName,
-                                     typeArguments,
-                                     ifaceName,
-                                     typeContext.propertyData().properties());
-        }
-
         // static T create(Config config)
         addCreateFromConfigMethod(blueprintDef,
                                   configuredData,
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/CustomMethods.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/CustomMethods.java
index 03d919f9125..8f75293ca09 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/CustomMethods.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/CustomMethods.java
@@ -19,6 +19,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -129,7 +130,8 @@ private static GeneratedMethod prototypeMethod(Errors.Collector errors,
                            customMethod.returnType(),
                            generatedArgs,
                            // todo the javadoc may differ (such as when we have an additional parameter for instance methods)
-                           customMethod.javadoc()),
+                           customMethod.javadoc(),
+                           customMethod.typeParameters()),
                 annotations,
                 codeGenerator);
     }
@@ -178,7 +180,8 @@ private static GeneratedMethod builderMethod(Errors.Collector errors,
                            customMethod.name(),
                            typeInformation.prototypeBuilder(),
                            generatedArgs,
-                           customMethod.javadoc()),
+                           customMethod.javadoc(),
+                           customMethod.typeParameters),
                 annotations,
                 codeGenerator);
     }
@@ -227,7 +230,8 @@ private static GeneratedMethod factoryMethod(Errors.Collector errors,
                                               customMethod.name(),
                                               customMethod.returnType(),
                                               customMethod.arguments(),
-                                              customMethod.javadoc()),
+                                              customMethod.javadoc(),
+                                              customMethod.typeParameters()),
                                    annotations,
                                    codeGenerator);
     }
@@ -314,7 +318,26 @@ private static List<CustomMethod> findMethods(TypeContext.TypeInformation typeIn
                             .filter(Predicate.not(String::isBlank)) // we do not care about blank values
                             .toList();
 
-                    Method customMethod = new Method(customMethodsType.typeName(), methodName, returnType, arguments, javadoc);
+                    List<TypeName> typeNames = it.typeParameters();
+                    List<TypeName> typeParametersToUse = new ArrayList<>();
+                    if (!typeNames.isEmpty()) {
+                        // look for type parameters that differ in name from the ones defined by the blueprint
+                        Set<String> usedNames = typeInformation.blueprintType().declaredType()
+                                .typeArguments()
+                                .stream()
+                                .map(TypeName::className)
+                                .collect(Collectors.toSet());
+                        typeNames.stream()
+                                .filter(methodTypeParam -> !usedNames.contains(methodTypeParam.className()))
+                                .forEach(typeParametersToUse::add);
+                    }
+
+                    Method customMethod = new Method(customMethodsType.typeName(),
+                                                     methodName,
+                                                     returnType,
+                                                     arguments,
+                                                     javadoc,
+                                                     typeParametersToUse);
 
                     return new CustomMethod(customMethod,
                                             methodProcessor.process(errors,
@@ -343,7 +366,8 @@ record Method(TypeName declaringType,
                   String name,
                   TypeName returnType,
                   List<Argument> arguments,
-                  List<String> javadoc) {
+                  List<String> javadoc,
+                  List<TypeName> typeParameters) {
 
     }
 
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
index dc6c215dbf3..d8c7008e24b 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
@@ -44,6 +44,8 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 
+import static io.helidon.builder.codegen.Types.CONFIG_BUILDER_SUPPORT;
+import static io.helidon.builder.codegen.Types.REGISTRY_BUILDER_SUPPORT;
 import static io.helidon.codegen.CodegenUtil.capitalize;
 import static io.helidon.common.types.TypeNames.LIST;
 import static io.helidon.common.types.TypeNames.MAP;
@@ -92,7 +94,7 @@ static void generate(ClassModel.Builder classModel,
 
             if (typeContext.configuredData().configured() || hasConfig(typeContext.propertyData().properties())) {
                 builder.addInterface(TypeName.builder()
-                                             .from(Types.PROTOTYPE_CONFIGURED_BUILDER)
+                                             .from(Types.CONFIG_CONFIGURED_BUILDER)
                                              .addTypeArgument(TypeName.createFromGenericDeclaration("BUILDER"))
                                              .addTypeArgument(TypeName.createFromGenericDeclaration("PROTOTYPE"))
                                              .build());
@@ -183,10 +185,23 @@ private static void addCustomBuilderMethods(TypeContext typeContext, InnerClass.
             for (String annotation : customMethod.generatedMethod().annotations()) {
                 method.addAnnotation(Annotation.parse(annotation));
             }
-            for (CustomMethods.Argument argument : generated.arguments()) {
-                method.addParameter(param -> param.name(argument.name())
-                        .type(argument.typeName()));
+            int argSize = generated.arguments().size();
+            for (int i = 0; i < argSize; i++) {
+                CustomMethods.Argument argument = generated.arguments().get(i);
+
+                if (i == argSize - 1 && argument.typeName().array() && !argument.typeName().primitive()) {
+                    // last argument
+                    method.addParameter(param -> param.name(argument.name())
+                            .type(TypeName.builder(argument.typeName())
+                                          .array(false)
+                                          .build())
+                            .vararg(true));
+                } else {
+                    method.addParameter(param -> param.name(argument.name())
+                            .type(argument.typeName()));
+                }
             }
+
             if (!generated.javadoc().isEmpty()) {
                 Javadoc javadoc = Javadoc.builder()
                         .from(Javadoc.parse(generated.javadoc()))
@@ -194,6 +209,9 @@ private static void addCustomBuilderMethods(TypeContext typeContext, InnerClass.
                         .build();
                 method.javadoc(javadoc);
             }
+            for (TypeName typeParameter : customMethod.generatedMethod().method().typeParameters()) {
+                method.addGenericArgument(TypeArgument.create(typeParameter));
+            }
             builder.addMethod(method);
         }
     }
@@ -366,6 +384,7 @@ public BUILDER config(Config config) {
         if (configured.configured()) {
             for (PrototypeProperty child : properties) {
                 if (child.configuredOption().configured() && !child.configuredOption().provider()) {
+                    // registry service can never reach here, as they do not support Option.Configured
                     child.typeHandler().generateFromConfig(builder,
                                                            child.configuredOption(),
                                                            child.factoryMethods());
@@ -422,7 +441,7 @@ private static void fromInstanceMethod(InnerClass.Builder builder, TypeContext t
                     methodBuilder.addContentLine("());");
                 }
             }
-            if (property.configuredOption().provider()) {
+            if (property.configuredOption().provider() || property.registryService()) {
                 methodBuilder.addContentLine(property.typeHandler().name() + "DiscoverServices = false;");
             }
         }
@@ -500,7 +519,7 @@ private static void fromBuilderMethod(InnerClass.Builder classBuilder,
                     methodBuilder.addContentLine(setterName + "(builder." + getterName + "());");
                 }
             }
-            if (property.configuredOption().provider()) {
+            if (property.configuredOption().provider() || property.registryService()) {
                 methodBuilder.addContent(property.name() + "DiscoverServices");
                 methodBuilder.addContentLine(" = builder." + property.name() + "DiscoverServices;");
             }
@@ -536,11 +555,16 @@ private static void fields(InnerClass.Builder classBuilder, TypeContext typeCont
             if (!isBuilder || !isConfigProperty(child)) {
                 classBuilder.addField(child.fieldDeclaration(isBuilder));
             }
-            if (isBuilder && child.configuredOption().provider()) {
+            if (isBuilder && (child.configuredOption().provider())) {
                 classBuilder.addField(builder -> builder.type(boolean.class)
                         .name(child.name() + "DiscoverServices")
                         .defaultValue(String.valueOf(child.configuredOption().providerDiscoverServices())));
             }
+            if (isBuilder && (child.registryService())) {
+                classBuilder.addField(builder -> builder.type(boolean.class)
+                        .name(child.name() + "DiscoverServices")
+                        .defaultValue("true"));
+            }
             if (isBuilder && child.typeHandler().declaredType().isList()) {
                 classBuilder.addField(builder -> builder.type(boolean.class)
                         .name("is" + capitalize(child.name()) + "Mutated")
@@ -567,20 +591,20 @@ private static void preBuildPrototypeMethod(InnerClass.Builder classBuilder,
         typeContext.typeInfo()
                 .superPrototype()
                 .ifPresent(it -> preBuildBuilder.addContentLine("super.preBuildPrototype();"));
-        if (typeContext.propertyData().hasProvider()) {
+        if (typeContext.typeInfo().supportsServiceRegistry() || typeContext.propertyData().hasProvider()) {
             boolean configured = typeContext.configuredData().configured();
 
-            if (configured) {
+            if (configured && typeContext.propertyData().hasProvider()) {
                 // need to have a non-null config instance
                 preBuildBuilder.addContent("var config = this.config == null ? ")
-                                .addContent(Types.COMMON_CONFIG)
-                                        .addContentLine(".empty() : this.config;");
+                        .addContent(Types.COMMON_CONFIG)
+                        .addContentLine(".empty() : this.config;");
             }
 
             if (typeContext.typeInfo().supportsServiceRegistry()) {
-                preBuildBuilder.addContent("var registry = this.serviceRegistry == null ? ")
-                                .addContent(Types.GLOBAL_SERVICE_REGISTRY)
-                                        .addContentLine(".registry() : this.serviceRegistry;");
+                preBuildBuilder.addContent("var registry = ")
+                        .addContent(Optional.class)
+                        .addContentLine(".ofNullable(this.serviceRegistry);");
             }
 
             for (PrototypeProperty property : typeContext.propertyData().properties()) {
@@ -609,6 +633,9 @@ private static void preBuildPrototypeMethod(InnerClass.Builder classBuilder,
                                                        defaultDiscoverServices);
                     }
 
+                } else if (property.registryService()) {
+                    serviceRegistryProperty(preBuildBuilder,
+                                            property);
                 }
             }
         }
@@ -639,7 +666,9 @@ private static void serviceLoaderPropertyDiscovery(Method.Builder preBuildBuilde
             if (typeName.isList() || typeName.isSet()) {
                 preBuildBuilder.addContent("this.add")
                         .addContent(capitalize(property.name()))
-                        .addContent("(discoverServices(config, \"")
+                        .addContent("(")
+                        .addContent(CONFIG_BUILDER_SUPPORT)
+                        .addContent(".discoverServices(config, \"")
                         .addContent(configuredOption.configKey())
                         .addContent("\", serviceLoader, ")
                         .addContent(providerType.genericTypeName())
@@ -651,7 +680,9 @@ private static void serviceLoaderPropertyDiscovery(Method.Builder preBuildBuilde
                         .addContent(property.name())
                         .addContentLine("));");
             } else {
-                preBuildBuilder.addContent("discoverService(config, \"")
+                preBuildBuilder
+                        .addContent(CONFIG_BUILDER_SUPPORT)
+                        .addContent(".discoverService(config, \"")
                         .addContent(configuredOption.configKey())
                         .addContent("\", serviceLoader, ")
                         .addContent(providerType)
@@ -675,6 +706,48 @@ private static void serviceLoaderPropertyDiscovery(Method.Builder preBuildBuilde
         preBuildBuilder.addContentLine("}");
     }
 
+    private static void serviceRegistryProperty(Method.Builder preBuildBuilder,
+                                                PrototypeProperty property) {
+        TypeName typeName = property.typeHandler().declaredType();
+        if (typeName.isList()) {
+            preBuildBuilder
+                    .addContent("this.add")
+                    .addContent(capitalize(property.name()))
+                    .addContent("(")
+                    .addContent(REGISTRY_BUILDER_SUPPORT)
+                    .addContent(".serviceList(registry, ")
+                    .addContentCreate(property.typeHandler().actualType())
+                    .addContent(", ")
+                    .addContent(property.name())
+                    .addContentLine("DiscoverServices));");
+        } else if (typeName.isSet()) {
+            preBuildBuilder
+                    .addContent("this.add")
+                    .addContent(capitalize(property.name()))
+                    .addContent("(")
+                    .addContent(REGISTRY_BUILDER_SUPPORT)
+                    .addContent(".serviceSet(registry, ")
+                    .addContentCreate(property.typeHandler().actualType())
+                    .addContent(", ")
+                    .addContent(property.name())
+                    .addContentLine("DiscoverServices));");
+        } else {
+            preBuildBuilder
+                    .addContent(REGISTRY_BUILDER_SUPPORT)
+                    .addContent(".service(registry, ")
+                    .addContentCreate(property.typeHandler().actualType())
+                    .addContent(", ")
+                    .addContent(Optional.class)
+                    .addContent(".ofNullable(")
+                    .addContent(property.name())
+                    .addContent("), ")
+                    .addContent(property.name())
+                    .addContent("DiscoverServices).ifPresent(this::")
+                    .addContent(property.setterName())
+                    .addContentLine(");");
+        }
+    }
+
     private static void serviceRegistryPropertyDiscovery(Method.Builder preBuildBuilder,
                                                          PrototypeProperty property,
                                                          boolean propertyConfigured,
@@ -687,7 +760,7 @@ private static void serviceRegistryPropertyDiscovery(Method.Builder preBuildBuil
                 preBuildBuilder.addContent("this.add")
                         .addContent(capitalize(property.name()))
                         .addContent("(")
-                        .addContent(Types.REGISTRY_SUPPORT)
+                        .addContent(CONFIG_BUILDER_SUPPORT)
                         .addContentLine(".discoverServices(config,")
                         .increaseContentPadding()
                         .increaseContentPadding()
@@ -709,7 +782,7 @@ private static void serviceRegistryPropertyDiscovery(Method.Builder preBuildBuil
                         .decreaseContentPadding();
             } else {
                 preBuildBuilder
-                        .addContent(Types.REGISTRY_SUPPORT)
+                        .addContent(CONFIG_BUILDER_SUPPORT)
                         .addContentLine(".discoverService(config,")
                         .increaseContentPadding()
                         .increaseContentPadding()
@@ -1037,8 +1110,9 @@ private static void hashCodeMethod(InnerClass.Builder classBuilder,
             }
 
             method.addContent(equalityFields.stream()
-                                      .filter(it -> !(it.typeName().isOptional()
-                                                              && it.typeHandler().actualType().equals(Types.CHAR_ARRAY)))
+                                      .filter(it -> !(
+                                              it.typeName().isOptional()
+                                                      && it.typeHandler().actualType().equals(Types.CHAR_ARRAY)))
                                       .map(PrototypeProperty::name)
                                       .collect(Collectors.joining(", ")))
                     .addContent(")");
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerCollection.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerCollection.java
index 31ebdb6acca..1aacb6514c5 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerCollection.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/TypeHandlerCollection.java
@@ -256,7 +256,7 @@ void setters(InnerClass.Builder classBuilder,
                  TypeName returnType,
                  Javadoc blueprintJavadoc) {
 
-        if (configured.provider()) {
+        if (configured.provider() || configured.registryService()) {
             discoverServicesSetter(classBuilder, configured, returnType, blueprintJavadoc);
         }
 
@@ -265,8 +265,11 @@ void setters(InnerClass.Builder classBuilder,
         declaredSetters(classBuilder, configured, returnType, blueprintJavadoc);
 
         if (factoryMethods.createTargetType().isPresent()) {
-            // if there is a factory method for the return type, we also have setters for the type (probably config object)
-            factorySetter(classBuilder, configured, returnType, blueprintJavadoc, factoryMethods.createTargetType().get());
+            FactoryMethods.FactoryMethod factoryMethod = factoryMethods.createTargetType().get();
+            if (factoryMethod.factoryMethodReturnType().isList() || factoryMethod.factoryMethodReturnType().isSet()) {
+                // if there is a factory method for the return type, we also have setters for the type (probably config object)
+                factorySetter(classBuilder, configured, returnType, blueprintJavadoc, factoryMethod);
+            }
         }
 
         if (configured.singular()) {
diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
index f7b05bb3701..f6c840325af 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/Types.java
@@ -37,7 +37,6 @@ final class Types {
     static final TypeName SERVICE_REGISTRY = TypeName.create("io.helidon.service.registry.ServiceRegistry");
     static final TypeName GLOBAL_SERVICE_REGISTRY = TypeName.create("io.helidon.service.registry.GlobalServiceRegistry");
     static final TypeName SERVICES = TypeName.create("io.helidon.service.registry.Services");
-    static final TypeName REGISTRY_SUPPORT = TypeName.create("io.helidon.service.builder.BuilderRegistrySupport");
 
     static final TypeName BUILDER_DESCRIPTION = TypeName.create("io.helidon.builder.api.Description");
 
@@ -49,7 +48,6 @@ final class Types {
     static final TypeName PROTOTYPE_CONFIGURED = TypeName.create("io.helidon.builder.api.Prototype.Configured");
     static final TypeName PROTOTYPE_PROVIDES = TypeName.create("io.helidon.builder.api.Prototype.Provides");
     static final TypeName PROTOTYPE_BUILDER = TypeName.create("io.helidon.builder.api.Prototype.Builder");
-    static final TypeName PROTOTYPE_CONFIGURED_BUILDER = TypeName.create("io.helidon.builder.api.Prototype.ConfiguredBuilder");
     static final TypeName PROTOTYPE_CUSTOM_METHODS = TypeName.create("io.helidon.builder.api.Prototype.CustomMethods");
     static final TypeName PROTOTYPE_FACTORY_METHOD = TypeName.create("io.helidon.builder.api.Prototype.FactoryMethod");
     static final TypeName PROTOTYPE_BUILDER_METHOD = TypeName.create("io.helidon.builder.api.Prototype.BuilderMethod");
@@ -85,6 +83,12 @@ final class Types {
     static final TypeName OPTION_TYPE = TypeName.create("io.helidon.builder.api.Option.Type");
     static final TypeName OPTION_DECORATOR = TypeName.create("io.helidon.builder.api.Option.Decorator");
 
+    static final TypeName CONFIG_CONFIGURED_BUILDER = TypeName.create(
+            "io.helidon.common.config.ConfigBuilderSupport.ConfiguredBuilder");
+    static final TypeName CONFIG_BUILDER_SUPPORT = TypeName.create("io.helidon.common.config.ConfigBuilderSupport");
+
+    static final TypeName REGISTRY_BUILDER_SUPPORT = TypeName.create("io.helidon.service.registry.RegistryBuilderSupport");
+
     private Types() {
     }
 }
diff --git a/builder/codegen/src/main/java/module-info.java b/builder/codegen/src/main/java/module-info.java
index 03028027941..daf59b4212a 100644
--- a/builder/codegen/src/main/java/module-info.java
+++ b/builder/codegen/src/main/java/module-info.java
@@ -23,7 +23,6 @@
     requires io.helidon.common.types;
     requires io.helidon.codegen;
     requires io.helidon.codegen.classmodel;
-    requires java.desktop;
 
     exports io.helidon.builder.codegen;
 
diff --git a/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java b/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
index 32d0b890c0f..3385d2930d0 100644
--- a/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
+++ b/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
@@ -40,10 +40,10 @@
 import io.helidon.common.types.TypeName;
 
 import static io.helidon.builder.processor.Types.CHAR_ARRAY_TYPE;
+import static io.helidon.builder.processor.Types.CONFIG_CONFIGURED_BUILDER;
 import static io.helidon.builder.processor.Types.CONFIG_TYPE;
 import static io.helidon.builder.processor.Types.OVERRIDE;
 import static io.helidon.builder.processor.Types.PROTOTYPE_BUILDER;
-import static io.helidon.builder.processor.Types.PROTOTYPE_CONFIGURED_BUILDER;
 import static io.helidon.builder.processor.Types.STRING_TYPE;
 import static io.helidon.common.processor.GeneratorTools.capitalize;
 import static io.helidon.common.processor.classmodel.ClassModel.TYPE_TOKEN;
@@ -93,7 +93,7 @@ static void generate(ClassModel.Builder classModel,
 
             if (typeContext.configuredData().configured() || hasConfig(typeContext.propertyData().properties())) {
                 builder.addInterface(TypeName.builder()
-                                             .from(TypeName.create(PROTOTYPE_CONFIGURED_BUILDER))
+                                             .from(CONFIG_CONFIGURED_BUILDER)
                                              .addTypeArgument(TypeName.createFromGenericDeclaration("BUILDER"))
                                              .addTypeArgument(TypeName.createFromGenericDeclaration("PROTOTYPE"))
                                              .build());
diff --git a/builder/processor/src/main/java/io/helidon/builder/processor/Types.java b/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
index fda9f783f2c..23c62863cf1 100644
--- a/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
+++ b/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
@@ -38,7 +38,6 @@ final class Types {
     static final String FACTORY_METHOD = "io.helidon.builder.api.Prototype.FactoryMethod";
     static final String PROTOTYPE_BUILDER = "io.helidon.builder.api.Prototype.Builder";
     static final String PROTOTYPE_CONFIGURED = "io.helidon.builder.api.Prototype.Configured";
-    static final String PROTOTYPE_CONFIGURED_BUILDER = "io.helidon.builder.api.Prototype.ConfiguredBuilder";
     static final String PROTOTYPE_BLUEPRINT = "io.helidon.builder.api.Prototype.Blueprint";
     static final String PROTOTYPE_FACTORY = "io.helidon.builder.api.Prototype.Factory";
     static final String PROTOTYPE_ANNOTATED = "io.helidon.builder.api.Prototype.Annotated";
@@ -111,6 +110,10 @@ final class Types {
     static final TypeName LINKED_HASH_SET_TYPE = TypeName.create(LinkedHashSet.class);
     static final TypeName ARRAY_LIST_TYPE = TypeName.create(ArrayList.class);
 
+    static final TypeName CONFIG_CONFIGURED_BUILDER = TypeName.create(
+            "io.helidon.common.config.ConfigBuilderSupport.ConfiguredBuilder");
+    static final TypeName CONFIG_BUILDER_SUPPORT = TypeName.create("io.helidon.common.config.ConfigBuilderSupport");
+
     private Types() {
     }
 }
diff --git a/builder/tests/builder/pom.xml b/builder/tests/builder/pom.xml
index bb670f36128..e60957cd550 100644
--- a/builder/tests/builder/pom.xml
+++ b/builder/tests/builder/pom.xml
@@ -39,10 +39,6 @@
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-registry</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-builder</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
diff --git a/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java b/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
index 48566e93919..11b105483e3 100644
--- a/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
+++ b/builder/tests/builder/src/main/java/io/helidon/builder/test/testsubjects/WithProviderRegistryBlueprint.java
@@ -22,7 +22,7 @@
 
 import io.helidon.builder.api.Option;
 import io.helidon.builder.api.Prototype;
-import io.helidon.common.mapper.MapperManager;
+import io.helidon.common.mapper.Mappers;
 
 @Prototype.Blueprint
 @Prototype.Configured
@@ -72,14 +72,14 @@ interface WithProviderRegistryBlueprint {
     List<ProviderNoImpls.SomeService> listNoImplNotDiscover();
 
     @Option.RegistryService
-    Optional<MapperManager> mapperManager();
+    Optional<Mappers> mappers();
 
     @Option.RegistryService
-    MapperManager mapperManagerExplicit();
+    Mappers mappersExplicit();
 
     @Option.RegistryService
-    List<MapperManager> mapperManagers();
+    List<Mappers> mappersList();
 
     @Option.RegistryService
-    Set<MapperManager> mapperManagerSet();
+    Set<Mappers> mappersSet();
 }
diff --git a/builder/tests/builder/src/main/java/module-info.java b/builder/tests/builder/src/main/java/module-info.java
index 9706e29f293..f1db16c08c2 100644
--- a/builder/tests/builder/src/main/java/module-info.java
+++ b/builder/tests/builder/src/main/java/module-info.java
@@ -25,7 +25,6 @@
     requires io.helidon.common.config;
     requires io.helidon.builder.api;
     requires io.helidon.service.registry;
-    requires io.helidon.service.builder;
 
     exports io.helidon.builder.test.testsubjects;
 
diff --git a/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java b/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
index 86055fb26a4..aabad49addc 100644
--- a/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
+++ b/builder/tests/builder/src/test/java/io/helidon/builder/test/ProviderRegistryTest.java
@@ -21,7 +21,7 @@
 import io.helidon.builder.test.testsubjects.SomeProvider;
 import io.helidon.builder.test.testsubjects.WithProviderRegistry;
 import io.helidon.common.Errors;
-import io.helidon.common.mapper.MapperManager;
+import io.helidon.common.mapper.Mappers;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 
@@ -51,7 +51,7 @@ void testMinimalDefined() {
          */
         WithProviderRegistry value = WithProviderRegistry.builder()
                 .config(config.get("min-defined"))
-                .mapperManagerExplicit(MapperManager.global())
+                .mappersExplicit(Mappers.create())
                 .build();
 
         assertThat(value.oneDiscover().prop(), is("some-1"));
@@ -79,7 +79,7 @@ void testAllDefined() {
          */
         WithProviderRegistry value = WithProviderRegistry.builder()
                 .config(config.get("all-defined"))
-                .mapperManagerExplicit(MapperManager.global())
+                .mappersExplicit(Mappers.create())
                 .build();
 
         assertThat(value.oneDiscover().prop(), is("config"));
@@ -107,7 +107,7 @@ void testFail() {
         Errors.ErrorMessagesException fail = assertThrows(Errors.ErrorMessagesException.class,
                                                           () -> WithProviderRegistry.builder()
                                                                   .config(config.get("fail"))
-                                                                  .mapperManagerExplicit(MapperManager.global())
+                                                                  .mappersExplicit(Mappers.create())
                                                                   .build());
 
         assertThat(fail.getMessages(), hasSize(1));
@@ -122,7 +122,7 @@ Single value list (when not using discovery). When discovery is used, all in ser
          */
         WithProviderRegistry value = WithProviderRegistry.builder()
                 .config(config.get("single-list"))
-                .mapperManagerExplicit(MapperManager.global())
+                .mappersExplicit(Mappers.create())
                 .build();
 
         assertThat(value.oneNotDiscover().prop(), is("config2"));
@@ -143,7 +143,7 @@ void testDisabledDiscoveryOnTheCopy() {
         WithProviderRegistry value = WithProviderRegistry.builder()
                 .listDiscoverDiscoverServices(false)
                 .oneNotDiscover(someService) //This needs to be set, otherwise validation fails
-                .mapperManagerExplicit(MapperManager.global())
+                .mappersExplicit(Mappers.create())
                 .build();
         assertThat(value.listDiscover(), is(List.of()));
 
@@ -158,12 +158,13 @@ void testDisabledDiscoveryOnTheCopiedBuilder() {
         SomeProvider.SomeService someService = new DummyService();
         WithProviderRegistry.Builder value = WithProviderRegistry.builder()
                 .listDiscoverDiscoverServices(false)
-                .mapperManagerExplicit(MapperManager.global())
+                .mappersExplicit(Mappers.create())
                 .oneNotDiscover(someService);
 
         WithProviderRegistry copy = WithProviderRegistry.builder()
                 .from(value)
                 .build();
+
         assertThat(copy.listDiscover(), is(List.of()));
     }
 
diff --git a/builder/tests/codegen/pom.xml b/builder/tests/codegen/pom.xml
index 18d8e34e44e..56aae2c3df5 100644
--- a/builder/tests/codegen/pom.xml
+++ b/builder/tests/codegen/pom.xml
@@ -48,11 +48,6 @@
             <artifactId>helidon-service-registry</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-builder</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>io.helidon.builder</groupId>
             <artifactId>helidon-builder-api</artifactId>
diff --git a/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java b/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
index 5641ddd9bfb..02788c1578f 100644
--- a/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
+++ b/builder/tests/codegen/src/test/java/io/helidon/builder/codegen/TypesTest.java
@@ -35,9 +35,10 @@
 import io.helidon.builder.api.RuntimeType;
 import io.helidon.common.Generated;
 import io.helidon.common.config.Config;
+import io.helidon.common.config.ConfigBuilderSupport;
 import io.helidon.common.types.TypeName;
-import io.helidon.service.builder.BuilderRegistrySupport;
 import io.helidon.service.registry.GlobalServiceRegistry;
+import io.helidon.service.registry.RegistryBuilderSupport;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.Services;
 
@@ -100,7 +101,6 @@ void testTypes() {
         checkField(toCheck, checked, fields, "PROTOTYPE_CONFIGURED", Prototype.Configured.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_PROVIDES", Prototype.Provides.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_BUILDER", Prototype.Builder.class);
-        checkField(toCheck, checked, fields, "PROTOTYPE_CONFIGURED_BUILDER", Prototype.ConfiguredBuilder.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_CUSTOM_METHODS", Prototype.CustomMethods.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_FACTORY_METHOD", Prototype.FactoryMethod.class);
         checkField(toCheck, checked, fields, "PROTOTYPE_BUILDER_METHOD", Prototype.BuilderMethod.class);
@@ -134,9 +134,13 @@ void testTypes() {
         checkField(toCheck, checked, fields, "OPTION_DECORATOR", Option.Decorator.class);
         checkField(toCheck, checked, fields, "OPTION_REGISTRY_SERVICE", Option.RegistryService.class);
 
-        checkField(toCheck, checked, fields, "REGISTRY_SUPPORT", BuilderRegistrySupport.class);
         checkField(toCheck, checked, fields, "SERVICES", Services.class);
 
+        checkField(toCheck, checked, fields, "CONFIG_BUILDER_SUPPORT", ConfigBuilderSupport.class);
+        checkField(toCheck, checked, fields, "CONFIG_CONFIGURED_BUILDER", ConfigBuilderSupport.ConfiguredBuilder.class);
+
+        checkField(toCheck, checked, fields, "REGISTRY_BUILDER_SUPPORT", RegistryBuilderSupport.class);
+
         assertThat(toCheck, IsEmptyCollection.empty());
     }
 
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/ElementSignature.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/ElementSignature.java
index a167313516d..6e045d1c970 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/ElementSignature.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/ElementSignature.java
@@ -45,6 +45,39 @@ public sealed interface ElementSignature permits ElementSignatures.FieldSignatur
                                                  ElementSignatures.MethodSignature,
                                                  ElementSignatures.ParameterSignature,
                                                  ElementSignatures.NoSignature {
+    /**
+     * A field signature.
+     *
+     * @param type type of the field
+     * @param name name of the field
+     * @return a new field signature
+     */
+    static ElementSignature createField(TypeName type, String name) {
+        return ElementSignatures.createField(type, name);
+    }
+
+    /**
+     * A constructor signature.
+     *
+     * @param parameters list of types of parameters
+     * @return a new constructor signature
+     */
+    static ElementSignature createConstructor(List<TypeName> parameters) {
+        return ElementSignatures.createConstructor(parameters);
+    }
+
+    /**
+     * A method signature.
+     *
+     * @param returnType return type of the method
+     * @param name name of the method
+     * @param parameters parameter types of the method
+     * @return a new method signature
+     */
+    static ElementSignature createMethod(TypeName returnType, String name, List<TypeName> parameters) {
+        return ElementSignatures.createMethod(returnType, name, parameters);
+    }
+
     /**
      * Type of the element. Resolves as follows:
      * <ul>
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedType.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedType.java
index e962800d60a..f78594ff1f0 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedType.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedType.java
@@ -64,4 +64,11 @@ static ResolvedType create(TypeName typeName) {
      * @return the type name this resolved type represents
      */
     TypeName type();
+
+    /**
+     * The resolved name including all type arguments.
+     *
+     * @return fully qualified class name with all type arguments
+     */
+    String resolvedName();
 }
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedTypeImpl.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedTypeImpl.java
index 24c73cd5fc6..eddfb6a7d0d 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedTypeImpl.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/ResolvedTypeImpl.java
@@ -32,6 +32,11 @@ public TypeName type() {
         return typeName;
     }
 
+    @Override
+    public String resolvedName() {
+        return resolvedName;
+    }
+
     @Override
     public int hashCode() {
         return noTypes ? typeName.hashCode() : resolvedName.hashCode();
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNameSupport.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNameSupport.java
index 7c87d4eaced..791acb5f485 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNameSupport.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNameSupport.java
@@ -18,6 +18,7 @@
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
@@ -192,6 +193,11 @@ static void type(TypeName.BuilderBase<?, ?> builder, Type type) {
             }
             return;
         }
+        if (reflectGenericType instanceof WildcardType) {
+            builder.className("?");
+            builder.wildcard(true);
+            return;
+        }
 
         throw new IllegalArgumentException("We can only create a type from a class, GenericType, or a ParameterizedType,"
                                                    + " but got: " + reflectGenericType.getClass().getName());
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNames.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNames.java
index caf18dbf866..b3d513c516e 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNames.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypeNames.java
@@ -30,6 +30,7 @@
 
 import io.helidon.common.Generated;
 import io.helidon.common.GenericType;
+import io.helidon.common.Size;
 
 /**
  * Commonly used type names.
@@ -87,6 +88,13 @@ public final class TypeNames {
      * Type name for {@link java.lang.annotation.Target}.
      */
     public static final TypeName TARGET = TypeName.create(Target.class);
+    /**
+     * Wildcard type name, represented in code by {@code ?}.
+     */
+    public static final TypeName WILDCARD = TypeName.builder()
+            .className("?")
+            .wildcard(true)
+            .build();
 
     /*
     Primitive types and their boxed counterparts
@@ -199,6 +207,10 @@ public final class TypeNames {
      * Helidon {@link io.helidon.common.GenericType}.
      */
     public static final TypeName GENERIC_TYPE = TypeName.create(GenericType.class);
+    /**
+     * Type name for {@link io.helidon.common.Size}.
+     */
+    public static final TypeName SIZE = TypeName.create(Size.class);
 
     private TypeNames() {
     }
diff --git a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
index 3de312eb13c..ff33c88c696 100644
--- a/builder/tests/common-types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
+++ b/builder/tests/common-types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
@@ -188,4 +188,13 @@ default Object originatingElementValue() {
      */
     @Option.Access("")
     ElementSignature signature();
+
+    /**
+     * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+     * this would return the generic type {@code T} with no upper or lower bounds.
+     *
+     * @return list of type parameters of this element
+     */
+    @Option.Singular
+    List<TypeName> typeParameters();
 }
diff --git a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeFactory.java b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeFactory.java
index 83ddf357e66..f30ca8fc3e7 100644
--- a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeFactory.java
+++ b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeFactory.java
@@ -243,6 +243,11 @@ private static Optional<TypeName> createTypeName(Set<TypeMirror> processed, Elem
             return createTypeName(processed, ee.getReturnType());
         }
 
+        if (type.getKind() == ElementKind.TYPE_PARAMETER) {
+            TypeMirror mirror = type.asType();
+            return createTypeName(processed, mirror);
+        }
+
         List<String> classNames = new ArrayList<>();
         String simpleName = type.getSimpleName().toString();
 
diff --git a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
index 3bb8a300cea..1d54a0fec1c 100644
--- a/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
+++ b/codegen/apt/src/main/java/io/helidon/codegen/apt/AptTypeInfoFactory.java
@@ -30,6 +30,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.AnnotationValue;
@@ -183,6 +184,7 @@ public static Optional<TypedElementInfo> createTypedElementInfoFromElement(AptCo
                 .map(Modifier::toString)
                 .collect(Collectors.toSet());
         Set<TypeName> thrownChecked = Set.of();
+        List<TypeName> typeParameters = new ArrayList<>();
 
         if (v instanceof ExecutableElement ee) {
             typeMirror = Objects.requireNonNull(ee.getReturnType());
@@ -209,6 +211,17 @@ public static Optional<TypedElementInfo> createTypedElementInfoFromElement(AptCo
                     .filter(it -> isCheckedException(ctx, it))
                     .flatMap(it -> AptTypeFactory.createTypeName(it).stream())
                     .collect(Collectors.toSet());
+
+            var elementTypeParameters = ee.getTypeParameters();
+            if (!elementTypeParameters.isEmpty()) {
+                // we need to keep the formal order and number of type parameters; if we cannot create it, just use error
+                elementTypeParameters.stream()
+                        .map(AptTypeFactory::createTypeName)
+                        .flatMap(it -> it.isPresent()
+                                ? it.stream()
+                                : Stream.of(TypeName.createFromGenericDeclaration("error")))
+                        .forEach(typeParameters::add);
+            }
         } else if (v instanceof VariableElement ve) {
             typeMirror = Objects.requireNonNull(ve.asType());
         }
@@ -254,6 +267,7 @@ public static Optional<TypedElementInfo> createTypedElementInfoFromElement(AptCo
                 .accessModifier(accessModifier(modifierNames))
                 .throwsChecked(thrownChecked)
                 .parameterArguments(params)
+                .typeParameters(typeParameters)
                 .originatingElement(v);
 
         // To be failure-tolerant, as the ECJ may not provide an enclosing element for a VariableElement.
diff --git a/codegen/class-model/src/main/java/io/helidon/codegen/classmodel/TypeArgument.java b/codegen/class-model/src/main/java/io/helidon/codegen/classmodel/TypeArgument.java
index f18cbbfffef..7dbde98365b 100644
--- a/codegen/class-model/src/main/java/io/helidon/codegen/classmodel/TypeArgument.java
+++ b/codegen/class-model/src/main/java/io/helidon/codegen/classmodel/TypeArgument.java
@@ -53,6 +53,24 @@ public static TypeArgument create(String token) {
         return builder().token(token).build();
     }
 
+    /**
+     * Creates a new instance from a generic type name.
+     *
+     * @param typeName type name to use
+     * @return a new type argument
+     */
+    public static TypeArgument create(TypeName typeName) {
+        var builder = TypeArgument.builder()
+                .token(typeName.className());
+
+        typeName.upperBounds()
+                .forEach(it -> builder.bound(it).lowerBound(false));
+        typeName.lowerBounds()
+                .forEach(it -> builder.bound(it).lowerBound(true));
+
+        return builder.build();
+    }
+
     /**
      * Return new {@link Builder} instance.
      *
diff --git a/common/config/pom.xml b/common/config/pom.xml
index b9238f1f0e9..5d99847286d 100644
--- a/common/config/pom.xml
+++ b/common/config/pom.xml
@@ -37,6 +37,14 @@
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common-mapper</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.builder</groupId>
+            <artifactId>helidon-builder-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
diff --git a/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java b/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
new file mode 100644
index 00000000000..060cbc8b9db
--- /dev/null
+++ b/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
@@ -0,0 +1,177 @@
+package io.helidon.common.config;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.helidon.builder.api.Prototype;
+import io.helidon.common.HelidonServiceLoader;
+import io.helidon.service.registry.ServiceRegistry;
+
+/**
+ * Methods used from generated code in builders when
+ * {@link io.helidon.builder.api.Prototype.Configured} is used.
+ */
+public final class ConfigBuilderSupport {
+    private ConfigBuilderSupport() {
+    }
+
+    /**
+     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     *
+     * @param config          configuration of the option
+     * @param configKey       configuration key associated with this option
+     * @param serviceRegistry service registry instance
+     * @param providerType    type of the service provider (contract)
+     * @param configType      type of the configuration
+     * @param allFromRegistry whether to use all services from the registry
+     * @param existingValues  existing values that was explicitly configured by the user
+     * @param <T>             type of the service
+     * @return instances from the user augmented with instances from the registry
+     */
+    public static <T extends NamedService> List<T> discoverServices(Config config,
+                                                                    String configKey,
+                                                                    Optional<ServiceRegistry> serviceRegistry,
+                                                                    Class<? extends ConfiguredProvider<T>> providerType,
+                                                                    Class<T> configType,
+                                                                    boolean allFromRegistry,
+                                                                    List<T> existingValues) {
+
+        return ProvidedUtil.discoverServices(config,
+                                             configKey,
+                                             serviceRegistry,
+                                             providerType,
+                                             configType,
+                                             allFromRegistry,
+                                             existingValues);
+    }
+
+    /**
+     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
+     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
+     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     *
+     * @param config           configuration of the option
+     * @param configKey        configuration key associated with this option
+     * @param serviceRegistry  service registry instance
+     * @param providerType     type of the service provider (contract)
+     * @param configType       type of the configuration
+     * @param discoverServices whether to discover services from registry
+     * @param existingValue    existing value that was explicitly configured by the user
+     * @param <T>              type of the service
+     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
+     */
+    public static <T extends NamedService> Optional<T>
+    discoverService(Config config,
+                    String configKey,
+                    Optional<ServiceRegistry> serviceRegistry,
+                    Class<? extends ConfiguredProvider<T>> providerType,
+                    Class<T> configType,
+                    boolean discoverServices,
+                    Optional<T> existingValue) {
+
+        return ProvidedUtil.discoverService(config,
+                                            configKey,
+                                            serviceRegistry,
+                                            providerType,
+                                            configType,
+                                            discoverServices,
+                                            existingValue);
+    }
+
+
+    /**
+     * Discover services from configuration.
+     * If already configured instances already contain a service of the same type and name that would be added from
+     * configuration, the configuration would be ignored (e.g. the user must make a choice whether to configure, or
+     * set using an API).
+     *
+     * @param config               configuration located at the parent node of the service providers
+     * @param configKey            configuration key of the provider list
+     *                             (either a list node, or object, where each child is one service)
+     * @param serviceLoader        helidon service loader for the expected type
+     * @param providerType         type of the service provider interface
+     * @param configType           type of the configured service
+     * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
+     *                             node
+     * @param existingInstances    already configured instances
+     * @param <S>                  type of the expected service
+     * @param <T>                  type of the configured service provider that creates instances of S
+     * @return list of discovered services, ordered by {@link io.helidon.common.Weight} (highest weight is first in the list)
+     */
+    public static <S extends NamedService, T extends ConfiguredProvider<S>> List<S>
+    discoverServices(Config config,
+                     String configKey,
+                     HelidonServiceLoader<T> serviceLoader,
+                     Class<T> providerType,
+                     Class<S> configType,
+                     boolean allFromServiceLoader,
+                     List<S> existingInstances) {
+        return ProvidedUtil.discoverServices(config,
+                                             configKey,
+                                             serviceLoader,
+                                             providerType,
+                                             configType,
+                                             allFromServiceLoader,
+                                             existingInstances);
+    }
+
+    /**
+     * Discover service from configuration. If an instance is already configured using a builder, it will not be
+     * discovered from configuration (e.g. the user must make a choice whether to configure, or set using API).
+     *
+     * @param config               configuration located at the parent node of the service providers
+     * @param configKey            configuration key of the provider list
+     *                             (either a list node, or object, where each child is one service - this method requires
+     *                             *                             zero to one configured services)
+     * @param serviceLoader        helidon service loader for the expected type
+     * @param providerType         type of the service provider interface
+     * @param configType           type of the configured service
+     * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
+     *                             node
+     * @param existingValue        value already configured, if the name is same as discovered from configuration
+     * @param <S>                  type of the expected service
+     * @param <T>                  type of the configured service provider that creates instances of S
+     * @return the first service (ordered by {@link io.helidon.common.Weight} that is discovered, or empty optional if none
+     *         is found
+     */
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    public static <S extends NamedService, T extends ConfiguredProvider<S>> Optional<S>
+    discoverService(Config config,
+                    String configKey,
+                    HelidonServiceLoader<T> serviceLoader,
+                    Class<T> providerType,
+                    Class<S> configType,
+                    boolean allFromServiceLoader,
+                    Optional<S> existingValue) {
+        return ProvidedUtil.discoverService(config,
+                                            configKey,
+                                            serviceLoader,
+                                            providerType,
+                                            configType,
+                                            allFromServiceLoader,
+                                            existingValue);
+    }
+
+    /**
+     * Extension of {@link io.helidon.builder.api.Prototype.Builder} that supports configuration.
+     * If a blueprint is marked as {@code @Configured}, build will accept configuration.
+     *
+     * @param <BUILDER>   type of the builder
+     * @param <PROTOTYPE> type of the prototype to be built
+     */
+    public interface ConfiguredBuilder<BUILDER, PROTOTYPE> extends Prototype.Builder<BUILDER, PROTOTYPE> {
+        /**
+         * Update builder from configuration.
+         * Any configured option that is defined on this prototype will be checked in configuration, and if it exists,
+         * it will override current value for that option on this builder.
+         * Options that do not exist in the provided config will not impact current values.
+         * The config instance is kept and may be used in builder decorator, it is not available in prototype implementation.
+         *
+         * @param config configuration to use
+         * @return updated builder instance
+         */
+        BUILDER config(Config config);
+    }
+}
diff --git a/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java b/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
index 387dfdc2a85..dcb8bb6ebd7 100644
--- a/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
+++ b/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
@@ -25,6 +25,7 @@
 import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.LazyValue;
 import io.helidon.common.config.spi.ConfigProvider;
+import io.helidon.service.registry.Services;
 
 /**
  * Global configuration can be set by a user before any Helidon code is invoked, to override default discovery
@@ -89,14 +90,23 @@ public static Config config(Supplier<Config> config) {
      * @param config configuration to use
      * @param overwrite whether to overwrite an existing configured value
      * @return current global config
+     * @deprecated use {@link io.helidon.service.registry.Services#get(Class)} instead
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     public static Config config(Supplier<Config> config, boolean overwrite) {
         Objects.requireNonNull(config);
 
         if (overwrite || !configured()) {
             // there is a certain risk we may do this twice, if two components try to set global config in parallel.
             // as the result was already unclear (as order matters), we do not need to be 100% thread safe here
-            CONFIG.set(config.get());
+            Config config1 = config.get();
+            CONFIG.set(config1);
+
+            try {
+                Services.set(Config.class, config1);
+            } catch (Exception e) {
+                // todo log in warning, as this will not work in the future
+            }
         }
         return CONFIG.get();
     }
diff --git a/service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java b/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
similarity index 61%
rename from service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java
rename to common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
index e525265e51d..2e0506a5b58 100644
--- a/service/builder/src/main/java/io/helidon/service/builder/BuilderRegistrySupport.java
+++ b/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
@@ -1,4 +1,20 @@
-package io.helidon.service.builder;
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.common.config;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -10,21 +26,12 @@
 import java.util.Set;
 
 import io.helidon.builder.api.Prototype;
-import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.ConfiguredProvider;
-import io.helidon.common.config.NamedService;
+import io.helidon.common.HelidonServiceLoader;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.Services;
 
-/**
- * Support for services from service registry in a generated builder.
- * <p>
- * All public methods on this type are used from generated code.
- */
-public final class BuilderRegistrySupport {
+final class ProvidedUtil {
     private static final System.Logger PROVIDER_LOGGER = System.getLogger(Prototype.class.getName() + ".provider");
-
     /**
      * Special configuration key that can be defined on provided options (loaded through ServiceLoader) that defines
      * the mapping to a provider.
@@ -49,38 +56,90 @@ public final class BuilderRegistrySupport {
      */
     private static final String KEY_SERVICE_ENABLED = "enabled";
 
-    private BuilderRegistrySupport() {
+    private ProvidedUtil() {
+    }
+
+    /**
+     * Discover service from configuration.
+     * This method looks for a single provider only.
+     *
+     * @param config           configuration located at the parent node of the service providers
+     * @param configKey        configuration key of the provider list
+     *                         (either a list node, or object, where each child is one service)
+     * @param serviceLoader    helidon service loader for the expected type
+     * @param providerType     service provider interface type
+     * @param configType       configured service type
+     * @param discoverServices whether all services from service loader should be used, or only the ones with configured
+     *                         node
+     * @param existingValue    value already configured, if the name is same as discovered from configuration
+     * @param <T>              type of the expected service
+     * @return first service by {@link io.helidon.common.Weight}, or empty optional
+     */
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    static <T extends NamedService> Optional<T>
+    discoverService(Config config,
+                    String configKey,
+                    HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
+                    Class<? extends ConfiguredProvider<T>> providerType,
+                    Class<T> configType,
+                    boolean discoverServices,
+                    Optional<T> existingValue) {
+
+        // there is an explicit configuration for this service, ignore configuration
+        if (existingValue.isPresent()) {
+            return Optional.empty();
+        }
+
+        // all child nodes of the current node
+        List<Config> serviceConfigList = config.get(configKey).asNodeList()
+                .orElseGet(List::of);
+
+        // if more than one is configured in config, fail
+        // if more than one exists in service loader, use the first one
+        if (serviceConfigList.size() > 1) {
+            throw new ConfigException("There can only be one provider configured for " + config.key());
+        }
+
+        List<T> services = discoverServices(config,
+                                            configKey,
+                                            serviceLoader,
+                                            providerType,
+                                            configType,
+                                            discoverServices,
+                                            List.of());
+
+        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
     }
 
     /**
-     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
+     * Discover services from configuration.
      *
-     * @param config          configuration of the option
-     * @param configKey       configuration key associated with this option
-     * @param serviceRegistry service registry instance
-     * @param providerType    type of the service provider (contract)
-     * @param configType      type of the configuration
-     * @param allFromRegistry whether to use all services from the registry
-     * @param existingValues  existing values that was explicitly configured by the user
-     * @param <T>             type of the service
-     * @return instances from the user augmented with instances from the registry
+     * @param config               configuration located at the parent node of the service providers
+     * @param configKey            configuration key of the provider list
+     *                             (either a list node, or object, where each child is one service)
+     * @param serviceLoader        helidon service loader for the expected type
+     * @param providerType         service provider interface type
+     * @param configType           configured service type
+     * @param allFromServiceLoader whether all services from service loader should be used, or only the ones with configured
+     *                             node
+     * @param existingInstances    already configured instances
+     * @param <T>                  type of the expected service
+     * @return list of discovered services, ordered by {@link io.helidon.common.Weight} (highest weight first)
      */
-    public static <T extends NamedService> List<T> discoverServices(Config config,
-                                                                    String configKey,
-                                                                    ServiceRegistry serviceRegistry,
-                                                                    Class<? extends ConfiguredProvider<T>> providerType,
-                                                                    Class<T> configType,
-                                                                    boolean allFromRegistry,
-                                                                    List<T> existingValues) {
+    static <T extends NamedService> List<T> discoverServices(Config config,
+                                                             String configKey,
+                                                             HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
+                                                             Class<? extends ConfiguredProvider<T>> providerType,
+                                                             Class<T> configType,
+                                                             boolean allFromServiceLoader,
+                                                             List<T> existingInstances) {
 
         // type and name is a unique identification of a service - for services already defined on the builder
         // do not add them from configuration (as this would duplicate service instances)
         Set<TypeAndName> ignoredServices = new HashSet<>();
-        existingValues.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
+        existingInstances.forEach(it -> ignoredServices.add(new TypeAndName(it.type(), it.name())));
 
-        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromRegistry);
+        boolean discoverServices = config.get(configKey + "-discover-services").asBoolean().orElse(allFromServiceLoader);
         Config providersConfig = config.get(configKey);
 
         List<ConfiguredService> configuredServices = new ArrayList<>();
@@ -97,7 +156,7 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         // now we have all service configurations, we can start building up instances
         if (providersConfig.isList()) {
             // driven by order of declaration in config
-            return servicesFromList(new RealRegistry(serviceRegistry),
+            return servicesFromList(serviceLoader,
                                     providerType,
                                     configType,
                                     configuredServices,
@@ -106,7 +165,7 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         } else {
             // driven by service loader order
             return servicesFromObject(providersConfig,
-                                      new RealRegistry(serviceRegistry),
+                                      serviceLoader,
                                       providerType,
                                       configType,
                                       configuredServices,
@@ -115,77 +174,13 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         }
     }
 
-    /**
-     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
-     *
-     * @param config           configuration of the option
-     * @param configKey        configuration key associated with this option
-     * @param serviceRegistry  service registry instance
-     * @param providerType     type of the service provider (contract)
-     * @param configType       type of the configuration
-     * @param discoverServices whether to discover services from registry
-     * @param existingValue    existing value that was explicitly configured by the user
-     * @param <T>              type of the service
-     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
-     */
-    public static <T extends NamedService> Optional<T>
-    discoverService(Config config,
-                    String configKey,
-                    ServiceRegistry serviceRegistry,
-                    Class<? extends ConfiguredProvider<T>> providerType,
-                    Class<T> configType,
-                    boolean discoverServices,
-                    Optional<T> existingValue) {
-
-        // there is an explicit configuration for this service, ignore configuration
-        if (existingValue.isPresent()) {
-            return Optional.empty();
-        }
-
-        // all child nodes of the current node
-        List<Config> serviceConfigList = config.get(configKey).asNodeList()
-                .orElseGet(List::of);
-
-        // if more than one is configured in config, fail
-        // if more than one exists in service loader, use the first one
-        if (serviceConfigList.size() > 1) {
-            throw new ConfigException("There can only be one provider configured for " + config.key());
-        }
-
-        List<T> services = discoverServices(config,
-                                            configKey,
-                                            serviceRegistry,
-                                            providerType,
-                                            configType,
-                                            discoverServices,
-                                            List.of());
-
-        return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
-    }
-
-    /**
-     * Used to discover services from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
-     * This method uses static access (when no registry is explicitly defined).
-     *
-     * @param config          configuration of the option
-     * @param configKey       configuration key associated with this option
-     * @param providerType    type of the service provider (contract)
-     * @param configType      type of the configuration
-     * @param allFromRegistry whether to use all services from the registry
-     * @param existingValues  existing values that was explicitly configured by the user
-     * @param <T>             type of the service
-     * @return instances from the user augmented with instances from the registry
-     */
-    public static <T extends NamedService> List<T> discoverServices(Config config,
-                                                                    String configKey,
-                                                                    Class<? extends ConfiguredProvider<T>> providerType,
-                                                                    Class<T> configType,
-                                                                    boolean allFromRegistry,
-                                                                    List<T> existingValues) {
+    static <T extends NamedService> List<T> discoverServices(Config config,
+                                                             String configKey,
+                                                             Optional<ServiceRegistry> serviceRegistry,
+                                                             Class<? extends ConfiguredProvider<T>> providerType,
+                                                             Class<T> configType,
+                                                             boolean allFromRegistry,
+                                                             List<T> existingValues) {
 
         // type and name is a unique identification of a service - for services already defined on the builder
         // do not add them from configuration (as this would duplicate service instances)
@@ -205,11 +200,14 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         for (Config serviceConfig : serviceConfigList) {
             configuredServices.add(configuredService(serviceConfig, isList));
         }
+        RegistryWrap wrap = serviceRegistry.isPresent()
+                ? new RealRegistry(serviceRegistry.get())
+                : StaticAccessRegistry.INSTANCE;
 
         // now we have all service configurations, we can start building up instances
         if (providersConfig.isList()) {
             // driven by order of declaration in config
-            return servicesFromList(StaticAccessRegistry.INSTANCE,
+            return servicesFromList(wrap,
                                     providerType,
                                     configType,
                                     configuredServices,
@@ -218,7 +216,7 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         } else {
             // driven by service loader order
             return servicesFromObject(providersConfig,
-                                      StaticAccessRegistry.INSTANCE,
+                                      wrap,
                                       providerType,
                                       configType,
                                       configuredServices,
@@ -227,24 +225,10 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         }
     }
 
-    /**
-     * Used to discover service from {@link io.helidon.service.registry.ServiceRegistry} for builder options annotated
-     * with {@link io.helidon.builder.api.Option.Provider}, if the blueprint is annotated with
-     * {@link io.helidon.builder.api.Prototype.RegistrySupport}.
-     * This method uses static access (when no registry is explicitly defined).
-     *
-     * @param config           configuration of the option
-     * @param configKey        configuration key associated with this option
-     * @param providerType     type of the service provider (contract)
-     * @param configType       type of the configuration
-     * @param discoverServices whether to discover services from registry
-     * @param existingValue    existing value that was explicitly configured by the user
-     * @param <T>              type of the service
-     * @return an instance, if available in the registry, or if provided by the user (user's value wins)
-     */
-    public static <T extends NamedService> Optional<T>
+    static <T extends NamedService> Optional<T>
     discoverService(Config config,
                     String configKey,
+                    Optional<ServiceRegistry> serviceRegistry,
                     Class<? extends ConfiguredProvider<T>> providerType,
                     Class<T> configType,
                     boolean discoverServices,
@@ -267,6 +251,7 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
 
         List<T> services = discoverServices(config,
                                             configKey,
+                                            serviceRegistry,
                                             providerType,
                                             configType,
                                             discoverServices,
@@ -275,6 +260,119 @@ public static <T extends NamedService> List<T> discoverServices(Config config,
         return services.isEmpty() ? Optional.empty() : Optional.of(services.getFirst());
     }
 
+    private static <T extends NamedService> List<T>
+    servicesFromObject(Config providersConfig,
+                       HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
+                       Class<? extends ConfiguredProvider<T>> providerType,
+                       Class<T> configType,
+                       List<ConfiguredService> configuredServices,
+                       boolean allFromServiceLoader,
+                       Set<TypeAndName> ignoredServices) {
+        // order is determined by service loader
+        Set<String> availableProviders = new HashSet<>();
+        Map<String, ConfiguredService> allConfigs = new HashMap<>();
+        configuredServices.forEach(it -> allConfigs.put(it.typeAndName().type, it));
+        Set<String> unusedConfigs = new HashSet<>(allConfigs.keySet());
+
+        List<T> result = new ArrayList<>();
+
+        serviceLoader.forEach(provider -> {
+            ConfiguredService configuredService = allConfigs.get(provider.configKey());
+            availableProviders.add(provider.configKey());
+            unusedConfigs.remove(provider.configKey());
+            if (configuredService == null) {
+                if (allFromServiceLoader) {
+                    // even though the specific key does not exist, we want to have the real config tree, so we can get to the
+                    // root of it
+                    // when there is no configuration, the name defaults to the type
+                    String type = provider.configKey();
+                    if (ignoredServices.add(new TypeAndName(type, type))) {
+                        result.add(provider.create(providersConfig.get(type), type));
+                    } else {
+                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + new TypeAndName(type, type)
+                                    + " is already added in builder, ignoring configured one.");
+                        }
+                    }
+                }
+            } else {
+                if (configuredService.enabled()) {
+                    if (ignoredServices.add(configuredService.typeAndName())) {
+                        result.add(provider.create(configuredService.serviceConfig(),
+                                                   configuredService.typeAndName().name()));
+                    } else {
+                        if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                            PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + configuredService.typeAndName()
+                                    + " is already added in builder, ignoring configured one.");
+                        }
+                    }
+                }
+            }
+        });
+        if (!unusedConfigs.isEmpty()) {
+            throw new ConfigException("Unknown provider configured. Expected providers with types: " + unusedConfigs
+                                              + ", but only the following providers are supported: " + availableProviders
+                                              + ", provider interface: " + providerType.getName()
+                                              + ", configured service: " + configType.getName());
+        }
+        return result;
+    }
+
+    private static <T extends NamedService> List<T>
+    servicesFromList(HelidonServiceLoader<? extends ConfiguredProvider<T>> serviceLoader,
+                     Class<? extends ConfiguredProvider<T>> providerType,
+                     Class<T> configType,
+                     List<ConfiguredService> configuredServices,
+                     boolean allFromServiceLoader,
+                     Set<TypeAndName> ignoredServices) {
+        Map<String, ConfiguredProvider<T>> allProvidersByType = new HashMap<>();
+        Map<String, ConfiguredProvider<T>> unusedProvidersByType = new LinkedHashMap<>();
+        serviceLoader.forEach(it -> {
+            allProvidersByType.put(it.configKey(), it);
+            unusedProvidersByType.put(it.configKey(), it);
+        });
+
+        List<T> result = new ArrayList<>();
+
+        // first add all configured
+        for (ConfiguredService service : configuredServices) {
+            TypeAndName typeAndName = service.typeAndName();
+            if (!ignoredServices.add(typeAndName)) {
+                unusedProvidersByType.remove(typeAndName.type());
+
+                if (PROVIDER_LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                    PROVIDER_LOGGER.log(System.Logger.Level.DEBUG, "Service: " + typeAndName
+                            + " is already added in builder, ignoring configured one.");
+                }
+
+                continue;
+            }
+            ConfiguredProvider<T> provider = allProvidersByType.get(typeAndName.type());
+            if (provider == null) {
+                throw new ConfigException("Unknown provider configured. Expecting a provider with type \"" + typeAndName.type()
+                                                  + "\", but only the following providers are supported: "
+                                                  + allProvidersByType.keySet() + ", "
+                                                  + "provider interface: " + providerType.getName()
+                                                  + ", configured service: " + configType.getName());
+            }
+            unusedProvidersByType.remove(typeAndName.type());
+            if (service.enabled()) {
+                result.add(provider.create(service.serviceConfig(), typeAndName.name()));
+            }
+        }
+
+        // then (if desired) add the rest
+        if (allFromServiceLoader) {
+            unusedProvidersByType.forEach((type, provider) -> {
+                if (ignoredServices.add(new TypeAndName(type, type))) {
+                    result.add(provider.create(Config.empty(), type));
+                }
+            });
+        }
+
+        return result;
+    }
+
     private static ConfiguredService configuredService(Config serviceConfig, boolean isList) {
         if (isList) {
             // order is significant
diff --git a/common/config/src/main/java/module-info.java b/common/config/src/main/java/module-info.java
index 9e0842c930e..cac01107aeb 100644
--- a/common/config/src/main/java/module-info.java
+++ b/common/config/src/main/java/module-info.java
@@ -21,6 +21,7 @@
 
     requires transitive io.helidon.common;
     requires transitive io.helidon.common.mapper;
+    requires io.helidon.service.registry;
 
     exports io.helidon.common.config;
     exports io.helidon.common.config.spi;
diff --git a/common/mapper/pom.xml b/common/mapper/pom.xml
index 567fb46285c..23f2b7e8350 100644
--- a/common/mapper/pom.xml
+++ b/common/mapper/pom.xml
@@ -41,6 +41,18 @@
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.builder</groupId>
+            <artifactId>helidon-builder-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.common</groupId>
+            <artifactId>helidon-common-types</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
@@ -52,4 +64,59 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.builder</groupId>
+                            <artifactId>helidon-builder-codegen</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-apt</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.builder</groupId>
+                        <artifactId>helidon-builder-codegen</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+        </plugins>
+    </build>
 </project>
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/BuiltInMappers.java b/common/mapper/src/main/java/io/helidon/common/mapper/BuiltInMappers.java
index e2a42d4333d..f54cac3f981 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/BuiltInMappers.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/BuiltInMappers.java
@@ -44,6 +44,7 @@
 import java.util.function.Function;
 import java.util.regex.Pattern;
 
+import io.helidon.common.Weight;
 import io.helidon.common.mapper.spi.MapperProvider;
 
 /*
@@ -51,6 +52,7 @@
  * This does not contain many of date/time mapping, as that is context sensitive (e.g. you need a different
  * format depending on the component used).
  */
+@Weight(10)
 class BuiltInMappers implements MapperProvider {
     private static final Map<ClassPair, Mapper<?, ?>> MAPPERS;
 
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java b/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
index 88bdef3ab83..53b0893276b 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
@@ -19,8 +19,12 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import io.helidon.common.Weight;
 import io.helidon.common.mapper.spi.MapperProvider;
+import io.helidon.service.registry.Service;
 
+@Service.Singleton
+@Weight(0.1)
 class DefaultMapperProvider implements MapperProvider {
     private static final Map<CacheKey, ProviderResponse> CACHE = new ConcurrentHashMap<>();
 
@@ -38,7 +42,6 @@ public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, Strin
     }
 
     private static ProviderResponse fromString(Class<?> target) {
-        // todo add all supported types
         if (target.equals(int.class) || target.equals(Integer.class)) {
             return new ProviderResponse(Support.COMPATIBLE, o -> Integer.parseInt((String) o));
         }
@@ -49,7 +52,6 @@ private static ProviderResponse fromString(Class<?> target) {
     }
 
     private static ProviderResponse toString(Class<?> source) {
-        // todo add all supported types (explicitly)
         return new ProviderResponse(Support.COMPATIBLE, String::valueOf);
     }
 
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java b/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
index 2c2786c4d78..83b29413104 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
@@ -15,8 +15,11 @@
  */
 package io.helidon.common.mapper;
 
+import java.util.Set;
 import java.util.function.Function;
 
+import io.helidon.common.GenericType;
+
 /**
  * A generic and general approach to mapping two types.
  * A mapper is unidirectional - from {@code SOURCE} to {@code TARGET}.
@@ -38,4 +41,41 @@ public interface Mapper<SOURCE, TARGET> extends Function<SOURCE, TARGET> {
     default TARGET apply(SOURCE source){
         return map(source);
     }
+
+    /**
+     * Source type of the mapper. This does not need to be implemented when registered using
+     * {@link io.helidon.common.mapper.MappersConfig.Builder} {@code addMapper} methods.
+     * <p>
+     * It MUST be implemented when implementing a service (i.e. {@link io.helidon.service.registry.Service.Singleton}).
+     *
+     * @return type of the source this mapper support
+     */
+    default GenericType<SOURCE> sourceType() {
+        throw new IllegalStateException("If you create a mapper service, you need to implement the sourceType() and targetType() "
+                                                + "methods");
+    }
+
+    /**
+     * Target type of the mapper. This does not need to be implemented when registered using
+     * {@link io.helidon.common.mapper.MappersConfig.Builder} {@code addMapper} methods.
+     * <p>
+     * It MUST be implemented when implementing a service (i.e. {@link io.helidon.service.registry.Service.Singleton}).
+     *
+     * @return type of the target this mapper support
+     */
+    default GenericType<TARGET> targetType() {
+        throw new IllegalStateException("If you create a mapper service, you need to implement the sourceType() and targetType() "
+                                                + "methods");
+    }
+
+    /**
+     * Qualifiers of the mapper. This is only used when the mapper is provided as
+     * {@link io.helidon.service.registry.ServiceRegistry} service, otherwise qualifiers provided when registering this
+     * mapper are used.
+     *
+     * @return qualifiers of this mapper, defaults to empty set
+     */
+    default Set<String> qualifiers() {
+        return Set.of();
+    }
 }
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MapperManager.java b/common/mapper/src/main/java/io/helidon/common/mapper/MapperManager.java
index bb07fabb0fb..da33c63261f 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MapperManager.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MapperManager.java
@@ -38,14 +38,20 @@
  * found for the {@link io.helidon.common.GenericType} pair, an attempt is to locate a mapper for
  * the underlying class *IF* the generic type represents a simple class (e.g. not a generic type declaration)</li>
  * </ul>
+ *
+ * @deprecated use {@link io.helidon.common.mapper.Mappers} instead
  */
-public interface MapperManager {
+@Deprecated(forRemoval = true, since = "4.2.0")
+public interface MapperManager extends Mappers {
     /**
      * Get an instance of the configured global manager. If none is explicitly set, an instance is created using
      * discovered and built-in mappers.
      *
      * @return global mapper manager
+     * @deprecated use {@link io.helidon.service.registry.Services#get(Class)} - i.e. {@code Services.get(Mappers.class)}, or
+     *          use your registry instance in a similar way
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static MapperManager global() {
         return GlobalManager.mapperManager();
     }
@@ -54,7 +60,11 @@ static MapperManager global() {
      * Configure a new global mapper manager.
      *
      * @param manager mapper manager to use
+     * @deprecated use {@link io.helidon.service.registry.Services#set(Class, Object[])} -
+     *      i.e. {@code Services.get(Mappers.class, myMappers)} before the program starts
+     *      (must be configured before it is first used)
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static void global(MapperManager manager) {
         GlobalManager.mapperManager(manager);
     }
@@ -63,7 +73,9 @@ static void global(MapperManager manager) {
      * Create a fluent API builder to create a customized mapper manager.
      *
      * @return a new builder
+     * @deprecated use {@link io.helidon.common.mapper.Mappers#builder()} instead
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static Builder builder() {
         return new Builder();
     }
@@ -73,7 +85,9 @@ static Builder builder() {
      * loaded {@link io.helidon.common.mapper.spi.MapperProvider MapperProviders}.
      *
      * @return create a new mapper manager from service loader
+     * @deprecated use {@link io.helidon.common.mapper.Mappers#create()} instead
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static MapperManager create() {
         return MapperManager.builder().build();
     }
@@ -127,7 +141,10 @@ <SOURCE, TARGET> Optional<Mapper<SOURCE, TARGET>> mapper(GenericType<SOURCE> sou
 
     /**
      * Fluent API builder for {@link io.helidon.common.mapper.MapperManager}.
+     *
+     * @deprecated use {@link io.helidon.common.mapper.MappersConfig.Builder}, obtained from {@link Mappers#builder()}
      */
+    @Deprecated(since = "4.2.0", forRemoval = true)
     final class Builder implements io.helidon.common.Builder<Builder, MapperManager> {
         private HelidonServiceLoader.Builder<MapperProvider> providers = HelidonServiceLoader
                 .builder(ServiceLoader.load(MapperProvider.class));
@@ -146,7 +163,7 @@ public MapperManager build() {
             }
             providers.addService(new DefaultMapperProvider(), 0);
             providers.useSystemServiceLoader(discoverServices);
-            return new MapperManagerImpl(this);
+            return new MappersImpl(this);
         }
 
         /**
@@ -172,7 +189,9 @@ public Builder addMapperProvider(MapperProvider provider) {
          *                 documentation for details about priority handling)
          * @return updated builder instance
          * @see #addMapperProvider(io.helidon.common.mapper.spi.MapperProvider)
+         * @deprecated we have switched to using weights instead of priority, this method will be removed without replacement
          */
+        @Deprecated(forRemoval = true, since = "4.2.0")
         public Builder addMapperProvider(MapperProvider provider, int priority) {
             this.providers.addService(provider, priority);
             return this;
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
new file mode 100644
index 00000000000..fde42ddef9e
--- /dev/null
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
@@ -0,0 +1,75 @@
+package io.helidon.common.mapper;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+
+import io.helidon.builder.api.RuntimeType;
+import io.helidon.common.GenericType;
+
+@RuntimeType.PrototypedBy(MappersConfig.class)
+public interface Mappers extends RuntimeType.Api<MappersConfig> {
+    static MappersConfig.Builder builder() {
+        return MappersConfig.builder();
+    }
+
+    static Mappers create() {
+        return builder().build();
+    }
+
+    static Mappers create(MappersConfig config) {
+        return new MappersImpl(config);
+    }
+
+    static Mappers create(Consumer<MappersConfig.Builder> consumer) {
+        return builder()
+                .update(consumer)
+                .build();
+    }
+
+    /**
+     * Map from source to target.
+     *
+     * @param source     object to map
+     * @param sourceType type of the source object (to locate the mapper)
+     * @param targetType type of the target object (to locate the mapper)
+     * @param qualifiers qualifiers of the usage (such as {@code http-headers, http}, most specific one first)
+     * @param <SOURCE>   type of the source
+     * @param <TARGET>   type of the target
+     * @return result of the mapping
+     * @throws MapperException in case the mapper was not found or failed
+     */
+    <SOURCE, TARGET> TARGET map(SOURCE source,
+                                GenericType<SOURCE> sourceType,
+                                GenericType<TARGET> targetType,
+                                String... qualifiers)
+            throws MapperException;
+
+    /**
+     * Map from source to target.
+     *
+     * @param source     object to map
+     * @param sourceType class of the source object (to locate the mapper)
+     * @param targetType class of the target object (to locate the mapper)
+     * @param qualifiers qualifiers of the usage (such as {@code http-headers, http}, most specific one first)
+     * @param <SOURCE>   type of the source
+     * @param <TARGET>   type of the target
+     * @return result of the mapping
+     * @throws MapperException in case the mapper was not found or failed
+     */
+    <SOURCE, TARGET> TARGET map(SOURCE source, Class<SOURCE> sourceType, Class<TARGET> targetType, String... qualifiers)
+            throws MapperException;
+
+    /**
+     * Obtain a mapper for the provided types and qualifiers.
+     *
+     * @param sourceType type to map from
+     * @param targetType type to map to
+     * @param qualifiers qualifiers of the mapper
+     * @param <SOURCE>   source type
+     * @param <TARGET>   target type
+     * @return mapper if found
+     */
+    <SOURCE, TARGET> Optional<Mapper<SOURCE, TARGET>> mapper(GenericType<SOURCE> sourceType,
+                                                             GenericType<TARGET> targetType,
+                                                             String... qualifiers);
+}
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
new file mode 100644
index 00000000000..9807ed2f6b5
--- /dev/null
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
@@ -0,0 +1,53 @@
+package io.helidon.common.mapper;
+
+import java.util.List;
+
+import io.helidon.builder.api.Option;
+import io.helidon.builder.api.Prototype;
+import io.helidon.common.mapper.spi.MapperProvider;
+
+/**
+ * Mappers configuration.
+ * <p>
+ * All mappers registered within this type (through its builder) are ordered by their weight, regardless of
+ * order of configuration on builder.
+ */
+@Prototype.Blueprint(decorator = MappersConfigSupport.BuilderDecorator.class)
+@Prototype.RegistrySupport
+@Prototype.CustomMethods(MappersConfigSupport.CustomMethods.class)
+interface MappersConfigBlueprint extends Prototype.Factory<Mappers> {
+    /**
+     * Mapper providers allow for introduction of new mappers into the system.
+     * A mapper provider can be exposed either as a {@link io.helidon.service.registry.ServiceRegistry}
+     * service, or a {@link java.util.ServiceLoader}, but never both.
+     * <p>
+     * Mapper providers are ordered by their {@link io.helidon.common.Weight}.
+     *
+     * @return a list of configured mapper providers
+     */
+    @Option.Singular
+    @Option.RegistryService
+    List<MapperProvider> mapperProviders();
+
+    /**
+     * Mappers discovered through {@link io.helidon.service.registry.ServiceRegistry}, or explicitly created
+     * that implement both {@link Mapper#sourceType()} and {@link Mapper#targetType()} methods.
+     * <p>
+     * Mappers are ordered by {@link io.helidon.common.Weight} together with {@link MappersConfig#mapperProviders()} to
+     * create a single list.
+     *
+     * @return list of mappers
+     */
+    @Option.Singular
+    @Option.RegistryService
+    List<Mapper<?, ?>> mappers();
+
+    /**
+     * Whether to use built-in mappers.
+     * Defaults to {@code true}.
+     *
+     * @return whether to use built in mappers (such as String to Integer)
+     */
+    @Option.DefaultBoolean(true)
+    boolean useBuiltInMappers();
+}
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
new file mode 100644
index 00000000000..9c7d9841270
--- /dev/null
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
@@ -0,0 +1,221 @@
+package io.helidon.common.mapper;
+
+import java.util.List;
+import java.util.Set;
+
+import io.helidon.builder.api.Prototype;
+import io.helidon.common.GenericType;
+import io.helidon.common.Weighted;
+import io.helidon.common.Weights;
+import io.helidon.common.mapper.spi.MapperProvider;
+
+final class MappersConfigSupport {
+    private MappersConfigSupport() {
+    }
+
+    static final class CustomMethods {
+        private CustomMethods() {
+        }
+
+        /**
+         * Add a mapper to the list of mapper.
+         *
+         * @param mapper     the mapper to map source instances to target instances
+         * @param sourceType class of the source instance
+         * @param targetType class of the target instance
+         * @param qualifiers supported qualifiers of this mapper (if none provided, will return a compatible response)
+         * @param <S>        type of source
+         * @param <T>        type of target
+         */
+        @Prototype.BuilderMethod
+        static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
+                                     Mapper<S, T> mapper,
+                                     Class<S> sourceType,
+                                     Class<T> targetType,
+                                     String... qualifiers) {
+            addMapper(builder, mapper, sourceType, targetType, Weighted.DEFAULT_WEIGHT, qualifiers);
+        }
+
+        /**
+         * Add a mapper to the list of mapper.
+         *
+         * @param mapper     the mapper to map source instances to target instances
+         * @param sourceType generic type of the source instance
+         * @param targetType generic type of the target instance
+         * @param qualifiers qualifiers of this mapper, if empty, will be a compatible mapper
+         * @param <S>        type of source
+         * @param <T>        type of target
+         */
+        @Prototype.BuilderMethod
+        static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
+                                     Mapper<S, T> mapper,
+                                     GenericType<S> sourceType,
+                                     GenericType<T> targetType,
+                                     String... qualifiers) {
+
+            addMapper(builder, mapper, sourceType, targetType, Weighted.DEFAULT_WEIGHT, qualifiers);
+        }
+
+        /**
+         * Add a mapper to the list of mapper with a custom priority.
+         *
+         * @param mapper     the mapper to map source instances to target instances
+         * @param sourceType class of the source instance
+         * @param targetType class of the target instance
+         * @param weight     weight of the mapper
+         * @param qualifiers supported qualifiers of this mapper (if none provided, will return a compatible response)
+         * @param <S>        type of source
+         * @param <T>        type of target
+         */
+        @Prototype.BuilderMethod
+        static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
+                                     Mapper<S, T> mapper,
+                                     Class<S> sourceType,
+                                     Class<T> targetType,
+                                     double weight,
+                                     String... qualifiers) {
+            builder.addMapperProvider(new ClassMapperProvider(mapper,
+                                                              sourceType,
+                                                              targetType,
+                                                              weight,
+                                                              Set.of(qualifiers)));
+        }
+
+        /**
+         * Add a mapper to the list of mapper with custom priority.
+         *
+         * @param mapper     the mapper to map source instances to target instances
+         * @param sourceType generic type of the source instance
+         * @param targetType generic type of the target instance
+         * @param weight     weight of the mapper
+         * @param qualifiers qualifiers of this mapper, if empty, will be a compatible mapper
+         * @param <S>        type of source
+         * @param <T>        type of target
+         */
+        @Prototype.BuilderMethod
+        static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
+                                     Mapper<S, T> mapper,
+                                     GenericType<S> sourceType,
+                                     GenericType<T> targetType,
+                                     double weight,
+                                     String... qualifiers) {
+            if (sourceType.isClass() && targetType.isClass()) {
+                builder.addMapperProvider(new ClassMapperProvider(mapper,
+                                                                  sourceType.rawType(),
+                                                                  targetType.rawType(),
+                                                                  weight,
+                                                                  Set.of(qualifiers)));
+            } else {
+                builder.addMapperProvider(new GenericMapperProvider(mapper,
+                                                                    sourceType,
+                                                                    targetType,
+                                                                    weight,
+                                                                    Set.of(qualifiers)));
+            }
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static final class GenericMapperProvider implements MapperProvider, Weighted {
+
+        private final Mapper mapper;
+        private final GenericType sourceType;
+        private final GenericType targetType;
+        private final double weight;
+        private final Set<String> qualifiers;
+
+        private GenericMapperProvider(Mapper mapper,
+                                      GenericType sourceType,
+                                      GenericType targetType,
+                                      double weight,
+                                      Set<String> qualifiers) {
+            this.mapper = mapper;
+            this.sourceType = sourceType;
+            this.targetType = targetType;
+            this.weight = weight;
+            this.qualifiers = qualifiers;
+        }
+
+        @Override
+        public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, String qualifier) {
+            return ProviderResponse.unsupported();
+        }
+
+        @Override
+        public ProviderResponse mapper(GenericType<?> sourceType, GenericType<?> targetType, String qualifier) {
+            if ((sourceType.equals(this.sourceType)) && (targetType.equals(this.targetType))) {
+                if (this.qualifiers.contains(qualifier)) {
+                    return new ProviderResponse(Support.SUPPORTED, mapper);
+                } else {
+                    return new ProviderResponse(Support.COMPATIBLE, mapper);
+                }
+
+            }
+            return ProviderResponse.unsupported();
+        }
+
+        @Override
+        public double weight() {
+            return weight;
+        }
+    }
+
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    private static final class ClassMapperProvider implements MapperProvider, Weighted {
+        private final Mapper<Object, Object> mapper;
+        private final Class<Object> sourceType;
+        private final Class<Object> targetType;
+        private final double weight;
+        private final Set<String> qualifiers;
+
+        private ClassMapperProvider(Mapper mapper,
+                                    Class sourceType,
+                                    Class targetType,
+                                    double weight,
+                                    Set<String> qualifiers) {
+            this.mapper = mapper;
+            this.sourceType = sourceType;
+            this.targetType = targetType;
+            this.weight = weight;
+            this.qualifiers = qualifiers;
+        }
+
+        @Override
+        public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, String qualifier) {
+            if ((this.sourceType == sourceClass) && (this.targetType == targetClass)) {
+                if (this.qualifiers.contains(qualifier)) {
+                    return new MapperProvider.ProviderResponse(MapperProvider.Support.SUPPORTED, mapper);
+                } else {
+                    return new MapperProvider.ProviderResponse(MapperProvider.Support.COMPATIBLE, mapper);
+                }
+            }
+            return MapperProvider.ProviderResponse.unsupported();
+        }
+
+        @Override
+        public double weight() {
+            return weight;
+        }
+    }
+
+    static class BuilderDecorator implements Prototype.BuilderDecorator<MappersConfig.BuilderBase<?, ?>> {
+        BuilderDecorator() {
+        }
+
+        @Override
+        public void decorate(MappersConfig.BuilderBase<?, ?> target) {
+            if (target.useBuiltInMappers()) {
+                target.addMapperProvider(new BuiltInMappers());
+            }
+
+            List<Mapper<?, ?>> mappers =  target.mappers();
+            for (Mapper<?, ?> mapper : mappers) {
+                target.addMapperProvider(new GenericMapperProvider(mapper,
+                                                                   mapper.sourceType(),
+                                                                   mapper.targetType(),
+                                                                   Weights.find(mapper, Weighted.DEFAULT_WEIGHT),
+                                                                   mapper.qualifiers()));
+            }
+        }
+    }
+}
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
new file mode 100644
index 00000000000..7a376ebfb9d
--- /dev/null
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
@@ -0,0 +1,29 @@
+package io.helidon.common.mapper;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+import io.helidon.common.mapper.spi.MapperProvider;
+import io.helidon.service.registry.Service;
+
+@Service.Singleton
+class MappersFactory implements Supplier<Mappers> {
+    private final List<MapperProvider> mapperProviders;
+    private final List<Mapper<?, ?>> mappers;
+
+    @Service.Inject
+    MappersFactory(List<MapperProvider> mapperProviders, List<Mapper<?, ?>> mappers) {
+        this.mapperProviders = mapperProviders;
+        this.mappers = mappers;
+    }
+
+    @Override
+    public Mappers get() {
+        return Mappers.builder()
+                .mapperProvidersDiscoverServices(false)
+                .mappersDiscoverServices(false)
+                .update(it -> mappers.forEach(it::addMapper))
+                .update(it -> mapperProviders.forEach(it::addMapperProvider))
+                .build();
+    }
+}
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MapperManagerImpl.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersImpl.java
similarity index 91%
rename from common/mapper/src/main/java/io/helidon/common/mapper/MapperManagerImpl.java
rename to common/mapper/src/main/java/io/helidon/common/mapper/MappersImpl.java
index b0e4b2b2752..d4ae35c37c7 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MapperManagerImpl.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersImpl.java
@@ -16,6 +16,7 @@
 
 package io.helidon.common.mapper;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -24,17 +25,40 @@
 import java.util.function.BiFunction;
 
 import io.helidon.common.GenericType;
+import io.helidon.common.Weights;
 import io.helidon.common.mapper.spi.MapperProvider;
+import io.helidon.service.registry.Service;
 
 /**
- * Implementation of {@link io.helidon.common.mapper.MapperManager}.
+ * Implementation of {@link io.helidon.common.mapper.Mappers}.
  */
-final class MapperManagerImpl implements MapperManager {
-    private final List<MapperProvider> providers;
+@SuppressWarnings("removal")
+@Service.Singleton
+final class MappersImpl implements MapperManager, Mappers {
     private final Map<ClassCacheKey, Mapper<?, ?>> classCache = new ConcurrentHashMap<>();
     private final Map<GenericCacheKey, Mapper<?, ?>> typeCache = new ConcurrentHashMap<>();
 
-    MapperManagerImpl(Builder builder) {
+    private final List<MapperProvider> providers;
+    private final MappersConfig prototype;
+
+    @Service.Inject
+    MappersImpl() {
+        this(MappersConfig.create());
+    }
+
+    MappersImpl(MappersConfig prototype) {
+        this.prototype = prototype;
+        List<MapperProvider> providers = new ArrayList<>(prototype.mapperProviders());
+        Weights.sort(providers);
+        this.providers = providers;
+    }
+
+    @SuppressWarnings("removal")
+    MappersImpl(MapperManager.Builder builder) {
+        this.prototype = MappersConfig.builder()
+                .useBuiltInMappers(false)
+                .mapperProviders(builder.mapperProviders())
+                .buildPrototype();
         this.providers = builder.mapperProviders();
     }
 
@@ -76,6 +100,11 @@ public <SOURCE, TARGET> Optional<Mapper<SOURCE, TARGET>> mapper(GenericType<SOUR
         return Optional.of(mapper);
     }
 
+    @Override
+    public MappersConfig prototype() {
+        return prototype;
+    }
+
     int classCacheSize() {
         return classCache.size();
     }
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java b/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
index 8fbe804de8f..c5fcf6397f0 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
@@ -42,7 +42,7 @@ public interface OptionalValue<T> extends Value<T> {
      * @param qualifiers    qualifiers of the mapper
      * @return an empty value
      */
-    static <T> OptionalValue<T> create(MapperManager mapperManager, String name, Class<T> type, String... qualifiers) {
+    static <T> OptionalValue<T> create(Mappers mapperManager, String name, Class<T> type, String... qualifiers) {
         Objects.requireNonNull(name, "Name of the Value must not be null");
         return create(mapperManager, name, GenericType.create(type), qualifiers);
     }
@@ -58,7 +58,7 @@ static <T> OptionalValue<T> create(MapperManager mapperManager, String name, Cla
      * @param <T>           type of the value
      * @return an empty value
      */
-    static <T> OptionalValue<T> create(MapperManager mapperManager, String name, GenericType<T> type, String... qualifiers) {
+    static <T> OptionalValue<T> create(Mappers mapperManager, String name, GenericType<T> type, String... qualifiers) {
         Objects.requireNonNull(name, "Name of the Value must not be null");
         return new ValueEmpty<>(mapperManager, type, name, qualifiers);
     }
@@ -73,7 +73,7 @@ static <T> OptionalValue<T> create(MapperManager mapperManager, String name, Gen
      * @param <T>           type of the value
      * @return a value backed by data
      */
-    static <T> OptionalValue<T> create(MapperManager mapperManager, String name, T value, String... qualifiers) {
+    static <T> OptionalValue<T> create(Mappers mapperManager, String name, T value, String... qualifiers) {
         Objects.requireNonNull(name, "Name of the Value must not be null");
         Objects.requireNonNull(value, "Value content for Value " + name + " must not be null, use empty(String) instead");
         return new ValueBacked<>(mapperManager, name, value, qualifiers);
@@ -90,7 +90,7 @@ static <T> OptionalValue<T> create(MapperManager mapperManager, String name, T v
      * @param <T>           type of the value
      * @return a value backed by data
      */
-    static <T> OptionalValue<T> create(MapperManager mapperManager,
+    static <T> OptionalValue<T> create(Mappers mapperManager,
                                        String name,
                                        T value,
                                        GenericType<T> type,
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Value.java b/common/mapper/src/main/java/io/helidon/common/mapper/Value.java
index be7f63b6755..b9f47ca4f30 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/Value.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Value.java
@@ -42,7 +42,7 @@ public interface Value<T> {
      * @param <T>           type of the value
      * @return a value backed by data
      */
-    static <T> Value<T> create(MapperManager mapperManager, String name, T value, String... qualifiers) {
+    static <T> Value<T> create(Mappers mapperManager, String name, T value, String... qualifiers) {
         Objects.requireNonNull(name, "Name of the Value must not be null");
         Objects.requireNonNull(value, "Value content for Value " + name + " must not be null, use empty(String) instead");
         return new ValueBacked<>(mapperManager, name, value, qualifiers);
@@ -59,7 +59,7 @@ static <T> Value<T> create(MapperManager mapperManager, String name, T value, St
      * @param <T>           type of the value
      * @return a value backed by data
      */
-    static <T> Value<T> create(MapperManager mapperManager, String name, T value, GenericType<T> type, String... qualifiers) {
+    static <T> Value<T> create(Mappers mapperManager, String name, T value, GenericType<T> type, String... qualifiers) {
         Objects.requireNonNull(name, "Name of the Value must not be null");
         Objects.requireNonNull(value, "Value content for Value " + name + " must not be null, use empty(String) instead");
         return new ValueBacked<>(mapperManager, name, value, type, qualifiers);
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java b/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
index 517f219fb5f..87f5912acd9 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
@@ -23,13 +23,13 @@
 import io.helidon.common.GenericType;
 
 class ValueBacked<T> implements OptionalValue<T> {
-    private final MapperManager mapperManager;
+    private final Mappers mapperManager;
     private final String name;
     private final T value;
     private final GenericType<T> type;
     private final String[] qualifiers;
 
-    ValueBacked(MapperManager mapperManager, String name, T value, GenericType<T> type, String[] qualifiers) {
+    ValueBacked(Mappers mapperManager, String name, T value, GenericType<T> type, String[] qualifiers) {
         Objects.requireNonNull(mapperManager);
         Objects.requireNonNull(name);
         Objects.requireNonNull(value);
@@ -41,7 +41,7 @@ class ValueBacked<T> implements OptionalValue<T> {
         this.qualifiers = qualifiers;
     }
 
-    ValueBacked(MapperManager mapperManager, String name, T value, String[] qualifiers) {
+    ValueBacked(Mappers mapperManager, String name, T value, String[] qualifiers) {
         this(mapperManager, name, value, null, qualifiers);
     }
 
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java b/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
index c44578ebf0a..33a3c0f1a2f 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
@@ -24,12 +24,12 @@
 import io.helidon.common.GenericType;
 
 class ValueEmpty<T> implements OptionalValue<T> {
-    private final MapperManager mapperManager;
+    private final Mappers mapperManager;
     private final GenericType<T> type;
     private final String name;
     private final String[] qualifiers;
 
-    ValueEmpty(MapperManager mapperManager, GenericType<T> type, String name, String[] qualifiers) {
+    ValueEmpty(Mappers mapperManager, GenericType<T> type, String name, String[] qualifiers) {
         this.mapperManager = mapperManager;
         this.type = type;
         this.name = name;
diff --git a/common/mapper/src/main/java/module-info.java b/common/mapper/src/main/java/module-info.java
index 23f255af38b..df8812d7f2c 100644
--- a/common/mapper/src/main/java/module-info.java
+++ b/common/mapper/src/main/java/module-info.java
@@ -19,6 +19,11 @@
  */
 module io.helidon.common.mapper {
     requires transitive io.helidon.common;
+    requires transitive io.helidon.builder.api;
+
+    requires io.helidon.common.types;
+
+    requires io.helidon.service.registry;
 
     exports io.helidon.common.mapper;
     exports io.helidon.common.mapper.spi;
diff --git a/common/mapper/src/main/resources/META-INF/helidon/service.loader b/common/mapper/src/main/resources/META-INF/helidon/service.loader
new file mode 100644
index 00000000000..9a2000c98d4
--- /dev/null
+++ b/common/mapper/src/main/resources/META-INF/helidon/service.loader
@@ -0,0 +1,2 @@
+# List of service contracts we want to support either from service registry, or from service loader
+io.helidon.common.mapper.spi.MapperProvider
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java b/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
new file mode 100644
index 00000000000..f74f70c6dee
--- /dev/null
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
@@ -0,0 +1,23 @@
+package io.helidon.common.mapper;
+
+import io.helidon.common.GenericType;
+import io.helidon.common.Size;
+import io.helidon.service.registry.Service;
+
+@Service.Singleton
+class CustomMapper implements Mapper<String, Size> {
+    @Override
+    public Size map(String string) {
+        return Size.parse(string);
+    }
+
+    @Override
+    public GenericType<String> sourceType() {
+        return GenericType.STRING;
+    }
+
+    @Override
+    public GenericType<Size> targetType() {
+        return GenericType.create(Size.class);
+    }
+}
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTest.java b/common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTestDeprecated.java
similarity index 87%
rename from common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTest.java
rename to common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTestDeprecated.java
index 06bfe86b075..373df299092 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTest.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/MapperManagerTestDeprecated.java
@@ -31,7 +31,8 @@
 /**
  * Unit test for {@link MapperManager}.
  */
-class MapperManagerTest {
+@SuppressWarnings("removal")
+class MapperManagerTestDeprecated {
     @Test
     void testUsingServiceLoader() {
         MapperManager mm = MapperManager.create();
@@ -42,11 +43,11 @@ void testUsingServiceLoader() {
         assertThat(result, is(10));
 
         // using generic types
-        result = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, ServiceLoaderMapper2.INTEGER_TYPE, "default");
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
         assertThat(result, is(11));
 
         // search for opposite (use class, find type and vice versa)
-        Long longResult = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, GenericType.create(Long.class), "default");
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
         assertThat(longResult, is(10L));
         // must be the same
         longResult = mm.map(source, String.class, Long.class, "default");
@@ -55,7 +56,7 @@ void testUsingServiceLoader() {
         Short shortResult = mm.map(source, String.class, Short.class, "default");
         assertThat(shortResult, is((short) 10));
         // must be the same
-        shortResult = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, ServiceLoaderMapper2.SHORT_TYPE, "default");
+        shortResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.SHORT_TYPE, "default");
         assertThat(shortResult, is((short) 10));
 
         assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
@@ -65,7 +66,7 @@ void testUsingServiceLoader() {
     void testUsingCustomProviders() {
         MapperManager mm = MapperManager.builder()
                 .discoverServices(false)
-                .addMapperProvider(new ServiceLoaderMapper1())
+                .addMapperProvider(new ServiceLoaderMapper())
                 .build();
 
         String source = "10";
@@ -74,19 +75,19 @@ void testUsingCustomProviders() {
         assertThat(result, is(10));
 
         // using generic types
-        result = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, ServiceLoaderMapper2.INTEGER_TYPE, "default");
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
         assertThat(result, is(10));
 
         // search for opposite (use class, find type and vice versa)
-        Long longResult = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, GenericType.create(Long.class), "default");
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
         assertThat(longResult, is(10L));
         // must be the same
         longResult = mm.map(source, String.class, Long.class, "default");
         assertThat(longResult, is(10L));
 
         assertThrows(MapperException.class, () -> mm.map(source, String.class, Short.class, "default"));
-        assertThrows(MapperException.class, () -> mm.map(source, ServiceLoaderMapper2.STRING_TYPE,
-                                                         ServiceLoaderMapper2.SHORT_TYPE, "default"));
+        assertThrows(MapperException.class, () -> mm.map(source, ServiceRegistryMapper.STRING_TYPE,
+                                                         ServiceRegistryMapper.SHORT_TYPE, "default"));
         assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
     }
 
@@ -94,7 +95,7 @@ void testUsingCustomProviders() {
     void testUsingServiceLoaderAndCustomMappers() {
         MapperManager mm = MapperManager.builder()
                 .addMapper(String::valueOf, Integer.class, String.class)
-                .addMapper(String::valueOf, ServiceLoaderMapper2.SHORT_TYPE, ServiceLoaderMapper2.STRING_TYPE)
+                .addMapper(String::valueOf, ServiceRegistryMapper.SHORT_TYPE, ServiceRegistryMapper.STRING_TYPE)
                 .build();
 
         String source = "10";
@@ -103,11 +104,11 @@ void testUsingServiceLoaderAndCustomMappers() {
         assertThat(result, is(10));
 
         // using generic types
-        result = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, ServiceLoaderMapper2.INTEGER_TYPE, "default");
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
         assertThat(result, is(11));
 
         // search for opposite (use class, find type and vice versa)
-        Long longResult = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, GenericType.create(Long.class), "default");
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
         assertThat(longResult, is(10L));
         // must be the same
         longResult = mm.map(source, String.class, Long.class, "default");
@@ -116,7 +117,7 @@ void testUsingServiceLoaderAndCustomMappers() {
         Short shortResult = mm.map(source, String.class, Short.class, "default");
         assertThat(shortResult, is((short) 10));
         // must be the same
-        shortResult = mm.map(source, ServiceLoaderMapper2.STRING_TYPE, ServiceLoaderMapper2.SHORT_TYPE, "default");
+        shortResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.SHORT_TYPE, "default");
         assertThat(shortResult, is((short) 10));
 
         assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
@@ -124,12 +125,12 @@ void testUsingServiceLoaderAndCustomMappers() {
         // and add tests for integer and short types
         String stringResult = mm.map(42, Integer.class, String.class, "default");
         assertThat(stringResult, is("42"));
-        stringResult = mm.map(42, GenericType.create(Integer.class), ServiceLoaderMapper2.STRING_TYPE, "default");
+        stringResult = mm.map(42, GenericType.create(Integer.class), ServiceRegistryMapper.STRING_TYPE, "default");
         assertThat(stringResult, is("42"));
 
         stringResult = mm.map((short) 42, Short.class, String.class, "default");
         assertThat(stringResult, is("42"));
-        stringResult = mm.map((short) 42, ServiceLoaderMapper2.SHORT_TYPE, ServiceLoaderMapper2.STRING_TYPE, "default");
+        stringResult = mm.map((short) 42, ServiceRegistryMapper.SHORT_TYPE, ServiceRegistryMapper.STRING_TYPE, "default");
         assertThat(stringResult, is("42"));
     }
 
@@ -246,7 +247,7 @@ void testEmptyValue() {
 
     @Test
     void testCacheWorks() {
-        MapperManagerImpl mm = new MapperManagerImpl(MapperManager.builder()
+        MappersImpl mm = new MappersImpl(MapperManager.builder()
                                                              .addMapperProvider(new TestProvider()));
         assertThat(mm.classCacheSize(), is(0));
         assertThat(mm.typeCacheSize(), is(0));
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/MappersTest.java b/common/mapper/src/test/java/io/helidon/common/mapper/MappersTest.java
new file mode 100644
index 00000000000..403a65b7c5b
--- /dev/null
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/MappersTest.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.common.mapper;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import io.helidon.common.GenericType;
+import io.helidon.common.Size;
+import io.helidon.common.mapper.spi.MapperProvider;
+import io.helidon.common.mapper.spi.MapperProvider.ProviderResponse;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Unit test for {@link io.helidon.common.mapper.Mappers}.
+ */
+class MappersTest {
+    @Test
+    void testUsingServiceLoader() {
+        Mappers mm = Mappers.create();
+
+        String source = "10";
+        // using classes
+        Integer result = mm.map(source, String.class, Integer.class, "default");
+        assertThat(result, is(10));
+
+        // uses the highest weight - ServiceRegistryMapper
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
+        assertThat(result, is(11));
+
+        // search for opposite (use class, find type and vice versa)
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
+        assertThat(longResult, is(10L));
+        // must be the same
+        longResult = mm.map(source, String.class, Long.class, "default");
+        assertThat(longResult, is(10L));
+
+        Short shortResult = mm.map(source, String.class, Short.class, "default");
+        assertThat(shortResult, is((short) 10));
+        // must be the same
+        shortResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.SHORT_TYPE, "default");
+        assertThat(shortResult, is((short) 10));
+
+        assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
+    }
+
+    @Test
+    void testUsingCustomProviders() {
+        Mappers mm = Mappers.builder()
+                .mapperProvidersDiscoverServices(false)
+                .mapperProviders(List.of(new ServiceLoaderMapper()))
+                .useBuiltInMappers(false)
+                .build();
+
+        String source = "10";
+        // using classes
+        Integer result = mm.map(source, String.class, Integer.class, "default");
+        assertThat(result, is(10));
+
+        // using generic types
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
+        assertThat(result, is(10));
+
+        // search for opposite (use class, find type and vice versa)
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
+        assertThat(longResult, is(10L));
+        // must be the same
+        longResult = mm.map(source, String.class, Long.class, "default");
+        assertThat(longResult, is(10L));
+
+        assertThrows(MapperException.class, () -> mm.map(source, String.class, Short.class, "default"));
+        assertThrows(MapperException.class, () -> mm.map(source, ServiceRegistryMapper.STRING_TYPE,
+                                                         ServiceRegistryMapper.SHORT_TYPE, "default"));
+        assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
+    }
+
+    @Test
+    void testUsingServiceLoaderAndCustomMappers() {
+        Mappers mm = Mappers.builder()
+                .addMapper(String::valueOf, Integer.class, String.class)
+                .addMapper(String::valueOf, ServiceRegistryMapper.SHORT_TYPE, ServiceRegistryMapper.STRING_TYPE)
+                .build();
+
+        String source = "10";
+        // using classes
+        Integer result = mm.map(source, String.class, Integer.class, "default");
+        assertThat(result, is(10));
+
+        // using generic types
+        // uses the highest weight - the ServiceRegistryMapper
+        result = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.INTEGER_TYPE, "default");
+        assertThat(result, is(11));
+
+        // search for opposite (use class, find type and vice versa)
+        Long longResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, GenericType.create(Long.class), "default");
+        assertThat(longResult, is(10L));
+        // must be the same
+        longResult = mm.map(source, String.class, Long.class, "default");
+        assertThat(longResult, is(10L));
+
+        Short shortResult = mm.map(source, String.class, Short.class, "default");
+        assertThat(shortResult, is((short) 10));
+        // must be the same
+        shortResult = mm.map(source, ServiceRegistryMapper.STRING_TYPE, ServiceRegistryMapper.SHORT_TYPE, "default");
+        assertThat(shortResult, is((short) 10));
+
+        assertThrows(MapperException.class, () -> mm.map(source, String.class, Object.class, "default"));
+
+        // and add tests for integer and short types
+        String stringResult = mm.map(42, Integer.class, String.class, "default");
+        assertThat(stringResult, is("42"));
+        stringResult = mm.map(42, GenericType.create(Integer.class), ServiceRegistryMapper.STRING_TYPE, "default");
+        assertThat(stringResult, is("42"));
+
+        stringResult = mm.map((short) 42, Short.class, String.class, "default");
+        assertThat(stringResult, is("42"));
+        stringResult = mm.map((short) 42, ServiceRegistryMapper.SHORT_TYPE, ServiceRegistryMapper.STRING_TYPE, "default");
+        assertThat(stringResult, is("42"));
+    }
+
+    @Test
+    void testQualifiedMapping() {
+        Mappers mapperManager = Mappers.builder()
+                .addMapperProvider((t1, t2, qualifier) -> {
+                    if (qualifier.equals("http")) {
+                        return new ProviderResponse(MapperProvider.Support.SUPPORTED, req -> "http_" + req);
+                    }
+                    return ProviderResponse.unsupported();
+                })
+                .addMapperProvider((t1, t2, qualifier) -> {
+                    if (qualifier.equals("http/header")) {
+                        return new ProviderResponse(MapperProvider.Support.SUPPORTED, req -> "http_header_" + req);
+                    }
+                    return ProviderResponse.unsupported();
+                })
+                .addMapperProvider((t1, t2, qualifier) -> {
+                    if (qualifier.equals("http/query")) {
+                        return new ProviderResponse(MapperProvider.Support.SUPPORTED, req -> "http_query_" + req);
+                    }
+                    return ProviderResponse.unsupported();
+                })
+                .useBuiltInMappers(false)
+                .build();
+
+        assertThrows(MapperException.class, () -> mapperManager.map("value", String.class, String.class, ""));
+
+        // http qualifier exists
+        String value = mapperManager.map("value", String.class, String.class, "http");
+        assertThat(value, is("http_value"));
+
+        // http/header qualifier exist
+        value = mapperManager.map("value", String.class, String.class, "http", "header");
+        assertThat(value, is("http_header_value"));
+
+        // http/query qualifier exists
+        value = mapperManager.map("value", String.class, String.class, "http", "query");
+        assertThat(value, is("http_query_value"));
+
+        // should fall back to http qualifier
+        value = mapperManager.map("value", String.class, String.class, "http", "matrix");
+        assertThat(value, is("http_value"));
+    }
+
+    @Test
+    void testCustomMapper() {
+        // make sure the custom mapper is discovered and maps values
+        Mappers mappers = Mappers.create();
+        Size result = mappers.map("12 KB", String.class, Size.class);
+
+        assertThat(result, is(Size.create(12, Size.Unit.KIB)));
+    }
+
+    @Test
+    void testExistingValue() {
+        // int -> double
+        // not double to int
+
+        Mappers mapperManager = Mappers.builder()
+                .useBuiltInMappers(true)
+                .mapperProvidersDiscoverServices(false)
+                .addMapperProvider((t1, t2, qualifier) -> {
+                    if (t1.equals(Integer.class) && t2.equals(Double.class)) {
+                        return new ProviderResponse(MapperProvider.Support.SUPPORTED, anInt -> ((Integer) anInt).doubleValue());
+                    }
+                    return ProviderResponse.unsupported();
+                })
+                .build();
+
+        Value<String> value = Value.create(mapperManager, "name", "42");
+        assertThat(value.get(), is("42"));
+
+        Value<Integer> integerValue = value.as(Integer.class);
+        assertThat(integerValue.get(), is(42));
+
+        value = integerValue.asString();
+        assertThat(value.get(), is("42"));
+
+        Value<Double> doubleValue = integerValue.as(Double.class);
+        assertThat(doubleValue.get(), is(42D));
+
+        assertThrows(MapperException.class, () -> doubleValue.as(Integer.class));
+    }
+
+    @Test
+    void testEmptyValue() {
+        // int -> double
+        // not double to int
+
+        Mappers mapperManager = Mappers.builder()
+                .useBuiltInMappers(true)
+                .addMapperProvider((t1, t2, qualifier) -> {
+                    if (t1.equals(Integer.class) && t2.equals(Double.class)) {
+                        return new ProviderResponse(MapperProvider.Support.SUPPORTED, anInt -> ((Integer) anInt).doubleValue());
+                    }
+                    return ProviderResponse.unsupported();
+                })
+                .build();
+
+        OptionalValue<String> value = OptionalValue.create(mapperManager, "name", String.class);
+        assertThrows(NoSuchElementException.class, value::get);
+        assertThat(value.isPresent(), is(false));
+        assertThat(value.isEmpty(), is(true));
+
+        OptionalValue<Integer> integerValue = value.as(Integer.class);
+        assertThrows(NoSuchElementException.class, integerValue::get);
+        assertThat(integerValue.isPresent(), is(false));
+        assertThat(integerValue.isEmpty(), is(true));
+
+        value = integerValue.asString();
+        assertThrows(NoSuchElementException.class, value::get);
+        assertThat(value.isPresent(), is(false));
+        assertThat(value.isEmpty(), is(true));
+
+        OptionalValue<Double> doubleValue = integerValue.as(Double.class);
+        assertThrows(NoSuchElementException.class, doubleValue::get);
+        assertThat(doubleValue.isPresent(), is(false));
+        assertThat(doubleValue.isEmpty(), is(true));
+
+        assertThrows(MapperException.class, () -> doubleValue.as(Integer.class));
+    }
+
+    @Test
+    void testCacheWorks() {
+        MappersImpl mm = new MappersImpl(Mappers.builder()
+                                                 .addMapperProvider(new TestProvider())
+                                                 .buildPrototype());
+        assertThat(mm.classCacheSize(), is(0));
+        assertThat(mm.typeCacheSize(), is(0));
+
+        mm.map("value", String.class, String.class, "value");
+        mm.map("value", String.class, String.class, "value");
+        mm.map("value", String.class, String.class, "value");
+        assertThat(mm.classCacheSize(), is(1));
+
+        mm.map("value", GenericType.STRING, GenericType.STRING, "value");
+        mm.map("value", GenericType.STRING, GenericType.STRING, "value");
+        mm.map("value", GenericType.STRING, GenericType.STRING, "value");
+        assertThat(mm.typeCacheSize(), is(1));
+    }
+
+    private static class TestProvider implements MapperProvider {
+        @Override
+        public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, String qualifier) {
+            return new ProviderResponse(Support.SUPPORTED, req -> req);
+        }
+
+        @Override
+        public ProviderResponse mapper(GenericType<?> sourceType, GenericType<?> targetType, String qualifier) {
+            return MapperProvider.super.mapper(sourceType, targetType, qualifier);
+        }
+    }
+}
\ No newline at end of file
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper1.java b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
similarity index 95%
rename from common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper1.java
rename to common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
index c5d5a68bfbd..f838ae946c7 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper1.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
@@ -20,7 +20,7 @@
 /**
  * Maps String to Integer and String to Long using class.
  */
-public class ServiceLoaderMapper1 implements MapperProvider {
+public class ServiceLoaderMapper implements MapperProvider {
     @Override
     public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, String qualifier) {
         if ((sourceClass.equals(String.class)) && (targetClass.equals(Integer.class))) {
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper2.java b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
similarity index 88%
rename from common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper2.java
rename to common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
index 28aae543dba..e6b07204151 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper2.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
@@ -16,12 +16,17 @@
 package io.helidon.common.mapper;
 
 import io.helidon.common.GenericType;
+import io.helidon.common.Weight;
+import io.helidon.common.Weighted;
 import io.helidon.common.mapper.spi.MapperProvider;
+import io.helidon.service.registry.Service;
 
 /**
  * Maps String to Integer, and String to Short using type.
  */
-public class ServiceLoaderMapper2 implements MapperProvider {
+@Weight(Weighted.DEFAULT_WEIGHT + 1)
+@Service.Singleton
+class ServiceRegistryMapper implements MapperProvider {
     static final GenericType<String> STRING_TYPE = GenericType.create(String.class);
     static final GenericType<Integer> INTEGER_TYPE = GenericType.create(Integer.class);
     static final GenericType<Short> SHORT_TYPE = GenericType.create(Short.class);
diff --git a/common/mapper/src/test/resources/META-INF/services/io.helidon.common.mapper.spi.MapperProvider b/common/mapper/src/test/resources/META-INF/services/io.helidon.common.mapper.spi.MapperProvider
index fe23bb48cb4..6ccdb059429 100644
--- a/common/mapper/src/test/resources/META-INF/services/io.helidon.common.mapper.spi.MapperProvider
+++ b/common/mapper/src/test/resources/META-INF/services/io.helidon.common.mapper.spi.MapperProvider
@@ -14,5 +14,4 @@
 # limitations under the License.
 #
 
-io.helidon.common.mapper.ServiceLoaderMapper1
-io.helidon.common.mapper.ServiceLoaderMapper2
\ No newline at end of file
+io.helidon.common.mapper.ServiceLoaderMapper
diff --git a/common/types/src/main/java/io/helidon/common/types/TypedElementInfo.java b/common/types/src/main/java/io/helidon/common/types/TypedElementInfo.java
index 9560152bd7e..320dfb4c6f4 100644
--- a/common/types/src/main/java/io/helidon/common/types/TypedElementInfo.java
+++ b/common/types/src/main/java/io/helidon/common/types/TypedElementInfo.java
@@ -74,6 +74,7 @@ abstract class BuilderBase<BUILDER extends TypedElementInfo.BuilderBase<BUILDER,
         private final List<Annotation> elementTypeAnnotations = new ArrayList<>();
         private final List<Annotation> inheritedAnnotations = new ArrayList<>();
         private final List<TypeName> componentTypes = new ArrayList<>();
+        private final List<TypeName> typeParameters = new ArrayList<>();
         private final List<TypedElementInfo> parameterArguments = new ArrayList<>();
         private final Set<TypeName> throwsChecked = new LinkedHashSet<>();
         private final Set<Modifier> elementModifiers = new LinkedHashSet<>();
@@ -84,6 +85,7 @@ abstract class BuilderBase<BUILDER extends TypedElementInfo.BuilderBase<BUILDER,
         private boolean isElementTypeAnnotationsMutated;
         private boolean isInheritedAnnotationsMutated;
         private boolean isParameterArgumentsMutated;
+        private boolean isTypeParametersMutated;
         private ElementKind kind;
         private ElementSignature signature;
         private Object originatingElement;
@@ -132,6 +134,10 @@ public BUILDER from(TypedElementInfo prototype) {
             addThrowsChecked(prototype.throwsChecked());
             originatingElement(prototype.originatingElement());
             signature(prototype.signature());
+            if (!isTypeParametersMutated) {
+                typeParameters.clear();
+            }
+            addTypeParameters(prototype.typeParameters());
             if (!isAnnotationsMutated) {
                 annotations.clear();
             }
@@ -187,6 +193,14 @@ public BUILDER from(TypedElementInfo.BuilderBase<?, ?> builder) {
             addThrowsChecked(builder.throwsChecked);
             builder.originatingElement().ifPresent(this::originatingElement);
             builder.signature().ifPresent(this::signature);
+            if (isTypeParametersMutated) {
+                if (builder.isTypeParametersMutated) {
+                    addTypeParameters(builder.typeParameters);
+                }
+            } else {
+                typeParameters.clear();
+                addTypeParameters(builder.typeParameters);
+            }
             if (isAnnotationsMutated) {
                 if (builder.isAnnotationsMutated) {
                     addAnnotations(builder.annotations);
@@ -408,7 +422,7 @@ public BUILDER addComponentTypes(List<? extends TypeName> componentTypes) {
          * @return updated builder instance
          * @see #modifiers()
          */
-        public BUILDER modifiers(Set<? extends String> modifiers) {
+        public BUILDER modifiers(Set<String> modifiers) {
             Objects.requireNonNull(modifiers);
             this.modifiers.clear();
             this.modifiers.addAll(modifiers);
@@ -422,7 +436,7 @@ public BUILDER modifiers(Set<? extends String> modifiers) {
          * @return updated builder instance
          * @see #modifiers()
          */
-        public BUILDER addModifiers(Set<? extends String> modifiers) {
+        public BUILDER addModifiers(Set<String> modifiers) {
             Objects.requireNonNull(modifiers);
             this.modifiers.addAll(modifiers);
             return self();
@@ -663,6 +677,68 @@ public BUILDER originatingElement(Object originatingElement) {
             return self();
         }
 
+        /**
+         * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+         * this would return the generic type {@code T} with no upper or lower bounds.
+         *
+         * @param typeParameters list of type parameters of this element
+         * @return updated builder instance
+         * @see #typeParameters()
+         */
+        public BUILDER typeParameters(List<? extends TypeName> typeParameters) {
+            Objects.requireNonNull(typeParameters);
+            isTypeParametersMutated = true;
+            this.typeParameters.clear();
+            this.typeParameters.addAll(typeParameters);
+            return self();
+        }
+
+        /**
+         * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+         * this would return the generic type {@code T} with no upper or lower bounds.
+         *
+         * @param typeParameters list of type parameters of this element
+         * @return updated builder instance
+         * @see #typeParameters()
+         */
+        public BUILDER addTypeParameters(List<? extends TypeName> typeParameters) {
+            Objects.requireNonNull(typeParameters);
+            isTypeParametersMutated = true;
+            this.typeParameters.addAll(typeParameters);
+            return self();
+        }
+
+        /**
+         * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+         * this would return the generic type {@code T} with no upper or lower bounds.
+         *
+         * @param typeParameter list of type parameters of this element
+         * @return updated builder instance
+         * @see #typeParameters()
+         */
+        public BUILDER addTypeParameter(TypeName typeParameter) {
+            Objects.requireNonNull(typeParameter);
+            this.typeParameters.add(typeParameter);
+            isTypeParametersMutated = true;
+            return self();
+        }
+
+        /**
+         * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+         * this would return the generic type {@code T} with no upper or lower bounds.
+         *
+         * @param consumer list of type parameters of this element
+         * @return updated builder instance
+         * @see #typeParameters()
+         */
+        public BUILDER addTypeParameter(Consumer<TypeName.Builder> consumer) {
+            Objects.requireNonNull(consumer);
+            var builder = TypeName.builder();
+            consumer.accept(builder);
+            this.typeParameters.add(builder.build());
+            return self();
+        }
+
         /**
          * List of declared and known annotations for this element.
          * Note that "known" implies that the annotation is visible, which depends
@@ -978,6 +1054,16 @@ public Optional<ElementSignature> signature() {
             return Optional.ofNullable(signature);
         }
 
+        /**
+         * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+         * this would return the generic type {@code T} with no upper or lower bounds.
+         *
+         * @return the type parameters
+         */
+        public List<TypeName> typeParameters() {
+            return typeParameters;
+        }
+
         /**
          * List of declared and known annotations for this element.
          * Note that "known" implies that the annotation is visible, which depends
@@ -1120,6 +1206,7 @@ protected static class TypedElementInfoImpl implements TypedElementInfo {
             private final List<Annotation> elementTypeAnnotations;
             private final List<Annotation> inheritedAnnotations;
             private final List<TypeName> componentTypes;
+            private final List<TypeName> typeParameters;
             private final List<TypedElementInfo> parameterArguments;
             private final Optional<TypeName> enclosingType;
             private final Optional<Object> originatingElement;
@@ -1154,6 +1241,7 @@ protected TypedElementInfoImpl(TypedElementInfo.BuilderBase<?, ?> builder) {
                 this.throwsChecked = Collections.unmodifiableSet(new LinkedHashSet<>(builder.throwsChecked()));
                 this.originatingElement = builder.originatingElement();
                 this.signature = builder.signature().get();
+                this.typeParameters = List.copyOf(builder.typeParameters());
                 this.annotations = List.copyOf(builder.annotations());
                 this.inheritedAnnotations = List.copyOf(builder.inheritedAnnotations());
             }
@@ -1248,6 +1336,11 @@ public ElementSignature signature() {
                 return signature;
             }
 
+            @Override
+            public List<TypeName> typeParameters() {
+                return typeParameters;
+            }
+
             @Override
             public List<Annotation> annotations() {
                 return annotations;
@@ -1273,6 +1366,7 @@ public boolean equals(Object o) {
                         && Objects.equals(parameterArguments, other.parameterArguments())
                         && Objects.equals(throwsChecked, other.throwsChecked())
                         && Objects.equals(signature, other.signature())
+                        && Objects.equals(typeParameters, other.typeParameters())
                         && Objects.equals(annotations, other.annotations())
                         && Objects.equals(inheritedAnnotations, other.inheritedAnnotations());
             }
@@ -1286,6 +1380,7 @@ public int hashCode() {
                                     parameterArguments,
                                     throwsChecked,
                                     signature,
+                                    typeParameters,
                                     annotations,
                                     inheritedAnnotations);
             }
diff --git a/common/types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java b/common/types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
index 3de312eb13c..ff33c88c696 100644
--- a/common/types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
+++ b/common/types/src/main/java/io/helidon/common/types/TypedElementInfoBlueprint.java
@@ -188,4 +188,13 @@ default Object originatingElementValue() {
      */
     @Option.Access("")
     ElementSignature signature();
+
+    /**
+     * Type parameters of this element. Such as when a method is declared as {@code <T> T generate(Class<T> type)},
+     * this would return the generic type {@code T} with no upper or lower bounds.
+     *
+     * @return list of type parameters of this element
+     */
+    @Option.Singular
+    List<TypeName> typeParameters();
 }
diff --git a/config/config/src/main/java/io/helidon/config/BuilderImpl.java b/config/config/src/main/java/io/helidon/config/BuilderImpl.java
index a1bd6f09681..1cad8967a8e 100644
--- a/config/config/src/main/java/io/helidon/config/BuilderImpl.java
+++ b/config/config/src/main/java/io/helidon/config/BuilderImpl.java
@@ -46,6 +46,7 @@
 import io.helidon.config.spi.ConfigSource;
 import io.helidon.config.spi.MergingStrategy;
 import io.helidon.config.spi.OverrideSource;
+import io.helidon.service.registry.ServiceRegistry;
 
 /**
  * {@link Config} Builder implementation.
@@ -99,6 +100,7 @@ class BuilderImpl implements Config.Builder {
     private boolean systemPropertiesSourceEnabled;
     private boolean environmentVariablesSourceEnabled;
     private boolean envVarAliasGeneratorEnabled;
+    private ServiceRegistry serviceRegistry;
 
     BuilderImpl() {
         overrideSource = OverrideSources.empty();
@@ -353,6 +355,12 @@ public AbstractConfigImpl build() {
                 .newConfig();
     }
 
+    @Override
+    public Config.Builder serviceRegistry(ServiceRegistry serviceRegistry) {
+        this.serviceRegistry = serviceRegistry;
+        return this;
+    }
+
     private static void addBuiltInMapperServices(List<PrioritizedMapperProvider> prioritizedMappers) {
         // we must add default mappers using a known priority (200), so they can be overridden by services
         // and yet we can still define a service that is only used after these (such as config beans)
diff --git a/config/config/src/main/java/io/helidon/config/Config.java b/config/config/src/main/java/io/helidon/config/Config.java
index efdc44966e6..9837ba62d57 100644
--- a/config/config/src/main/java/io/helidon/config/Config.java
+++ b/config/config/src/main/java/io/helidon/config/Config.java
@@ -39,6 +39,7 @@
 import io.helidon.config.spi.MergingStrategy;
 import io.helidon.config.spi.OverrideSource;
 import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceRegistry;
 
 /**
  * <h2>Configuration</h2>
@@ -383,6 +384,12 @@ static Builder builder() {
         return new BuilderImpl();
     }
 
+    static Builder builder(ServiceRegistry serviceRegistry) {
+        return new BuilderImpl()
+                .serviceRegistry(serviceRegistry);
+
+    }
+
     /**
      * Creates a new {@link Config} loaded from the specified {@link ConfigSource}s.
      * No other sources will be included.
@@ -406,7 +413,10 @@ static Config just(Supplier<? extends ConfigSource>... configSources) {
      * global config registered in not an instance of this type.
      *
      * @return global config instance, creates one if not yet registered
+     * @deprecated either use {@link io.helidon.service.registry.Services#get(Class)} instead for static access,
+     *  inject an instance into your service when creating a service, or use your service registry instance
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static Config global() {
         if (GlobalConfig.configured()) {
             io.helidon.common.config.Config global = GlobalConfig.config();
@@ -425,7 +435,10 @@ static Config global() {
      * This method registers also {@link io.helidon.common.config.GlobalConfig} instance.
      *
      * @param config to configure as global
+     * @deprecated use {@link io.helidon.service.registry.Services#set(Class, Object[])} to register a static instance for the
+     *      global service registry; when using a custom service registry instance, set is on the registry configuration builder
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     static void global(Config config) {
         GlobalConfig.config(() -> config, true);
         BuilderImpl.GlobalConfigHolder.set(config);
@@ -1788,5 +1801,13 @@ default Builder metaConfig() {
          * @return updated builder from meta configuration
          */
         Builder config(Config metaConfig);
+
+        /**
+         * Configure an explicit service registry to use to discover services (config sources, parsers etc.).
+         *
+         * @param serviceRegistry registry to use
+         * @return updated builder instance
+         */
+        Builder serviceRegistry(ServiceRegistry serviceRegistry);
     }
 }
diff --git a/config/config/src/main/java/io/helidon/config/ConfigProvider.java b/config/config/src/main/java/io/helidon/config/ConfigProvider.java
index c4b2912bd9d..5cd1f79978c 100644
--- a/config/config/src/main/java/io/helidon/config/ConfigProvider.java
+++ b/config/config/src/main/java/io/helidon/config/ConfigProvider.java
@@ -34,11 +34,11 @@
 import io.helidon.config.spi.ConfigSource;
 import io.helidon.service.registry.Service;
 
-@Service.Provider
-@Service.ExternalContracts(Config.class)
+@Service.Singleton
 class ConfigProvider implements Config {
     private final Config config;
 
+    @Service.Inject
     ConfigProvider(Supplier<MetaConfig> metaConfig,
                    Supplier<List<ConfigSource>> configSources,
                    Supplier<List<ConfigParser>> configParsers,
diff --git a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
index 6baee99d396..6ef039d7c77 100644
--- a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
+++ b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
@@ -102,6 +102,9 @@ public class DbMapperProviderImpl implements MapperProvider  {
         return Collections.unmodifiableMap(mappers);
     }
 
+    public DbMapperProviderImpl() {
+    }
+
     @Override
     public ProviderResponse mapper(Class<?> sourceClass, Class<?> targetClass, String qualifier) {
         Map<Class<?>, Mapper<?, ?>> targetMap = MAPPERS.get(sourceClass);
diff --git a/etc/checkstyle-suppressions.xml b/etc/checkstyle-suppressions.xml
index 7d1ccf9e6d7..dad2a64f1ad 100644
--- a/etc/checkstyle-suppressions.xml
+++ b/etc/checkstyle-suppressions.xml
@@ -48,7 +48,7 @@ record here.
             checks="FileLength"/>
 
     <!-- This file is generating source file, and uses a lot of lines to append code -->
-    <suppress files="service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension\.java"
+    <suppress files="service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen\.java"
             checks="FileLength"/>
 
     <!--
diff --git a/inject/api/src/main/java/module-info.java b/inject/api/src/main/java/module-info.java
index 3d713636b5e..18b37f0c224 100644
--- a/inject/api/src/main/java/module-info.java
+++ b/inject/api/src/main/java/module-info.java
@@ -26,6 +26,7 @@
     requires io.helidon.common.types;
     requires io.helidon.common;
     requires io.helidon.logging.common;
+
     requires jakarta.inject;
 
     requires static io.helidon.config.metadata;
diff --git a/service/builder/pom.xml b/service/builder/pom.xml
deleted file mode 100644
index edebd907274..00000000000
--- a/service/builder/pom.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (c) 2024 Oracle and/or its affiliates.
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
--->
-
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://maven.apache.org/POM/4.0.0"
-        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <groupId>io.helidon.service</groupId>
-        <artifactId>helidon-service-project</artifactId>
-        <version>4.2.0-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>helidon-service-builder</artifactId>
-    <name>Helidon Service Builder</name>
-    <description>
-        Support for service registry in builders.
-        This must be separate from service registry itself, as we would create a cyclic dependency otherwise.
-        This module adds support for using service registry to discover service providers and services from
-        registry.
-    </description>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.helidon.common</groupId>
-            <artifactId>helidon-common-config</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-registry</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.builder</groupId>
-            <artifactId>helidon-builder-api</artifactId>
-        </dependency>
-    </dependencies>
-</project>
diff --git a/service/builder/src/main/java/module-info.java b/service/builder/src/main/java/module-info.java
deleted file mode 100644
index e278a9bfc05..00000000000
--- a/service/builder/src/main/java/module-info.java
+++ /dev/null
@@ -1,6 +0,0 @@
-module io.helidon.service.builder {
-    requires transitive io.helidon.common.config;
-    requires transitive io.helidon.service.registry;
-
-    exports io.helidon.service.builder;
-}
\ No newline at end of file
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
index 49211680d99..85d5bae69bf 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenAnnotations.java
@@ -1,9 +1,28 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.codegen;
 
 import io.helidon.common.types.Annotation;
 
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_NAMED;
 
-class ServiceCodegenAnnotations {
+final class ServiceCodegenAnnotations {
     static final Annotation WILDCARD_NAMED = Annotation.create(SERVICE_ANNOTATION_NAMED, "*");
+
+    private ServiceCodegenAnnotations() {
+    }
 }
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceContracts.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceContracts.java
index ed3fa8f35ad..db1cc5c3809 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceContracts.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceContracts.java
@@ -16,6 +16,7 @@
 
 package io.helidon.service.codegen;
 
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
@@ -214,15 +215,16 @@ public void addContracts(Set<ResolvedType> contractSet,
             typeInfoFactory.apply(withGenerics.genericTypeName())
                     .ifPresent(declaration -> {
                         TypeName tn = declaration.typeName();
+
+                        List<TypeName> wildcards = new ArrayList<>();
+                        List<TypeName> extendses = new ArrayList<>();
+                        boolean extendsValid = false;
+
                         for (int i = 0; i < withGenerics.typeArguments().size(); i++) {
                             TypeName declared = tn.typeArguments().get(i);
                             if (declared.generic()) {
                                 // Circle<?>
-                                contractSet.add(ResolvedType.create(
-                                        TypeName.builder()
-                                                .from(withGenerics)
-                                                .typeArguments(List.of(TypeNames.WILDCARD))
-                                                .build()));
+                                wildcards.add(TypeNames.WILDCARD);
 
                                 // Circle<Color>
                                 var asString = declared.toString();
@@ -230,15 +232,24 @@ public void addContracts(Set<ResolvedType> contractSet,
                                 if (index != -1) {
                                     TypeName extendedType = TypeName.create(asString.substring(index + 9));
                                     if (isEligible(extendedType)) {
-                                        contractSet.add(ResolvedType.create(
-                                                TypeName.builder()
-                                                        .from(withGenerics)
-                                                        .typeArguments(List.of(extendedType))
-                                                        .build()));
+                                        extendses.add(extendedType);
+                                        extendsValid = true;
                                     }
                                 }
-                            } else {
-                                contractSet.add(ResolvedType.create(declared));
+                            }
+                        }
+                        if (!wildcards.isEmpty()) {
+                            contractSet.add(ResolvedType.create(
+                                    TypeName.builder()
+                                            .from(withGenerics)
+                                            .typeArguments(wildcards)
+                                            .build()));
+                            if (extendsValid) {
+                                contractSet.add(ResolvedType.create(
+                                        TypeName.builder()
+                                                .from(withGenerics)
+                                                .typeArguments(extendses)
+                                                .build()));
                             }
                         }
                     });
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
index 8c27de412f3..f119862484f 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.codegen;
 
 import java.util.ArrayList;
@@ -73,6 +89,9 @@
 import static io.helidon.service.codegen.ServiceCodegenTypes.SET_OF_STRINGS;
 import static java.util.function.Predicate.not;
 
+/**
+ * Code generator of service descriptor for Helidon Services.
+ */
 public class ServiceDescriptorCodegen {
     private static final TypeName GENERATOR = TypeName.create(ServiceExtension.class);
     private static final TypeName DESCRIPTOR_TYPE = TypeName.builder(ServiceCodegenTypes.SERVICE_DESCRIPTOR)
@@ -124,6 +143,7 @@ public static ServiceDescriptorCodegen create(RegistryCodegenContext ctx) {
      * @param services  all types that are going to be described
      * @param typeInfo  type info of the service type
      */
+    @SuppressWarnings("checkstyle:MethodLength") // this already extracting the necessary steps
     public void service(TypeName generator, RegistryRoundContext roundCtx, Collection<TypeInfo> services, TypeInfo typeInfo) {
         packageName(roundCtx);
 
@@ -2094,33 +2114,6 @@ private void methodElementFields(ClassModel.Builder classModel,
                     .name(constantName)
                     .addContentCreate(typedElementInfo));
         }
-        /*
-        TypedElements.gatherElements(typeInfo)
-                .stream()
-                .filter(element -> ElementInfoPredicates.isMethod(element.element()))
-                .filter(element -> !ElementInfoPredicates.isPrivate(element.element()))
-                .forEach(element -> {
-                    var method = element.element();
-                    String uniqueName = ctx.uniqueName(typeInfo, method);
-                    String constantName = "METHOD_" + toConstantName(uniqueName);
-
-                    // add inherited annotations from interfaces
-                    List<Annotation> elementAnnotations = new ArrayList<>(method.annotations());
-                    addInterfaceAnnotations(elementAnnotations, element.abstractMethods());
-                    TypedElementInfo typedElementInfo = TypedElementInfo.builder()
-                            .from(method)
-                            .annotations(elementAnnotations)
-                            .build();
-                    classModel.addField(constant -> constant
-                            .description("Element info for method: {@code " + method.signature() + "}.")
-                            .accessModifier(AccessModifier.PUBLIC)
-                            .isStatic(true)
-                            .isFinal(true)
-                            .type(TypeNames.TYPED_ELEMENT_INFO)
-                            .name(constantName)
-                            .addContentCreate(typedElementInfo));
-                });
-         */
     }
 
     private void generateInterceptedType(RegistryRoundContext roundContext,
diff --git a/service/maven-plugin/pom.xml b/service/maven-plugin/pom.xml
index 7ba10c76e78..9a3492d9540 100644
--- a/service/maven-plugin/pom.xml
+++ b/service/maven-plugin/pom.xml
@@ -76,14 +76,6 @@
             <groupId>io.helidon.codegen</groupId>
             <artifactId>helidon-codegen-class-model</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-registry</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.helidon.service</groupId>
-            <artifactId>helidon-service-codegen</artifactId>
-        </dependency>
         <dependency>
             <groupId>io.helidon.service</groupId>
             <artifactId>helidon-service-codegen</artifactId>
diff --git a/service/pom.xml b/service/pom.xml
index a3da5ea1e66..06863ef4a66 100644
--- a/service/pom.xml
+++ b/service/pom.xml
@@ -46,7 +46,6 @@
         <module>codegen</module>
         <module>registry</module>
         <module>maven-plugin</module>
-        <module>builder</module>
     </modules>
 
     <build>
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java
new file mode 100644
index 00000000000..a02bf3ab470
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java
@@ -0,0 +1,94 @@
+package io.helidon.service.registry;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import io.helidon.common.types.TypeName;
+
+/**
+ * Methods used from generated code in builders when service registry (without Config) is used.
+ */
+public class RegistryBuilderSupport {
+    private RegistryBuilderSupport() {
+    }
+
+    /**
+     * Discover services from the registry.
+     *
+     * @param registry    service registry to use, if provided explicitly
+     * @param contract    contract that is requested
+     * @param useRegistry whether to use the service registry at all
+     * @param <T>         type of the contract
+     * @return a list of contract implementation from the registry
+     */
+    public static <T> List<T> serviceList(Optional<ServiceRegistry> registry,
+                                          TypeName contract,
+                                          boolean useRegistry) {
+        if (!useRegistry) {
+            return List.of();
+        }
+
+        List<T> result = new ArrayList<>();
+        if (registry.isPresent()) {
+            result.addAll(registry.get().all(contract));
+        } else {
+            result.addAll(Services.all(contract));
+        }
+
+        return List.copyOf(result);
+    }
+
+    /**
+     * Discover services from the registry.
+     *
+     * @param registry    service registry to use, if provided explicitly
+     * @param contract    contract that is requested
+     * @param useRegistry whether to use the service registry at all
+     * @param <T>         type of the contract
+     * @return a set of contract implementation
+     */
+    public static <T> Set<T> serviceSet(Optional<ServiceRegistry> registry,
+                                        TypeName contract,
+                                        boolean useRegistry) {
+        if (!useRegistry) {
+            return Set.of();
+        }
+
+        Set<T> result = new HashSet<>();
+        if (registry.isPresent()) {
+            result.addAll(registry.get().all(contract));
+        } else {
+            result.addAll(Services.all(contract));
+        }
+
+        return Set.copyOf(result);
+    }
+
+    /**
+     * Get the first service from the registry if not configured in the builder.
+     *
+     * @param registry      service registry to use, if provided explicitly
+     * @param contract      contract that is requested
+     * @param existingValue current values configured on the builder
+     * @param useRegistry   whether to use the service registry at all
+     * @param <T>           type of the contract
+     * @return a list of contract implementation, combined from what user provided in builder and what was discovered in registry
+     */
+    public static <T> Optional<T> service(Optional<ServiceRegistry> registry,
+                                          TypeName contract,
+                                          Optional<T> existingValue,
+                                          boolean useRegistry) {
+        if (existingValue.isPresent() || !useRegistry) {
+            return existingValue;
+        }
+
+        if (registry.isPresent()) {
+            return (registry.get().first(contract));
+        } else {
+            return Services.first(contract);
+        }
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
index 6f833ef683f..cdc3269d654 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetrics.java
@@ -1,8 +1,50 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
-public interface RegistryMetrics {
+/**
+ * Metrics provided by the service registry.
+ */
+public sealed interface RegistryMetrics permits RegistryMetricsImpl {
+    /**
+     * Number of lookups done in the registry.
+     *
+     * @return lookup count
+     */
     int lookupCount();
+
+    /**
+     * Number of full scan counts (going through every service in the registry and checking matches).
+     *
+     * @return full scan count
+     */
     int fullScanCount();
+
+    /**
+     * Number of times we attempted to get a cached lookup.
+     *
+     * @return cache access count
+     */
     int cacheAccessCount();
+
+    /**
+     * Number of times the cache provided a value.
+     *
+     * @return cache hit count
+     */
     int cacheHitCount();
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
index 0922e441113..328125f4cf4 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
@@ -2,7 +2,7 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-class RegistryMetricsImpl implements RegistryMetrics {
+final class RegistryMetricsImpl implements RegistryMetrics {
     private final AtomicInteger lookupCount = new AtomicInteger();
     private final AtomicInteger fullScanCount = new AtomicInteger();
     private final AtomicInteger cacheAccessCount = new AtomicInteger();
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
index d29b24bacd2..97b4b6e4195 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceDescriptor.java
@@ -30,7 +30,8 @@ public interface ServiceDescriptor<T> extends ServiceInfo {
     /**
      * Create a new service instance.
      *
-     * @param ctx dependency context with all dependencies of this service
+     * @param ctx                  dependency context with all dependencies of this service
+     * @param interceptionMetadata metadata handler for interception
      * @return a new instance, must be of the type T or a subclass
      */
     // we cannot return T, as it does not allow us to correctly handle inheritance
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
index 2332aa1a11f..3c79e6968ba 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
@@ -88,7 +88,8 @@ interface ServiceRegistryConfigBlueprint {
     boolean lookupCacheEnabled();
 
     /**
-     * Size of the lookup cache when {@link #lookupCacheEnabled()} is set to {@code true}.
+     * Size of the lookup cache when {@link io.helidon.service.registry.ServiceRegistryConfig#lookupCacheEnabled()}
+     * is set to {@code true}.
      *
      * @return cache size
      */
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 7e0cc93daf4..9d1f32e4b3c 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -104,6 +104,7 @@ public static ServiceRegistryManager create(ServiceRegistryConfig config) {
      *
      * @return service registry ready to be used
      */
+    @SuppressWarnings("checkstyle:methodLength") // already condensed; further extraction would decrease readability
     public ServiceRegistry registry() {
         Lock readLock = lifecycleLock.readLock();
         try {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Services.java b/service/registry/src/main/java/io/helidon/service/registry/Services.java
index d6441e25997..83cf64cb92d 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Services.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Services.java
@@ -4,6 +4,8 @@
 import java.util.Objects;
 import java.util.Optional;
 
+import io.helidon.common.types.TypeName;
+
 /**
  * Static access to the service registry.
  * <p>
@@ -112,6 +114,22 @@ public static <T> T get(Class<T> contract) {
         return GlobalServiceRegistry.registry().get(contract);
     }
 
+    /**
+     * Get the first instance of the contract, expecting the contract is available.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return an instance of the contract, never {@code null}
+     * @throws io.helidon.service.registry.ServiceRegistryException in case the contract is not available in the registry
+     * @throws java.lang.NullPointerException                       if either of the parameters is null
+     * @see #first(Class)
+     */
+    public static <T> T get(TypeName contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().get(contract);
+    }
+
+
     /**
      * Get all instances of the contract.
      *
@@ -125,6 +143,19 @@ public static <T> List<T> all(Class<T> contract) {
         return GlobalServiceRegistry.registry().all(contract);
     }
 
+    /**
+     * Get all instances of the contract.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return all instances in the registry, may be empty
+     * @throws java.lang.NullPointerException if either of the parameters is null
+     */
+    public static <T> List<T> all(TypeName contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().all(contract);
+    }
+
     /**
      * Get first instance of the contract from the registry, all an empty optional if none exist.
      *
@@ -137,4 +168,17 @@ public static <T> Optional<T> first(Class<T> contract) {
         Objects.requireNonNull(contract);
         return GlobalServiceRegistry.registry().first(contract);
     }
+
+    /**
+     * Get first instance of the contract from the registry, all an empty optional if none exist.
+     *
+     * @param contract contract to find
+     * @param <T>      type of the contract
+     * @return first instance, or an empty optional
+     * @throws java.lang.NullPointerException if either of the parameters is null
+     */
+    public static <T> Optional<T> first(TypeName contract) {
+        Objects.requireNonNull(contract);
+        return GlobalServiceRegistry.registry().first(contract);
+    }
 }

From ea8924aec721e7bbb6d848e2df43af7d35aa611e Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 10 Dec 2024 19:08:51 +0100
Subject: [PATCH 13/23] Fixed spotbugs, checkstyle etc.

---
 .../codegen/GenerateAbstractBuilder.java      | 12 ++++---
 .../helidon/common/config/GlobalConfig.java   | 28 ++++++++++++---
 common/configurable/etc/spotbugs/exclude.xml  |  5 +++
 .../helidon/common/mapper/GlobalManager.java  | 29 +++++++++++----
 .../io/helidon/common/mapper/Mappers.java     | 36 +++++++++++++++++++
 .../common/mapper/MappersConfigSupport.java   |  4 +++
 .../java/io/helidon/config/BuilderImpl.java   |  3 +-
 .../main/java/io/helidon/config/Config.java   | 17 ++++-----
 .../dbclient/DbMapperProviderImpl.java        |  3 ++
 service/maven-plugin/etc/spotbugs/exclude.xml |  4 +--
 service/maven-plugin/pom.xml                  |  8 -----
 .../helidon/service/registry/Activators.java  |  2 +-
 12 files changed, 112 insertions(+), 39 deletions(-)

diff --git a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
index d8c7008e24b..41961f09792 100644
--- a/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
+++ b/builder/codegen/src/main/java/io/helidon/builder/codegen/GenerateAbstractBuilder.java
@@ -202,6 +202,10 @@ private static void addCustomBuilderMethods(TypeContext typeContext, InnerClass.
                 }
             }
 
+            for (TypeName typeParameter : customMethod.generatedMethod().method().typeParameters()) {
+                method.addGenericArgument(TypeArgument.create(typeParameter));
+            }
+
             if (!generated.javadoc().isEmpty()) {
                 Javadoc javadoc = Javadoc.builder()
                         .from(Javadoc.parse(generated.javadoc()))
@@ -209,9 +213,7 @@ private static void addCustomBuilderMethods(TypeContext typeContext, InnerClass.
                         .build();
                 method.javadoc(javadoc);
             }
-            for (TypeName typeParameter : customMethod.generatedMethod().method().typeParameters()) {
-                method.addGenericArgument(TypeArgument.create(typeParameter));
-            }
+
             builder.addMethod(method);
         }
     }
@@ -322,8 +324,8 @@ public BUILDER config(Config config) {
         }
          */
         Javadoc javadoc = Javadoc.builder()
-                .addLine("Provide an explicit registry instance to use. ")
-                .addLine("<p/>")
+                .addLine("Provide an explicit registry instance to use.")
+                .addLine("<p>")
                 .addLine("If not configured, the {@link "
                                  + Types.GLOBAL_SERVICE_REGISTRY.fqName()
                                  + "} would be used to discover services.")
diff --git a/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java b/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
index dcb8bb6ebd7..4b6d41079ed 100644
--- a/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
+++ b/common/config/src/main/java/io/helidon/common/config/GlobalConfig.java
@@ -19,6 +19,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.ServiceLoader;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
@@ -35,8 +36,16 @@
  * configuration.
  * <p>
  * You may still use custom instances of configuration when using configurable APIs directly.
+ * @deprecated Use {@link io.helidon.service.registry.Services#get(Class)}, or
+ * {@link io.helidon.service.registry.ServiceRegistry#get(Class)} if you have an instance ready to obtain the "global"
+ * configuration; in case you are writing a registry service, simply inject the config instance; use
+ * {@link io.helidon.service.registry.Services#set(Class, Object[])} to use a custom instance of configuration, just make sure
+ * it is registered before it is used the first time
  */
+@Deprecated(forRemoval = true, since = "4.2.0")
 public final class GlobalConfig {
+    private static final System.Logger LOGGER = System.getLogger(GlobalConfig.class.getName());
+    private static final AtomicBoolean LOGGED_REGISTERED = new AtomicBoolean(false);
     private static final Config EMPTY = Config.empty();
     private static final LazyValue<Config> DEFAULT_CONFIG = LazyValue.create(() -> {
         List<ConfigProvider> providers = HelidonServiceLoader.create(ServiceLoader.load(ConfigProvider.class))
@@ -69,7 +78,9 @@ public static boolean configured() {
      * @return Helidon shared configuration instance if configured, or an empty configuration if not
      * @see #config(java.util.function.Supplier)
      * @see #config(java.util.function.Supplier, boolean)
+     * @deprecated use {@link io.helidon.service.registry.Services#get(Class)} instead
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     public static Config config() {
         return configured() ? CONFIG.get() : DEFAULT_CONFIG.get();
     }
@@ -79,7 +90,9 @@ public static Config config() {
      *
      * @param config configuration supplier to use if config is not yet configured
      * @return used global configuration instance
+     * @deprecated use {@link io.helidon.service.registry.Services#set(Class, Object[])} instead
      */
+    @Deprecated(forRemoval = true, since = "4.2.0")
     public static Config config(Supplier<Config> config) {
         return config(config, false);
     }
@@ -99,13 +112,20 @@ public static Config config(Supplier<Config> config, boolean overwrite) {
         if (overwrite || !configured()) {
             // there is a certain risk we may do this twice, if two components try to set global config in parallel.
             // as the result was already unclear (as order matters), we do not need to be 100% thread safe here
-            Config config1 = config.get();
-            CONFIG.set(config1);
+            Config configInstance = config.get();
+            CONFIG.set(configInstance);
 
             try {
-                Services.set(Config.class, config1);
+                Services.set(Config.class, configInstance);
             } catch (Exception e) {
-                // todo log in warning, as this will not work in the future
+                if (LOGGED_REGISTERED.compareAndSet(false, true)) {
+                    // only log this once
+                    LOGGER.log(System.Logger.Level.WARNING,
+                               "Attempting to set a config instance when it either was already "
+                                       + "set once, or it was already used by a component. "
+                                       + "This will not work in future versions of Helidon",
+                               e);
+                }
             }
         }
         return CONFIG.get();
diff --git a/common/configurable/etc/spotbugs/exclude.xml b/common/configurable/etc/spotbugs/exclude.xml
index 6c4faead676..93b6a8fe2d3 100644
--- a/common/configurable/etc/spotbugs/exclude.xml
+++ b/common/configurable/etc/spotbugs/exclude.xml
@@ -42,4 +42,9 @@
         <Method name="&lt;init&gt;"/>
         <Bug pattern = "VA_FORMAT_STRING_USES_NEWLINE"/>
     </Match>
+    <Match>
+        <!-- deprecated, need the common to decouple from config -->
+        <Class name="io.helidon.common.configurable.LruCache" />
+        <Bug pattern="NM_SAME_SIMPLE_NAME_AS_INTERFACE" />
+    </Match>
 </FindBugsFilter>
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java b/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
index 2aeae42d9e2..c37b9b86d00 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
@@ -16,25 +16,42 @@
 
 package io.helidon.common.mapper;
 
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import io.helidon.common.LazyValue;
+import io.helidon.service.registry.Services;
 
+// this class should be removed when deprecation is resolved
+@SuppressWarnings("removal")
 final class GlobalManager {
-    private static final LazyValue<MapperManager> DEFAULT_MAPPER = LazyValue.create(() -> MapperManager.builder()
-            .useBuiltIn(true)
-            .build());
+    private static final System.Logger LOGGER = System.getLogger(GlobalManager.class.getName());
+    private static final AtomicBoolean LOGGED_REGISTERED = new AtomicBoolean(false);
+
     private static final AtomicReference<MapperManager> MANAGER = new AtomicReference<>();
 
     private GlobalManager() {
     }
 
-    public static void mapperManager(MapperManager manager) {
+    static void mapperManager(MapperManager manager) {
         MANAGER.set(manager);
+
+        try {
+            Services.set(Mappers.class, manager);
+        } catch (Exception e) {
+            if (LOGGED_REGISTERED.compareAndSet(false, true)) {
+                // only log this once
+                LOGGER.log(System.Logger.Level.WARNING,
+                           "Attempting to set a Mappers (MapperManager) instance when it either was already "
+                                   + "set once, or it was already used by a component."
+                                   + " This will not work in future versions of"
+                                   + " Helidon",
+                           e);
+            }
+        }
     }
 
     static MapperManager mapperManager() {
         MapperManager mapperManager = MANAGER.get();
-        return mapperManager == null ? DEFAULT_MAPPER.get() : mapperManager;
+        return mapperManager == null ? Services.get(MapperManager.class) : mapperManager;
     }
 }
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
index fde42ddef9e..b6588e0451f 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
@@ -6,20 +6,56 @@
 import io.helidon.builder.api.RuntimeType;
 import io.helidon.common.GenericType;
 
+/**
+ * Mappers manager of all configured mappers.
+ * <p>
+ * To map a source to target, you can use either of the {@code map} methods defined in this interface,
+ * as they make sure that the mapping exists in either space.
+ * <ul>
+ * <li>If you call {@link #map(Object, Class, Class, String...)} and no mapper is found for the class pair,
+ * the implementation calls the {@link #map(Object, io.helidon.common.GenericType, io.helidon.common.GenericType, String...)}
+ * with {@link io.helidon.common.GenericType}s created for each parameters</li>
+ * <li>If you call {@link #map(Object, io.helidon.common.GenericType, io.helidon.common.GenericType, String...)} and no mapper is
+ * found for the {@link io.helidon.common.GenericType} pair, an attempt is to locate a mapper for
+ * the underlying class *IF* the generic type represents a simple class (e.g. not a generic type declaration)</li>
+ * </ul>
+ */
 @RuntimeType.PrototypedBy(MappersConfig.class)
 public interface Mappers extends RuntimeType.Api<MappersConfig> {
+    /**
+     * Create a new builder to customize configuration of {@link io.helidon.common.mapper.Mappers}.
+     *
+     * @return a new fluent API builder
+     */
     static MappersConfig.Builder builder() {
         return MappersConfig.builder();
     }
 
+    /**
+     * Create mappers using defaults.
+     *
+     * @return create new mappers
+     */
     static Mappers create() {
         return builder().build();
     }
 
+    /**
+     * Create new {@link io.helidon.common.mapper.Mappers} using the provided configuration.
+     *
+     * @param config mappers configuration
+     * @return a new mappers configured from the provided config
+     */
     static Mappers create(MappersConfig config) {
         return new MappersImpl(config);
     }
 
+    /**
+     * Create new {@link io.helidon.common.mapper.Mappers} customizing its configuration.
+     *
+     * @param consumer consumer of configuration builder
+     * @return a new configured mappers instance
+     */
     static Mappers create(Consumer<MappersConfig.Builder> consumer) {
         return builder()
                 .update(consumer)
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
index 9c7d9841270..ad6d1906463 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
@@ -20,6 +20,7 @@ private CustomMethods() {
         /**
          * Add a mapper to the list of mapper.
          *
+         * @param builder    ignored
          * @param mapper     the mapper to map source instances to target instances
          * @param sourceType class of the source instance
          * @param targetType class of the target instance
@@ -39,6 +40,7 @@ static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
         /**
          * Add a mapper to the list of mapper.
          *
+         * @param builder    ignored
          * @param mapper     the mapper to map source instances to target instances
          * @param sourceType generic type of the source instance
          * @param targetType generic type of the target instance
@@ -59,6 +61,7 @@ static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
         /**
          * Add a mapper to the list of mapper with a custom priority.
          *
+         * @param builder    ignored
          * @param mapper     the mapper to map source instances to target instances
          * @param sourceType class of the source instance
          * @param targetType class of the target instance
@@ -84,6 +87,7 @@ static <S, T> void addMapper(MappersConfig.BuilderBase<?, ?> builder,
         /**
          * Add a mapper to the list of mapper with custom priority.
          *
+         * @param builder    ignored
          * @param mapper     the mapper to map source instances to target instances
          * @param sourceType generic type of the source instance
          * @param targetType generic type of the target instance
diff --git a/config/config/src/main/java/io/helidon/config/BuilderImpl.java b/config/config/src/main/java/io/helidon/config/BuilderImpl.java
index 1cad8967a8e..07055c1d71e 100644
--- a/config/config/src/main/java/io/helidon/config/BuilderImpl.java
+++ b/config/config/src/main/java/io/helidon/config/BuilderImpl.java
@@ -100,7 +100,6 @@ class BuilderImpl implements Config.Builder {
     private boolean systemPropertiesSourceEnabled;
     private boolean environmentVariablesSourceEnabled;
     private boolean envVarAliasGeneratorEnabled;
-    private ServiceRegistry serviceRegistry;
 
     BuilderImpl() {
         overrideSource = OverrideSources.empty();
@@ -357,7 +356,7 @@ public AbstractConfigImpl build() {
 
     @Override
     public Config.Builder serviceRegistry(ServiceRegistry serviceRegistry) {
-        this.serviceRegistry = serviceRegistry;
+        // not yet implemented
         return this;
     }
 
diff --git a/config/config/src/main/java/io/helidon/config/Config.java b/config/config/src/main/java/io/helidon/config/Config.java
index 9837ba62d57..8b4efe22779 100644
--- a/config/config/src/main/java/io/helidon/config/Config.java
+++ b/config/config/src/main/java/io/helidon/config/Config.java
@@ -30,7 +30,6 @@
 
 import io.helidon.common.GenericType;
 import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.GlobalConfig;
 import io.helidon.config.spi.ConfigFilter;
 import io.helidon.config.spi.ConfigMapper;
 import io.helidon.config.spi.ConfigMapperProvider;
@@ -384,12 +383,6 @@ static Builder builder() {
         return new BuilderImpl();
     }
 
-    static Builder builder(ServiceRegistry serviceRegistry) {
-        return new BuilderImpl()
-                .serviceRegistry(serviceRegistry);
-
-    }
-
     /**
      * Creates a new {@link Config} loaded from the specified {@link ConfigSource}s.
      * No other sources will be included.
@@ -416,17 +409,18 @@ static Config just(Supplier<? extends ConfigSource>... configSources) {
      * @deprecated either use {@link io.helidon.service.registry.Services#get(Class)} instead for static access,
      *  inject an instance into your service when creating a service, or use your service registry instance
      */
+    @SuppressWarnings("removal")
     @Deprecated(forRemoval = true, since = "4.2.0")
     static Config global() {
-        if (GlobalConfig.configured()) {
-            io.helidon.common.config.Config global = GlobalConfig.config();
+        if (io.helidon.common.config.GlobalConfig.configured()) {
+            io.helidon.common.config.Config global = io.helidon.common.config.GlobalConfig.config();
             if (global instanceof Config cfg) {
                 return cfg;
             }
             return BuilderImpl.GlobalConfigHolder.get();
         }
         Config config = Config.create();
-        GlobalConfig.config(() -> config, true);
+        io.helidon.common.config.GlobalConfig.config(() -> config, true);
         return config;
     }
 
@@ -438,9 +432,10 @@ static Config global() {
      * @deprecated use {@link io.helidon.service.registry.Services#set(Class, Object[])} to register a static instance for the
      *      global service registry; when using a custom service registry instance, set is on the registry configuration builder
      */
+    @SuppressWarnings("removal")
     @Deprecated(forRemoval = true, since = "4.2.0")
     static void global(Config config) {
-        GlobalConfig.config(() -> config, true);
+        io.helidon.common.config.GlobalConfig.config(() -> config, true);
         BuilderImpl.GlobalConfigHolder.set(config);
     }
 
diff --git a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
index 6ef039d7c77..26e3e5668a1 100644
--- a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
+++ b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
@@ -102,6 +102,9 @@ public class DbMapperProviderImpl implements MapperProvider  {
         return Collections.unmodifiableMap(mappers);
     }
 
+    /**
+     * Public constructor required by {@link java.util.ServiceLoader}.
+     */
     public DbMapperProviderImpl() {
     }
 
diff --git a/service/maven-plugin/etc/spotbugs/exclude.xml b/service/maven-plugin/etc/spotbugs/exclude.xml
index f31710372a3..8b6176500c5 100644
--- a/service/maven-plugin/etc/spotbugs/exclude.xml
+++ b/service/maven-plugin/etc/spotbugs/exclude.xml
@@ -24,12 +24,12 @@
 
     <Match>
         <!-- Path comes from config or code -->
-        <Class name="io.helidon.service.registry.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Class name="io.helidon.service.maven.plugin.CreateApplicationAbstractMojo"/>
         <Bug pattern="PATH_TRAVERSAL_IN"/>
     </Match>
     <Match>
         <!-- Classpath is constructed from maven classpath -->
-        <Class name="io.helidon.service.registry.maven.plugin.CreateApplicationAbstractMojo"/>
+        <Class name="io.helidon.service.maven.plugin.CreateApplicationAbstractMojo"/>
         <Bug pattern="DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED"/>
     </Match>
 
diff --git a/service/maven-plugin/pom.xml b/service/maven-plugin/pom.xml
index 9a3492d9540..b6466622b2a 100644
--- a/service/maven-plugin/pom.xml
+++ b/service/maven-plugin/pom.xml
@@ -137,14 +137,6 @@
                     <goalPrefix>helidon-service</goalPrefix>
                     <skipErrorNoDescriptorsFound>false</skipErrorNoDescriptorsFound>
                 </configuration>
-                <executions>
-                    <execution>
-                        <id>help-goal</id>
-                        <goals>
-                            <goal>helpmojo</goal>
-                        </goals>
-                    </execution>
-                </executions>
             </plugin>
         </plugins>
     </build>
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Activators.java b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
index 550be405da1..5d388142a56 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Activators.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
@@ -799,7 +799,7 @@ private List<ServiceInfo> driversFromPlan(Map<Dependency, IpPlan<?>> ipSupplierM
             // I need the list of descriptors from the injection plan
             for (Map.Entry<Dependency, IpPlan<?>> entry : ipSupplierMap.entrySet()) {
                 Dependency dependency = entry.getKey();
-                if (createFor.equals(dependency.contract())
+                if (createFor.equals(ResolvedType.create(dependency.contract()))
                         && dependency.qualifiers().size() == 1
                         && dependency.qualifiers().contains(Qualifier.WILDCARD_NAMED)) {
                     return List.of(entry.getValue().descriptors());

From f5720f356b089df4f5e614f3aa8689d866950e38 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 10 Dec 2024 19:31:58 +0100
Subject: [PATCH 14/23] Copyright fixes.

---
 builder/api/src/main/java/module-info.java       |  2 +-
 .../processor/GenerateAbstractBuilder.java       |  2 +-
 .../java/io/helidon/builder/processor/Types.java |  2 +-
 .../io/helidon/common/HelidonServiceLoader.java  |  2 +-
 .../java/io/helidon/common/LruCacheTest.java     |  2 +-
 .../common/config/ConfigBuilderSupport.java      | 16 ++++++++++++++++
 .../io/helidon/common/config/ProvidedUtil.java   |  2 +-
 common/config/src/main/java/module-info.java     |  2 +-
 common/configurable/etc/spotbugs/exclude.xml     |  2 +-
 .../common/mapper/DefaultMapperProvider.java     |  2 +-
 .../io/helidon/common/mapper/GlobalManager.java  |  2 +-
 .../java/io/helidon/common/mapper/Mapper.java    |  2 +-
 .../java/io/helidon/common/mapper/Mappers.java   | 16 ++++++++++++++++
 .../common/mapper/MappersConfigBlueprint.java    | 16 ++++++++++++++++
 .../common/mapper/MappersConfigSupport.java      | 16 ++++++++++++++++
 .../io/helidon/common/mapper/MappersFactory.java | 16 ++++++++++++++++
 .../io/helidon/common/mapper/OptionalValue.java  |  2 +-
 .../io/helidon/common/mapper/ValueBacked.java    |  2 +-
 .../io/helidon/common/mapper/ValueEmpty.java     |  2 +-
 common/mapper/src/main/java/module-info.java     |  2 +-
 .../io/helidon/common/mapper/CustomMapper.java   | 16 ++++++++++++++++
 .../common/mapper/ServiceLoaderMapper.java       |  2 +-
 .../common/mapper/ServiceRegistryMapper.java     |  2 +-
 .../helidon/dbclient/DbMapperProviderImpl.java   |  2 +-
 .../PriorityAndServiceTypeComparatorTest.java    |  2 +-
 .../service/registry/RegistryBuilderSupport.java | 16 ++++++++++++++++
 .../service/registry/RegistryMetricsImpl.java    | 16 ++++++++++++++++
 .../io/helidon/service/registry/Services.java    | 16 ++++++++++++++++
 .../service/tests/inject/LateBindingTypes.java   | 16 ++++++++++++++++
 .../service/tests/inject/LateBindingTest.java    | 16 ++++++++++++++++
 30 files changed, 195 insertions(+), 19 deletions(-)

diff --git a/builder/api/src/main/java/module-info.java b/builder/api/src/main/java/module-info.java
index 037d6910d08..f65d56e0b9b 100644
--- a/builder/api/src/main/java/module-info.java
+++ b/builder/api/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java b/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
index 3385d2930d0..00d199c98d1 100644
--- a/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
+++ b/builder/processor/src/main/java/io/helidon/builder/processor/GenerateAbstractBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/builder/processor/src/main/java/io/helidon/builder/processor/Types.java b/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
index 23c62863cf1..9b66485ae1e 100644
--- a/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
+++ b/builder/processor/src/main/java/io/helidon/builder/processor/Types.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java b/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
index 5bc557b3dfd..3bafbc9aa44 100644
--- a/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
+++ b/common/common/src/main/java/io/helidon/common/HelidonServiceLoader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/common/src/test/java/io/helidon/common/LruCacheTest.java b/common/common/src/test/java/io/helidon/common/LruCacheTest.java
index d8fac97efa2..d1b56c96c00 100644
--- a/common/common/src/test/java/io/helidon/common/LruCacheTest.java
+++ b/common/common/src/test/java/io/helidon/common/LruCacheTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java b/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
index 060cbc8b9db..5158e8695f6 100644
--- a/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
+++ b/common/config/src/main/java/io/helidon/common/config/ConfigBuilderSupport.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.config;
 
 import java.util.List;
diff --git a/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java b/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
index 2e0506a5b58..ad2f31b51d3 100644
--- a/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
+++ b/common/config/src/main/java/io/helidon/common/config/ProvidedUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/config/src/main/java/module-info.java b/common/config/src/main/java/module-info.java
index cac01107aeb..d5cb643f9e8 100644
--- a/common/config/src/main/java/module-info.java
+++ b/common/config/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/configurable/etc/spotbugs/exclude.xml b/common/configurable/etc/spotbugs/exclude.xml
index 93b6a8fe2d3..0bf0414c552 100644
--- a/common/configurable/etc/spotbugs/exclude.xml
+++ b/common/configurable/etc/spotbugs/exclude.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2021, 2023 Oracle and/or its affiliates.
+    Copyright (c) 2021, 2024 Oracle and/or its affiliates.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java b/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
index 53b0893276b..e776cfbb9e7 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/DefaultMapperProvider.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java b/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
index c37b9b86d00..06e5fda532d 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/GlobalManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java b/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
index 83b29413104..3208e9c6cb1 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Mapper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
index b6588e0451f..55bfb9f8341 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/Mappers.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.mapper;
 
 import java.util.Optional;
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
index 9807ed2f6b5..0fc452885f0 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigBlueprint.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.mapper;
 
 import java.util.List;
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
index ad6d1906463..5cd072e5733 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersConfigSupport.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.mapper;
 
 import java.util.List;
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java b/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
index 7a376ebfb9d..42ed88c1b91 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/MappersFactory.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.mapper;
 
 import java.util.List;
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java b/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
index c5fcf6397f0..1136d5cfcc8 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/OptionalValue.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java b/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
index 87f5912acd9..a9b37443eb1 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/ValueBacked.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java b/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
index 33a3c0f1a2f..ae5b1a04fc2 100644
--- a/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
+++ b/common/mapper/src/main/java/io/helidon/common/mapper/ValueEmpty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2023, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/main/java/module-info.java b/common/mapper/src/main/java/module-info.java
index df8812d7f2c..ba4c4d6d0d8 100644
--- a/common/mapper/src/main/java/module-info.java
+++ b/common/mapper/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java b/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
index f74f70c6dee..1025bac5c75 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/CustomMapper.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.common.mapper;
 
 import io.helidon.common.GenericType;
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
index f838ae946c7..1980c296820 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceLoaderMapper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
index e6b07204151..24efebc87bd 100644
--- a/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
+++ b/common/mapper/src/test/java/io/helidon/common/mapper/ServiceRegistryMapper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
index 26e3e5668a1..f3c1fc2b71b 100644
--- a/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
+++ b/dbclient/dbclient/src/main/java/io/helidon/dbclient/DbMapperProviderImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java b/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
index 1ac02e754d1..996dd54fb66 100644
--- a/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
+++ b/inject/api/src/test/java/io/helidon/inject/api/PriorityAndServiceTypeComparatorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java
index a02bf3ab470..af4d877d74b 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryBuilderSupport.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.ArrayList;
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
index 328125f4cf4..4805f9bb672 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryMetricsImpl.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Services.java b/service/registry/src/main/java/io/helidon/service/registry/Services.java
index 83cf64cb92d..0ae9cb723a4 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Services.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Services.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.List;
diff --git a/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
index c83d69aacdb..79d0c379b5c 100644
--- a/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
+++ b/service/tests/inject/src/main/java/io/helidon/service/tests/inject/LateBindingTypes.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.tests.inject;
 
 import io.helidon.service.registry.Service;
diff --git a/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
index 5c236973006..785ffc80d1c 100644
--- a/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
+++ b/service/tests/inject/src/test/java/io/helidon/service/tests/inject/LateBindingTest.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.tests.inject;
 
 import java.util.List;

From 28823e1ec9a7abf6c6621d1333e413b230fbc3a3 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Mon, 16 Dec 2024 22:23:58 +0100
Subject: [PATCH 15/23] New main class generator, binding generator. All tests
 passing in services

---
 service/README.md                             |  13 +
 .../service/codegen/ServiceCodegenTypes.java  |  29 ++
 .../codegen/ServiceDescriptorCodegen.java     | 124 +++++-
 service/maven-plugin/README.md                |  21 +-
 .../maven/plugin/BindingGenerator.java        | 419 ++++++++++--------
 .../plugin/CreateApplicationAbstractMojo.java |  71 ++-
 .../plugin/CreateTestApplicationMojo.java     |   5 +
 .../service/maven/plugin/MainGenerator.java   |  97 ++++
 service/registry/pom.xml                      |   4 +
 .../helidon/service/registry/Activators.java  | 213 +++++----
 .../service/registry/ActivatorsPerLookup.java |  45 +-
 .../io/helidon/service/registry/Binding.java  |  19 +-
 .../registry/BindingDependencyContext.java    |  17 +
 .../io/helidon/service/registry/Bindings.java | 291 ++++++++++++
 .../service/registry/CoreServiceRegistry.java |  45 +-
 .../service/registry/DependencyBlueprint.java |  30 +-
 .../registry/DependencyCardinality.java       |  19 +
 .../registry/DependencyPlanBinder.java        | 125 +-----
 .../service/registry/InjectionContext.java    |  45 --
 .../registry/InstanceNameServiceManager.java  |  17 +
 .../registry/InterceptionMetadataImpl.java    |   4 +-
 .../io/helidon/service/registry/IpPlan.java   |  34 --
 .../registry/RegistryStartupProvider.java     | 102 +++++
 .../service/registry/ServiceManager.java      |  19 +-
 .../service/registry/ServicePlanBinder.java   | 202 ---------
 .../service/registry/ServiceProvider.java     | 146 +-----
 .../ServiceRegistryConfigBlueprint.java       |  32 +-
 .../registry/ServiceRegistryManager.java      | 301 ++++++++-----
 .../service/registry/ServiceSupplies.java     |  24 +-
 .../registry/SupplierDependencyContext.java   |  18 +
 .../registry/src/main/java/module-info.java   |   4 +
 .../codegen/ServiceCodegenTypesTest.java      |  11 +
 .../src/it/projects/test1/pom.xml             |   1 +
 .../src/it/projects/test2/pom.xml             |   1 +
 .../src/it/projects/test3/pom.xml             |   1 -
 .../inject/maven/plugin/ProjectsTestIT.java   |  44 +-
 .../test/registry/ServiceSupplier.java        |   2 +-
 .../service/tests/toolbox/AbstractSaw.java    |  42 +-
 .../service/tests/toolbox/TableSaw.java       |   6 +-
 .../service/tests/toolbox/ToolBox.java        |   2 +-
 .../tests/toolbox/impl/MainToolBox.java       |  12 +-
 .../service/tests/toolbox/ToolBoxTest.java    |  19 +-
 42 files changed, 1617 insertions(+), 1059 deletions(-)
 create mode 100644 service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/Bindings.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
 delete mode 100644 service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
 create mode 100644 service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java

diff --git a/service/README.md b/service/README.md
index daa46673506..42af5637451 100644
--- a/service/README.md
+++ b/service/README.md
@@ -625,6 +625,19 @@ Service instance based (to obtain registry metadata in addition to the instance)
 2. `Optional<ServiceInstance<Contract>>`
 3. `List<ServiceInstance<Contract>>`
 
+## Why are some dependency options not supported
+
+We do not support dependencies of types `List<Supplier<Contract>>` and `Optional<Supplier<Contract>>`, even though other frameworks (such as CDI) do have similar concepts.
+
+The reason is that we resolve all injection points as late as possible, and injecting these types would require an early resolution of instances.
+
+As we support optional factories (i.e. `Supplier<Optional<Contract>>`), and the concept of `ServicesFactory<Contract>`, we 
+do not know how many instances (and if any) are available at the time of injecting to a service.
+
+So if we supported `List<Supplier<Contract>>`, we would still need to resolve all the instances, so just use `List<Contract>` 
+for this purpose. If a supplier is need to break dependency cycle, use `Supplier<List<Contract>>`, and you will get instances
+resolved only once you call `get()` on the supplier.
+
 # Glossary
 
 | Term            | Description                                                                                                                                                                                                   |
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
index 1e0e11cea24..266a5e7e108 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceCodegenTypes.java
@@ -161,6 +161,11 @@ public final class ServiceCodegenTypes {
      */
     public static final TypeName SERVICE_CONFIG =
             TypeName.create("io.helidon.service.registry.ServiceRegistryConfig");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceRegistryConfig.Builder}.
+     */
+    public static final TypeName SERVICE_CONFIG_BUILDER =
+            TypeName.create("io.helidon.service.registry.ServiceRegistryConfig.Builder");
     /**
      * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.ServiceRegistry}.
      */
@@ -171,6 +176,16 @@ public final class ServiceCodegenTypes {
      */
     public static final TypeName SERVICE_REGISTRY_MANAGER =
             TypeName.create("io.helidon.service.registry.ServiceRegistryManager");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.DependencyCardinality}.
+     */
+    public static final TypeName DEPENDENCY_CARDINALITY =
+            TypeName.create("io.helidon.service.registry.DependencyCardinality");
+    /**
+     * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.registry.DependencyCardinality}.
+     */
+    public static final TypeName SERVICE_LOADER_DESCRIPTOR =
+            TypeName.create("io.helidon.service.registry.ServiceLoader__ServiceDescriptor");
     /**
      * {@link io.helidon.common.types.TypeName} for
      * {@code io.helidon.service.registry.GeneratedService.PerInstanceDescriptor}.
@@ -286,6 +301,12 @@ public final class ServiceCodegenTypes {
     public static final TypeName INTERCEPT_G_WRAPPER_QUALIFIED_FACTORY =
             TypeName.create("io.helidon.service.registry.GeneratedService.QualifiedFactoryInterceptionWrapper");
 
+    /**
+     * {@link io.helidon.common.types.TypeName} for
+     * {@code io.helidon.service.registry.RegistryStartupProvider}.
+     */
+    public static final TypeName REGISTRY_STARTUP_PROVIDER =
+            TypeName.create("io.helidon.service.registry.RegistryStartupProvider");
     /**
      * A Set of Qualifier.
      */
@@ -312,6 +333,12 @@ public final class ServiceCodegenTypes {
     public static final TypeName SET_OF_STRINGS = TypeName.builder(TypeNames.SET)
             .addTypeArgument(TypeNames.STRING)
             .build();
+    /**
+     * A list of Double.
+     */
+    public static final TypeName LIST_OF_DOUBLES = TypeName.builder(TypeNames.LIST)
+            .addTypeArgument(TypeNames.BOXED_DOUBLE)
+            .build();
     /**
      * A list of Dependency.
      */
@@ -334,3 +361,5 @@ public final class ServiceCodegenTypes {
     private ServiceCodegenTypes() {
     }
 }
+
+
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
index f119862484f..4d703c2fdb3 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
@@ -61,6 +61,7 @@
 import static io.helidon.service.codegen.CodegenHelper.annotationsField;
 import static io.helidon.service.codegen.ServiceCodegenTypes.ANY_GENERIC_TYPE;
 import static io.helidon.service.codegen.ServiceCodegenTypes.BUILDER_BLUEPRINT;
+import static io.helidon.service.codegen.ServiceCodegenTypes.DEPENDENCY_CARDINALITY;
 import static io.helidon.service.codegen.ServiceCodegenTypes.GENERIC_T_TYPE;
 import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_DELEGATE;
 import static io.helidon.service.codegen.ServiceCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
@@ -815,7 +816,7 @@ private List<ParamDefinition> toMethodParams(DescribedService service,
         return method.parameterArguments()
                 .stream()
                 .map(param -> {
-                    String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
+                    String constantName = "DEP_" + paramCounter.getAndIncrement();
                     var assignment = translateParameter(param.typeName(), constantName);
                     return new ParamDefinition(method,
                                                methodConstantName,
@@ -848,7 +849,7 @@ private void injectConstructorParams(DescribedService service,
         constructor.parameterArguments()
                 .stream()
                 .map(param -> {
-                    String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
+                    String constantName = "DEP_" + paramCounter.getAndIncrement();
                     var assignment = translateParameter(param.typeName(), constantName);
                     return new ParamDefinition(constructor,
                                                null,
@@ -877,7 +878,7 @@ private void fieldParam(DescribedService describedService,
                             List<ParamDefinition> result,
                             AtomicInteger paramCounter,
                             TypedElementInfo field) {
-        String constantName = "IP_PARAM_" + paramCounter.getAndIncrement();
+        String constantName = "DEP_" + paramCounter.getAndIncrement();
         var assignment = translateParameter(field.typeName(), constantName);
 
         result.add(new ParamDefinition(field,
@@ -1069,6 +1070,7 @@ private void injectionPointFields(ClassModel.Builder classModel,
                                       List<ParamDefinition> params) {
         // constant for injection points
         for (ParamDefinition param : params) {
+            DependencyMetadata dependencyMetadata = dependencyMetadata(param);
             classModel.addField(field -> field
                     .accessModifier(AccessModifier.PUBLIC)
                     .isStatic(true)
@@ -1145,6 +1147,25 @@ private void injectionPointFields(ClassModel.Builder classModel,
                             }
                         }
 
+                        if (!dependencyMetadata.cardinality.equals("REQUIRED")) {
+                            // only set if not default
+                            it.addContent(".cardinality(")
+                                    .addContent(DEPENDENCY_CARDINALITY)
+                                    .addContent(".")
+                                    .addContent(dependencyMetadata.cardinality())
+                                    .addContentLine(")");
+                        }
+                        if (dependencyMetadata.serviceInstance()) {
+                            it.addContent(".isServiceInstance(")
+                                    .addContent(String.valueOf(dependencyMetadata.serviceInstance()))
+                                    .addContentLine(")");
+                        }
+                        if (dependencyMetadata.supplier()) {
+                            it.addContent(".isSupplier(")
+                                    .addContent(String.valueOf(dependencyMetadata.supplier()))
+                                    .addContentLine(")");
+                        }
+
                         it.addContent(".build()")
                                 .decreaseContentPadding()
                                 .decreaseContentPadding();
@@ -1152,6 +1173,98 @@ private void injectionPointFields(ClassModel.Builder classModel,
         }
     }
 
+    private DependencyMetadata dependencyMetadata(ParamDefinition param) {
+        TypeName declared = param.declaredType();
+
+        // supplier is honored only on the first level (i.e. we do not support Optional<Supplier> or List<Supplier>)
+        boolean isSupplier = declared.isSupplier();
+        boolean isServiceInstance;
+        /*
+        REQUIRED
+        OPTIONAL
+        LIST
+         */
+        String cardinality;
+
+        if (isSupplier) {
+            // Supplier<List>, Supplier<ServiceInstance>, Supplier<Contract>, Supplier<Optional<ServiceInstance>> ...
+            declared = declared.typeArguments().getFirst();
+        }
+
+        if (declared.isSupplier()) {
+            throw new CodegenException("Dependency is declared as a Supplier<Supplier<>> - this is not supported",
+                                       param.elementInfo().originatingElementValue());
+        }
+
+        if (declared.isOptional()) {
+            // lists cannot be optional
+            cardinality = "OPTIONAL";
+            TypeName actualContract = declared.typeArguments().getFirst();
+            if (actualContract.isSupplier()) {
+                throw new CodegenException("Dependency has Optional<Supplier<>> - this is not supported, please use "
+                                                   + "Supplier<Optional>",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isOptional()) {
+                throw new CodegenException("Dependency has Optional<Optional<>> - this is not supported",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isList()) {
+                throw new CodegenException("Dependency has Optional<List<>> - this is not supported, Lists are empty if "
+                                                   + "no service satisfies them, so please use List<> instead",
+                                           param.elementInfo().originatingElementValue());
+            }
+            isServiceInstance = isServiceInstance(actualContract);
+        } else if (isServiceInstance(declared)) {
+            // service instance is a direct map to an instance, so cannot be list or optional
+            cardinality = "REQUIRED";
+            isServiceInstance = true;
+
+            TypeName actualContract = declared.typeArguments().getFirst();
+            if (actualContract.isSupplier()) {
+                throw new CodegenException("Dependency has ServiceInstance<Supplier<>> - this is not supported, please use "
+                                                   + "Supplier<ServiceInstance<>>",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isOptional()) {
+                throw new CodegenException("Dependency has ServiceInstance<Optional<>> - this is not supported, please use "
+                                                   + "Optional<ServiceInstance<?>>",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isList()) {
+                throw new CodegenException("Dependency has ServiceInstance<List<>> - this is not supported, please use"
+                                                   + "List<ServiceInstance<>>",
+                                           param.elementInfo().originatingElementValue());
+            }
+        } else if (declared.isList()) {
+            cardinality = "LIST";
+            TypeName actualContract = declared.typeArguments().getFirst();
+            if (actualContract.isSupplier()) {
+                throw new CodegenException("Dependency has List<Supplier<>> - this is not supported, please use "
+                                                   + "Supplier<List<>>",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isOptional()) {
+                throw new CodegenException("Dependency has List<Optional<>> - this is not supported",
+                                           param.elementInfo().originatingElementValue());
+            }
+            if (actualContract.isList()) {
+                throw new CodegenException("Dependency has List<List<>> - this is not supported",
+                                           param.elementInfo().originatingElementValue());
+            }
+            isServiceInstance = isServiceInstance(actualContract);
+        } else {
+            cardinality = "REQUIRED";
+            isServiceInstance = false;
+        }
+
+        return new DependencyMetadata(cardinality, isServiceInstance, isSupplier);
+    }
+
+    private boolean isServiceInstance(TypeName typeName) {
+        return typeName.equals(SERVICE_SERVICE_INSTANCE);
+    }
+
     private String ipIdDescription(TypeInfo service, ParamDefinition param) {
         TypeName serviceType = service.typeName();
         StringBuilder result = new StringBuilder("Injection point dependency for ");
@@ -2366,6 +2479,11 @@ private void addTypeConstant(ClassModel.Builder classModel,
         );
     }
 
+    private record DependencyMetadata(String cardinality,
+                                      boolean serviceInstance,
+                                      boolean supplier) {
+    }
+
     private record GenericTypeDeclaration(String constantName,
                                           TypeName typeName) {
     }
diff --git a/service/maven-plugin/README.md b/service/maven-plugin/README.md
index fc8a79d5955..e7368a81229 100644
--- a/service/maven-plugin/README.md
+++ b/service/maven-plugin/README.md
@@ -10,8 +10,25 @@ The Helidon Service Maven Plugin provides the following goals:
 This goal creates artifacts that are only valid for the service (assembled from libraries and its own sources).
 This goal generates:
 
-1. Application Binding - a mapping of services to injection points (to bypass runtime lookups) - generates class `Injection__Binding`
-2. Application Main - a generated main class that registers all services (to bypass service discovery) - generates class `ApplicationMain`
+1. Application Binding - a mapping of services to injection points (to bypass runtime lookups), and of service descriptors (to bypass runtime service discovery and reflection) - generates class `Application__Binding`
+
+To create a custom main class, use the following:
+```java
+public static void main(String[] args) {
+    // this will disable service discovery
+    ServiceRegistryManager.start(Application__Binding.create());
+    // alternative - to provide custom configuration; the configuration will only be updated from the generated binding class,
+    // all other options in the config will be left intact
+    // this will honor service discovery configured in the config!
+    // also if any run level is configured, run levels will not be modified; if you do not want to run any run level annotated
+    // service, simply set max run level to 0
+    ServiceRegistryManager.start(Application__Binding.create(), ServiceRegistryConfig.builder().build());
+}
+```
+
+To use a generated main class, enable it with the maven plugin, an `ApplicationMain` class will be code generated with
+a similar content.
+
 
 Usage of this plugin goal is not required, yet it is recommended for final application module, it will add
 - binding for injection points, to avoid runtime lookups
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
index abe97250e62..1fc4b2a08b6 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
@@ -18,6 +18,8 @@
 
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -25,6 +27,8 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 
 import io.helidon.codegen.CodegenException;
@@ -32,33 +36,31 @@
 import io.helidon.codegen.classmodel.ClassModel;
 import io.helidon.codegen.classmodel.ContentBuilder;
 import io.helidon.codegen.classmodel.Method;
-import io.helidon.codegen.compiler.Compiler;
-import io.helidon.codegen.compiler.CompilerOptions;
 import io.helidon.common.types.AccessModifier;
 import io.helidon.common.types.Annotation;
 import io.helidon.common.types.Annotations;
-import io.helidon.common.types.ElementKind;
 import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeInfo;
 import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
 import io.helidon.service.codegen.DescriptorClassCode;
 import io.helidon.service.codegen.HelidonMetaInfServices;
-import io.helidon.service.codegen.RegistryCodegenContext;
-import io.helidon.service.codegen.ServiceDescriptorCodegen;
 import io.helidon.service.metadata.DescriptorMetadata;
 import io.helidon.service.registry.Dependency;
 import io.helidon.service.registry.Interception;
 import io.helidon.service.registry.Lookup;
 import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.Service.RunLevel;
+import io.helidon.service.registry.ServiceDescriptor;
 import io.helidon.service.registry.ServiceInfo;
 import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
 
-import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_CONTRACT;
-import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.LIST_OF_DOUBLES;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_RUN_LEVEL;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_BINDING;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_CONFIG_BUILDER;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_INJECTION_POINT_FACTORY;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_LOADER_DESCRIPTOR;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_PLAN_BINDER;
-import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_SERVICE_INSTANCE;
 
 /**
  * The default implementation for {@link BindingGenerator}.
@@ -81,18 +83,18 @@ class BindingGenerator {
      * @param serviceTypes      types to process
      * @param typeName          generated binding type name
      * @param moduleName        name of the module of this maven module
-     * @param compilerOptions   compilation options
+     * @param sourcesToCompile  list of sources to compile
      */
     void createBinding(WrappedServices injectionServices,
                        Set<TypeName> serviceTypes,
                        TypeName typeName,
                        String moduleName,
-                       CompilerOptions compilerOptions) {
+                       List<Path> sourcesToCompile) {
         Objects.requireNonNull(injectionServices);
         Objects.requireNonNull(serviceTypes);
 
         try {
-            codegen(injectionServices, serviceTypes, typeName, moduleName, compilerOptions);
+            codegen(injectionServices, serviceTypes, typeName, moduleName, sourcesToCompile);
         } catch (CodegenException ce) {
             handleError(ce);
         } catch (Throwable te) {
@@ -104,7 +106,7 @@ void codegen(WrappedServices injectionServices,
                  Set<TypeName> serviceTypes,
                  TypeName typeName,
                  String moduleName,
-                 CompilerOptions compilerOptions) {
+                 List<Path> sourcesToCompile) {
         ClassModel.Builder classModel = ClassModel.builder()
                 .accessModifier(AccessModifier.PACKAGE_PRIVATE)
                 .copyright(CodegenUtil.copyright(GENERATOR,
@@ -121,7 +123,7 @@ void codegen(WrappedServices injectionServices,
 
         // deprecated default constructor - binding should always be service loaded
         classModel.addConstructor(ctr -> ctr
-                .accessModifier(AccessModifier.PACKAGE_PRIVATE));
+                .accessModifier(AccessModifier.PRIVATE));
 
         // public String name()
         classModel.addMethod(nameMethod -> nameMethod
@@ -130,40 +132,56 @@ void codegen(WrappedServices injectionServices,
                 .name("name")
                 .addContentLine("return \"" + moduleName + "\";"));
 
-        // public void configure(ServiceInjectionPlanBinder binder)
-        classModel.addMethod(configureMethod -> configureMethod
+        // public void binding(DependencyPlanBinder binder)
+        classModel.addMethod(bindingMethod -> bindingMethod
                 .addAnnotation(Annotations.OVERRIDE)
-                .name("configure")
+                .name("binding")
                 // constructors of services for service loader are usually deprecated in Helidon
                 .addAnnotation(Annotation.create(SuppressWarnings.class, "deprecation"))
                 .addParameter(binderParam -> binderParam
                         .name("binder")
                         .type(SERVICE_PLAN_BINDER))
+                .update(it -> createBindingMethodBody(injectionServices,
+                                                      serviceTypes,
+                                                      it)));
+
+        // public void configure(ServiceRegistryConfig.Builder builder)
+        classModel.addMethod(configureMethod -> configureMethod
+                .addAnnotation(Annotations.OVERRIDE)
+                .name("configure")
+                .addParameter(configBuilder -> configBuilder
+                        .name("builder")
+                        .type(SERVICE_CONFIG_BUILDER)
+                )
                 .update(it -> createConfigureMethodBody(injectionServices,
-                                                        serviceTypes,
-                                                        it)));
+                                                        classModel,
+                                                        it))
+        );
+        // static Application__Binding create()
+        classModel.addMethod(create -> create
+                .accessModifier(AccessModifier.PACKAGE_PRIVATE)
+                .returnType(typeName)
+                .name("create")
+                .isStatic(true)
+                .description("Create a new application binding instance.")
+                .addContent("return new ")
+                .addContent(typeName.className())
+                .addContentLine("();")
+        );
 
         Path generated = ctx.filer()
                 .writeSourceFile(classModel.build());
 
-        TypeInfo appTypeInfo = createAppTypeInfo(typeName);
-        RegistryCodegenContext registryCodegenContext = RegistryCodegenContext.create(ctx);
         MavenRoundContext roundContext = new MavenRoundContext(ctx);
-        ServiceDescriptorCodegen descriptorCodegen = ServiceDescriptorCodegen.create(registryCodegenContext);
-        descriptorCodegen.service(GENERATOR,
-                                  roundContext,
-                                  List.of(appTypeInfo),
-                                  appTypeInfo);
 
-        List<Path> toCompile = new ArrayList<>();
-        toCompile.add(generated);
+        sourcesToCompile.add(generated);
 
         HelidonMetaInfServices services = HelidonMetaInfServices.create(ctx.filer(), moduleName);
 
         for (DescriptorClassCode descriptor : roundContext.descriptors()) {
             Path path = ctx.filer().writeSourceFile(descriptor.classCode().classModel().build(),
                                                     descriptor.classCode().originatingElements());
-            toCompile.add(path);
+            sourcesToCompile.add(path);
 
             services.add(DescriptorMetadata.create(descriptor.registryType(),
                                                    descriptor.classCode().newType(),
@@ -173,7 +191,6 @@ void codegen(WrappedServices injectionServices,
         }
 
         services.write();
-        Compiler.compile(compilerOptions, toCompile.toArray(new Path[0]));
     }
 
     BindingPlan bindingPlan(WrappedServices services,
@@ -229,7 +246,7 @@ private static Consumer<ContentBuilder<?>> toContentBuilder(ServiceInfo serviceI
                     .addContent(")");
         } else {
             // the usual singleton instance
-            return it -> it.addContent(serviceInfo.descriptorType().fqName())
+            return it -> it.addContent(serviceInfo.descriptorType())
                     .addContent(".INSTANCE");
         }
     }
@@ -259,18 +276,148 @@ private static boolean isQualifiedInjectionTarget(ServiceInfo sp) {
         return hasContract || hasDependencies;
     }
 
-    private TypeInfo createAppTypeInfo(TypeName typeName) {
-        return TypeInfo.builder()
-                .kind(ElementKind.CLASS)
-                .typeName(typeName)
-                // to trigger generation of descriptor
-                .addAnnotation(Annotation.create(SERVICE_ANNOTATION_PROVIDER))
-                .addInterfaceTypeInfo(TypeInfo.builder()
-                                              .kind(ElementKind.INTERFACE)
-                                              .typeName(SERVICE_BINDING)
-                                              .addAnnotation(Annotation.create(SERVICE_ANNOTATION_CONTRACT))
-                                              .build())
-                .build();
+    private void createConfigureMethodBody(WrappedServices services,
+                                           ClassModel.Builder classModel,
+                                           Method.Builder method) {
+        /*
+        This method will:
+        - configure all run levels
+        - configure all services to avoid service discovery
+         */
+
+        configureRunLevels(services, classModel, method);
+        registerServiceDescriptors(services, classModel, method);
+    }
+
+    private void configureRunLevels(WrappedServices services, ClassModel.Builder classModel, Method.Builder method) {
+
+        /*
+        private static final List<Double> RUN_LEVELS = List.of(12D, 100D);
+        builder.runLevels(RUN_LEVELS);
+         */
+        runLevelsConstantField(classModel, services);
+        method.addContentLine("builder.runLevels(RUN_LEVELS);");
+
+    }
+
+    static void runLevelsConstantField(ClassModel.Builder classModel, WrappedServices services) {
+        Set<Double> runLevels = new TreeSet<>();
+
+        for (ServiceInfo serviceInfo : services.all()) {
+            if (serviceInfo.runLevel().isPresent()) {
+                runLevels.add(serviceInfo.runLevel().get());
+            }
+        }
+
+        List<Double> runLevelList = List.copyOf(runLevels);
+        classModel.addField(runLevelsField -> runLevelsField
+                .accessModifier(AccessModifier.PRIVATE)
+                .isStatic(true)
+                .isFinal(true)
+                .type(LIST_OF_DOUBLES)
+                .name("RUN_LEVELS")
+                .addContent(List.class)
+                .addContent(".of(")
+                .update(fieldBuilder -> {
+                    for (int i = 0; i < runLevelList.size(); i++) {
+                        double current = runLevelList.get(i);
+                        if (Double.compare(RunLevel.STARTUP, current) == 0) {
+                            fieldBuilder.addContent(SERVICE_ANNOTATION_RUN_LEVEL)
+                                    .addContent(".STARTUP");
+                        } else if (Double.compare(RunLevel.SERVER, current) == 0) {
+                            fieldBuilder.addContent(SERVICE_ANNOTATION_RUN_LEVEL)
+                                    .addContent(".SERVER");
+                        } else if (Double.compare(RunLevel.NORMAL, current) == 0) {
+                            fieldBuilder.addContent(SERVICE_ANNOTATION_RUN_LEVEL)
+                                    .addContent(".NORMAL");
+                        } else {
+                            fieldBuilder.addContent(String.valueOf(current))
+                                    .addContent("D");
+                        }
+                        if (i == runLevelList.size() - 1) {
+                            fieldBuilder.addContentLine("");
+                        } else {
+                            fieldBuilder.addContentLine(",");
+                        }
+                    }
+                })
+                .addContent(")")
+        );
+    }
+
+    private void registerServiceDescriptors(WrappedServices services, ClassModel.Builder classModel, Method.Builder method) {
+        List<ServiceLoader__ServiceDescriptor> serviceLoaded = new ArrayList<>();
+        List<TypeName> serviceDescriptors = new ArrayList<>();
+
+        // for each discovered service, add it to the configuration
+        for (ServiceInfo serviceInfo : services.all()) {
+            if (serviceInfo instanceof ServiceLoader__ServiceDescriptor sl) {
+                serviceLoaded.add(sl);
+            } else {
+                serviceDescriptors.add(serviceInfo.descriptorType());
+            }
+        }
+
+        Map<TypeName, String> providerConstants = new HashMap<>();
+        AtomicInteger constantCounter = new AtomicInteger();
+
+        serviceLoaded.stream()
+                .sorted(serviceLoaderComparator())
+                .forEach(it -> addServiceLoader(classModel, method, providerConstants, constantCounter, it));
+
+        if (!serviceLoaded.isEmpty() && !serviceDescriptors.isEmpty()) {
+            // visually separate service loaded services from service descriptors
+            method.addContentLine("");
+        }
+
+        // viceDescriptor(ImperativeFeature__ServiceDescriptor.INSTANCE);
+        serviceDescriptors.stream()
+                .sorted()
+                .forEach(it -> method
+                        .addContent("builder.addServiceDescriptor(")
+                        .addContent(it)
+                        .addContentLine(".INSTANCE);"));
+    }
+
+    private void addServiceLoader(ClassModel.Builder classModel,
+                                  Method.Builder main,
+                                  Map<TypeName, String> providerConstants,
+                                  AtomicInteger constantCounter,
+                                  ServiceLoader__ServiceDescriptor sl) {
+        // Generated code:
+        // builder.addServiceDescriptor(serviceLoader(PROVIDER_1,
+        //                                           YamlConfigParser.class,
+        //                                           () -> new io.helidon.config.yaml.YamlConfigParser(),
+        //                                           90.0));
+        TypeName providerInterface = sl.providerInterface();
+        String constantName = providerConstants.computeIfAbsent(providerInterface, it -> {
+            int i = constantCounter.getAndIncrement();
+            String constant = "PROVIDER_" + i;
+            classModel.addField(field -> field
+                    .accessModifier(AccessModifier.PRIVATE)
+                    .isStatic(true)
+                    .isFinal(true)
+                    .type(TypeNames.TYPE_NAME)
+                    .name(constant)
+                    .addContentCreate(providerInterface));
+            return constant;
+        });
+
+        main.addContent("builder.addServiceDescriptor(")
+                .addContent(SERVICE_LOADER_DESCRIPTOR)
+                .addContent(".create(")
+                .addContent(constantName)
+                .addContentLine(",")
+                .increaseContentPadding()
+                .increaseContentPadding()
+                .increaseContentPadding()
+                .addContent(sl.serviceType()).addContentLine(".class,")
+                .addContent("() -> new ").addContent(sl.serviceType()).addContentLine("(),")
+                .addContent(String.valueOf(sl.weight()))
+                .addContentLine("));")
+                .decreaseContentPadding()
+                .decreaseContentPadding()
+                .decreaseContentPadding();
     }
 
     private void handleError(CodegenException ce) {
@@ -344,9 +491,9 @@ private List<ServiceInfo> injectionPointProvidersFor(WrappedServices services, D
         return services.all(lookup);
     }
 
-    private void createConfigureMethodBody(WrappedServices services,
-                                           Set<TypeName> serviceTypes,
-                                           Method.Builder method) {
+    private void createBindingMethodBody(WrappedServices services,
+                                         Set<TypeName> serviceTypes,
+                                         Method.Builder method) {
         // find all interceptors and bind them
         List<ServiceInfo> interceptors =
                 services.all(Lookup.builder()
@@ -378,8 +525,7 @@ private void createConfigureMethodBody(WrappedServices services,
             method.addContentLine("")
                     .decreaseContentPadding();
         }
-        method.addContentLine(");")
-                .addContentLine("");
+        method.addContentLine(");");
 
         // first collect required dependencies by descriptor
         Map<TypeName, Set<Binding>> injectionPlan = new LinkedHashMap<>();
@@ -390,12 +536,12 @@ private void createConfigureMethodBody(WrappedServices services,
             }
         }
 
-        boolean supportNulls = false;
         // we group all bindings by descriptor they belong to
         injectionPlan.forEach((descriptorType, bindings) -> {
-            method.addContent("binder.bindTo(")
+            method.addContentLine("")
+                    .addContent("binder.service(")
                     .addContent(descriptorType.genericTypeName())
-                    .addContentLine(".INSTANCE)")
+                    .addContent(".INSTANCE)")
                     .increaseContentPadding();
 
             for (Binding binding : bindings) {
@@ -404,173 +550,56 @@ private void createConfigureMethodBody(WrappedServices services,
                         .addContent(".")
                         .addContent(binding.dependency.descriptorConstant());
 
-                buildTimeBinding(method, binding, ipId, supportNulls);
+                buildTimeBinding(method, binding, ipId);
             }
 
             /*
             Commit the dependencies
              */
-            method.addContentLine(".commit();")
-                    .decreaseContentPadding()
-                    .addContentLine("");
+            method.addContentLine(";")
+                    .decreaseContentPadding();
         });
     }
 
     /*
-    Very similar code is used for runtime discovery in ServiceProvider.planForIp
+    Very similar code is used for runtime discovery in io.helidon.service.registry.Bindings.DependencyBinding.discoverBinding
     make sure this is doing the same thing!
     Here we code generate the calls to the binding class
     */
     private void buildTimeBinding(Method.Builder method,
                                   Binding binding,
-                                  Consumer<ContentBuilder<?>> ipId,
-                                  boolean supportNulls) {
+                                  Consumer<ContentBuilder<?>> ipId) {
 
-        Dependency injectionPoint = binding.dependency();
         List<ServiceInfo> discovered = binding.descriptors();
         Iterator<Consumer<ContentBuilder<?>>> descriptors = discovered.stream()
                 .map(BindingGenerator::toContentBuilder)
                 .iterator();
 
-        TypeName ipType = injectionPoint.typeName();
-
-        // now there are a few options - optional, list, and single instance
-        if (ipType.isList()) {
-            TypeName typeOfList = ipType.typeArguments().getFirst();
-            if (typeOfList.isSupplier()) {
-                // inject List<Supplier<Contract>>
-                method.addContent(".bindListOfSuppliers(");
-            } else if (typeOfList.equals(SERVICE_SERVICE_INSTANCE)) {
-                method.addContent(".bindServiceInstanceList(");
-            } else {
-                // inject List<Contract>
-                method.addContent(".bindList(");
-            }
-            method.update(ipId::accept);
+        method.addContentLine("")
+                .addContent(".bind(")
+                .update(ipId::accept);
 
-            if (discovered.isEmpty()) {
-                method.addContentLine(")");
-            } else {
-                method.addContent(", ")
-                        .update(it -> {
-                            while (descriptors.hasNext()) {
-                                descriptors.next().accept(it);
-                                if (descriptors.hasNext()) {
-                                    it.addContent(", ");
-                                }
-                            }
-                        })
-                        .addContentLine(")");
-            }
-        } else if (ipType.isOptional()) {
-            TypeName typeOfOptional = ipType.typeArguments().getFirst();
-            if (typeOfOptional.isSupplier()) {
-                // inject Optional<Supplier<Contract>>
-                method.addContent(".bindOptionalOfSupplier(");
-            } else if (typeOfOptional.equals(SERVICE_SERVICE_INSTANCE)) {
-                // inject Optional<ServiceInstance<Contract>>
-                method.addContent(".bindOptionalOfServiceInstance(");
-            } else {
-                // inject Optional<Contract>
-                method.addContent(".bindOptional(");
-            }
-            method.update(ipId::accept);
-
-            if (discovered.isEmpty()) {
-                method.addContentLine(")");
-            } else {
-                method.addContent(", ");
-                descriptors.next().accept(method);
-                method.addContentLine(")");
-            }
-        } else if (ipType.isSupplier()) {
-            // one of the supplier options
-
-            TypeName typeOfSupplier = ipType.typeArguments().getFirst();
-            if (typeOfSupplier.isOptional()) {
-                // inject Supplier<Optional<Contract>>
-                method.addContent(".bindSupplierOfOptional(")
-                        .update(ipId::accept);
-                if (discovered.isEmpty()) {
-                    method.addContentLine(")");
-                } else {
-                    method.addContent(", ");
-                    descriptors.next().accept(method);
-                    method.addContentLine(")");
-                }
-            } else if (typeOfSupplier.isList()) {
-                // inject Supplier<List<Contract>>
-                method.addContent(".bindSupplierOfList(")
-                        .update(ipId::accept);
-                if (discovered.isEmpty()) {
-                    method.addContentLine(")");
-                } else {
-                    method.addContent(", ")
-                            .update(it -> {
-                                while (descriptors.hasNext()) {
-                                    descriptors.next().accept(it);
-                                    if (descriptors.hasNext()) {
-                                        it.addContent(", ");
-                                    }
-                                }
-                            })
-                            .addContentLine(")");
-                }
-            } else {
-                // inject Supplier<Contract>
-                method.addContent(".bindSupplier(")
-                        .update(ipId::accept);
-
-                if (discovered.isEmpty()) {
-                    // null binding is not supported at runtime
-                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
-                                                       + injectionPoint);
-                }
-                method.addContent(", ");
-                descriptors.next().accept(method);
-                method.addContentLine(")");
-            }
-        } else if (ipType.equals(SERVICE_SERVICE_INSTANCE)) {
-            // inject Contract
-            if (discovered.isEmpty()) {
-                if (supportNulls) {
-                    method.addContent(".bindNull(")
-                            .update(ipId::accept)
-                            .addContentLine(")");
-                } else {
-                    // null binding is not supported at runtime
-                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
-                                                       + injectionPoint);
-                }
-            } else {
-                method.addContent(".bindServiceInstance(")
-                        .update(ipId::accept)
-                        .addContent(", ")
-                        .update(descriptors.next()::accept)
-                        .addContentLine(")");
-            }
+        if (discovered.isEmpty()) {
+            method.addContent(")");
         } else {
-            // inject Contract
-            if (discovered.isEmpty()) {
-                if (supportNulls) {
-                    method.addContent(".bindNull(")
-                            .update(ipId::accept)
-                            .addContentLine(")");
-                } else {
-                    // null binding is not supported at runtime
-                    throw new CodegenException("Injection point requires a value, but no provider discovered: "
-                                                       + injectionPoint);
-                }
-            } else {
-                method.addContent(".bind(")
-                        .update(ipId::accept)
-                        .addContent(", ")
-                        .update(descriptors.next()::accept)
-                        .addContentLine(")");
-            }
+            method.addContent(", ")
+                    .update(it -> {
+                        while (descriptors.hasNext()) {
+                            descriptors.next().accept(it);
+                            if (descriptors.hasNext()) {
+                                it.addContent(", ");
+                            }
+                        }
+                    })
+                    .addContent(")");
         }
     }
 
+    private Comparator<ServiceLoader__ServiceDescriptor> serviceLoaderComparator() {
+        return Comparator.comparing(ServiceLoader__ServiceDescriptor::providerInterface)
+                .thenComparing(ServiceDescriptor::serviceType);
+    }
+
     record InjectionPlan(List<ServiceInfo> unqualifiedProviders,
                          List<ServiceInfo> qualifiedProviders) {
     }
@@ -580,8 +609,8 @@ record BindingPlan(TypeName descriptorType,
     }
 
     /**
-     * @param dependency to bind to
-     * @param descriptors    matching descriptors
+     * @param dependency  to bind to
+     * @param descriptors matching descriptors
      */
     record Binding(Dependency dependency,
                    List<ServiceInfo> descriptors) {
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
index 0b1f348c1de..778325c5dbd 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateApplicationAbstractMojo.java
@@ -42,6 +42,7 @@
 import io.helidon.codegen.CodegenScope;
 import io.helidon.codegen.ModuleInfo;
 import io.helidon.codegen.ModuleInfoSourceParser;
+import io.helidon.codegen.compiler.Compiler;
 import io.helidon.codegen.compiler.CompilerOptions;
 import io.helidon.common.types.TypeName;
 import io.helidon.service.registry.ServiceInfo;
@@ -53,14 +54,18 @@
 import org.apache.maven.project.MavenProject;
 
 /**
- * Abstract base for the Injection {@code maven-plugin} responsible for creating
+ * Abstract base for the Service {@code maven-plugin} responsible for creating
  * {@code Binding}, Test {@code Binding}, and application Main class.
  */
 abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
     /**
      * Class name of the binding class generated by Maven plugin (for end user application).
      */
-    protected static final String BINDING_CLASS_NAME = "Injection__Binding";
+    protected static final String BINDING_CLASS_NAME = "ApplicationBinding";
+    /**
+     * Class name of the main class generated by Maven plugin (for end user application).
+     */
+    protected static final String MAIN_CLASS_NAME = "ApplicationMain";
     /**
      * The -source argument for the Java compiler.
      * Note: using the same as maven-compiler for convenience and least astonishment.
@@ -75,12 +80,27 @@ abstract class CreateApplicationAbstractMojo extends CodegenAbstractMojo {
                defaultValue = "true")
     private boolean validate;
     /**
-     * Whether to generate binding class (provides generated injection plan for all services).
+     * Whether to generate binding class (provides generated injection plan for all services and registration of all
+     * service descriptors).
      */
     @Parameter(property = "helidon.service.registry.binding.generate",
                defaultValue = "true")
     private boolean generateBinding;
 
+    /**
+     * Whether to generate a main class that takes care of bootstrapping the service registry and initializing
+     * all services that have a RunLevel annotation.
+     */
+    @Parameter(property = "helidon.service.registry.main.generate", defaultValue = "false")
+    private boolean generateMain;
+
+    /**
+     * Name of the generated binding class.
+     */
+    @Parameter(property = "helidon.service.registry.main.class.name",
+               defaultValue = MAIN_CLASS_NAME)
+    private String mainClassName;
+
     /**
      * Default constructor.
      */
@@ -195,19 +215,50 @@ void applicationBinding(MavenCodegenContext scanContext,
             validator.validate(services);
         }
 
+        TypeName bindingTypeName = TypeName.create(packageName + "." + className);
+        List<Path> sourcesToCompile = new ArrayList<>();
+
         if (generateBinding) {
             // get the binding generator only after services are initialized (we need to ignore any existing apps)
-            BindingGenerator creator = new BindingGenerator(scanContext, failOnError());
-            TypeName bindingTypeName = TypeName.create(packageName + "." + className);
+            BindingGenerator generator = new BindingGenerator(scanContext, failOnError());
 
             getLog().info("Generating application binding: " + bindingTypeName.fqName());
 
-            creator.createBinding(services,
-                                  allServices,
-                                  bindingTypeName,
-                                  moduleName,
-                                  compilerOptions);
+            generator.createBinding(services,
+                                    allServices,
+                                    bindingTypeName,
+                                    moduleName,
+                                    sourcesToCompile);
         }
+
+        if (generateMain()) {
+            TypeName mainTypeName = TypeName.builder()
+                    .packageName(packageName)
+                    .className(mainClassName)
+                    .build();
+
+            MainGenerator generator = new MainGenerator(scanContext);
+            generator.createMain(services,
+                                 generateBinding,
+                                 bindingTypeName,
+                                 mainTypeName,
+                                 sourcesToCompile);
+        }
+
+        if (!sourcesToCompile.isEmpty()) {
+            Compiler.compile(compilerOptions, sourcesToCompile.toArray(new Path[0]));
+        }
+
+    }
+
+    /**
+     * Whether to generate a main class.
+     * Main class is only generated for main (production sources) and never for test.
+     *
+     * @return whether to generate main class
+     */
+    boolean generateMain() {
+        return generateMain;
     }
 
     /**
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
index 23c067462b3..3dc21081c27 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/CreateTestApplicationMojo.java
@@ -65,6 +65,11 @@ public class CreateTestApplicationMojo extends CreateApplicationAbstractMojo {
     public CreateTestApplicationMojo() {
     }
 
+    @Override
+    boolean generateMain() {
+        return false;
+    }
+
     @Override
     protected Path generatedSourceDirectory() {
         return generatedTestSourcesDirectory.toPath();
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
new file mode 100644
index 00000000000..47b18621cc5
--- /dev/null
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
@@ -0,0 +1,97 @@
+package io.helidon.service.maven.plugin;
+
+import java.nio.file.Path;
+import java.util.List;
+
+import io.helidon.codegen.CodegenUtil;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.codegen.classmodel.Method;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+
+import static io.helidon.service.codegen.ServiceCodegenTypes.REGISTRY_STARTUP_PROVIDER;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_CONFIG;
+import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_REGISTRY_MANAGER;
+
+/**
+ * Generates the application main class.
+ */
+class MainGenerator {
+    private static final TypeName GENERATOR = TypeName.create(MainGenerator.class);
+
+    private final MavenCodegenContext ctx;
+
+    MainGenerator(MavenCodegenContext ctx) {
+        this.ctx = ctx;
+    }
+
+    void createMain(WrappedServices services,
+                    boolean generateBinding,
+                    TypeName bindingTypeName,
+                    TypeName generatedType,
+                    List<Path> sourcesToCompile) {
+
+        ClassModel.Builder classModel = ClassModel.builder()
+                .type(generatedType)
+                .accessModifier(AccessModifier.PUBLIC)
+                .copyright(CodegenUtil.copyright(GENERATOR,
+                                                 GENERATOR,
+                                                 generatedType))
+                .addAnnotation(CodegenUtil.generatedAnnotation(GENERATOR,
+                                                               generatedType,
+                                                               generatedType,
+                                                               "1",
+                                                               ""))
+                .addDescriptionLine("Main class generated for Helidon Service Registry Application.")
+                .isFinal(true);
+
+        classModel.addConstructor(ctr -> ctr
+                .accessModifier(AccessModifier.PRIVATE));
+
+        classModel.addMethod(main -> main
+                .accessModifier(AccessModifier.PUBLIC)
+                .isStatic(true)
+                .returnType(TypeNames.PRIMITIVE_VOID)
+                .description("Start the application.")
+                .name("main")
+                .addParameter(args -> args
+                        .type(String[].class)
+                        .description("Command line arguments.")
+                        .name("args"))
+                .update(it -> mainMethodBody(services, generateBinding, bindingTypeName, classModel, it)));
+
+        Path generated = ctx.filer()
+                .writeSourceFile(classModel.build());
+        sourcesToCompile.add(generated);
+    }
+
+    private void mainMethodBody(WrappedServices services,
+                                boolean generateBinding,
+                                TypeName bindingTypeName,
+                                ClassModel.Builder classModel,
+                                Method.Builder method) {
+
+        if (!generateBinding) {
+            BindingGenerator.runLevelsConstantField(classModel, services);
+            method.addContent("var config = ")
+                    .addContent(SERVICE_CONFIG)
+                    .addContentLine(".builder().runLevels(RUN_LEVELS).build();");
+        }
+
+        method.addContent("var manager = ")
+                .addContent(SERVICE_REGISTRY_MANAGER)
+                .addContent(".start(");
+
+        if (generateBinding) {
+            method.addContent(bindingTypeName)
+                    .addContentLine(".create());");
+        } else {
+            method.addContentLine("config);");
+        }
+
+        method.addContent(REGISTRY_STARTUP_PROVIDER)
+                .addContentLine(".registerShutdownHandler(manager);");
+    }
+
+}
diff --git a/service/registry/pom.xml b/service/registry/pom.xml
index 0578105289b..2a820c01eda 100644
--- a/service/registry/pom.xml
+++ b/service/registry/pom.xml
@@ -39,6 +39,10 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>io.helidon</groupId>
+            <artifactId>helidon</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common</artifactId>
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Activators.java b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
index 5d388142a56..f78f2b0b373 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Activators.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
@@ -74,21 +74,29 @@ static <T> Activator<T> create(ServiceProvider<T> provider, T instance) {
 
     static <T> Supplier<Activator<T>> create(CoreServiceRegistry registry, ServiceProvider<T> provider) {
         ServiceDescriptor<T> descriptor = provider.descriptor();
+        // as this is going to create an instance of the service, we need the dependency context
+        var bindingPlan = registry.bindings().bindingPlan(descriptor);
+        DependencyContext dependencyContext = new BindingDependencyContext(bindingPlan);
 
         if (descriptor.scope().equals(Service.PerLookup.TYPE)) {
             return switch (descriptor.factoryType()) {
                 case NONE -> new MissingDescribedActivator<>(provider);
                 case SERVICE -> {
                     if (descriptor instanceof PerInstanceDescriptor dbd) {
-                        yield () -> new ActivatorsPerLookup.PerInstanceActivator<>(registry, provider, dbd);
+                        yield () -> new ActivatorsPerLookup.PerInstanceActivator<>(registry,
+                                                                                   dependencyContext,
+                                                                                   bindingPlan,
+                                                                                   provider,
+                                                                                   dbd);
                     }
-                    yield () -> new ActivatorsPerLookup.SingleServiceActivator<>(provider);
+                    yield () -> new ActivatorsPerLookup.SingleServiceActivator<>(provider, dependencyContext);
                 }
-                case SUPPLIER -> () -> new ActivatorsPerLookup.SupplierActivator<>(provider);
-                case SERVICES -> () -> new ActivatorsPerLookup.ServicesFactoryActivator<>(provider);
-                case INJECTION_POINT -> () -> new ActivatorsPerLookup.IpFactoryActivator<>(provider);
+                case SUPPLIER -> () -> new ActivatorsPerLookup.SupplierActivator<>(provider, dependencyContext);
+                case SERVICES -> () -> new ActivatorsPerLookup.ServicesFactoryActivator<>(provider, dependencyContext);
+                case INJECTION_POINT -> () -> new ActivatorsPerLookup.IpFactoryActivator<>(provider, dependencyContext);
                 case QUALIFIED -> () ->
                         new ActivatorsPerLookup.QualifiedFactoryActivator<>(provider,
+                                                                            dependencyContext,
                                                                             (QualifiedFactoryDescriptor) descriptor);
             };
         } else {
@@ -96,28 +104,62 @@ static <T> Supplier<Activator<T>> create(CoreServiceRegistry registry, ServicePr
                 case NONE -> new MissingDescribedActivator<>(provider);
                 case SERVICE -> {
                     if (descriptor instanceof PerInstanceDescriptor dbd) {
-                        yield () -> new PerInstanceActivator<>(registry, provider, dbd);
+                        yield () -> new PerInstanceActivator<>(registry, provider, dependencyContext, bindingPlan, dbd);
                     }
-                    yield () -> new Activators.SingleServiceActivator<>(provider);
+                    yield () -> new Activators.SingleServiceActivator<>(provider, dependencyContext);
                 }
-                case SUPPLIER -> () -> new Activators.SupplierActivator<>(provider);
-                case SERVICES -> () -> new ServicesFactoryActivator<>(provider);
-                case INJECTION_POINT -> () -> new IpFactoryActivator<>(provider);
+                case SUPPLIER -> () -> new Activators.SupplierActivator<>(provider, dependencyContext);
+                case SERVICES -> () -> new ServicesFactoryActivator<>(provider, dependencyContext);
+                case INJECTION_POINT -> () -> new IpFactoryActivator<>(provider, dependencyContext);
                 case QUALIFIED -> () ->
                         new QualifiedFactoryActivator<>(provider,
+                                                        dependencyContext,
                                                         (QualifiedFactoryDescriptor) descriptor);
             };
         }
     }
 
+    interface InstanceHolder<T> {
+        static <T> InstanceHolder<T> create(ServiceProvider<T> serviceProvider, DependencyContext dependencyContext) {
+            // the same instance is returned for the lifetime of the service provider
+            return new InstanceHolderImpl<>(dependencyContext,
+                                            serviceProvider.interceptionMetadata(),
+                                            serviceProvider.descriptor());
+        }
+
+        // we use the instance holder to hold either the actual instance,
+        // or the factory; this is a place for improvement
+        @SuppressWarnings("unchecked")
+        static <T> InstanceHolder<T> create(Object instance) {
+            return new FixedInstanceHolder<>((T) instance);
+        }
+
+        T get();
+
+        default void construct() {
+        }
+
+        default void inject() {
+        }
+
+        default void postConstruct() {
+        }
+
+        default void preDestroy() {
+        }
+    }
+
     abstract static class BaseActivator<T> implements Activator<T> {
         final ServiceProvider<T> provider;
+        final DependencyContext dependencyContext;
+
         private final ReadWriteLock instanceLock = new ReentrantReadWriteLock();
 
         volatile ActivationPhase currentPhase = ActivationPhase.INIT;
 
-        BaseActivator(ServiceProvider<T> provider) {
+        BaseActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
             this.provider = provider;
+            this.dependencyContext = dependencyContext;
         }
 
         // three states
@@ -365,9 +407,9 @@ static class FixedActivator<T> extends BaseActivator<T> {
         private final Optional<List<QualifiedInstance<T>>> instances;
 
         FixedActivator(ServiceProvider<T> provider, T instance) {
-            super(provider);
+            super(provider, null);
 
-            List<QualifiedInstance<T>> values = List.of(QualifiedInstance.create(instance, provider.serviceInfo().qualifiers()));
+            List<QualifiedInstance<T>> values = List.of(QualifiedInstance.create(instance, provider.descriptor().qualifiers()));
             this.instances = Optional.of(values);
         }
 
@@ -381,7 +423,7 @@ static class FixedSupplierActivator<T> extends BaseActivator<T> {
         private final Supplier<Optional<List<QualifiedInstance<T>>>> instances;
 
         FixedSupplierActivator(ServiceProvider<T> provider, Supplier<T> instanceSupplier) {
-            super(provider);
+            super(provider, null);
 
             instances = LazyValue.create(() -> {
                 List<QualifiedInstance<T>> values = List.of(QualifiedInstance.create(instanceSupplier.get(),
@@ -400,8 +442,8 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances() {
     static class FixedIpFactoryActivator<T> extends IpFactoryActivator<T> {
 
         FixedIpFactoryActivator(ServiceProvider<T> provider,
-                                       InjectionPointFactory<T> instance) {
-            super(provider);
+                                InjectionPointFactory<T> instance) {
+            super(provider, null);
             serviceInstance = InstanceHolder.create(instance);
         }
     }
@@ -409,7 +451,7 @@ static class FixedIpFactoryActivator<T> extends IpFactoryActivator<T> {
     static class FixedServicesFactoryActivator<T> extends ServicesFactoryActivator<T> {
         FixedServicesFactoryActivator(ServiceProvider<T> provider,
                                       Service.ServicesFactory<T> factory) {
-            super(provider);
+            super(provider, null);
             serviceInstance = InstanceHolder.create(factory);
         }
     }
@@ -417,7 +459,7 @@ static class FixedServicesFactoryActivator<T> extends ServicesFactoryActivator<T
     static class FixedQualifiedFactoryActivator<T> extends QualifiedFactoryActivator<T> {
         FixedQualifiedFactoryActivator(ServiceProvider<T> provider,
                                        QualifiedFactory<T, ?> factory) {
-            super(provider, (QualifiedFactoryDescriptor) provider.descriptor());
+            super(provider, null, (QualifiedFactoryDescriptor) provider.descriptor());
             serviceInstance = InstanceHolder.create(factory);
         }
     }
@@ -431,8 +473,8 @@ static class SingleServiceActivator<T> extends BaseActivator<T> {
         protected InstanceHolder<T> serviceInstance;
         protected List<QualifiedInstance<T>> targetInstances;
 
-        SingleServiceActivator(ServiceProvider<T> provider) {
-            super(provider);
+        SingleServiceActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -451,7 +493,7 @@ protected void construct(ActivationResult.Builder response) {
                 lock.lock();
                 if (serviceInstance == null) {
                     // it may have been set explicitly when creating registry
-                    this.serviceInstance = InstanceHolder.create(provider, provider.injectionPlan());
+                    this.serviceInstance = InstanceHolder.create(provider, dependencyContext);
                 }
                 this.serviceInstance.construct();
             } finally {
@@ -495,8 +537,8 @@ protected void preDestroy(ActivationResult.Builder response) {
      * {@code MyService implements Supplier<Contract>}.
      */
     static class SupplierActivator<T> extends SingleServiceActivator<T> {
-        SupplierActivator(ServiceProvider<T> provider) {
-            super(provider);
+        SupplierActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -531,8 +573,10 @@ static class QualifiedFactoryActivator<T> extends SingleServiceActivator<T> {
         private final Set<ResolvedType> supportedContracts;
         private final boolean anyMatch;
 
-        QualifiedFactoryActivator(ServiceProvider<T> provider, QualifiedFactoryDescriptor qpd) {
-            super(provider);
+        QualifiedFactoryActivator(ServiceProvider<T> provider,
+                                  DependencyContext dependencyContext,
+                                  QualifiedFactoryDescriptor qpd) {
+            super(provider, dependencyContext);
             this.supportedQualifier = qpd.qualifierType();
             this.supportedContracts = provider.descriptor()
                     .contracts()
@@ -588,8 +632,8 @@ private List<QualifiedInstance<T>> targetInstances(Lookup lookup, Qualifier qual
      * {@code MyService implements InjectionPointProvider}.
      */
     static class IpFactoryActivator<T> extends SingleServiceActivator<T> {
-        IpFactoryActivator(ServiceProvider<T> provider) {
-            super(provider);
+        IpFactoryActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -624,8 +668,8 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
      * {@code MyService implements ServicesProvider}.
      */
     static class ServicesFactoryActivator<T> extends SingleServiceActivator<T> {
-        ServicesFactoryActivator(ServiceProvider<T> provider) {
-            super(provider);
+        ServicesFactoryActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -672,39 +716,50 @@ static class PerInstanceActivator<T> extends BaseActivator<T> {
         private final CoreServiceRegistry registry;
         private final ResolvedType createFor;
         private final Lookup createForLookup;
+        private final Bindings.ServiceBindingPlan bindingPlan;
+
         private List<QualifiedServiceInstance<T>> serviceInstances;
         private List<QualifiedInstance<T>> targetInstances;
 
-        PerInstanceActivator(CoreServiceRegistry registry, ServiceProvider<T> provider, PerInstanceDescriptor dbd) {
-            super(provider);
+        PerInstanceActivator(CoreServiceRegistry registry,
+                             ServiceProvider<T> provider,
+                             DependencyContext dependencyContext,
+                             Bindings.ServiceBindingPlan bindingPlan,
+                             PerInstanceDescriptor dbd) {
+            super(provider, dependencyContext);
 
             this.registry = registry;
+            this.bindingPlan = bindingPlan;
             this.createFor = ResolvedType.create(dbd.createFor());
             this.createForLookup = Lookup.builder()
                     .addContract(createFor)
                     .build();
         }
 
-        static Map<Dependency, IpPlan<?>> updatePlan(Map<Dependency, IpPlan<?>> injectionPlan,
-                                                     ServiceInstance<?> driver,
-                                                     Qualifier name) {
-
-            Set<Dependency> ips = Set.copyOf(injectionPlan.keySet());
+        static DependencyContext updatePlan(Bindings.ServiceBindingPlan injectionPlan,
+                                            DependencyContext dependencyContext,
+                                            ServiceInstance<?> driver,
+                                            Qualifier name) {
 
             Set<ResolvedType> contracts = driver.contracts();
 
-            Map<Dependency, IpPlan<?>> updatedPlan = new HashMap<>(injectionPlan);
+            Map<Dependency, Supplier<Object>> targetPlan = new HashMap<>();
 
-            for (Dependency dependency : ips) {
+            for (Bindings.DependencyBinding binding : injectionPlan.allBindings()) {
+                Dependency dependency = binding.dependency();
+
+                boolean updated = false;
                 // injection point for the driving instance
                 if (contracts.contains(ResolvedType.create(dependency.contract()))
                         && dependency.qualifiers().isEmpty()) {
-                    if (ServiceInstance.TYPE.equals(dependency.typeName())) {
-                        // if the injection point has the same contract, no qualifiers, then it is the driving instance
-                        updatedPlan.put(dependency, new IpPlan<>(() -> driver, injectionPlan.get(dependency).descriptors()));
+                    updated = true;
+                    // if the injection point has the same contract, no qualifiers, then it is the driving instance
+                    if (dependency.isServiceInstance()) {
+                        // return ServiceInstance
+                        targetPlan.put(dependency, () -> driver);
                     } else {
-                        // if the injection point has the same contract, no qualifiers, then it is the driving instance
-                        updatedPlan.put(dependency, new IpPlan<>(driver, injectionPlan.get(dependency).descriptors()));
+                        // return instance
+                        targetPlan.put(dependency, driver::get);
                     }
                 }
                 // injection point for the service name
@@ -713,14 +768,18 @@ static Map<Dependency, IpPlan<?>> updatePlan(Map<Dependency, IpPlan<?>> injectio
                     if (dependency.qualifiers()
                             .stream()
                             .anyMatch(it -> Service.InstanceName.TYPE.equals(it.typeName()))) {
-                        updatedPlan.put(dependency,
-                                        new IpPlan<>(() -> name.value().orElse(Service.Named.DEFAULT_NAME),
-                                                     injectionPlan.get(dependency).descriptors()));
+                        updated = true;
+                        targetPlan.put(dependency, () -> name.value().orElse(Service.Named.DEFAULT_NAME));
                     }
                 }
+
+                if (!updated) {
+                    // fallback to original instance
+                    targetPlan.put(dependency, () -> dependencyContext.dependency(dependency));
+                }
             }
 
-            return updatedPlan;
+            return new SupplierDependencyContext(targetPlan);
         }
 
         @Override
@@ -728,7 +787,7 @@ protected void construct(ActivationResult.Builder response) {
             // at this moment, we must resolve services that are driving this instance
 
             // we do not want to use lookup, as that is doing too much for us
-            List<ServiceInstance<Object>> drivingInstances = driversFromPlan(provider.injectionPlan(), createFor)
+            List<ServiceInstance<Object>> drivingInstances = driversFromPlan(bindingPlan, createFor)
                     .stream()
                     .map(registry::serviceManager)
                     .flatMap(it -> it.activator()
@@ -739,7 +798,7 @@ protected void construct(ActivationResult.Builder response) {
                     .toList();
 
             serviceInstances = drivingInstances.stream()
-                    .map(it -> QualifiedServiceInstance.create(provider, it))
+                    .map(it -> QualifiedServiceInstance.create(provider, bindingPlan, dependencyContext, it))
                     .toList();
             for (QualifiedServiceInstance<T> serviceInstance : serviceInstances) {
                 serviceInstance.serviceInstance().construct();
@@ -795,23 +854,27 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
             return Optional.of(List.copyOf(response));
         }
 
-        private List<ServiceInfo> driversFromPlan(Map<Dependency, IpPlan<?>> ipSupplierMap, ResolvedType createFor) {
+        private List<ServiceInfo> driversFromPlan(Bindings.ServiceBindingPlan ipSupplierMap, ResolvedType createFor) {
             // I need the list of descriptors from the injection plan
-            for (Map.Entry<Dependency, IpPlan<?>> entry : ipSupplierMap.entrySet()) {
-                Dependency dependency = entry.getKey();
+            for (Bindings.DependencyBinding binding : ipSupplierMap.allBindings()) {
+                Dependency dependency = binding.dependency();
                 if (createFor.equals(ResolvedType.create(dependency.contract()))
                         && dependency.qualifiers().size() == 1
                         && dependency.qualifiers().contains(Qualifier.WILDCARD_NAMED)) {
-                    return List.of(entry.getValue().descriptors());
+                    return binding.descriptors();
                 }
             }
+
             // there is not
             return registry.servicesByContract(createFor);
         }
 
         private record QualifiedServiceInstance<T>(InstanceHolder<T> serviceInstance,
                                                    Set<Qualifier> qualifiers) {
-            static <T> QualifiedServiceInstance<T> create(ServiceProvider<T> provider, ServiceInstance<?> driver) {
+            static <T> QualifiedServiceInstance<T> create(ServiceProvider<T> provider,
+                                                          Bindings.ServiceBindingPlan bindingPlan,
+                                                          DependencyContext dependencyContext,
+                                                          ServiceInstance<?> driver) {
                 Set<Qualifier> qualifiers = driver.qualifiers();
                 Qualifier name = qualifiers.stream()
                         .filter(not(Qualifier.WILDCARD_NAMED::equals))
@@ -824,43 +887,13 @@ static <T> QualifiedServiceInstance<T> create(ServiceProvider<T> provider, Servi
                         .collect(Collectors.toSet());
                 newQualifiers.add(name);
 
-                Map<Dependency, IpPlan<?>> injectionPlan = updatePlan(provider.injectionPlan(), driver, name);
+                DependencyContext targetDependencyContext = updatePlan(bindingPlan, dependencyContext, driver, name);
 
-                return new QualifiedServiceInstance<>(InstanceHolder.create(provider, injectionPlan), newQualifiers);
+                return new QualifiedServiceInstance<>(InstanceHolder.create(provider, targetDependencyContext), newQualifiers);
             }
         }
     }
 
-    interface InstanceHolder<T> {
-        static <T> InstanceHolder<T> create(ServiceProvider<T> serviceProvider, Map<Dependency, IpPlan<?>> injectionPlan) {
-            // the same instance is returned for the lifetime of the service provider
-            return new InstanceHolderImpl<>(InjectionContext.create(injectionPlan),
-                                            serviceProvider.interceptionMetadata(),
-                                            serviceProvider.descriptor());
-        }
-
-        // we use the instance holder to hold either the actual instance,
-        // or the factory; this is a place for improvement
-        @SuppressWarnings("unchecked")
-        static <T> InstanceHolder<T> create(Object instance) {
-            return new FixedInstanceHolder<>((T) instance);
-        }
-
-        T get();
-
-        default void construct() {
-        }
-
-        default void inject() {
-        }
-
-        default void postConstruct() {
-        }
-
-        default void preDestroy() {
-        }
-    }
-
     private static class FixedInstanceHolder<T> implements InstanceHolder<T> {
         private final T instance;
 
@@ -882,15 +915,13 @@ private static class InstanceHolderImpl<T> implements InstanceHolder<T> {
         private volatile T instance;
 
         private InstanceHolderImpl(DependencyContext ctx,
-                               InterceptionMetadata interceptionMetadata,
-                               ServiceDescriptor<T> source) {
+                                   InterceptionMetadata interceptionMetadata,
+                                   ServiceDescriptor<T> source) {
             this.ctx = ctx;
             this.interceptionMetadata = interceptionMetadata;
             this.source = source;
         }
 
-
-
         @Override
         public T get() {
             return instance;
@@ -925,7 +956,7 @@ private static class MissingDescribedActivator<T> implements Supplier<Activator<
         private final String serviceType;
 
         private MissingDescribedActivator(ServiceProvider<T> provider) {
-            this.serviceType = provider.serviceInfo().serviceType().fqName();
+            this.serviceType = provider.descriptor().serviceType().fqName();
 
             if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
                 LOGGER.log(System.Logger.Level.DEBUG,
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java b/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
index 299962a0fde..dd314ee2fee 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ActivatorsPerLookup.java
@@ -19,7 +19,6 @@
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.locks.ReentrantLock;
@@ -60,8 +59,8 @@ private ActivatorsPerLookup() {
     static class SingleServiceActivator<T> extends Activators.BaseActivator<T> {
         protected OnDemandInstance<T> serviceInstance;
 
-        SingleServiceActivator(ServiceProvider<T> provider) {
-            super(provider);
+        SingleServiceActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -75,7 +74,7 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances() {
 
         @Override
         protected void construct(ActivationResult.Builder response) {
-            this.serviceInstance = new OnDemandInstance<>(InjectionContext.create(provider.injectionPlan()),
+            this.serviceInstance = new OnDemandInstance<>(dependencyContext,
                                                           provider.interceptionMetadata(),
                                                           provider.descriptor());
         }
@@ -90,8 +89,8 @@ protected void preDestroy(ActivationResult.Builder response) {
      * {@code MyService implements Supplier<Contract>}.
      */
     static class SupplierActivator<T> extends SingleServiceActivator<T> {
-        SupplierActivator(ServiceProvider<T> provider) {
-            super(provider);
+        SupplierActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @Override
@@ -133,8 +132,10 @@ static class QualifiedFactoryActivator<T> extends SingleServiceActivator<T> {
         private final Set<ResolvedType> supportedContracts;
         private final boolean anyMatch;
 
-        QualifiedFactoryActivator(ServiceProvider<T> provider, GeneratedService.QualifiedFactoryDescriptor qpd) {
-            super(provider);
+        QualifiedFactoryActivator(ServiceProvider<T> provider,
+                                  DependencyContext dependencyContext,
+                                  GeneratedService.QualifiedFactoryDescriptor qpd) {
+            super(provider, dependencyContext);
             this.supportedQualifier = qpd.qualifierType();
             this.supportedContracts = provider.descriptor().contracts()
                     .stream()
@@ -184,8 +185,8 @@ private List<QualifiedInstance<T>> targetInstances(Lookup lookup, Qualifier qual
      * {@code MyService implements InjectionPointProvider}.
      */
     static class IpFactoryActivator<T> extends SingleServiceActivator<T> {
-        IpFactoryActivator(ServiceProvider<T> provider) {
-            super(provider);
+        IpFactoryActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @SuppressWarnings("unchecked")
@@ -215,8 +216,8 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
      * {@code MyService implements ServicesProvider}.
      */
     static class ServicesFactoryActivator<T> extends SingleServiceActivator<T> {
-        ServicesFactoryActivator(ServiceProvider<T> provider) {
-            super(provider);
+        ServicesFactoryActivator(ServiceProvider<T> provider, DependencyContext dependencyContext) {
+            super(provider, dependencyContext);
         }
 
         @SuppressWarnings("unchecked")
@@ -244,16 +245,20 @@ protected Optional<List<QualifiedInstance<T>>> targetInstances(Lookup lookup) {
      */
     static class PerInstanceActivator<T> extends Activators.BaseActivator<T> {
         private final CoreServiceRegistry registry;
+        private final Bindings.ServiceBindingPlan bindingPlan;
         private final ResolvedType createFor;
 
         private List<QualifiedOnDemandInstance<T>> serviceInstances;
 
         PerInstanceActivator(CoreServiceRegistry registry,
+                             DependencyContext dependencyContext,
+                             Bindings.ServiceBindingPlan bindingPlan,
                              ServiceProvider<T> provider,
                              GeneratedService.PerInstanceDescriptor dbd) {
-            super(provider);
+            super(provider, dependencyContext);
 
             this.registry = registry;
+            this.bindingPlan = bindingPlan;
             this.createFor = ResolvedType.create(dbd.createFor());
         }
 
@@ -269,7 +274,7 @@ protected void construct(ActivationResult.Builder response) {
                             .stream()
                             .flatMap(List::stream)
                             .map(qi -> it.registryInstance(Lookup.EMPTY, qi)))
-                    .map(it -> QualifiedOnDemandInstance.create(provider, it))
+                    .map(it -> QualifiedOnDemandInstance.create(provider, bindingPlan, dependencyContext, it))
                     .collect(Collectors.toList());
         }
 
@@ -291,6 +296,8 @@ protected void preDestroy(ActivationResult.Builder response) {
     private record QualifiedOnDemandInstance<T>(OnDemandInstance<T> serviceInstance,
                                                 Set<Qualifier> qualifiers) {
         static <T> QualifiedOnDemandInstance<T> create(ServiceProvider<T> provider,
+                                                       Bindings.ServiceBindingPlan bindingPlan,
+                                                       DependencyContext dependencyContext,
                                                        ServiceInstance<?> driver) {
             Set<Qualifier> qualifiers = driver.qualifiers();
             Qualifier name = qualifiers.stream()
@@ -304,11 +311,13 @@ static <T> QualifiedOnDemandInstance<T> create(ServiceProvider<T> provider,
                     .collect(Collectors.toSet());
             newQualifiers.add(name);
 
-            Map<Dependency, IpPlan<?>> injectionPlan = Activators.PerInstanceActivator.updatePlan(provider.injectionPlan(),
-                                                                                                  driver,
-                                                                                                  name);
+            DependencyContext targetDependencyContext =
+                    Activators.PerInstanceActivator.updatePlan(bindingPlan,
+                                                               dependencyContext,
+                                                               driver,
+                                                               name);
 
-            return new QualifiedOnDemandInstance<>(new OnDemandInstance<>(InjectionContext.create(injectionPlan),
+            return new QualifiedOnDemandInstance<>(new OnDemandInstance<>(targetDependencyContext,
                                                                           provider.interceptionMetadata(),
                                                                           provider.descriptor()),
                                                    newQualifiers);
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Binding.java b/service/registry/src/main/java/io/helidon/service/registry/Binding.java
index 445ce4f89ce..4c9795702a2 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Binding.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Binding.java
@@ -27,7 +27,6 @@
  * <p>
  * Binding instances MUST NOT have injection points.
  */
-@Service.Contract
 public interface Binding {
     /**
      * Type name of this interface.
@@ -42,9 +41,21 @@ public interface Binding {
     String name();
 
     /**
-     * Configure injection points and dependencies in this application.
+     * For each service in this application, bind services that satisfy its injection points.
      *
-     * @param binder the binder used to register the service provider injection plans
+     * @param binder the binder used to register the service provider dependency injection plan
      */
-    void configure(DependencyPlanBinder binder);
+    void binding(DependencyPlanBinder binder);
+
+    /**
+     * Register all services with the configuration.
+     * When application binding is available to the registry, automatic discovery of services is disabled, and only services
+     * registered in this method will be used by the registry.
+     * <p>
+     * The services registered in this method must be aligned with {@link #binding(DependencyPlanBinder)}, as otherwise
+     * inconsistent registry would be created.
+     *
+     * @param builder configuration builder to register service descriptors
+     */
+    void configure(ServiceRegistryConfig.Builder builder);
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java b/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
new file mode 100644
index 00000000000..6803d41247a
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
@@ -0,0 +1,17 @@
+package io.helidon.service.registry;
+
+class BindingDependencyContext implements DependencyContext {
+    private final Bindings.ServiceBindingPlan serviceBinding;
+
+    BindingDependencyContext(Bindings.ServiceBindingPlan serviceBinding) {
+        this.serviceBinding = serviceBinding;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T dependency(Dependency dependency) {
+        Bindings.DependencyBinding binding = serviceBinding.binding(dependency);
+        // services that match
+        return (T) binding.instanceSupply().get();
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Bindings.java b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
new file mode 100644
index 00000000000..da01e3e0c0a
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
@@ -0,0 +1,291 @@
+package io.helidon.service.registry;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import io.helidon.common.types.ResolvedType;
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupply;
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyList;
+import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyOptional;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupply;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupplyList;
+import io.helidon.service.registry.ServiceSupplies.ServiceSupplyOptional;
+
+/**
+ * Contains bindings for each service.
+ * <p>
+ * A binding is a map of injection point to zero or more service descriptors that satisfy it.
+ */
+class Bindings {
+    private final Map<ResolvedType, List<DependencyBinding>> bindingsByContract = new HashMap<>();
+    private final Map<ServiceInfo, ServiceBindingPlan> bindingPlans = new IdentityHashMap<>();
+    private final ReentrantLock lock = new ReentrantLock();
+    private final CoreServiceRegistry registry;
+
+    Bindings(CoreServiceRegistry registry) {
+        this.registry = registry;
+    }
+
+    /*
+    Register each service known to the registry (via service descriptors)
+     */
+    void register(ServiceInfo serviceInfo) {
+        lock.lock();
+        try {
+            ServiceBindingPlan bindingPlan = new ServiceBindingPlan(registry, serviceInfo);
+            this.bindingPlans.put(serviceInfo, bindingPlan);
+            for (var binding : bindingPlan.allBindings()) {
+                bindingsByContract.computeIfAbsent(ResolvedType.create(binding.dependency.contract()), it -> new ArrayList<>())
+                        .add(binding);
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /*
+    A contract was late bound through Services.set(...), we must forget all bindings for that contract
+     */
+    void forgetContract(ResolvedType type) {
+        lock.lock();
+        try {
+            List<DependencyBinding> toRemove = bindingsByContract.remove(type);
+            if (toRemove == null) {
+                // nobody injects this contract
+                return;
+            }
+            toRemove.forEach(DependencyBinding::clear);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /*
+    Binding plan for a specific service, this allows us to:
+    - get contract instances to actually inject the service
+    - bind pre-built (compile time)
+     */
+    ServiceBindingPlan bindingPlan(ServiceInfo service) {
+        ServiceBindingPlan bindingPlan = bindingPlans.get(service);
+        if (bindingPlan == null) {
+            // this means we failed to bind services on registry startup, we should have complete knowledge of all
+            // available service infos
+            throw new ServiceRegistryException("An attempt to get binding plan for service that was not discovered: "
+                                                       + service.serviceType());
+        }
+        return bindingPlan;
+    }
+
+    static class ServiceBindingPlan {
+        private final Map<Dependency, DependencyBinding> bindingPlan = new HashMap<>();
+        private final ServiceInfo serviceInfo;
+        private final CoreServiceRegistry registry;
+
+        ServiceBindingPlan(CoreServiceRegistry registry, ServiceInfo serviceInfo) {
+            this.serviceInfo = serviceInfo;
+            this.registry = registry;
+            createBindings();
+        }
+
+        void ensure() {
+            for (Dependency dependency : serviceInfo.dependencies()) {
+                bindingPlan.get(dependency)
+                        .instanceSupply();
+            }
+        }
+
+        Collection<DependencyBinding> allBindings() {
+            return bindingPlan.values();
+        }
+
+        DependencyBinding binding(Dependency dependency) {
+            return bindingPlan.get(dependency);
+        }
+
+        private void createBindings() {
+            for (Dependency dependency : serviceInfo.dependencies()) {
+                bindingPlan.put(dependency, new DependencyBinding(registry, serviceInfo, dependency));
+            }
+        }
+    }
+
+    static class DependencyBinding {
+        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+        private final CoreServiceRegistry registry;
+        private final ServiceInfo serviceInfo;
+        private final Dependency dependency;
+        private final Lookup lookup;
+
+        private boolean bound;
+        private List<ServiceInfo> serviceInfos;
+        private Supplier<Object> instanceSupply;
+
+        private DependencyBinding(CoreServiceRegistry registry, ServiceInfo serviceInfo, Dependency dependency) {
+            this.registry = registry;
+            this.serviceInfo = serviceInfo;
+            this.dependency = dependency;
+            this.lookup = Lookup.builder()
+                    .dependency(dependency)
+                    .update(it -> {
+                        if (serviceInfo.contracts().contains(ResolvedType.create(dependency.contract()))
+                                && serviceInfo.qualifiers().containsAll(dependency.qualifiers())) {
+                            // when injecting a contract that we also implement, we must inject a service of lower weight
+                            it.weight(serviceInfo.weight());
+                        }
+                    })
+                    .build();
+        }
+
+        public List<ServiceInfo> descriptors() {
+            return serviceInfos;
+        }
+
+        Dependency dependency() {
+            return dependency;
+        }
+
+        /*
+        Bind from build time generated binding
+         */
+        void bind(List<ServiceInfo> serviceInfos) {
+            lock.writeLock().lock();
+            try {
+                this.bound = true;
+                this.serviceInfos = serviceInfos;
+                createInstanceSupply();
+            } finally {
+                lock.writeLock().unlock();
+            }
+        }
+
+        /*
+        A supplier of value to be injected into this dependency
+         */
+        Supplier<Object> instanceSupply() {
+            lock.readLock().lock();
+            try {
+                if (bound) {
+                    return instanceSupply;
+                }
+            } finally {
+                lock.readLock().unlock();
+            }
+
+            lock.writeLock().lock();
+            try {
+                if (bound) {
+                    return instanceSupply;
+                }
+                // we will provide a value in the next block, we are in write lock, so nobody can read now
+                bound = true;
+                discoverBinding();
+                createInstanceSupply();
+                return this.instanceSupply;
+            } finally {
+                lock.writeLock().unlock();
+            }
+        }
+
+        /*
+        Clear the binding if there was a late binding event
+         */
+        void clear() {
+            lock.writeLock().lock();
+            try {
+                bound = false;
+                serviceInfos = null;
+                instanceSupply = null;
+            } finally {
+                lock.writeLock().unlock();
+            }
+        }
+
+        private void createInstanceSupply() {
+            if (dependency.isServiceInstance()) {
+                createInstanceSupplyServiceInstance();
+            } else {
+                createInstanceSupplyDirectContract();
+            }
+            if (dependency.isSupplier()) {
+                this.instanceSupply = new DependencySupplier(dependency, this.instanceSupply);
+            }
+        }
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        private void createInstanceSupplyDirectContract() {
+            this.instanceSupply = switch (dependency.cardinality()) {
+                case REQUIRED -> new ServiceSupply<>(lookup,
+                                                     managers(serviceInfos));
+                case OPTIONAL -> new ServiceSupplyOptional<>(lookup,
+                                                             managers(serviceInfos));
+                case LIST -> new ServiceSupplyList<>(lookup,
+                                                     managers(serviceInfos));
+            };
+        }
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        private void createInstanceSupplyServiceInstance() {
+            this.instanceSupply = switch (dependency.cardinality()) {
+                case REQUIRED -> new ServiceInstanceSupply<>(lookup,
+                                                             managers(serviceInfos));
+                case OPTIONAL -> new ServiceInstanceSupplyOptional<>(lookup,
+                                                                     managers(serviceInfos));
+                case LIST -> new ServiceInstanceSupplyList<>(lookup,
+                                                             managers(serviceInfos));
+            };
+        }
+
+        @SuppressWarnings("rawtypes")
+        private List managers(List<ServiceInfo> serviceInfos) {
+            return serviceInfos.stream()
+                    .map(registry::serviceManager)
+                    .collect(Collectors.toUnmodifiableList());
+        }
+
+        private void discoverBinding() {
+            // lookup services, exclude ourself (when doing chained injection, we lookup by weight)
+            List<ServiceInfo> found = registry.lookupServices(lookup)
+                    .stream()
+                    .filter(it -> it != serviceInfo)
+                    .collect(Collectors.toList());
+            if (found.isEmpty() && (dependency.cardinality() == DependencyCardinality.REQUIRED)) {
+                throw new ServiceRegistryException("There is no service in registry that satisfied this dependency: "
+                                                           + dependency);
+            }
+
+            // we need all service descriptors, as a service may not yield a service
+            // (such as optional suppliers, ServicesFactory etc.), so we use the next one
+
+            this.serviceInfos = found;
+        }
+
+        private static class DependencySupplier implements Supplier<Object> {
+            private final Dependency dependency;
+            private final Supplier<Object> instanceSupply;
+
+            DependencySupplier(Dependency dependency, Supplier<Object> instanceSupply) {
+                this.dependency = dependency;
+                this.instanceSupply = instanceSupply;
+            }
+
+            @Override
+            public Object get() {
+                return instanceSupply;
+            }
+
+            @Override
+            public String toString() {
+                return "DependencySupplier for " + dependency + ", supply: " + instanceSupply;
+            }
+        }
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
index fffd510b4b7..9333a3936a1 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
@@ -82,11 +82,16 @@ class CoreServiceRegistry implements ServiceRegistry, Scopes {
     private final Lock scopeHandlerInstancesLock = new ReentrantLock();
     private final boolean interceptionEnabled;
     private final InterceptionMetadata interceptionMetadata;
+    private final ServiceManager<String> serviceManagerForInstanceName;
 
     // runtime fields (to obtain actual service instances)
     // service descriptor to its manager
     private final Map<ServiceInfo, ServiceManager<?>> servicesByDescriptor = new IdentityHashMap<>();
     private final ActivationRequest activationRequest;
+
+    private final Bindings bindings;
+    private final boolean allowLateBinding;
+
     private Map<ServiceInfo, ServiceManager<Interception.Interceptor>> interceptors;
 
     @SuppressWarnings("unchecked")
@@ -106,6 +111,9 @@ class CoreServiceRegistry implements ServiceRegistry, Scopes {
         this.interceptionMetadata = interceptionEnabled
                 ? InterceptionMetadataImpl.create(this)
                 : InterceptionMetadataImpl.noop();
+        // again - we leak our instance early, but it is not used until runtime from bindings
+        this.bindings = new Bindings(this);
+        this.allowLateBinding = config.allowLateBinding();
 
         // these must be bound here, as the instance exists now
         // (and we do not want to allow post-constructor binding)
@@ -133,6 +141,8 @@ class CoreServiceRegistry implements ServiceRegistry, Scopes {
         For each known service descriptor, create an appropriate service manager
          */
         descriptors.forEach(descriptor -> {
+            bindings.register(descriptor);
+
             Object instance = explicitInstances.get(descriptor);
             ServiceProvider<Object> provider = new ServiceProvider<>(
                     this,
@@ -141,19 +151,23 @@ class CoreServiceRegistry implements ServiceRegistry, Scopes {
             if (instance != null) {
                 Activator<Object> activator = Activators.create(provider, instance);
                 servicesByDescriptor.put(descriptor,
-                                         new ServiceManager<>(scopeSupplier(descriptor),
+                                         new ServiceManager<>(this,
+                                                              scopeSupplier(descriptor),
                                                               provider,
                                                               true,
                                                               () -> activator));
             } else {
                 // we must always prefer explicit instances - so if specified, we will never override it
                 servicesByDescriptor.putIfAbsent(descriptor,
-                                                 new ServiceManager<>(scopeSupplier(descriptor),
+                                                 new ServiceManager<>(this,
+                                                                      scopeSupplier(descriptor),
                                                                       provider,
                                                                       false,
                                                                       Activators.create(this, provider)));
             }
         });
+
+        this.serviceManagerForInstanceName = new InstanceNameServiceManager(this);
     }
 
     @Override
@@ -361,6 +375,10 @@ public RegistryMetrics metrics() {
         return metrics;
     }
 
+    Bindings bindings() {
+        return bindings;
+    }
+
     <T> void add(Class<T> contract, double weight, T instance) {
         stateWriteLock.lock();
         try {
@@ -377,7 +395,8 @@ <T> void add(Class<T> contract, double weight, T instance) {
                                                                          vt);
                 Activator<Object> activator = Activators.create(provider, instance);
 
-                servicesByDescriptor.put(vt, new ServiceManager<>(scopeSupplier(vt),
+                servicesByDescriptor.put(vt, new ServiceManager<>(this,
+                                                                  scopeSupplier(vt),
                                                                   provider,
                                                                   true,
                                                                   () -> activator));
@@ -396,6 +415,11 @@ <T> void add(Class<T> contract, double weight, T instance) {
 
     @SuppressWarnings("unchecked")
     <T> void set(Class<T> contract, T[] instances) {
+        if (!allowLateBinding) {
+            throw new ServiceRegistryException("This service registry instance does not support late binding, as it was "
+                                                       + "explicitly disabled through registry configuration: " + id);
+        }
+
         stateWriteLock.lock();
         try {
             ResolvedType contractType = ResolvedType.create(contract);
@@ -413,7 +437,8 @@ <T> void set(Class<T> contract, T[] instances) {
                                                                              vt);
                     Activator<Object> activator = Activators.create(provider, instance);
 
-                    servicesByDescriptor.put(vt, new ServiceManager<>(scopeSupplier(vt),
+                    servicesByDescriptor.put(vt, new ServiceManager<>(this,
+                                                                      scopeSupplier(vt),
                                                                       provider,
                                                                       true,
                                                                       () -> activator));
@@ -432,11 +457,14 @@ <T> void set(Class<T> contract, T[] instances) {
                                                                + "A service provider must have exactly one instance.");
                 }
                 Activator<Object> activator = Activators.create(provider, instances[0]);
-                servicesByDescriptor.put(serviceInfo, new ServiceManager<>(scopeSupplier(serviceInfo),
+                servicesByDescriptor.put(serviceInfo, new ServiceManager<>(this,
+                                                                           scopeSupplier(serviceInfo),
                                                                            provider,
                                                                            true,
                                                                            () -> activator));
             }
+            // reset bindings, as build-time binding would ignore instances explicitly set
+            bindings.forgetContract(contractType);
         } finally {
             stateWriteLock.unlock();
         }
@@ -461,6 +489,9 @@ List<ServiceInfo> servicesByContract(ResolvedType contract) {
 
     @SuppressWarnings("unchecked")
     <T> ServiceManager<T> serviceManager(ServiceInfo info) {
+        if (info == InstanceName__ServiceDescriptor.INSTANCE) {
+            return (ServiceManager<T>) serviceManagerForInstanceName;
+        }
         ServiceManager<T> result = (ServiceManager<T>) servicesByDescriptor.get(info);
         if (result == null) {
             throw new ServiceRegistryException("Attempt to use service info not managed by this registry: " + info);
@@ -480,7 +511,7 @@ void interceptors(ServiceInfo... serviceInfos) {
             Set<ServiceInfo> ordered = new TreeSet<>(SERVICE_INFO_COMPARATOR);
             for (ServiceInfo serviceInfo : serviceInfos) {
                 ServiceManager<Object> serviceManager = this.serviceManager(serviceInfo);
-                ordered.add(serviceManager.injectDescriptor());
+                ordered.add(serviceManager.descriptor());
             }
 
             // there may be more than one application, we need to add to existing
@@ -539,7 +570,7 @@ List<ServiceManager<Interception.Interceptor>> interceptors() {
 
     void ensureInjectionPlans() {
         servicesByDescriptor.values()
-                .forEach(ServiceManager::ensureInjectionPlan);
+                .forEach(ServiceManager::ensureBindingPlan);
     }
 
     private void cacheAndAccess(Lookup lookup, List<ServiceInfo> result) {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
index a11d9536a37..d651f296ee2 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyBlueprint.java
@@ -29,9 +29,9 @@
 
 /**
  * Dependency metadata.
- * The basic dependency supports other services to be passed to a constructor parameter.
- * The dependency may be a contract, {@link java.util.List} of contracts, or an {@link java.util.Optional}
- * of contract, or {@link java.util.function.Supplier} of any of these.
+ * <p>
+ * Dependencies can be injected into a service through a constructor. We also support field injection, though it is not
+ * recommended due to complicated unit testing.
  */
 @Prototype.Blueprint
 interface DependencyBlueprint {
@@ -140,4 +140,28 @@ interface DependencyBlueprint {
      */
     @Option.Redundant(stringValue = false)
     Optional<String> method();
+
+    /**
+     * Cardinality of this dependency. Defaults to {@link io.helidon.service.registry.DependencyCardinality#REQUIRED}.
+     *
+     * @return cardinality of this dependency
+     */
+    @Option.Default("REQUIRED")
+    DependencyCardinality cardinality();
+
+    /**
+     * Whether this dependency uses {@link io.helidon.service.registry.ServiceInstance}.
+     * Defaults to {@code false}, which means the service is injected via its contract.
+     *
+     * @return whether the dependency is declared as a {@link io.helidon.service.registry.ServiceInstance}
+     */
+    boolean isServiceInstance();
+
+    /**
+     * Whether this dependency uses a {@link java.util.function.Supplier} instead of a direct instance.
+     * This defaults to {@code false}.
+     *
+     * @return whether the dependency injection point uses a supplier
+     */
+    boolean isSupplier();
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
new file mode 100644
index 00000000000..afb256e2047
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
@@ -0,0 +1,19 @@
+package io.helidon.service.registry;
+
+/**
+ * Cardinality of the injection point.
+ */
+public enum DependencyCardinality {
+    /**
+     * Optional instance (the dependency is declared as {@code Optional<MyContract>}, this does not imply nullability.
+     */
+    OPTIONAL,
+    /**
+     * Required instance.
+     */
+    REQUIRED,
+    /**
+     * List of instances.
+     */
+    LIST
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
index 24a4abb3b5d..137685140e3 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyPlanBinder.java
@@ -31,7 +31,7 @@ public interface DependencyPlanBinder {
      * @param descriptor the service to receive the injection plan.
      * @return the binder to use for binding the injection plan to the service provider
      */
-    Binder bindTo(ServiceInfo descriptor);
+    Binder service(ServiceInfo descriptor);
 
     /**
      * Bind all discovered interceptors.
@@ -53,129 +53,12 @@ interface Binder {
          * Binds a single service to the injection point identified by the id.
          * The injection point expects a single service instance.
          *
-         * @param dependency the injection point identity
-         * @param descriptor the service descriptor to bind to this identity
-         * @return the binder builder
-         */
-        Binder bind(Dependency dependency,
-                    ServiceInfo descriptor);
-
-        /**
-         * Bind to an optional field, with zero or one services.
-         * The injection point expects an {@link java.util.Optional} of service instance.
-         *
-         * @param dependency  injection point identity
-         * @param descriptors the service descriptor to bind (zero or one)
-         * @return the binder builder
-         */
-        Binder bindOptional(Dependency dependency,
-                            ServiceInfo... descriptors);
-
-        /**
-         * Binds to a list field, with zero or more services.
-         * The injection point expects a {@link java.util.List} of service instances.
-         *
-         * @param dependency  the injection point identity
-         * @param descriptors service descriptors to bind to this identity (zero or more)
-         * @return the binder builder
-         */
-        Binder bindList(Dependency dependency,
-                        ServiceInfo... descriptors);
-
-        /**
-         * Binds to a supplier field.
-         * The injection point expects a {@link java.util.function.Supplier} of service.
-         *
-         * @param dependency the injection point identity
-         * @param descriptor the service descriptor to bind to this identity.
-         * @return the binder builder
-         */
-        Binder bindSupplier(Dependency dependency,
-                            ServiceInfo descriptor);
-
-        /**
-         * Bind to a supplier of optional field.
-         * The injection point expects a {@link java.util.function.Supplier} of {@link java.util.Optional} of service.
-         *
-         * @param dependency injection point identity
-         * @param descriptor the service descriptor to bind (zero or one)
-         * @return the binder builder
-         */
-        Binder bindSupplierOfOptional(Dependency dependency,
-                                      ServiceInfo... descriptor);
-
-        /**
-         * Bind to an optional supplier field.
-         * The injection point expects a {@link java.util.function.Supplier} of {@link java.util.Optional} of service.
-         *
-         * @param dependency injection point identity
-         * @param descriptor the service descriptor to bind (zero or one)
-         * @return the binder builder
-         */
-        Binder bindOptionalOfSupplier(Dependency dependency,
-                                      ServiceInfo... descriptor);
-
-        /**
-         * Bind to a supplier of list.
-         * The injection point expects a {@link java.util.function.Supplier} of {@link java.util.List} of services.
-         *
          * @param dependency  the injection point identity
-         * @param descriptors service descriptor to bind to this identity (zero or more)
+         * @param descriptor  the service descriptor to bind to this identity
          * @return the binder builder
          */
-        Binder bindSupplierOfList(Dependency dependency,
-                                  ServiceInfo... descriptors);
-
-        /**
-         * Bind to a list of suppliers.
-         * The injection point expects a {@link java.util.List} of {@link java.util.function.Supplier Suppliers} of service.
-         *
-         * @param dependency  the injection point identity
-         * @param descriptors service descriptor to bind to this identity (zero or more)
-         * @return the binder builder
-         */
-        Binder bindListOfSuppliers(Dependency dependency,
-                                   ServiceInfo... descriptors);
-
-        /**
-         * Represents a null bind.
-         *
-         * @param dependency the injection point identity
-         * @return the binder builder
-         */
-        Binder bindNull(Dependency dependency);
-
-        /**
-         * Bind service instance.
-         *
-         * @param dependency the injection point identity
-         * @param descriptor the service descriptor to bind
-         * @return the binder builder
-         */
-        Binder bindServiceInstance(Dependency dependency, ServiceInfo descriptor);
-
-        /**
-         * Bind to a list of service instances.
-         *
-         * @param dependency  the injection point identity
-         * @param descriptors the service descriptors to bind (zero or more)
-         * @return the binder builder
-         */
-        Binder bindServiceInstanceList(Dependency dependency, ServiceInfo... descriptors);
-
-        /**
-         * Bind to an optional of service instance.
-         *
-         * @param dependency the injection point identity
-         * @param descriptor the service descriptor to bind (zero or one)
-         * @return the binder builder
-         */
-        Binder bindOptionalOfServiceInstance(Dependency dependency, ServiceInfo... descriptor);
-
-        /**
-         * Commits the bindings for this service provider.
-         */
-        void commit();
+        Binder bind(Dependency dependency,
+                    ServiceInfo... descriptor);
 
     }
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java b/service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
deleted file mode 100644
index 1ca996e9bb8..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/InjectionContext.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.Map;
-import java.util.NoSuchElementException;
-
-class InjectionContext implements DependencyContext {
-    private final Map<Dependency, IpPlan<?>> injectionPlan;
-
-    InjectionContext(Map<Dependency, IpPlan<?>> injectionPlan) {
-        this.injectionPlan = injectionPlan;
-    }
-
-    static DependencyContext create(Map<Dependency, IpPlan<?>> injectionPlan) {
-        return new InjectionContext(injectionPlan);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <T> T dependency(Dependency dependency) {
-        IpPlan<?> ipPlan = injectionPlan.get(dependency);
-        if (ipPlan == null) {
-            throw new NoSuchElementException("Cannot resolve injection id " + dependency + " for service "
-                                                     + dependency.service().fqName()
-                                                     + ", this dependency was not declared in "
-                                                     + "the service descriptor");
-        }
-        return (T) ipPlan.get();
-    }
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java b/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
new file mode 100644
index 00000000000..26676e53797
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
@@ -0,0 +1,17 @@
+package io.helidon.service.registry;
+
+class InstanceNameServiceManager extends ServiceManager<String> {
+    InstanceNameServiceManager(CoreServiceRegistry registry) {
+        // this is never used - we replace it in dependency injection plan with the correct instance
+        super(registry, () -> null, null, true, () -> null);
+    }
+
+    @Override
+    void ensureBindingPlan() {
+    }
+
+    @Override
+    ServiceInfo descriptor() {
+        return InstanceName__ServiceDescriptor.INSTANCE;
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
index ad76cbc0c66..bb388af3037 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InterceptionMetadataImpl.java
@@ -112,11 +112,11 @@ private List<Supplier<Interception.Interceptor>> interceptors(List<Annotation> t
         List<Supplier<Interception.Interceptor>> result = new ArrayList<>();
 
         for (ServiceManager<Interception.Interceptor> interceptor : allInterceptors) {
-            if (applicable(typeAnnotations, interceptor.injectDescriptor())) {
+            if (applicable(typeAnnotations, interceptor.descriptor())) {
                 result.add(new ServiceSupply<>(Lookup.EMPTY, List.of(interceptor)));
                 continue;
             }
-            if (applicable(element.annotations(), interceptor.injectDescriptor())) {
+            if (applicable(element.annotations(), interceptor.descriptor())) {
                 result.add(new ServiceSupply<>(Lookup.EMPTY, List.of(interceptor)));
             }
         }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/IpPlan.java b/service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
deleted file mode 100644
index 8aed49ffe23..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/IpPlan.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.function.Supplier;
-
-/**
- * Injection point plan of injection.
- *
- * @param valueSupplier supplier of the value
- * @param descriptors   descriptor(s) used to obtain the value(s) in the supplier
- * @param <T>           type of the value
- */
-record IpPlan<T>(Supplier<T> valueSupplier,
-                 ServiceInfo... descriptors) implements Supplier<T> {
-    @Override
-    public T get() {
-        return valueSupplier.get();
-    }
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
new file mode 100644
index 00000000000..424c9ca298d
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
@@ -0,0 +1,102 @@
+package io.helidon.service.registry;
+
+import java.util.List;
+import java.util.Optional;
+
+import io.helidon.Main;
+import io.helidon.common.Weight;
+import io.helidon.common.Weighted;
+import io.helidon.spi.HelidonShutdownHandler;
+import io.helidon.spi.HelidonStartupProvider;
+
+/**
+ * {@link java.util.ServiceLoader} implementation of a Helidon startup provider for Helidon Service Registry based
+ * applications.
+ */
+@Weight(Weighted.DEFAULT_WEIGHT) // explicit default weight, this should be the "default" startup class
+public class RegistryStartupProvider implements HelidonStartupProvider {
+    private static final System.Logger LOGGER = System.getLogger(RegistryStartupProvider.class.getName());
+
+    /**
+     * Default constructor required by {@link java.util.ServiceLoader}.
+     *
+     * @deprecated please do not use directly
+     */
+    @Deprecated
+    public RegistryStartupProvider() {
+    }
+
+    /**
+     * Register a shutdown handler.
+     * The handler is registered, and never de-registered. This method should only be used by main classes of applications.
+     * If a custom shutdown is desired, please use
+     * {@link io.helidon.Main#addShutdownHandler(io.helidon.spi.HelidonShutdownHandler)} directly.
+     *
+     * @param registryManager registry manager
+     */
+    public static void registerShutdownHandler(ServiceRegistryManager registryManager) {
+        System.Logger logger = System.getLogger(RegistryStartupProvider.class.getName());
+        Main.addShutdownHandler(new RegistryShutdownHandler(logger, registryManager));
+    }
+
+    @Override
+    public void start(String[] arguments) {
+        var manager = ServiceRegistryManager.create();
+        var registry = manager.registry();
+        registerShutdownHandler(manager);
+
+        for (Double runLevel : runLevels(registry)) {
+            List<Object> all = registry.all(Lookup.builder()
+                                                    .addScope(Service.Singleton.TYPE)
+                                                    .runLevel(runLevel)
+                                                    .build());
+            if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
+                LOGGER.log(System.Logger.Level.DEBUG, "Starting services in run level: " + runLevel + ": ");
+                for (Object o : all) {
+                    LOGGER.log(System.Logger.Level.DEBUG, "\t" + o);
+                }
+            } else if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                LOGGER.log(System.Logger.Level.TRACE, "Starting services in run level: " + runLevel);
+            }
+        }
+    }
+
+    private List<Double> runLevels(ServiceRegistry registry) {
+        // child classes will have this method code generated at build time
+        return registry.lookupServices(Lookup.EMPTY)
+                .stream()
+                .map(ServiceInfo::runLevel)
+                .flatMap(Optional::stream)
+                .distinct()
+                .sorted()
+                .toList();
+    }
+
+    // higher than default, so we stop server as a service, not through shutdown
+    @Weight(Weighted.DEFAULT_WEIGHT + 10)
+    private static final class RegistryShutdownHandler implements HelidonShutdownHandler {
+        private final System.Logger logger;
+        private final ServiceRegistryManager registryManager;
+
+        private RegistryShutdownHandler(System.Logger logger, ServiceRegistryManager registryManager) {
+            this.logger = logger;
+            this.registryManager = registryManager;
+        }
+
+        @Override
+        public void shutdown() {
+            try {
+                registryManager.shutdown();
+            } catch (Exception e) {
+                logger.log(System.Logger.Level.ERROR,
+                           "Failed to shutdown Helidon Inject registry",
+                           e);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "Helidon Inject shutdown handler";
+        }
+    }
+}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
index 7abd5a5d6d0..9d71249b3e9 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceManager.java
@@ -30,12 +30,15 @@ class ServiceManager<T> {
     private final ServiceProvider<T> provider;
     private final boolean explicitInstance;
     private final Supplier<Activator<T>> activatorSupplier;
+    private final CoreServiceRegistry registry;
     private final Supplier<Scope> scopeSupplier;
 
-    ServiceManager(Supplier<Scope> scopeSupplier,
+    ServiceManager(CoreServiceRegistry registry,
+                   Supplier<Scope> scopeSupplier,
                    ServiceProvider<T> provider,
                    boolean explicitInstance,
                    Supplier<Activator<T>> activatorSupplier) {
+        this.registry = registry;
         this.scopeSupplier = scopeSupplier;
         this.provider = provider;
         this.explicitInstance = explicitInstance;
@@ -47,12 +50,14 @@ public String toString() {
         return provider.descriptor().serviceType().classNameWithEnclosingNames();
     }
 
-    void ensureInjectionPlan() {
+    void ensureBindingPlan() {
         if (explicitInstance) {
             // we do not need injection plan, if service was provided as an instance
             return;
         }
-        provider.injectionPlan();
+        registry.bindings()
+                .bindingPlan(provider.descriptor())
+                .ensure();
     }
 
     ServiceInstance<T> registryInstance(Lookup lookup, QualifiedInstance<T> instance) {
@@ -61,18 +66,10 @@ ServiceInstance<T> registryInstance(Lookup lookup, QualifiedInstance<T> instance
                                          instance);
     }
 
-    DependencyPlanBinder.Binder servicePlanBinder() {
-        return provider.servicePlanBinder();
-    }
-
     ServiceInfo descriptor() {
         return provider.descriptor();
     }
 
-    ServiceInfo injectDescriptor() {
-        return provider.descriptor();
-    }
-
     /*
     Get service activator for the scope it is in (always works for singleton, may fail for other)
     this provides an instance of an activator that is bound to a scope instance
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java b/service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
deleted file mode 100644
index dddad478bad..00000000000
--- a/service/registry/src/main/java/io/helidon/service/registry/ServicePlanBinder.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright (c) 2024 Oracle and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.helidon.service.registry;
-
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-import java.util.stream.Stream;
-
-import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupply;
-import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyList;
-import io.helidon.service.registry.ServiceSupplies.ServiceInstanceSupplyOptional;
-import io.helidon.service.registry.ServiceSupplies.ServiceSupply;
-import io.helidon.service.registry.ServiceSupplies.ServiceSupplyList;
-import io.helidon.service.registry.ServiceSupplies.ServiceSupplyOptional;
-
-class ServicePlanBinder implements DependencyPlanBinder.Binder {
-    private final Map<Dependency, IpPlan<?>> injectionPlan = new LinkedHashMap<>();
-
-    private final ServiceDescriptor<?> self;
-    private final Consumer<Map<Dependency, IpPlan<?>>> injectionPlanConsumer;
-    private final CoreServiceRegistry registry;
-
-    private ServicePlanBinder(CoreServiceRegistry registry,
-                              ServiceDescriptor<?> self,
-                              Consumer<Map<Dependency, IpPlan<?>>> injectionPlanConsumer) {
-        this.registry = registry;
-        this.self = self;
-        this.injectionPlanConsumer = injectionPlanConsumer;
-    }
-
-    static <T> DependencyPlanBinder.Binder create(CoreServiceRegistry registry,
-                                                  ServiceDescriptor<T> descriptor,
-                                                  Consumer<Map<Dependency, IpPlan<?>>> planConsumer) {
-        return new ServicePlanBinder(registry, descriptor, planConsumer);
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bind(Dependency dependency, ServiceInfo descriptor) {
-        if (descriptor == InstanceName__ServiceDescriptor.INSTANCE) {
-            injectionPlan.put(dependency, new IpPlan<>(new InstanceNameFailingSupplier(dependency), descriptor));
-        } else {
-            ServiceSupply<?> supply = new ServiceSupply<>(Lookup.create(dependency),
-                                                          List.of(registry.serviceManager(descriptor)));
-
-            injectionPlan.put(dependency, new IpPlan<>(supply, descriptor));
-        }
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindServiceInstance(Dependency dependency, ServiceInfo descriptor) {
-        var supply = new ServiceInstanceSupply<>(Lookup.create(dependency), List.of(registry.serviceManager(descriptor)));
-        injectionPlan.put(dependency, new IpPlan<>(supply, descriptor));
-
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindOptional(Dependency dependency, ServiceInfo... descriptors) {
-        ServiceSupplyOptional<?> supply = new ServiceSupplyOptional<>(Lookup.create(dependency),
-                                                                      toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindOptionalOfServiceInstance(Dependency dependency, ServiceInfo... descriptors) {
-        var supply = new ServiceInstanceSupplyOptional<>(Lookup.create(dependency),
-                                                         toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindList(Dependency dependency, ServiceInfo... descriptors) {
-        ServiceSupplyList<?> supply = new ServiceSupplyList<>(Lookup.create(dependency),
-                                                              toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindServiceInstanceList(Dependency dependency, ServiceInfo... descriptors) {
-        var supply = new ServiceInstanceSupplyList<>(Lookup.create(dependency),
-                                                     toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindSupplier(Dependency dependency, ServiceInfo descriptor) {
-        ServiceSupply<?> supply = new ServiceSupply<>(Lookup.create(dependency),
-                                                      toManagers(descriptor));
-
-        injectionPlan.put(dependency, new IpPlan<>(() -> supply, descriptor));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindSupplierOfOptional(Dependency dependency, ServiceInfo... descriptors) {
-        ServiceSupplyOptional<?> supply = new ServiceSupplyOptional<>(Lookup.create(dependency),
-                                                                      toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(() -> supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindSupplierOfList(Dependency dependency, ServiceInfo... descriptors) {
-        ServiceSupplyList<?> supply = new ServiceSupplyList<>(Lookup.create(dependency),
-                                                              toManagers(descriptors));
-
-        injectionPlan.put(dependency, new IpPlan<>(() -> supply, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindOptionalOfSupplier(Dependency dependency, ServiceInfo... descriptors) {
-        // we must resolve this right now, so we just use the first descriptor, and hope the user did not inject
-        // this in a wrong scope
-        ServiceSupply<?> supply = new ServiceSupply<>(Lookup.create(dependency),
-                                                      toManagers(descriptors[0]));
-        injectionPlan.put(dependency, new IpPlan<>(() -> Optional.of(supply), descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindListOfSuppliers(Dependency dependency, ServiceInfo... descriptors) {
-        Lookup lookup = Lookup.create(dependency);
-        // we must resolve the list right now (one for each descriptor)
-        List<ServiceSupply<Object>> supplies = Stream.of(descriptors)
-                .map(this::toManagers)
-                .map(it -> new ServiceSupply<>(lookup, it))
-                .toList();
-
-        injectionPlan.put(dependency, new IpPlan<>(() -> supplies, descriptors));
-        return this;
-    }
-
-    @Override
-    public DependencyPlanBinder.Binder bindNull(Dependency dependency) {
-        injectionPlan.put(dependency, new IpPlan<>(() -> null));
-        return this;
-    }
-
-    @Override
-    public void commit() {
-        injectionPlanConsumer.accept(Map.copyOf(injectionPlan));
-    }
-
-    @Override
-    public String toString() {
-        return "Service plan binder for " + self.serviceType();
-    }
-
-    private <T> List<ServiceManager<T>> toManagers(ServiceInfo... descriptors) {
-        List<ServiceManager<T>> result = new ArrayList<>();
-        for (ServiceInfo descriptor : descriptors) {
-            result.add(registry.serviceManager(descriptor));
-        }
-        return result;
-    }
-
-    private static final class InstanceNameFailingSupplier implements Supplier<Object> {
-        private final Dependency dependency;
-
-        private InstanceNameFailingSupplier(Dependency dependency) {
-            this.dependency = dependency;
-        }
-
-        @Override
-        public Object get() {
-            throw new ServiceRegistryException(
-                    "@" + Service.InstanceName.class.getName()
-                            + "should have been resolved to correct name during lookup for "
-                            + dependency);
-        }
-    }
-}
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
index bf2d5a25c13..cd005cd5c46 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceProvider.java
@@ -16,14 +16,10 @@
 
 package io.helidon.service.registry;
 
-import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
 
 import io.helidon.common.types.ResolvedType;
-import io.helidon.common.types.TypeName;
 
 /**
  * Takes care of a single service descriptor.
@@ -31,14 +27,11 @@
  * @param <T> type of the provided service
  */
 class ServiceProvider<T> {
-    private final CoreServiceRegistry registry;
-    private final ServiceInfo serviceInfo;
     private final ServiceDescriptor<T> descriptor;
 
     private final ActivationRequest activationRequest;
     private final InterceptionMetadata interceptionMetadata;
     private final Contracts.ContractLookup contracts;
-    private volatile Map<Dependency, IpPlan<?>> injectionPlan = null;
 
     ServiceProvider(CoreServiceRegistry serviceRegistry,
                     ServiceDescriptor<T> descriptor) {
@@ -46,10 +39,8 @@ class ServiceProvider<T> {
         Objects.requireNonNull(serviceRegistry);
         Objects.requireNonNull(descriptor);
 
-        this.registry = serviceRegistry;
-        this.interceptionMetadata = registry.interceptionMetadata();
-        this.activationRequest = registry.activationRequest();
-        this.serviceInfo = descriptor;
+        this.interceptionMetadata = serviceRegistry.interceptionMetadata();
+        this.activationRequest = serviceRegistry.activationRequest();
         this.descriptor = descriptor;
 
         this.contracts = Contracts.create(descriptor);
@@ -57,31 +48,13 @@ class ServiceProvider<T> {
 
     @Override
     public String toString() {
-        return "ServiceProvider for " + serviceInfo.serviceType().fqName();
-    }
-
-    ServiceInfo serviceInfo() {
-        return serviceInfo;
+        return "ServiceProvider for " + descriptor.serviceType().fqName();
     }
 
     ServiceDescriptor<T> descriptor() {
         return descriptor;
     }
 
-    DependencyPlanBinder.Binder servicePlanBinder() {
-        return ServicePlanBinder.create(registry, descriptor, it -> this.injectionPlan = it);
-    }
-
-    Map<Dependency, IpPlan<?>> injectionPlan() {
-        Map<Dependency, IpPlan<?>> usedIp = injectionPlan;
-        if (usedIp == null) {
-            // no application, we have to create injection plan from current services
-            usedIp = createInjectionPlan();
-            this.injectionPlan = usedIp;
-        }
-        return usedIp;
-    }
-
     InterceptionMetadata interceptionMetadata() {
         return interceptionMetadata;
     }
@@ -93,117 +66,4 @@ Set<ResolvedType> contracts(Lookup lookup) {
     ActivationRequest activationRequest() {
         return activationRequest;
     }
-
-    private Map<Dependency, IpPlan<?>> createInjectionPlan() {
-        // for core services, we must use Dependency, for inject services, we must use Dependency
-        List<? extends Dependency> dependencies = descriptor.dependencies();
-
-        if (dependencies.isEmpty()) {
-            return Map.of();
-        }
-
-        AtomicReference<Map<Dependency, IpPlan<?>>> injectionPlan = new AtomicReference<>();
-
-        DependencyPlanBinder.Binder binder = ServicePlanBinder.create(registry,
-                                                                      descriptor,
-                                                                      injectionPlan::set);
-        for (Dependency injectionPoint : dependencies) {
-            planForIp(binder, injectionPoint);
-        }
-
-        binder.commit();
-
-        return injectionPlan.get();
-    }
-
-    private void planForIp(DependencyPlanBinder.Binder injectionPlan,
-                           Dependency injectionPoint) {
-        /*
-         very similar code is used in ApplicationCreator.buildTimeBinding
-         make sure this is kept in sync!
-         */
-        Lookup lookup = Lookup.create(injectionPoint);
-
-        if (descriptor.contracts().containsAll(lookup.contracts())
-                && descriptor.qualifiers().equals(lookup.qualifiers())) {
-            // injection point lookup must have a single contract for each injection point
-            // if this service implements the contracts actually required, we must look for services with lower weight
-            // but only if we also have the same qualifiers
-            lookup = Lookup.builder(lookup)
-                    .weight(descriptor.weight())
-                    .build();
-        }
-
-        List<ServiceInfo> discovered = registry.lookupServices(lookup)
-                .stream()
-                .filter(it -> it != descriptor)
-                .toList();
-
-        /*
-        Very similar code is used for build time code generation in ApplicationCreator.buildTimeBinding
-        make sure this is kept in sync!
-         */
-        TypeName ipType = injectionPoint.typeName();
-
-        // now there are a few options - optional, list, and single instance
-        if (ipType.isList()) {
-            ServiceInfo[] descriptors = discovered.toArray(new ServiceInfo[0]);
-            TypeName typeOfList = ipType.typeArguments().getFirst();
-            if (typeOfList.isSupplier()) {
-                // inject List<Supplier<Contract>>
-                injectionPlan.bindListOfSuppliers(injectionPoint, descriptors);
-            } else if (typeOfList.equals(ServiceInstance.TYPE)) {
-                injectionPlan.bindServiceInstanceList(injectionPoint, descriptors);
-            } else {
-                // inject List<Contract>
-                injectionPlan.bindList(injectionPoint, descriptors);
-            }
-        } else if (ipType.isOptional()) {
-            // inject Optional<Contract>
-            if (discovered.isEmpty()) {
-                injectionPlan.bindOptional(injectionPoint);
-            } else {
-                TypeName typeOfOptional = ipType.typeArguments().getFirst();
-                if (typeOfOptional.isSupplier()) {
-                    injectionPlan.bindOptionalOfSupplier(injectionPoint, discovered.getFirst());
-                } else if (typeOfOptional.equals(ServiceInstance.TYPE)) {
-                    injectionPlan.bindOptionalOfServiceInstance(injectionPoint, discovered.getFirst());
-                } else {
-                    injectionPlan.bindOptional(injectionPoint, discovered.getFirst());
-                }
-            }
-        } else if (ipType.isSupplier()) {
-            // one of the supplier options
-            TypeName typeOfSupplier = ipType.typeArguments().getFirst();
-            if (typeOfSupplier.isOptional()) {
-                // inject Supplier<Optional<Contract>>
-                injectionPlan.bindSupplierOfOptional(injectionPoint, discovered.toArray(new ServiceInfo[0]));
-            } else if (typeOfSupplier.isList()) {
-                // inject Supplier<List<Contract>>
-                injectionPlan.bindSupplierOfList(injectionPoint, discovered.toArray(new ServiceInfo[0]));
-            } else {
-                // inject Supplier<Contract>
-                if (discovered.isEmpty()) {
-                    // null binding is not supported at runtime
-                    throw new ServiceRegistryException(injectionPoint.service().fqName()
-                                                               + ": expected to resolve a service matching injection point "
-                                                               + injectionPoint);
-                }
-                injectionPlan.bindSupplier(injectionPoint, discovered.getFirst());
-            }
-        } else {
-            // inject Contract
-            if (discovered.isEmpty()) {
-                // null binding is not supported at runtime
-                throw new ServiceRegistryException(injectionPoint.service().fqName()
-                                                   + ": expected to resolve a service matching injection point "
-                                                           + injectionPoint);
-            }
-            if (ipType.equals(ServiceInstance.TYPE)) {
-                injectionPlan.bindServiceInstance(injectionPoint, discovered.getFirst());
-            } else {
-                injectionPlan.bind(injectionPoint, discovered.getFirst());
-            }
-        }
-    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
index 3c79e6968ba..4e8891d21b5 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryConfigBlueprint.java
@@ -117,9 +117,10 @@ interface ServiceRegistryConfigBlueprint {
 
     /**
      * Flag indicating whether compile-time generated {@link io.helidon.service.registry.Binding}'s
-     * should be used at initialization.
-     * Even if set to {@code true}, this is effective only if an {@link io.helidon.service.registry.Binding}
-     * was generated using Helidon Service Maven Plugin.
+     * should be used at initialization when starting the registry using
+     * {@link io.helidon.service.registry.ServiceRegistryManager#start(Binding)}.
+     * <p>
+     * This option is ignored when starting the service registry in any other way.
      *
      * @return the flag indicating whether the provider is permitted to use binding generated code from compile-time,
      *         defaults to {@code true}
@@ -127,4 +128,29 @@ interface ServiceRegistryConfigBlueprint {
      */
     @Option.DefaultBoolean(true)
     boolean useBinding();
+
+    /**
+     * Maximal run level to handle when starting from {@link io.helidon.service.registry.ServiceRegistryManager#start(Binding)}.
+     * This setting is ignored when starting registry using
+     * other means, as run levels are not handled by default.
+     *
+     * @return maximal run level to lookup during application startup when using generated binding
+     */
+    @Option.DefaultDouble(Double.MAX_VALUE)
+    double maxRunLevel();
+
+    /**
+     * Run levels that should be initialized at startup.
+     * Generated {@link io.helidon.service.registry.Binding} will configure all declared run levels of services in the
+     * application.
+     * <p>
+     * Note that the result WILL be ordered before use, so initialization will always be handled from the smallest run level
+     * to the highest.
+     *
+     * @return run levels to initialize, up to {@link #maxRunLevel()}, only used when starting the registry through
+     * {@link io.helidon.service.registry.ServiceRegistryManager#start(Binding)}
+     * or {@link io.helidon.service.registry.ServiceRegistryManager#start(Binding, ServiceRegistryConfig)}
+     */
+    @Option.Singular
+    List<Double> runLevels();
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 9d1f32e4b3c..2b863aea3ec 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -31,11 +31,9 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-import io.helidon.common.types.Annotation;
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
-import io.helidon.common.types.TypedElementInfo;
 import io.helidon.service.metadata.DescriptorMetadata;
 
 /**
@@ -63,7 +61,6 @@ public final class ServiceRegistryManager {
             })
             .thenComparing(ServiceInfo::serviceType);
     private static final System.Logger LOGGER = System.getLogger(ServiceRegistryManager.class.getName());
-    private static final InterceptionMetadata NO_OP_INTERCEPT_META = new NoOpInterceptMeta();
 
     private final ReentrantReadWriteLock lifecycleLock = new ReentrantReadWriteLock();
     private final ServiceRegistryConfig config;
@@ -76,6 +73,71 @@ public final class ServiceRegistryManager {
         this.discovery = serviceDiscovery;
     }
 
+    /**
+     * Create a new manager based on the provided binding (usually code generated), and start the service registry
+     * services according to the configured run levels. Honor configured options.
+     * <p>
+     * Configuration options are handled as follows:
+     * <ul>
+     *     <li>{@link ServiceRegistryConfig#runLevels()} - if any run level is configured, it is honored; if no run levels
+     *          are configured (the default), run levels are updated from generated bindings; to disable any run levels, set
+     *          the {@link ServiceRegistryConfig#maxRunLevel()} to 0</li>
+     *     <li>{@link ServiceRegistryConfig#discoverServices()} - honored as configured; as default is {@code true},
+     *     we recommend you set this to {@code false}, as all services should be registered explicitly via the generated
+     *     binding</li>
+     *     <li>{@link ServiceRegistryConfig#serviceDescriptors()} - honored, and additional descriptors are added via the
+     *     generated binding; usually this should not be configured by hand, as there should not be additional descriptors
+     *     that were not discovered by the plugin that generates build time binding</li>
+     *     <li>All other configuration options are honored as configured, and not updated</li>
+     * </ul>
+     *
+     * @param binding generated binding
+     * @param config  configuration to use (see rules above)
+     * @return a new registry manager with an initialized registry
+     */
+    public static ServiceRegistryManager start(Binding binding, ServiceRegistryConfig config) {
+        ServiceRegistryConfig.Builder configBuilder = ServiceRegistryConfig.builder(config)
+                .update(binding::configure);
+
+        if (!config.runLevels().isEmpty()) {
+            configBuilder.runLevels(config.runLevels());
+        }
+
+        ServiceRegistryConfig updatedConfig = configBuilder.build();
+        ServiceRegistryManager manager = create(updatedConfig);
+
+        return boundManager(binding, updatedConfig, manager);
+    }
+
+    /**
+     * Start the service registry with no generated binding with the provided config.
+     * This method honors {@link ServiceRegistryConfig#maxRunLevel()} and {@link ServiceRegistryConfig#runLevels()}
+     * to initialize services that fit.
+     *
+     * @param config configuration of the service registry
+     * @return a new registry manager with initialized registry
+     */
+    public static ServiceRegistryManager start(ServiceRegistryConfig config) {
+        return start(new NoOpBinding(), config);
+    }
+
+    /**
+     * Create a new manager based on the provided binding (usually code generated), and start the service registry
+     * services according to the configured run levels.
+     *
+     * @param binding generated binding
+     * @return a new registry manager with an initialized registry
+     */
+    public static ServiceRegistryManager start(Binding binding) {
+        ServiceRegistryConfig config = ServiceRegistryConfig.builder()
+                .discoverServices(false)
+                .update(binding::configure)
+                .build();
+
+        ServiceRegistryManager manager = create(config);
+        return boundManager(binding, config, manager);
+    }
+
     /**
      * Create a new service registry manager with default configuration.
      *
@@ -104,8 +166,90 @@ public static ServiceRegistryManager create(ServiceRegistryConfig config) {
      *
      * @return service registry ready to be used
      */
-    @SuppressWarnings("checkstyle:methodLength") // already condensed; further extraction would decrease readability
     public ServiceRegistry registry() {
+        return registry(new NoOpBinding());
+    }
+
+    /**
+     * Shutdown the managed service registry.
+     */
+    public void shutdown() {
+        Lock lock = lifecycleLock.writeLock();
+        try {
+            lock.lock();
+            if (registry == null) {
+                // registry was never requested,
+                return;
+            }
+
+            registry.shutdown();
+            registry = null;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static ServiceRegistryManager boundManager(Binding binding,
+                                                       ServiceRegistryConfig config,
+                                                       ServiceRegistryManager manager) {
+        ServiceRegistry registry = manager.registry(binding);
+        GlobalServiceRegistry.registry(registry);
+
+        double maxRunLevel = config.maxRunLevel();
+        List<Double> runLevels = new ArrayList<>(config.runLevels());
+        Collections.sort(runLevels);
+        for (Double runLevel : runLevels) {
+            if (runLevel > maxRunLevel) {
+                // no more
+                break;
+            }
+
+            List<Object> all = registry.all(Lookup.builder()
+                                                    .addScope(Service.Singleton.TYPE)
+                                                    .runLevel(runLevel)
+                                                    .build());
+            if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
+                LOGGER.log(System.Logger.Level.DEBUG, "Starting services in run level: " + runLevel + ": ");
+                for (Object o : all) {
+                    LOGGER.log(System.Logger.Level.DEBUG, "\t" + o);
+                }
+            } else if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                LOGGER.log(System.Logger.Level.TRACE, "Starting services in run level: " + runLevel);
+            }
+        }
+
+        return manager;
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static ServiceDescriptor<?> virtualDescriptor(ServiceRegistryConfig config,
+                                                          ServiceDiscovery discovery,
+                                                          ServiceDescriptor<?> descriptor) {
+        TypeName serviceType = descriptor.serviceType();
+        var fromConfig = config.serviceDescriptors()
+                .stream()
+                .filter(registered -> registered.serviceType().equals(serviceType))
+                .findFirst();
+
+        if (fromConfig.isPresent()) {
+            return fromConfig.get();
+        }
+
+        return discovery.allMetadata()
+                .stream()
+                .filter(handler -> contains(handler.contracts(), serviceType))
+                .map(DescriptorHandler::descriptor)
+                .filter(desc -> desc.serviceType().equals(serviceType))
+                .findFirst()
+                .map(it -> (ServiceDescriptor) it)
+                .orElse(descriptor);
+    }
+
+    private static boolean contains(Set<ResolvedType> contracts, TypeName type) {
+        return contracts.stream().anyMatch(it -> it.type().equals(type));
+    }
+
+    private ServiceRegistry registry(Binding binding) {
         Lock readLock = lifecycleLock.readLock();
         try {
             readLock.lock();
@@ -138,8 +282,6 @@ public ServiceRegistry registry() {
             Map<TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders =
                     new HashMap<>();
 
-            List<ServiceDescriptor<Binding>> bindings = new ArrayList<>();
-
             config.serviceInstances()
                     .forEach((desc, instance) -> {
                         var descriptor = desc;
@@ -149,8 +291,7 @@ public ServiceRegistry registry() {
                         }
 
                         descriptors.add(descriptor);
-                        bind(bindings,
-                             scopeHandlers,
+                        bind(scopeHandlers,
                              servicesByType,
                              servicesByContract,
                              qualifiedProvidersByQualifier,
@@ -161,8 +302,7 @@ public ServiceRegistry registry() {
 
             for (var descriptor : config.serviceDescriptors()) {
                 descriptors.add(descriptor);
-                bind(bindings,
-                     scopeHandlers,
+                bind(scopeHandlers,
                      servicesByType,
                      servicesByContract,
                      qualifiedProvidersByQualifier,
@@ -184,19 +324,14 @@ public ServiceRegistry registry() {
                 }
 
                 ServiceDescriptor<?> descriptor = descriptorMeta.descriptor();
-                if (contains(descriptor.contracts(), Binding.TYPE)) {
-                    bindings.add((ServiceDescriptor<Binding>) descriptor);
-                    // applications are not bound to the registry
-                } else {
-                    descriptors.add(descriptor);
-                    bind(bindings,
-                         scopeHandlers,
-                         servicesByType,
-                         servicesByContract,
-                         qualifiedProvidersByQualifier,
-                         typedQualifiedProviders,
-                         descriptor);
-                }
+
+                descriptors.add(descriptor);
+                bind(scopeHandlers,
+                     servicesByType,
+                     servicesByContract,
+                     qualifiedProvidersByQualifier,
+                     typedQualifiedProviders,
+                     descriptor);
             }
 
             // add service registry information (service registry cannot be overridden in any way)
@@ -206,8 +341,7 @@ public ServiceRegistry registry() {
             descriptors.add(scopesDescriptor);
             descriptors.add(registryDescriptor);
 
-            bind(bindings,
-                 scopeHandlers,
+            bind(scopeHandlers,
                  servicesByType,
                  servicesByContract,
                  qualifiedProvidersByQualifier,
@@ -217,8 +351,7 @@ public ServiceRegistry registry() {
             ServiceDescriptor<?> interceptDescriptor = InterceptionMetadata__ServiceDescriptor.INSTANCE;
             descriptors.add(interceptDescriptor);
 
-            bind(bindings,
-                 scopeHandlers,
+            bind(scopeHandlers,
                  servicesByType,
                  servicesByContract,
                  qualifiedProvidersByQualifier,
@@ -246,14 +379,8 @@ public ServiceRegistry registry() {
                                                typedQualifiedProviders,
                                                accessedContracts);
 
-            // now check if we have an application, and if so, apply it
             if (config.useBinding()) {
-                for (ServiceDescriptor<Binding> binding : bindings) {
-                    // applications cannot have dependencies
-                    Binding bindingInstance = (Binding) binding.instantiate(DependencyContext.create(Map.of()),
-                                                                            NO_OP_INTERCEPT_META);
-                    bindingInstance.configure(new ApplicationPlanBinder(bindingInstance, registry));
-                }
+                binding.binding(new ApplicationPlanBinder(binding, registry));
             }
 
             // and if application was not bound using binding(s), we need to create the bindings now
@@ -265,67 +392,13 @@ public ServiceRegistry registry() {
         }
     }
 
-    /**
-     * Shutdown the managed service registry.
-     */
-    public void shutdown() {
-        Lock lock = lifecycleLock.writeLock();
-        try {
-            lock.lock();
-            if (registry == null) {
-                // registry was never requested,
-                return;
-            }
-
-            registry.shutdown();
-            registry = null;
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    @SuppressWarnings("rawtypes")
-    private static ServiceDescriptor<?> virtualDescriptor(ServiceRegistryConfig config,
-                                                          ServiceDiscovery discovery,
-                                                          ServiceDescriptor<?> descriptor) {
-        TypeName serviceType = descriptor.serviceType();
-        var fromConfig = config.serviceDescriptors()
-                .stream()
-                .filter(registered -> registered.serviceType().equals(serviceType))
-                .findFirst();
-        if (fromConfig.isPresent()) {
-            return fromConfig.get();
-        }
-
-        return discovery.allMetadata()
-                .stream()
-                .filter(handler -> contains(handler.contracts(), serviceType))
-                .map(DescriptorHandler::descriptor)
-                .filter(desc -> desc.serviceType().equals(serviceType))
-                .findFirst()
-                .map(it -> (ServiceDescriptor) it)
-                .orElse(descriptor);
-    }
-
-    private static boolean contains(Set<ResolvedType> contracts, TypeName type) {
-        return contracts.stream().anyMatch(it -> it.type().equals(type));
-    }
-
-    @SuppressWarnings("unchecked")
-    private void bind(List<ServiceDescriptor<Binding>> bindings,
-                      Map<TypeName, ServiceInfo> scopeHandlers,
+    private void bind(Map<TypeName, ServiceInfo> scopeHandlers,
                       Map<TypeName, ServiceInfo> servicesByType,
                       Map<ResolvedType, Set<ServiceInfo>> servicesByContract,
                       Map<TypeName, Set<ServiceInfo>> qualifiedProvidersByQualifier,
                       Map<TypedQualifiedProviderKey, Set<ServiceInfo>> typedQualifiedProviders,
                       ServiceDescriptor<?> descriptor) {
 
-        if (contains(descriptor.contracts(), Binding.TYPE)) {
-            bindings.add((ServiceDescriptor<Binding>) descriptor);
-            // application is not bound to the registry
-            return;
-        }
-
         if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
             if (descriptor instanceof ServiceLoader__ServiceDescriptor sl) {
                 LOGGER.log(System.Logger.Level.TRACE,
@@ -418,21 +491,23 @@ private static class ApplicationPlanBinder implements DependencyPlanBinder {
 
         private final Binding appInstance;
         private final CoreServiceRegistry registry;
+        private final Bindings bindings;
 
         private ApplicationPlanBinder(Binding appInstance, CoreServiceRegistry registry) {
             this.appInstance = appInstance;
             this.registry = registry;
+            this.bindings = registry.bindings();
         }
 
         @Override
-        public Binder bindTo(ServiceInfo descriptor) {
-            ServiceManager<Object> serviceManager = registry.serviceManager(descriptor);
+        public Binder service(ServiceInfo descriptor) {
+            Bindings.ServiceBindingPlan serviceBindingPlan = bindings.bindingPlan(descriptor);
 
             if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                LOGGER.log(System.Logger.Level.DEBUG, "binding injection plan to " + serviceManager);
+                LOGGER.log(System.Logger.Level.DEBUG, "binding injection plan to " + descriptor.serviceType().fqName());
             }
 
-            return serviceManager.servicePlanBinder();
+            return new ServiceBinder(serviceBindingPlan);
         }
 
         @Override
@@ -444,28 +519,36 @@ public void interceptors(ServiceInfo... descriptors) {
         public String toString() {
             return "Service binder for application: " + appInstance.name();
         }
+
+        private static class ServiceBinder implements Binder {
+            private final Bindings.ServiceBindingPlan serviceBindingPlan;
+
+            ServiceBinder(Bindings.ServiceBindingPlan serviceBindingPlan) {
+                this.serviceBindingPlan = serviceBindingPlan;
+            }
+
+            @Override
+            public Binder bind(Dependency dependency, ServiceInfo... descriptor) {
+                serviceBindingPlan.binding(dependency)
+                        .bind(List.of(descriptor));
+
+                return this;
+            }
+        }
     }
 
-    private static class NoOpInterceptMeta implements InterceptionMetadata {
+    private static class NoOpBinding implements Binding {
+        @Override
+        public String name() {
+            return "no-op";
+        }
+
         @Override
-        public <T> InterceptionInvoker<T> createInvoker(ServiceInfo descriptor,
-                                                        Set<Qualifier> typeQualifiers,
-                                                        List<Annotation> typeAnnotations,
-                                                        TypedElementInfo element,
-                                                        InterceptionInvoker<T> targetInvoker,
-                                                        Set<Class<? extends Throwable>> checkedExceptions) {
-            return targetInvoker;
+        public void binding(DependencyPlanBinder binder) {
         }
 
         @Override
-        public <T> InterceptionInvoker<T> createInvoker(Object serviceInstance,
-                                                        ServiceInfo descriptor,
-                                                        Set<Qualifier> typeQualifiers,
-                                                        List<Annotation> typeAnnotations,
-                                                        TypedElementInfo element,
-                                                        InterceptionInvoker<T> targetInvoker,
-                                                        Set<Class<? extends Throwable>> checkedExceptions) {
-            return targetInvoker;
+        public void configure(ServiceRegistryConfig.Builder builder) {
         }
     }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
index 7d0977a4cee..dc55ae4e269 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
@@ -54,7 +54,29 @@ private static <T> List<ServiceInstance<T>> explodeFilterAndSort(Lookup lookup,
             result.addAll(thisManager);
         }
 
-        result.sort(RegistryInstanceComparator.instance());
+        if (result.isEmpty() || result.size() == 1) {
+            traceLookupInstances(lookup, result);
+            return List.copyOf(result);
+        }
+
+        /*
+        The instances are now ordered by weight of the service providers (implementation or factory)
+        We now need to update the ordering, to put unqualified instances first (unless a qualified lookup was done)
+        We cannot re-order them using the usual comparator, as the weight of the instance is never set
+         */
+        if (lookup.qualifiers().isEmpty()) {
+            List<ServiceInstance<T>> unqualified = new ArrayList<>();
+            List<ServiceInstance<T>> qualified = new ArrayList<>();
+            for (ServiceInstance<T> instance : result) {
+                if (instance.qualifiers().isEmpty()) {
+                    unqualified.add(instance);
+                } else {
+                    qualified.add(instance);
+                }
+            }
+            unqualified.addAll(qualified);
+            result = unqualified;
+        }
 
         traceLookupInstances(lookup, result);
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java b/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java
new file mode 100644
index 00000000000..efeb7b1b479
--- /dev/null
+++ b/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java
@@ -0,0 +1,18 @@
+package io.helidon.service.registry;
+
+import java.util.Map;
+import java.util.function.Supplier;
+
+class SupplierDependencyContext implements DependencyContext {
+    private final Map<Dependency, Supplier<Object>> dependencyPlan;
+
+    SupplierDependencyContext(Map<Dependency, Supplier<Object>> dependencyPlan) {
+        this.dependencyPlan = dependencyPlan;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T dependency(Dependency dependency) {
+        return (T) dependencyPlan.get(dependency).get();
+    }
+}
diff --git a/service/registry/src/main/java/module-info.java b/service/registry/src/main/java/module-info.java
index c3e620f291a..46e95c92d74 100644
--- a/service/registry/src/main/java/module-info.java
+++ b/service/registry/src/main/java/module-info.java
@@ -32,9 +32,13 @@
 
     requires io.helidon.service.metadata;
     requires io.helidon.metadata.hson;
+    requires io.helidon;
 
     requires transitive io.helidon.builder.api;
     requires transitive io.helidon.common.types;
 
     exports io.helidon.service.registry;
+
+    provides io.helidon.spi.HelidonStartupProvider
+            with io.helidon.service.registry.RegistryStartupProvider;
 }
\ No newline at end of file
diff --git a/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java b/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
index 923c13cfaf1..bb6b76fa664 100644
--- a/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
+++ b/service/tests/codegen/src/test/java/io/helidon/service/tests/codegen/ServiceCodegenTypesTest.java
@@ -34,6 +34,7 @@
 import io.helidon.service.codegen.ServiceCodegenTypes;
 import io.helidon.service.registry.Binding;
 import io.helidon.service.registry.Dependency;
+import io.helidon.service.registry.DependencyCardinality;
 import io.helidon.service.registry.DependencyContext;
 import io.helidon.service.registry.DependencyPlanBinder;
 import io.helidon.service.registry.Event;
@@ -45,9 +46,11 @@
 import io.helidon.service.registry.InterceptionInvoker;
 import io.helidon.service.registry.InterceptionMetadata;
 import io.helidon.service.registry.Qualifier;
+import io.helidon.service.registry.RegistryStartupProvider;
 import io.helidon.service.registry.Service;
 import io.helidon.service.registry.ServiceDescriptor;
 import io.helidon.service.registry.ServiceInstance;
+import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.ServiceRegistryConfig;
 import io.helidon.service.registry.ServiceRegistryManager;
@@ -93,6 +96,7 @@ void testTypes() {
         checkField(toCheck, checked, fields, "SERVICE_DEPENDENCY", Dependency.class);
         checkField(toCheck, checked, fields, "SERVICE_DEPENDENCY_CONTEXT", DependencyContext.class);
         checkField(toCheck, checked, fields, "SERVICE_DESCRIPTOR", ServiceDescriptor.class);
+        checkField(toCheck, checked, fields, "REGISTRY_STARTUP_PROVIDER", RegistryStartupProvider.class);
 
         checkField(toCheck, checked, fields, "BUILDER_BLUEPRINT", Prototype.Blueprint.class);
         checkField(toCheck, checked, fields, "GENERATED_ANNOTATION", Generated.class);
@@ -114,8 +118,11 @@ void testTypes() {
         checkField(toCheck, checked, fields, "SERVICE_QUALIFIED_FACTORY", Service.QualifiedFactory.class);
 
         checkField(toCheck, checked, fields, "SERVICE_CONFIG", ServiceRegistryConfig.class);
+        checkField(toCheck, checked, fields, "SERVICE_CONFIG_BUILDER", ServiceRegistryConfig.Builder.class);
         checkField(toCheck, checked, fields, "SERVICE_REGISTRY", ServiceRegistry.class);
         checkField(toCheck, checked, fields, "SERVICE_REGISTRY_MANAGER", ServiceRegistryManager.class);
+        checkField(toCheck, checked, fields, "DEPENDENCY_CARDINALITY", DependencyCardinality.class);
+        checkField(toCheck, checked, fields, "SERVICE_LOADER_DESCRIPTOR", ServiceLoader__ServiceDescriptor.class);
 
         // api.Interception.*
         checkField(toCheck, checked, fields, "INTERCEPTION_INTERCEPTED", Interception.Intercepted.class);
@@ -169,6 +176,10 @@ void testTypes() {
                 .type(List.class)
                 .addTypeArgument(TypeName.create(Dependency.class))
                 .build());
+        checkField(toCheck, checked, fields, "LIST_OF_DOUBLES", TypeName.builder()
+                .type(List.class)
+                .addTypeArgument(TypeName.create(Double.class))
+                .build());
         checkField(toCheck, checked, fields, "SET_OF_QUALIFIERS", TypeName.builder()
                 .type(Set.class)
                 .addTypeArgument(TypeName.create(Qualifier.class))
diff --git a/service/tests/maven-plugin/src/it/projects/test1/pom.xml b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
index 5f7b01e6f61..475692cf740 100644
--- a/service/tests/maven-plugin/src/it/projects/test1/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
@@ -81,6 +81,7 @@
                 </dependencies>
                 <configuration>
                     <failOnWarning>true</failOnWarning>
+                    <generateMain>true</generateMain>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/service/tests/maven-plugin/src/it/projects/test2/pom.xml b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
index 4e13b33360d..8b2a5732465 100644
--- a/service/tests/maven-plugin/src/it/projects/test2/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
@@ -80,6 +80,7 @@
                     </dependency>
                 </dependencies>
                 <configuration>
+                    <generateMain>true</generateMain>
                     <packageName>my.updated</packageName>
                     <mainClassName>UpdatedMain</mainClassName>
                     <bindingClassName>UpdatedBinding</bindingClassName>
diff --git a/service/tests/maven-plugin/src/it/projects/test3/pom.xml b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
index ecb517ed452..2abe8151597 100644
--- a/service/tests/maven-plugin/src/it/projects/test3/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
@@ -81,7 +81,6 @@
                 </dependencies>
                 <configuration>
                     <generateBinding>false</generateBinding>
-                    <generateMain>false</generateMain>
                     <failOnWarning>true</failOnWarning>
                 </configuration>
             </plugin>
diff --git a/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java b/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
index e3782e06c1f..878909e5961 100644
--- a/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
+++ b/service/tests/maven-plugin/src/test/java/io/helidon/service/tests/inject/maven/plugin/ProjectsTestIT.java
@@ -42,28 +42,26 @@ void test1(String basedir) {
         Path compiledClasses = projectPath.resolve("target/classes/my/module");
         Path generatedSources = projectPath.resolve("target/generated-sources/annotations/my/module");
 
-        assertThat("Generated by the Maven plugin", generatedSources.resolve("Injection__Binding.java"), fileExists());
-        assertThat("Generated by the Maven plugin",
-                   generatedSources.resolve("Injection__Binding__ServiceDescriptor.java"),
-                   fileExists());
+        assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationBinding.java"), fileExists());
+        assertThat("Should nto be generated by the Maven plugin",
+                   generatedSources.resolve("ApplicationBinding__ServiceDescriptor.java"),
+                   not(fileExists()));
         assertThat("Generated by the service inject codegen during compilation",
                    generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
                    fileExists());
-        // Main class not yet ready
-        // assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationMain.java"), fileExists());
+        assertThat("Generated by the Maven plugin", generatedSources.resolve("ApplicationMain.java"), fileExists());
         assertThat("Not a generated type, exists in project sources only",
                    generatedSources.resolve("ServiceType.java"),
                    not(fileExists()));
 
-        assertThat("Generated by the Maven plugin", compiledClasses.resolve("Injection__Binding.class"), fileExists());
-        assertThat("Generated by the Maven plugin",
-                   compiledClasses.resolve("Injection__Binding__ServiceDescriptor.class"),
-                   fileExists());
+        assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationBinding.class"), fileExists());
+        assertThat("Should nto be generated by the Maven plugin",
+                   generatedSources.resolve("ApplicationBinding__ServiceDescriptor.java"),
+                   not(fileExists()));
         assertThat("Generated by the service inject codegen during compilation",
                    compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
                    fileExists());
-        // Main class not yet ready
-        // assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationMain.class"), fileExists());
+        assertThat("Generated by the Maven plugin", compiledClasses.resolve("ApplicationMain.class"), fileExists());
         assertThat("Compiled service", compiledClasses.resolve("ServiceType.class"), fileExists());
 
     }
@@ -85,11 +83,10 @@ void test2(String basedir) {
                    fileExists());
         assertThat("Generated by the Maven plugin",
                    generatedCustomSources.resolve("UpdatedBinding__ServiceDescriptor.java"),
+                   not(fileExists()));
+        assertThat("Generated by the Maven plugin",
+                   generatedCustomSources.resolve("UpdatedMain.java"),
                    fileExists());
-        // Main class not yet ready
-        //        assertThat("Generated by the Maven plugin",
-        //                   generatedCustomSources.resolve("UpdatedMain.java"),
-        //                   fileExists());
         assertThat("Generated by the service inject codegen during compilation",
                    generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
                    fileExists());
@@ -102,11 +99,10 @@ void test2(String basedir) {
                    fileExists());
         assertThat("Generated by the Maven plugin",
                    compiledCustomClasses.resolve("UpdatedBinding__ServiceDescriptor.class"),
+                   not(fileExists()));
+        assertThat("Generated by the Maven plugin",
+                   compiledCustomClasses.resolve("UpdatedMain.class"),
                    fileExists());
-        // Main class not yet ready
-        //        assertThat("Generated by the Maven plugin",
-        //                   compiledCustomClasses.resolve("UpdatedMain.class"),
-        //                   fileExists());
         assertThat("Generated by the service inject codegen during compilation",
                    compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
                    fileExists());
@@ -125,10 +121,10 @@ void test3(String basedir) {
         Path generatedSources = projectPath.resolve("target/generated-sources/annotations/my/module");
 
         assertThat("Should not be generated by the Maven plugin",
-                   generatedSources.resolve("Injection__Binding.java"),
+                   generatedSources.resolve("ApplicationBinding.java"),
                    not(fileExists()));
         assertThat("Should nto be generated by the Maven plugin",
-                   generatedSources.resolve("Injection__Binding__ServiceDescriptor.java"),
+                   generatedSources.resolve("ApplicationBinding__ServiceDescriptor.java"),
                    not(fileExists()));
         assertThat("Generated by the service inject codegen during compilation",
                    generatedSources.resolve("ServiceType__ServiceDescriptor.java"),
@@ -141,10 +137,10 @@ void test3(String basedir) {
                    not(fileExists()));
 
         assertThat("Should not be generated by the Maven plugin",
-                   compiledClasses.resolve("Injection__Binding.class"),
+                   compiledClasses.resolve("ApplicationBinding.class"),
                    not(fileExists()));
         assertThat("Should nto be generated by the Maven plugin",
-                   compiledClasses.resolve("Injection__Binding__ServiceDescriptor.class"),
+                   compiledClasses.resolve("ApplicationBinding__ServiceDescriptor.class"),
                    not(fileExists()));
         assertThat("Generated by the service inject codegen during compilation",
                    compiledClasses.resolve("ServiceType__ServiceDescriptor.class"),
diff --git a/service/tests/registry/src/main/java/io/helidon/service/test/registry/ServiceSupplier.java b/service/tests/registry/src/main/java/io/helidon/service/test/registry/ServiceSupplier.java
index ee764915071..73fd8b072fb 100644
--- a/service/tests/registry/src/main/java/io/helidon/service/test/registry/ServiceSupplier.java
+++ b/service/tests/registry/src/main/java/io/helidon/service/test/registry/ServiceSupplier.java
@@ -21,7 +21,7 @@
 
 import io.helidon.service.registry.Service;
 
-@Service.Provider
+@Service.PerLookup
 class ServiceSupplier implements Supplier<SuppliedContract> {
     private static final AtomicInteger COUNTER = new AtomicInteger();
 
diff --git a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
index cbca92c23db..b133ecae846 100644
--- a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/AbstractSaw.java
@@ -33,12 +33,12 @@ public abstract class AbstractSaw extends Verification implements Tool {
     @Service.Inject Supplier<AbstractBlade> fieldInjectedPkgPrivateProviderInAbstractBase;
     @Service.Inject Optional<AbstractBlade> fieldInjectedPkgPrivateOptionalInAbstractBase;
     @Service.Inject List<AbstractBlade> fieldInjectedPkgPrivateListInAbstractBase;
-    @Service.Inject List<Supplier<AbstractBlade>> fieldInjectedPkgPrivateProviderListInAbstractBase;
+    @Service.Inject Supplier<List<AbstractBlade>> fieldInjectedPkgPrivateProviderListInAbstractBase;
 
     Supplier<AbstractBlade> setterInjectedPkgPrivateProviderInAbstractBase;
     Optional<AbstractBlade> setterInjectedPkgPrivateOptionalInAbstractBase;
     List<AbstractBlade> setterInjectedPkgPrivateListInAbstractBase;
-    List<Supplier<AbstractBlade>> setterInjectedPkgPrivateProviderListInAbstractBase;
+    Supplier<List<AbstractBlade>> setterInjectedPkgPrivateProviderListInAbstractBase;
 
     int setterInjectedPkgPrivateProviderInAbstractBaseInjectedCount;
     int setterInjectedPkgPrivateOptionalInAbstractBaseInjectedCount;
@@ -46,7 +46,7 @@ public abstract class AbstractSaw extends Verification implements Tool {
     int setterInjectedPkgPrivateProviderListInAbstractBaseInjectedCount;
 
     @Service.Inject
-    public void setBladeProviders(List<Supplier<AbstractBlade>> blades) {
+    public void setBladeProviders(Supplier<List<AbstractBlade>> blades) {
         setterInjectedPkgPrivateProviderListInAbstractBase = blades;
         setterInjectedPkgPrivateProviderListInAbstractBaseInjectedCount++;
     }
@@ -59,8 +59,16 @@ public void verifyState() {
                 + ".fieldInjectedProtectedProviderInAbstractBase", null, false, DullBlade.class);
         verifyInjected(fieldInjectedProtectedListInAbstractBase, getClass()
                 + ".fieldInjectedProtectedListInAbstractBase", null, 1, AbstractBlade.class);
-        verifyInjected(setterInjectedPkgPrivateProviderListInAbstractBase, getClass()
-                + ".setterInjectedPkgPrivateProviderListInAbstractBase", null, 1, Supplier.class);
+        verifyInjected(setterInjectedPkgPrivateProviderListInAbstractBase,
+                       getClass() + ".setterInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       false,
+                       List.class);
+        verifyInjected(setterInjectedPkgPrivateProviderListInAbstractBase.get(),
+                       getClass() + ".setterInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       1,
+                       AbstractBlade.class);
 
         // we use cardinality of the InjectionPointProvider
         verifyInjected(fieldInjectedPkgPrivateProviderInAbstractBase, getClass()
@@ -69,8 +77,16 @@ public void verifyState() {
                 + ".fieldInjectedPkgPrivateOptionalInAbstractBase", null, true, DullBlade.class);
         verifyInjected(fieldInjectedPkgPrivateListInAbstractBase, getClass()
                 + ".fieldInjectedPkgPrivateListInAbstractBase", null, 1, DullBlade.class);
-        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase, getClass()
-                + ".fieldInjectedPkgPrivateProviderListInAbstractBase", null, 1, Supplier.class);
+        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase,
+                       getClass() + ".fieldInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       false,
+                       List.class);
+        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase.get(),
+                       getClass() + ".fieldInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       1,
+                       AbstractBlade.class);
 
         // we use cardinality of the InjectionPointProvider
         verifyInjected(setterInjectedPkgPrivateProviderInAbstractBase, getClass()
@@ -82,8 +98,16 @@ public void verifyState() {
         verifyInjected(setterInjectedPkgPrivateListInAbstractBase, getClass()
                                + ".setBladeList(List<AbstractBlade> blades)",
                        setterInjectedPkgPrivateListInAbstractBaseInjectedCount, 1, DullBlade.class);
-        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase, getClass()
-                + ".fieldInjectedPkgPrivateProviderListInAbstractBase", null, 1, Supplier.class);
+        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase,
+                       getClass() + ".fieldInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       false,
+                       List.class);
+        verifyInjected(fieldInjectedPkgPrivateProviderListInAbstractBase.get(),
+                       getClass() + ".fieldInjectedPkgPrivateProviderListInAbstractBase",
+                       null,
+                       1,
+                       AbstractBlade.class);
     }
 
     @Service.Inject
diff --git a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
index e28160108cf..e6aff654bde 100644
--- a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/TableSaw.java
@@ -44,12 +44,12 @@ class TableSaw extends AbstractSaw {
 
     @Service.Inject
     @Service.Named(CoarseBlade.NAME)
-    List<Supplier<AbstractBlade>> coarseBladeFieldInjectedPkgPrivateProviderListInSubClass;
+    Supplier<List<AbstractBlade>> coarseBladeFieldInjectedPkgPrivateProviderListInSubClass;
 
     Supplier<AbstractBlade> setterInjectedPkgPrivateProviderInSubClass;
     Optional<AbstractBlade> setterInjectedPkgPrivateOptionalInSubClass;
     List<AbstractBlade> setterInjectedPkgPrivateListInSubClass;
-    List<Supplier<AbstractBlade>> setterInjectedPkgPrivateProviderListInSubClass;
+    Supplier<List<AbstractBlade>> setterInjectedPkgPrivateProviderListInSubClass;
     int setterInjectedPkgPrivateProviderInSubClassInjectedCount;
     int setterInjectedPkgPrivateOptionalInSubClassInjectedCount;
     int setterInjectedPkgPrivateListInSubClassInjectedCount;
@@ -136,7 +136,7 @@ void setAllBladesInSubclass(@Service.Named("*") List<AbstractBlade> blades) {
     }
 
     @Service.Inject
-    void setBladeProviderListInSubclass(List<Supplier<AbstractBlade>> blades) {
+    void setBladeProviderListInSubclass(Supplier<List<AbstractBlade>> blades) {
         setterInjectedPkgPrivateProviderListInSubClass = blades;
         setterInjectedPkgPrivateProviderListInSubClassInjectedCount++;
     }
diff --git a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
index 7581ca9ecfc..564fb82a93d 100644
--- a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/ToolBox.java
@@ -32,7 +32,7 @@ public interface ToolBox {
      *
      * @return for testing
      */
-    List<Supplier<Tool>> toolsInBox();
+    Supplier<List<Tool>> toolsInBox();
 
     /**
      * Testing.
diff --git a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
index a8658e127f8..5e542ffab7d 100644
--- a/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
+++ b/service/tests/toolbox/src/main/java/io/helidon/service/tests/toolbox/impl/MainToolBox.java
@@ -30,8 +30,8 @@
 @Service.Singleton
 public class MainToolBox implements ToolBox {
 
-    private final List<Supplier<Tool>> allTools;
-    private final List<Supplier<Hammer>> allHammers;
+    private final Supplier<List<Tool>> allTools;
+    private final Supplier<List<Hammer>> allHammers;
     private final Supplier<Hammer> bigHammer;
     private final Screwdriver screwdriver;
     public int postConstructCallCount;
@@ -43,10 +43,10 @@ public class MainToolBox implements ToolBox {
     private Supplier<Hammer> setPreferredHammer;
 
     @Service.Inject
-    MainToolBox(List<Supplier<Tool>> allTools,
+    MainToolBox(Supplier<List<Tool>> allTools,
                 Screwdriver screwdriver,
                 @Service.Named("big") Supplier<Hammer> bigHammer,
-                List<Supplier<Hammer>> allHammers) {
+                Supplier<List<Hammer>> allHammers) {
         this.allTools = Objects.requireNonNull(allTools);
         this.screwdriver = Objects.requireNonNull(screwdriver);
         this.bigHammer = bigHammer;
@@ -54,7 +54,7 @@ public class MainToolBox implements ToolBox {
     }
 
     @Override
-    public List<Supplier<Tool>> toolsInBox() {
+    public Supplier<List<Tool>> toolsInBox() {
         return allTools;
     }
 
@@ -63,7 +63,7 @@ public Supplier<Hammer> preferredHammer() {
         return preferredHammer;
     }
 
-    public List<Supplier<Hammer>> allHammers() {
+    public Supplier<List<Hammer>> allHammers() {
         return allHammers;
     }
 
diff --git a/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java b/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
index 58b5c1f62b3..b9e54cc645b 100644
--- a/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
+++ b/service/tests/toolbox/src/test/java/io/helidon/service/tests/toolbox/ToolBoxTest.java
@@ -84,7 +84,7 @@ void toolbox() {
         assertThat(mtb.preDestroyCallCount, equalTo(0));
         assertThat(mtb.setterCallCount, equalTo(1));
 
-        List<Supplier<Tool>> allTools = mtb.toolsInBox();
+        List<Tool> allTools = mtb.toolsInBox().get();
         assertThat(allTools, hasSize(7));
         assertThat(mtb.screwdriver(), notNullValue());
 
@@ -94,22 +94,21 @@ void toolbox() {
         assertThat(hammer.get(), instanceOf(BigHammer.class));
 
         List<String> toolTypes = allTools.stream()
-                .map(Supplier::get)
                 .map(Object::getClass)
                 .map(Class::getSimpleName)
                 .toList();
-        assertThat(toolTypes, contains("SledgeHammer", // weight + 2, tbox.impl.SledgeHammer
-                                       "BigHammer", // weight + 1, tbox.impl.BigHammer
-                                       "TableSaw",  // tbox.TableSaw
-                                       "AwlImpl", // tbox.impl.AwlImpl
-                                       "HandSaw", // tbox.impl.HandSaw
-                                       "Screwdriver", // tbox.impl.Screwdriver
-                                       "LittleHammer" // tbox.impl.LittleHammer, has qualifier Named
+        assertThat(toolTypes, contains("SledgeHammer", // unqualified, weight + 2, tbox.impl.SledgeHammer
+                                       "TableSaw",  // unqualified, default weight, tbox.TableSaw
+                                       "AwlImpl", // unqualified, default weight, tbox.impl.AwlImpl
+                                       "HandSaw", // unqualified, default weight, tbox.impl.HandSaw
+                                       "Screwdriver", // unqualified, default weight, tbox.impl.Screwdriver
+                                       "BigHammer", // qualified - named, preferred, weight + 1, tbox.impl.BigHammer
+                                       "LittleHammer" // qualified - named, default weight, tbox.impl.LittleHammer
         ));
 
         List<String> hammers = mtb.allHammers()
+                .get()
                 .stream()
-                .map(Supplier::get)
                 .map(Object::getClass)
                 .map(Class::getSimpleName)
                 .toList();

From cb2a49d9317df1c647df5f0698e3cbe28ac1882e Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 01:12:43 +0100
Subject: [PATCH 16/23] Fix config provider to honor default config sources
 when meta configuration is not present. Added a test to validate it.

---
 .../io/helidon/config/ConfigProvider.java     |  95 ++-----------
 .../java/io/helidon/config/MetaConfig.java    |  25 ++--
 .../io/helidon/config/MetaConfigFactory.java  |  34 +++++
 .../helidon/service/codegen/CoreService.java  |   4 +-
 .../service/codegen/DescriptorClassCode.java  |  10 --
 .../codegen/DescriptorClassCodeImpl.java      |   1 -
 .../service/codegen/RegistryRoundContext.java |   6 +-
 .../service/codegen/RoundContextImpl.java     |   5 +-
 .../codegen/ServiceDescriptorCodegen.java     |  15 +-
 .../ServiceRegistryCodegenExtension.java      |   8 +-
 .../service/codegen/ServiceSuperType.java     |  22 +--
 .../maven/plugin/BindingGenerator.java        |   3 +-
 .../service/maven/plugin/MainGenerator.java   |  16 +++
 .../maven/plugin/MavenRoundContext.java       |   5 +-
 .../service/metadata/DescriptorMetadata.java  |  41 +-----
 .../metadata/DescriptorMetadataImpl.java      |  10 +-
 .../helidon/service/registry/Activators.java  |  15 +-
 .../registry/BindingDependencyContext.java    |  19 +++
 .../io/helidon/service/registry/Bindings.java |  18 ++-
 .../registry/CoreServiceDiscovery.java        |   8 +-
 .../service/registry/CoreServiceRegistry.java |  15 +-
 .../registry/DependencyCardinality.java       |  16 +++
 .../registry/ExistingInstanceDescriptor.java  |   5 -
 .../registry/InstanceNameServiceManager.java  |  16 +++
 .../InstanceName__ServiceDescriptor.java      |   5 -
 .../service/registry/LookupSupport.java       |   8 +-
 .../registry/RegistryStartupProvider.java     |  16 +++
 .../io/helidon/service/registry/Service.java  |   9 --
 .../ServiceLoader__ServiceDescriptor.java     |   5 -
 .../registry/ServiceRegistryManager.java      |  13 --
 .../service/registry/ServiceSupplies.java     |  53 -------
 .../registry/SupplierDependencyContext.java   |  16 +++
 .../service/registry/VirtualDescriptor.java   |   5 -
 service/tests/config/pom.xml                  | 129 ++++++++++++++++++
 .../service/tests/config/TestConfig.java      |  46 +++++++
 .../src/test/resources/application.yaml       |  23 ++++
 service/tests/pom.xml                         |   1 +
 .../integration/packaging/inject/Main.java    |   7 +-
 38 files changed, 418 insertions(+), 330 deletions(-)
 create mode 100644 config/config/src/main/java/io/helidon/config/MetaConfigFactory.java
 create mode 100644 service/tests/config/pom.xml
 create mode 100644 service/tests/config/src/test/java/io/helidon/service/tests/config/TestConfig.java
 create mode 100644 service/tests/config/src/test/resources/application.yaml

diff --git a/config/config/src/main/java/io/helidon/config/ConfigProvider.java b/config/config/src/main/java/io/helidon/config/ConfigProvider.java
index 5cd1f79978c..fc14e2f8657 100644
--- a/config/config/src/main/java/io/helidon/config/ConfigProvider.java
+++ b/config/config/src/main/java/io/helidon/config/ConfigProvider.java
@@ -18,16 +18,12 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 import io.helidon.common.config.Config;
-import io.helidon.common.config.ConfigException;
-import io.helidon.common.config.ConfigValue;
-import io.helidon.common.config.GlobalConfig;
 import io.helidon.config.spi.ConfigFilter;
 import io.helidon.config.spi.ConfigMapperProvider;
 import io.helidon.config.spi.ConfigParser;
@@ -35,20 +31,22 @@
 import io.helidon.service.registry.Service;
 
 @Service.Singleton
-class ConfigProvider implements Config {
+class ConfigProvider implements Supplier<Config> {
     private final Config config;
 
+    @SuppressWarnings("removal")
     @Service.Inject
-    ConfigProvider(Supplier<MetaConfig> metaConfig,
+    ConfigProvider(Supplier<Optional<MetaConfig>> metaConfig,
                    Supplier<List<ConfigSource>> configSources,
                    Supplier<List<ConfigParser>> configParsers,
                    Supplier<List<ConfigFilter>> configFilters,
                    Supplier<List<ConfigMapperProvider>> configMappers) {
-        if (GlobalConfig.configured()) {
-            config = GlobalConfig.config();
+        if (io.helidon.common.config.GlobalConfig.configured()) {
+            config = io.helidon.common.config.GlobalConfig.config();
         } else {
             config = io.helidon.config.Config.builder()
-                    .config(metaConfig.get().metaConfiguration())
+                    .update(it -> metaConfig.get().ifPresent(metaConfigInstance ->
+                                                               it.config(metaConfigInstance.metaConfiguration())))
                     .update(it -> configSources.get()
                             .forEach(it::addSource))
                     .update(it -> defaultConfigSources(it, configParsers))
@@ -69,81 +67,8 @@ class ConfigProvider implements Config {
     }
 
     @Override
-    public Key key() {
-        return config.key();
-    }
-
-    @Override
-    public Config root() {
-        return config.root();
-    }
-
-    @Override
-    public Config get(String key) throws io.helidon.common.config.ConfigException {
-        return config.get(key);
-    }
-
-    @Override
-    public Config detach() throws io.helidon.common.config.ConfigException {
-        return config.detach();
-    }
-
-    @Override
-    public boolean exists() {
-        return config.exists();
-    }
-
-    @Override
-    public boolean isLeaf() {
-        return config.isLeaf();
-    }
-
-    @Override
-    public boolean isObject() {
-        return config.isObject();
-    }
-
-    @Override
-    public boolean isList() {
-        return config.isList();
-    }
-
-    @Override
-    public boolean hasValue() {
-        return config.hasValue();
-    }
-
-    @Override
-    public <T> io.helidon.common.config.ConfigValue<T> as(Class<T> type) {
-        return config.as(type);
-    }
-
-    @Override
-    public <T> io.helidon.common.config.ConfigValue<T> map(Function<Config, T> mapper) {
-        return config.map(mapper);
-    }
-
-    @Override
-    public <T> io.helidon.common.config.ConfigValue<List<T>> asList(Class<T> type) throws
-            io.helidon.common.config.ConfigException {
-        return config.asList(type);
-    }
-
-    @Override
-    public <T> io.helidon.common.config.ConfigValue<List<T>> mapList(Function<Config, T> mapper) throws
-            io.helidon.common.config.ConfigException {
-        return config.mapList(mapper);
-    }
-
-    @Override
-    public <C extends Config> io.helidon.common.config.ConfigValue<List<C>> asNodeList() throws
-            io.helidon.common.config.ConfigException {
-        return config.asNodeList();
-    }
-
-    @Override
-    public ConfigValue<Map<String, String>> asMap() throws ConfigException {
-        return config.asMap();
+    public Config get() {
+        return config;
     }
 
     private void defaultConfigSources(io.helidon.config.Config.Builder configBuilder,
diff --git a/config/config/src/main/java/io/helidon/config/MetaConfig.java b/config/config/src/main/java/io/helidon/config/MetaConfig.java
index f78a7df2edb..cea064a168b 100644
--- a/config/config/src/main/java/io/helidon/config/MetaConfig.java
+++ b/config/config/src/main/java/io/helidon/config/MetaConfig.java
@@ -31,7 +31,6 @@
 import io.helidon.config.spi.OverrideSource;
 import io.helidon.config.spi.PollingStrategy;
 import io.helidon.config.spi.RetryPolicy;
-import io.helidon.service.registry.Service;
 
 /**
  * Meta configuration.
@@ -69,7 +68,6 @@
  *     <li>Classpath resource config source for resource {@code default.yaml} that is mandatory</li>
  * </ul>
  */
-@Service.Provider
 public final class MetaConfig {
     private static final System.Logger LOGGER = System.getLogger(MetaConfig.class.getName());
     private static final Set<MediaType> SUPPORTED_MEDIA_TYPES;
@@ -97,7 +95,7 @@ public final class MetaConfig {
 
     /**
      * Create configuration from meta configuration (files or classpath resources), or create a default config instance
-     *  if meta configuration is not present.
+     * if meta configuration is not present.
      *
      * @return a config instance
      */
@@ -177,7 +175,8 @@ public static RetryPolicy retryPolicy(Config metaConfig) {
     /**
      * Load a config source (or config sources) based on its meta configuration.
      * The metaConfig must contain a key {@code type} that defines the type of the source to be found via providers, and
-     *   a key {@code properties} with configuration of the config sources
+     * a key {@code properties} with configuration of the config sources
+     *
      * @param sourceMetaConfig meta configuration of a config source
      * @return config source instance
      * @see Config.Builder#config(Config)
@@ -207,15 +206,6 @@ public static List<ConfigSource> configSource(Config sourceMetaConfig) {
         }
     }
 
-    /**
-     * Meta configuration if provided, or empty config if not.
-     *
-     * @return meta configuration
-     */
-    public Config metaConfiguration() {
-        return this.metaConfig;
-    }
-
     // override config source
     static OverrideSource overrideSource(Config sourceMetaConfig) {
         String type = sourceMetaConfig.get("type").asString().get();
@@ -240,6 +230,15 @@ static List<ConfigSource> configSources(Config metaConfig) {
         return configSources;
     }
 
+    /**
+     * Meta configuration if provided, or empty config if not.
+     *
+     * @return meta configuration
+     */
+    public Config metaConfiguration() {
+        return this.metaConfig;
+    }
+
     private static Config createDefault() {
         // use defaults
         Config.Builder builder = Config.builder();
diff --git a/config/config/src/main/java/io/helidon/config/MetaConfigFactory.java b/config/config/src/main/java/io/helidon/config/MetaConfigFactory.java
new file mode 100644
index 00000000000..f2c69f9e98a
--- /dev/null
+++ b/config/config/src/main/java/io/helidon/config/MetaConfigFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.config;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import io.helidon.service.registry.Service;
+
+/**
+ * A ServiceRegistry factory that creates the meta config only if it is defined.
+ */
+@Service.Singleton
+class MetaConfigFactory implements Supplier<Optional<MetaConfig>> {
+    @Override
+    public Optional<MetaConfig> get() {
+        return MetaConfig.metaConfig()
+                .map(it -> new MetaConfig());
+    }
+}
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/CoreService.java b/service/codegen/src/main/java/io/helidon/service/codegen/CoreService.java
index 42dc6c7e13a..cc615bf83d9 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/CoreService.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/CoreService.java
@@ -212,12 +212,12 @@ private static ServiceSuperType superType(RegistryCodegenContext ctx, TypeInfo s
 
         for (TypeInfo service : services) {
             if (service.typeName().equals(superType.typeName())) {
-                return ServiceSuperType.create(service, "core", superTypeToExtend);
+                return ServiceSuperType.create(service, superTypeToExtend);
             }
         }
         // if not found in current list, try checking existing types
         return ctx.typeInfo(expectedSuperDescriptor)
-                .map(it -> ServiceSuperType.create(superType, "core", superTypeToExtend))
+                .map(it -> ServiceSuperType.create(superType, superTypeToExtend))
                 .orElseGet(ServiceSuperType::create);
     }
 
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
index c9a464af0cc..f11be9047b9 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
@@ -29,19 +29,16 @@ public interface DescriptorClassCode {
      * Create a new instance.
      *
      * @param classCode        class code that contains necessary information for the generated class.
-     * @param registryType     type of registry that generates the descriptor (core, inject)
      * @param weight           weight of the service this descriptor describes
      * @param contracts        contracts of the service (i.e. {@code MyContract})
      * @param factoryContracts factory contracts of this service (i.e. {@code Supplier<MyContract>})
      * @return a new class code of service descriptor
      */
     static DescriptorClassCode create(ClassCode classCode,
-                                      String registryType,
                                       double weight,
                                       Set<ResolvedType> contracts,
                                       Set<ResolvedType> factoryContracts) {
         return new DescriptorClassCodeImpl(classCode,
-                                           registryType,
                                            weight,
                                            contracts,
                                            factoryContracts);
@@ -54,13 +51,6 @@ static DescriptorClassCode create(ClassCode classCode,
      */
     ClassCode classCode();
 
-    /**
-     * Type of registry of this descriptor.
-     *
-     * @return registry type
-     */
-    String registryType();
-
     /**
      * Weight of the new descriptor.
      *
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCodeImpl.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCodeImpl.java
index 653876f247a..1ee34fd24e1 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCodeImpl.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCodeImpl.java
@@ -22,7 +22,6 @@
 import io.helidon.common.types.ResolvedType;
 
 record DescriptorClassCodeImpl(ClassCode classCode,
-                               String registryType,
                                double weight,
                                Set<ResolvedType> contracts,
                                Set<ResolvedType> factoryContracts) implements DescriptorClassCode {
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/RegistryRoundContext.java b/service/codegen/src/main/java/io/helidon/service/codegen/RegistryRoundContext.java
index d9c60c095dc..90c5bec8601 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/RegistryRoundContext.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/RegistryRoundContext.java
@@ -32,7 +32,6 @@ public interface RegistryRoundContext extends RoundContext {
     /**
      * Add a new service descriptor.
      *
-     * @param registryType        service registry this descriptor is designed for (core is the "top" level)
      * @param serviceType         type of the service (the implementation class we generate descriptor for)
      * @param descriptorType      type of the service descriptor
      * @param descriptor          descriptor class model
@@ -42,10 +41,7 @@ public interface RegistryRoundContext extends RoundContext {
      * @param originatingElements possible originating elements (such as Element in APT, or ClassInfo in classpath scanning)
      * @throws java.lang.IllegalStateException if an attempt is done to register a new descriptor for the same type
      */
-    // all parameters are needed, no sense in creating a builder
-    @SuppressWarnings("checkstyle:ParameterNumber")
-    void addDescriptor(String registryType,
-                       TypeName serviceType,
+    void addDescriptor(TypeName serviceType,
                        TypeName descriptorType,
                        ClassModel.Builder descriptor,
                        double weight,
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/RoundContextImpl.java b/service/codegen/src/main/java/io/helidon/service/codegen/RoundContextImpl.java
index b147542385f..04c770098d9 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/RoundContextImpl.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/RoundContextImpl.java
@@ -133,15 +133,13 @@ public void addGeneratedType(TypeName type,
     }
 
     @Override
-    public void addDescriptor(String registryType,
-                              TypeName serviceType,
+    public void addDescriptor(TypeName serviceType,
                               TypeName descriptorType,
                               ClassModel.Builder descriptor,
                               double weight,
                               Set<ResolvedType> contracts,
                               Set<ResolvedType> factoryContracts,
                               Object... originatingElements) {
-        Objects.requireNonNull(registryType);
         Objects.requireNonNull(serviceType);
         Objects.requireNonNull(descriptorType);
         Objects.requireNonNull(descriptor);
@@ -150,7 +148,6 @@ public void addDescriptor(String registryType,
 
         addDescriptorConsumer
                 .accept(new DescriptorClassCodeImpl(new ClassCode(descriptorType, descriptor, serviceType, originatingElements),
-                                                    registryType,
                                                     weight,
                                                     contracts,
                                                     factoryContracts));
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
index 4d703c2fdb3..f9d38a9af56 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceDescriptorCodegen.java
@@ -298,8 +298,7 @@ public void service(TypeName generator, RegistryRoundContext roundCtx, Collectio
             metaInfFactoryContracts.add(ResolvedType.create(serviceTypeName));
         }
 
-        roundCtx.addDescriptor("core",
-                               serviceTypeName,
+        roundCtx.addDescriptor(serviceTypeName,
                                service.descriptorType(),
                                classModel,
                                weight(typeInfo).orElse(Weighted.DEFAULT_WEIGHT),
@@ -386,8 +385,7 @@ void describe(RegistryRoundContext roundCtx, TypeInfo typeInfo, Annotation descr
         Set<ResolvedType> serviceContracts = new HashSet<>(contracts);
         serviceContracts.add(ResolvedType.create(serviceTypeName));
 
-        roundCtx.addDescriptor("core",
-                               serviceTypeName,
+        roundCtx.addDescriptor(serviceTypeName,
                                service.descriptorType(),
                                classModel,
                                weight(serviceDescriptor.typeInfo()).orElse(Weighted.DEFAULT_WEIGHT),
@@ -561,9 +559,6 @@ private ServiceSuperType superType(TypeInfo typeInfo, Collection<TypeInfo> servi
             return ServiceSuperType.create();
         }
         TypeInfo superType = superTypeInfoOptional.get();
-        String serviceType = superType.hasAnnotation(SERVICE_ANNOTATION_PROVIDER)
-                ? "core"
-                : "inject";
 
         TypeName expectedSuperDescriptor = ctx.descriptorType(superType.typeName());
         TypeName superTypeToExtend = TypeName.builder(expectedSuperDescriptor)
@@ -571,12 +566,12 @@ private ServiceSuperType superType(TypeInfo typeInfo, Collection<TypeInfo> servi
                 .build();
         for (TypeInfo service : services) {
             if (service.typeName().equals(superType.typeName())) {
-                return ServiceSuperType.create(service, serviceType, superTypeToExtend);
+                return ServiceSuperType.create(service, superTypeToExtend);
             }
         }
         // if not found in current list, try checking existing types
         return ctx.typeInfo(expectedSuperDescriptor)
-                .map(it -> ServiceSuperType.create(superType, serviceType, superTypeToExtend))
+                .map(it -> ServiceSuperType.create(superType, superTypeToExtend))
                 .orElseGet(ServiceSuperType::create);
     }
 
@@ -1514,7 +1509,7 @@ private void dependenciesMethod(ClassModel.Builder classModel, DescribedService
                     .returnType(LIST_OF_DEPENDENCIES)
                     .name("dependencies")
                     .update(it -> {
-                        if (hasSuperType && !service.superType().serviceType().equals("core")) {
+                        if (hasSuperType) {
                             it.addContent("return ")
                                     .addContent(SERVICE_G_DEPENDENCY_SUPPORT)
                                     .addContentLine(".combineDependencies(DEPENDENCIES, super.dependencies());");
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceRegistryCodegenExtension.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceRegistryCodegenExtension.java
index bc105d8b6bf..2d4898f52fa 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceRegistryCodegenExtension.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceRegistryCodegenExtension.java
@@ -113,11 +113,8 @@ public void process(io.helidon.codegen.RoundContext roundContext) {
                     .map(ResolvedType::create)
                     .collect(Collectors.toUnmodifiableSet());
 
-            String registryType = descriptorAnnot.stringValue("registryType").orElse("core");
-
             // predefined service descriptor
-            generatedServiceDescriptors.add(DescriptorMetadata.create(registryType,
-                                                                      typeInfo.typeName(),
+            generatedServiceDescriptors.add(DescriptorMetadata.create(typeInfo.typeName(),
                                                                       weight,
                                                                       contracts,
                                                                       Set.of()));
@@ -196,8 +193,7 @@ This is no longer going to write the types, as it is now (correctly) delegated t
         // generate all code
         for (var descriptor : descriptors) {
             ClassCode classCode = descriptor.classCode();
-            generatedServiceDescriptors.add(DescriptorMetadata.create(descriptor.registryType(),
-                                                                      classCode.newType(),
+            generatedServiceDescriptors.add(DescriptorMetadata.create(classCode.newType(),
                                                                       descriptor.weight(),
                                                                       descriptor.contracts(),
                                                                       descriptor.factoryContracts()));
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceSuperType.java b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceSuperType.java
index a875526d1f1..bcaec637c60 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/ServiceSuperType.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/ServiceSuperType.java
@@ -27,11 +27,9 @@
  */
 public final class ServiceSuperType {
     private final TypeInfo typeInfo;
-    private final String descriptorType;
     private final TypeName descriptorTypeName;
 
-    private ServiceSuperType(TypeInfo typeInfo, String descriptorType, TypeName descriptoryTypeName) {
-        this.descriptorType = descriptorType;
+    private ServiceSuperType(TypeInfo typeInfo, TypeName descriptoryTypeName) {
         this.descriptorTypeName = descriptoryTypeName;
         this.typeInfo = typeInfo;
     }
@@ -40,16 +38,14 @@ private ServiceSuperType(TypeInfo typeInfo, String descriptorType, TypeName desc
      * Create a registry based super type.
      *
      * @param typeInfo           type info of the super type
-     * @param descriptorType     descriptor type (core, inject etc.) of the descriptor
      * @param descriptorTypeName type name of the service descriptor of the extended type
      * @return a new super type for a real super type
      */
-    public static ServiceSuperType create(TypeInfo typeInfo, String descriptorType, TypeName descriptorTypeName) {
+    public static ServiceSuperType create(TypeInfo typeInfo, TypeName descriptorTypeName) {
         Objects.requireNonNull(typeInfo);
-        Objects.requireNonNull(descriptorType);
         Objects.requireNonNull(descriptorTypeName);
 
-        return new ServiceSuperType(typeInfo, descriptorType, descriptorTypeName);
+        return new ServiceSuperType(typeInfo, descriptorTypeName);
     }
 
     /**
@@ -58,7 +54,7 @@ public static ServiceSuperType create(TypeInfo typeInfo, String descriptorType,
      * @return super type that is not present
      */
     public static ServiceSuperType create() {
-        return new ServiceSuperType(null, null, null);
+        return new ServiceSuperType(null, null);
     }
 
     /**
@@ -79,16 +75,6 @@ public boolean empty() {
         return typeInfo == null;
     }
 
-    /**
-     * Type of the service descriptor, either {@code core} for core service registry, or other depending on supported
-     * types (such as {@code inject}).
-     *
-     * @return type of the service
-     */
-    public String serviceType() {
-        return descriptorType == null ? "core" : descriptorType;
-    }
-
     /**
      * Type information of the super service type of this service.
      *
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
index 1fc4b2a08b6..335aabce204 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/BindingGenerator.java
@@ -183,8 +183,7 @@ void codegen(WrappedServices injectionServices,
                                                     descriptor.classCode().originatingElements());
             sourcesToCompile.add(path);
 
-            services.add(DescriptorMetadata.create(descriptor.registryType(),
-                                                   descriptor.classCode().newType(),
+            services.add(DescriptorMetadata.create(descriptor.classCode().newType(),
                                                    descriptor.weight(),
                                                    descriptor.contracts(),
                                                    Set.of()));
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
index 47b18621cc5..faadacd6836 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.maven.plugin;
 
 import java.nio.file.Path;
diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
index 0f54f311245..68e7726edc0 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MavenRoundContext.java
@@ -41,8 +41,7 @@ class MavenRoundContext implements RegistryRoundContext {
     }
 
     @Override
-    public void addDescriptor(String registryType,
-                              TypeName serviceType,
+    public void addDescriptor(TypeName serviceType,
                               TypeName descriptorType,
                               ClassModel.Builder descriptor,
                               double weight,
@@ -53,7 +52,7 @@ public void addDescriptor(String registryType,
                                      descriptor,
                                      serviceType,
                                      originatingElements);
-        descriptors.add(DescriptorClassCode.create(cc, registryType, weight, contracts, factoryContracts));
+        descriptors.add(DescriptorClassCode.create(cc, weight, contracts, factoryContracts));
     }
 
     @Override
diff --git a/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadata.java b/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadata.java
index 49323167adc..be46c8a6132 100644
--- a/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadata.java
+++ b/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadata.java
@@ -17,7 +17,6 @@
 package io.helidon.service.metadata;
 
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
@@ -27,58 +26,22 @@
  * Metadata of a service descriptor, as stored in Helidon specific file {@value Descriptors#SERVICE_REGISTRY_LOCATION}.
  */
 public interface DescriptorMetadata {
-    /**
-     * {@link #registryType()} for core services.
-     */
-    String REGISTRY_TYPE_CORE = "core";
-
-    /**
-     * Create a new instance from descriptor information, i.e. when code generating the descriptor metadata.
-     *
-     * @param registryType type of registry, such as {@link #REGISTRY_TYPE_CORE}
-     * @param descriptor   type of the service descriptor (the generated file from {@code helidon-service-codegen})
-     * @param weight       weight of the service descriptor
-     * @param contracts    contracts the service implements
-     * @return a new descriptor metadata instance
-     * @deprecated use {@link #create(String, io.helidon.common.types.TypeName, double, java.util.Set, java.util.Set)} instead
-     */
-    @Deprecated(forRemoval = true, since = "4.2.0")
-    static DescriptorMetadata create(String registryType, TypeName descriptor, double weight, Set<TypeName> contracts) {
-        return new DescriptorMetadataImpl(
-                registryType,
-                weight,
-                descriptor,
-                contracts.stream()
-                        .map(ResolvedType::create)
-                        .collect(Collectors.toUnmodifiableSet()),
-                Set.of());
-    }
-
     /**
      * Create a new instance from descriptor information, i.e. when code generating the descriptor metadata.
      *
-     * @param registryType     type of registry, such as {@link #REGISTRY_TYPE_CORE}
      * @param descriptor       type of the service descriptor (the generated file from {@code helidon-service-codegen})
      * @param weight           weight of the service descriptor
      * @param contracts        contracts the service implements
      * @param factoryContracts factory contracts the service instance implements
      * @return a new descriptor metadata instance
      */
-    static DescriptorMetadata create(String registryType,
-                                     TypeName descriptor,
+    static DescriptorMetadata create(TypeName descriptor,
                                      double weight,
                                      Set<ResolvedType> contracts,
                                      Set<ResolvedType> factoryContracts) {
-        return new DescriptorMetadataImpl(registryType, weight, descriptor, contracts, factoryContracts);
+        return new DescriptorMetadataImpl(weight, descriptor, contracts, factoryContracts);
     }
 
-    /**
-     * Type of registry, such as {@code core}.
-     *
-     * @return registry type this descriptor is created for
-     */
-    String registryType();
-
     /**
      * Descriptor type name.
      *
diff --git a/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadataImpl.java b/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadataImpl.java
index 7a0084837db..ff9d6e3ff2d 100644
--- a/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadataImpl.java
+++ b/service/metadata/src/main/java/io/helidon/service/metadata/DescriptorMetadataImpl.java
@@ -25,15 +25,13 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.metadata.hson.Hson;
 
-record DescriptorMetadataImpl(String registryType,
-                              double weight,
+record DescriptorMetadataImpl(double weight,
                               TypeName descriptorType,
                               Set<ResolvedType> contracts,
                               Set<ResolvedType> factoryContracts) implements DescriptorMetadata {
 
     private static final int CURRENT_DESCRIPTOR_VERSION = 1;
     private static final int DEFAULT_DESCRIPTOR_VERSION = 1;
-    private static final String HSON_TYPE = "type";
     private static final String HSON_WEIGHT = "weight";
     private static final String HSON_DESCRIPTOR = "descriptor";
     private static final String HSON_CONTRACTS = "contracts";
@@ -50,7 +48,6 @@ static DescriptorMetadata create(String moduleName, String location, Hson.Struct
                                                     + service.stringValue(HSON_DESCRIPTOR, "N/A"));
         }
 
-        String type = service.stringValue(HSON_TYPE, REGISTRY_TYPE_CORE);
         TypeName descriptor = service.stringValue(HSON_DESCRIPTOR)
                 .map(TypeName::create)
                 .orElseThrow(() -> new IllegalStateException("Could not parse service metadata "
@@ -70,16 +67,13 @@ static DescriptorMetadata create(String moduleName, String location, Hson.Struct
                 .map(ResolvedType::create)
                 .collect(Collectors.toSet());
 
-        return new DescriptorMetadataImpl(type, weight, descriptor, contracts, factoryContracts);
+        return new DescriptorMetadataImpl(weight, descriptor, contracts, factoryContracts);
     }
 
     @Override
     public Hson.Struct toHson() {
         var builder = Hson.structBuilder();
 
-        if (!registryType.equals(REGISTRY_TYPE_CORE)) {
-            builder.set(HSON_TYPE, registryType);
-        }
         if (weight != Weighted.DEFAULT_WEIGHT) {
             builder.set(HSON_WEIGHT, weight);
         }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Activators.java b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
index f78f2b0b373..f6e8e195efa 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Activators.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Activators.java
@@ -560,8 +560,19 @@ protected void setTargetInstances() {
             }
             // the instance list is created just once, hardcoded to the instance we have just created
             Supplier<T> instanceSupplier = (Supplier<T>) serviceInstance.get();
-            this.targetInstances = List.of(QualifiedInstance.create(instanceSupplier.get(),
-                                                                    provider.descriptor().qualifiers()));
+            T value = instanceSupplier.get();
+            if (value instanceof Optional opt) {
+                if (opt.isPresent()) {
+                    value = (T) opt.get();
+                    this.targetInstances = List.of(QualifiedInstance.create(value,
+                                                                            provider.descriptor().qualifiers()));
+                } else {
+                    this.targetInstances = List.of();
+                }
+            } else {
+                this.targetInstances = List.of(QualifiedInstance.create(value,
+                                                                        provider.descriptor().qualifiers()));
+            }
         }
     }
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java b/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
index 6803d41247a..0e46ce40050 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/BindingDependencyContext.java
@@ -1,5 +1,24 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
+/**
+ * Dependency context backed by a binding, to allow generated binding, late binding, and runtime computed binding.
+ */
 class BindingDependencyContext implements DependencyContext {
     private final Bindings.ServiceBindingPlan serviceBinding;
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Bindings.java b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
index da01e3e0c0a..4f3eaee232b 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.ArrayList;
@@ -252,7 +268,7 @@ private List managers(List<ServiceInfo> serviceInfos) {
         }
 
         private void discoverBinding() {
-            // lookup services, exclude ourself (when doing chained injection, we lookup by weight)
+            // lookup services, exclude ourselves (when doing chained injection, we lookup by weight)
             List<ServiceInfo> found = registry.lookupServices(lookup)
                     .stream()
                     .filter(it -> it != serviceInfo)
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
index ab6e4ae7461..e4554d243f3 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceDiscovery.java
@@ -171,8 +171,7 @@ private static DescriptorHandlerImpl createServiceProviderDescriptor(TypeName pr
         }
 
         ServiceDescriptor<Object> descriptor = ServiceLoader__ServiceDescriptor.create(providerType, provider, weight);
-        return new DescriptorHandlerImpl(DescriptorMetadata.create("core",
-                                                                   descriptor.descriptorType(),
+        return new DescriptorHandlerImpl(DescriptorMetadata.create(descriptor.descriptorType(),
                                                                    weight,
                                                                    descriptor.contracts(),
                                                                    descriptor.factoryContracts()),
@@ -219,11 +218,6 @@ public ServiceDescriptor<?> descriptor() {
             return descriptorSupplier.get();
         }
 
-        @Override
-        public String registryType() {
-            return metadata.registryType();
-        }
-
         @Override
         public TypeName descriptorType() {
             return metadata.descriptorType();
diff --git a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
index 9333a3936a1..52b9e0e9395 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/CoreServiceRegistry.java
@@ -309,10 +309,9 @@ public List<ServiceInfo> lookupServices(Lookup lookup) {
                     if (!result.isEmpty()) {
                         traceLookup(lookup, "by single contract", result);
                         if (cacheEnabled) {
-                            cacheAndAccess(lookup, result);
-                        } else {
-                            result.forEach(this::accessed);
+                            cache.put(lookup, result);
                         }
+
                         return result;
                     }
                 }
@@ -350,9 +349,7 @@ public List<ServiceInfo> lookupServices(Lookup lookup) {
             }
 
             if (cacheEnabled) {
-                cacheAndAccess(lookup, result);
-            } else {
-                result.forEach(this::accessed);
+                cache.put(lookup, result);
             }
 
             traceLookup(lookup, "full result", result);
@@ -534,6 +531,7 @@ <T> List<ServiceManager<T>> lookupManagers(Lookup lookup) {
 
         for (ServiceInfo service : lookupServices(lookup)) {
             result.add(serviceManager(service));
+            accessed(service);
         }
 
         return result;
@@ -573,11 +571,6 @@ void ensureInjectionPlans() {
                 .forEach(ServiceManager::ensureBindingPlan);
     }
 
-    private void cacheAndAccess(Lookup lookup, List<ServiceInfo> result) {
-        cache.put(lookup, result);
-        result.forEach(this::accessed);
-    }
-
     private void accessed(ServiceInfo service) {
         stateReadLock.lock();
         try {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java b/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
index afb256e2047..8409afaec7b 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/DependencyCardinality.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 /**
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
index 9866603eacc..57979ca262c 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ExistingInstanceDescriptor.java
@@ -119,9 +119,4 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(instance, contracts, weight);
     }
-
-    @Override
-    public TypeName scope() {
-        return Service.Singleton.TYPE;
-    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java b/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
index 26676e53797..b0b8eee4e8f 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InstanceNameServiceManager.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 class InstanceNameServiceManager extends ServiceManager<String> {
diff --git a/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
index ec60f656069..20a5e9b54de 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/InstanceName__ServiceDescriptor.java
@@ -57,11 +57,6 @@ public Set<ResolvedType> contracts() {
         return CONTRACTS;
     }
 
-    @Override
-    public TypeName scope() {
-        return Service.Singleton.TYPE;
-    }
-
     @Override
     public FactoryType factoryType() {
         return FactoryType.NONE;
diff --git a/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java b/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
index e6e9adcd34f..20282396ec9 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/LookupSupport.java
@@ -131,13 +131,9 @@ public void decorate(Lookup.BuilderBase<?, ?> builder, Optional<Dependency> depe
             } else {
                 builder.dependency().ifPresent(existing -> {
                     // clear if contained only IP stuff
-                    boolean shouldClear = true;
-                    if (!builder.qualifiers().equals(existing.qualifiers())) {
-                        shouldClear = false;
+                    boolean shouldClear = builder.qualifiers().equals(existing.qualifiers());
 
-                    }
-                    if (!(
-                            builder.contracts().contains(ResolvedType.create(existing.contract()))
+                    if (!(builder.contracts().contains(ResolvedType.create(existing.contract()))
                                     && builder.contracts().size() == 1)) {
                         shouldClear = false;
                     }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
index 424c9ca298d..2863d8f234d 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.List;
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Service.java b/service/registry/src/main/java/io/helidon/service/registry/Service.java
index aaef3554eb5..5fb6d69d5de 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Service.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Service.java
@@ -441,15 +441,6 @@ private Service() {
          */
         TypeName TYPE = TypeName.create(Descriptor.class);
 
-        /**
-         * Type of service registry that should read this descriptor. Defaults to
-         * {@value DescriptorHandler#REGISTRY_TYPE_CORE}, so the descriptor must only implement
-         * {@link io.helidon.service.registry.ServiceDescriptor}.
-         *
-         * @return type of registry this descriptor supports
-         */
-        String registryType() default DescriptorHandler.REGISTRY_TYPE_CORE;
-
         /**
          * The weight of the service. This is required for predefined descriptors, as we do not want
          * to instantiate them unless really needed.
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
index 8b77ea676cd..cfce817690a 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceLoader__ServiceDescriptor.java
@@ -133,11 +133,6 @@ public Set<ResolvedType> contracts() {
             return contracts;
         }
 
-        @Override
-        public TypeName scope() {
-            return Service.Singleton.TYPE;
-        }
-
         @Override
         public Object instantiate(DependencyContext ctx, InterceptionMetadata metadata) {
             return instance.get();
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 2b863aea3ec..25dfce21114 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -34,7 +34,6 @@
 import io.helidon.common.types.ResolvedType;
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
-import io.helidon.service.metadata.DescriptorMetadata;
 
 /**
  * Manager is responsible for managing the state of a {@link io.helidon.service.registry.ServiceRegistry}.
@@ -310,19 +309,7 @@ private ServiceRegistry registry(Binding binding) {
                      descriptor);
             }
 
-            boolean logUnsupported = LOGGER.isLoggable(System.Logger.Level.TRACE);
-
             for (var descriptorMeta : discovery.allMetadata()) {
-                String registryType = descriptorMeta.registryType();
-                if (!(DescriptorMetadata.REGISTRY_TYPE_CORE.equals(registryType) || "inject".equals(registryType))) {
-                    // we support only core and inject
-                    if (logUnsupported) {
-                        LOGGER.log(System.Logger.Level.TRACE,
-                                   "Ignoring service of type \"" + descriptorMeta.registryType() + "\": " + descriptorMeta);
-                    }
-                    continue;
-                }
-
                 ServiceDescriptor<?> descriptor = descriptorMeta.descriptor();
 
                 descriptors.add(descriptor);
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
index dc55ae4e269..a34521f81c1 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
@@ -17,7 +17,6 @@
 package io.helidon.service.registry;
 
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
@@ -209,56 +208,4 @@ public List<ServiceInstance<T>> get() {
                     .collect(Collectors.toUnmodifiableList());
         }
     }
-
-    private static class RegistryInstanceComparator implements Comparator<ServiceInstance<?>> {
-        private static final RegistryInstanceComparator INSTANCE = new RegistryInstanceComparator();
-
-        private RegistryInstanceComparator() {
-        }
-
-        /**
-         * Returns a service provider comparator.
-         *
-         * @return the service provider comparator
-         */
-        static RegistryInstanceComparator instance() {
-            return INSTANCE;
-        }
-
-        @Override
-        public int compare(ServiceInstance<?> p1,
-                           ServiceInstance<?> p2) {
-            if (p1 == p2) {
-                return 0;
-            }
-
-            // unqualified instances always first (even if lower weight)
-            if (p1.qualifiers().isEmpty() && !p2.qualifiers().isEmpty()) {
-                return -1;
-            }
-
-            if (p2.qualifiers().isEmpty() && !p1.qualifiers().isEmpty()) {
-                return 1;
-            }
-
-            // @default name before any other name
-            if (p1.qualifiers().contains(Qualifier.DEFAULT_NAMED) && !p2.qualifiers().contains(Qualifier.DEFAULT_NAMED)) {
-                return -1;
-            }
-
-            if (p2.qualifiers().contains(Qualifier.DEFAULT_NAMED) && !p1.qualifiers().contains(Qualifier.DEFAULT_NAMED)) {
-                return 1;
-            }
-
-            // weights
-            int comp = Double.compare(p2.weight(), p1.weight());
-            if (comp != 0) {
-                return comp;
-            }
-
-            // last by name
-            return p1.serviceType().compareTo(p2.serviceType());
-        }
-
-    }
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java b/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java
index efeb7b1b479..9ea494b9833 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/SupplierDependencyContext.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.helidon.service.registry;
 
 import java.util.Map;
diff --git a/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java b/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
index 90865b20ad0..32fe4e3ac1c 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/VirtualDescriptor.java
@@ -87,11 +87,6 @@ public boolean equals(Object o) {
                 && (instance == that.instance);
     }
 
-    @Override
-    public TypeName scope() {
-        return Service.Singleton.TYPE;
-    }
-
     @Override
     public String toString() {
         return "VirtualDescriptor for contract " + serviceType + " (" + weight + ")";
diff --git a/service/tests/config/pom.xml b/service/tests/config/pom.xml
new file mode 100644
index 00000000000..19cb50819b4
--- /dev/null
+++ b/service/tests/config/pom.xml
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2024 Oracle and/or its affiliates.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="http://maven.apache.org/POM/4.0.0"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>io.helidon.service.tests</groupId>
+        <artifactId>helidon-service-tests-project</artifactId>
+        <version>4.2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>helidon-service-tests-config</artifactId>
+    <name>Helidon Service Tests Config</name>
+    <description>Tests for service registry and config integration</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-registry</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.config</groupId>
+            <artifactId>helidon-config-yaml</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-all</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.helidon.common.testing</groupId>
+            <artifactId>helidon-common-testing-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-apt</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.service</groupId>
+                            <artifactId>helidon-service-codegen</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                        <path>
+                            <groupId>io.helidon.codegen</groupId>
+                            <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                            <version>${helidon.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-apt</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.service</groupId>
+                        <artifactId>helidon-service-codegen</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>io.helidon.codegen</groupId>
+                        <artifactId>helidon-codegen-helidon-copyright</artifactId>
+                        <version>${helidon.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>enforce-jakarta-not-included</id>
+                        <goals>
+                            <goal>enforce</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <bannedDependencies>
+                                    <excludes>
+                                        <exclude>jakarta.inject:jakarta.inject-api</exclude>
+                                        <exclude>jakarta.annotation:jakarta.annotation-api</exclude>
+                                    </excludes>
+                                </bannedDependencies>
+                            </rules>
+                            <fail>true</fail>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/service/tests/config/src/test/java/io/helidon/service/tests/config/TestConfig.java b/service/tests/config/src/test/java/io/helidon/service/tests/config/TestConfig.java
new file mode 100644
index 00000000000..10df139fdc7
--- /dev/null
+++ b/service/tests/config/src/test/java/io/helidon/service/tests/config/TestConfig.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.service.tests.config;
+
+import io.helidon.common.config.Config;
+import io.helidon.service.registry.ServiceRegistry;
+import io.helidon.service.registry.ServiceRegistryManager;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class TestConfig {
+    @Test
+    public void testConfig() {
+        ServiceRegistryManager manager = ServiceRegistryManager.create();
+        ServiceRegistry registry = manager.registry();
+        System.setProperty("io.helidon.service.tests.config.TestConfig.port", "8888");
+
+        Config registryConfig = registry.get(Config.class);
+        Config defaultConfig = Config.create();
+
+        assertThat("Config.create()",
+                   defaultConfig.get("io.helidon.service.tests.config.TestConfig.port").asInt().get(),
+                   is(8888));
+        assertThat("registry.get(Config.class)",
+                   registryConfig.get("io.helidon.service.tests.config.TestConfig.port").asInt().get(),
+                   is(8888));
+
+    }
+}
diff --git a/service/tests/config/src/test/resources/application.yaml b/service/tests/config/src/test/resources/application.yaml
new file mode 100644
index 00000000000..06a0dcc31b4
--- /dev/null
+++ b/service/tests/config/src/test/resources/application.yaml
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2024 Oracle and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+io:
+  helidon:
+    service:
+      tests:
+        config:
+          TestConfig:
+            port: 8080
\ No newline at end of file
diff --git a/service/tests/pom.xml b/service/tests/pom.xml
index 6c739b83e02..2ddca7ff27d 100644
--- a/service/tests/pom.xml
+++ b/service/tests/pom.xml
@@ -44,6 +44,7 @@
 
     <modules>
         <module>codegen</module>
+        <module>config</module>
         <module>registry</module>
         <module>inject</module>
         <module>lookup</module>
diff --git a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
index 13a36b89bc7..a53953ba971 100644
--- a/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
+++ b/tests/integration/packaging/inject/src/main/java/io/helidon/tests/integration/packaging/inject/Main.java
@@ -23,6 +23,7 @@
 import io.helidon.service.registry.Service;
 import io.helidon.service.registry.ServiceRegistry;
 import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.service.registry.Services;
 
 /**
  * We must provide a main class when using modularized jar file with main class attribute,
@@ -36,11 +37,13 @@ public class Main {
     }
 
     public static void main(String[] args) {
+        System.out.println(System.getProperties());
         LogConfig.configureRuntime();
 
         // makes sure global config is initialized
-        Config config = GlobalConfig.config();
-        GlobalConfig.config(() -> config);
+        Config config = Config.create();
+        GlobalConfig.config(() -> config, true);
+        Services.set(Config.class, config);
 
         ServiceRegistry registry = ServiceRegistryManager.create()
                 .registry();

From 1b8ae0aed7a7ee953650a83fdee0a83e20f61757 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 01:15:40 +0100
Subject: [PATCH 17/23] Updated docs.

---
 .../helidon/service/registry/ServiceRegistryManager.java  | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 25dfce21114..6ddcc7b1f3b 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -74,7 +74,9 @@ public final class ServiceRegistryManager {
 
     /**
      * Create a new manager based on the provided binding (usually code generated), and start the service registry
-     * services according to the configured run levels. Honor configured options.
+     * services according to the configured run levels.
+     * <p>
+     * Registers the registry as the {@link io.helidon.service.registry.GlobalServiceRegistry}.
      * <p>
      * Configuration options are handled as follows:
      * <ul>
@@ -112,6 +114,8 @@ public static ServiceRegistryManager start(Binding binding, ServiceRegistryConfi
      * Start the service registry with no generated binding with the provided config.
      * This method honors {@link ServiceRegistryConfig#maxRunLevel()} and {@link ServiceRegistryConfig#runLevels()}
      * to initialize services that fit.
+     * <p>
+     * Registers the registry as the {@link io.helidon.service.registry.GlobalServiceRegistry}.
      *
      * @param config configuration of the service registry
      * @return a new registry manager with initialized registry
@@ -123,6 +127,8 @@ public static ServiceRegistryManager start(ServiceRegistryConfig config) {
     /**
      * Create a new manager based on the provided binding (usually code generated), and start the service registry
      * services according to the configured run levels.
+     * <p>
+     * Registers the registry as the {@link io.helidon.service.registry.GlobalServiceRegistry}.
      *
      * @param binding generated binding
      * @return a new registry manager with an initialized registry

From adbce97f8bfff336cdcf76ea02582d11c994435f Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 01:18:59 +0100
Subject: [PATCH 18/23] A small update to the generated code and registry, to
 register shutdown handler for started registry managers.

---
 .../java/io/helidon/service/maven/plugin/MainGenerator.java   | 4 ----
 .../io/helidon/service/registry/ServiceRegistryManager.java   | 1 +
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
index faadacd6836..1c0e7946ec7 100644
--- a/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
+++ b/service/maven-plugin/src/main/java/io/helidon/service/maven/plugin/MainGenerator.java
@@ -26,7 +26,6 @@
 import io.helidon.common.types.TypeName;
 import io.helidon.common.types.TypeNames;
 
-import static io.helidon.service.codegen.ServiceCodegenTypes.REGISTRY_STARTUP_PROVIDER;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_CONFIG;
 import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_REGISTRY_MANAGER;
 
@@ -105,9 +104,6 @@ private void mainMethodBody(WrappedServices services,
         } else {
             method.addContentLine("config);");
         }
-
-        method.addContent(REGISTRY_STARTUP_PROVIDER)
-                .addContentLine(".registerShutdownHandler(manager);");
     }
 
 }
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 6ddcc7b1f3b..4ef720d0966 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -197,6 +197,7 @@ public void shutdown() {
     private static ServiceRegistryManager boundManager(Binding binding,
                                                        ServiceRegistryConfig config,
                                                        ServiceRegistryManager manager) {
+        RegistryStartupProvider.registerShutdownHandler(manager);
         ServiceRegistry registry = manager.registry(binding);
         GlobalServiceRegistry.registry(registry);
 

From 5d074acab9484e61e8a62f661edc3d1f1ae3f1e5 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 16:08:46 +0100
Subject: [PATCH 19/23] Update documentation

---
 .../io/helidon/builder/api/Prototype.java     |  2 -
 service/README.md                             | 79 +++++++++++++++----
 service/maven-plugin/README.md                | 41 +++++-----
 .../registry/RegistryStartupProvider.java     | 35 +-------
 .../io/helidon/service/registry/Service.java  | 12 ++-
 .../registry/ServiceRegistryManager.java      | 71 ++++++++++++++---
 service/tests/maven-plugin/pom.xml            |  6 ++
 7 files changed, 158 insertions(+), 88 deletions(-)

diff --git a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
index 93c5f946d25..064459f6b22 100644
--- a/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
+++ b/builder/api/src/main/java/io/helidon/builder/api/Prototype.java
@@ -365,8 +365,6 @@ public interface OptionDecorator<B, T> {
      * <p>
      * When using this annotation, you cannot use {@code serviceRegistry} as a custom option in your blueprint, as it will
      * be added by the annotation processor, to allow customization of the registry instance.
-     * <p>
-     * This
      */
     @Target(ElementType.TYPE)
     @Retention(RetentionPolicy.CLASS)
diff --git a/service/README.md b/service/README.md
index 42af5637451..4dcb84a7813 100644
--- a/service/README.md
+++ b/service/README.md
@@ -291,8 +291,7 @@ class MyImpl implements MyContract {
 }
 ```
 
-This means the service instance itself is an implementation of the contract, and when this service is used to satisfy an injection
-point, we will get an instance of `MyImpl`.
+This means the service instance itself is an implementation of the contract, and when this service is used to satisfy a dependency injection point, we will get an instance of `MyImpl`.
 
 But such an approach is only feasible if the contract is an interface, and we are fine with doing a full implementation.
 There may be cases, where this is not sufficient:
@@ -549,26 +548,76 @@ Lookup parameter options:
 
 # Startup
 
-The following options are available to start a service registry (and the application):
+Helidon provides a Maven plugin (`io.helidon.service:helidon-service-maven-plugin`, goal `create-application`) to generate
+build time bindings, that can be used to start the service registry without any classpath discovery and reflection.
+Default name is `ApplicationBinding` (customizable)
 
-1. Use API to create an `io.helidon.service.registry.ServiceRegistryManager`
-2. Use the Helidon startup class `io.helidon.Main`, which will use the injection main class through service loader
-3. Use a generated main class, by default named `ApplicationMain` in the main package of the application (supports customization)
+Methods that accept the bindings are on `io.helidon.service.registry.ServiceRegistryManager`:
+1. `start(Binding)` - starts the service registry with the generated binding, initializing all singleton and per-lookup services annotated with a `@RunLevel` annotation (i.e. `start(ApplicationBinding.create())`)
+2. `start(Binding, ServiceRegistryConfig)` - same as above, allows for customization of configuration, if used, do not forget to set discovery to `false` to prevent automated discovery from the classpath
+
+All options to start a Helidon application that uses service registry:
+1. A custom Main method using `ServiceRegistryManager.start(...)` methods, or `ServiceRegistryManager.create(...)` methods
+2. A generated `ApplicationMain` - optional feature of the Maven plugin, requires property `generateMain` to be set to `true`
+3. The Helidon startup class `io.helidon.Main`, which will start the registry manager and initialize all `RunLevel` services, though it uses service discover (which in turn must use reflection to get service descriptor instances) 
+
+## Generated Binding
+
+Helidon Service Maven plugin must be configured to generate binding. Binding is only used by the application 
+(i.e. not by library modules).
+
+Example of Maven plugin configuration:
+```xml
+<plugin>
+    <groupId>io.helidon.service</groupId>
+    <artifactId>helidon-service-maven-plugin</artifactId>
+    <version>${helidon.version}</version>
+    <executions>
+        <execution>
+            <id>create-application</id>
+            <goals>
+                <goal>create-application</goal>
+            </goals>
+        </execution>
+    </executions>
+</plugin>
+```
+
+A class `ApplicationBinding` is generated with 
+- all dependency injection point bindings (i.e. which services satisfy injection points, to bypass analysis at startup)
+- registration of all service descriptor with config (to avoid discovery and reflection at runtime)
+- all run levels to initialize (to avoid service registry lookup that returns all services at runtime)
+
+The generated binding can be used to start a service registry as mentioned above, via `ServiceRegistryManager`.
 
 ## Generated Main Class
 
-To generate a main class, the Helidon Service Inject Maven plugin must be configured.
-This is expected to be configured only for an application (i.e. not for library modules) - this is the reason we do not generate it automatically.
+Helidon Service Maven plugin must be configured to generate a Main class. Main class is only used by the application
+(i.e. not by library modules).
 
-The generated main class will contain full, reflection less configuration of the service registry. It registers all services directly through API, and disables service discovery from classpath.
+Example of Maven plugin configuration (`generateMain` is `false` by default):
+```xml
+<plugin>
+    <groupId>io.helidon.service</groupId>
+    <artifactId>helidon-service-maven-plugin</artifactId>
+    <version>${helidon.version}</version>
+    <executions>
+        <execution>
+            <id>create-application</id>
+            <goals>
+                <goal>create-application</goal>
+            </goals>
+        </execution>
+    </executions>
+    <configuration>
+        <generateMain>true</generateMain>
+    </configuration>
+</plugin>
+```
 
-The Main class can also be customized; to do this:
-1. Create a custom class (let's call it `CustomMain` as an example)
-2. The class must extend the injection main class (`public abstract class CustomMain extends InjectionMain`)
-3. The class must be annotated with `@Service.Main`, so it is discovered by annotation processor
-4. Implement any desired methods; the generated class will only implement `serviceDescriptors(ServiceRegistryConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
+The generated class will use the generated binding to start service registry.
 
-For details on how to configure your build, see [Maven Plugin](../maven-plugin/README.md).
+For details on how to configure your build, see [Maven Plugin](./maven-plugin/README.md).
 
 # Other
 
diff --git a/service/maven-plugin/README.md b/service/maven-plugin/README.md
index e7368a81229..f21b093c66c 100644
--- a/service/maven-plugin/README.md
+++ b/service/maven-plugin/README.md
@@ -8,29 +8,24 @@ The Helidon Service Maven Plugin provides the following goals:
 # Create application artifacts Maven goals
 
 This goal creates artifacts that are only valid for the service (assembled from libraries and its own sources).
-This goal generates:
 
-1. Application Binding - a mapping of services to injection points (to bypass runtime lookups), and of service descriptors (to bypass runtime service discovery and reflection) - generates class `Application__Binding`
+This goal generates application binding - a mapping of services to injection points (to bypass runtime lookups), and of service
+descriptors (to bypass runtime service discovery and reflection) - generates class `ApplicationBinding`
+
+The binding class is expected to be used from a custom main class, similar to the following:
 
-To create a custom main class, use the following:
 ```java
 public static void main(String[] args) {
     // this will disable service discovery
     ServiceRegistryManager.start(Application__Binding.create());
-    // alternative - to provide custom configuration; the configuration will only be updated from the generated binding class,
-    // all other options in the config will be left intact
-    // this will honor service discovery configured in the config!
-    // also if any run level is configured, run levels will not be modified; if you do not want to run any run level annotated
-    // service, simply set max run level to 0
-    ServiceRegistryManager.start(Application__Binding.create(), ServiceRegistryConfig.builder().build());
 }
 ```
 
-To use a generated main class, enable it with the maven plugin, an `ApplicationMain` class will be code generated with
+To use a generated main class, enable it with the maven plugin, and an `ApplicationMain` class will be code generated with
 a similar content.
 
-
 Usage of this plugin goal is not required, yet it is recommended for final application module, it will add
+
 - binding for injection points, to avoid runtime lookups
 - explicit registration of all services into `ServiceRegistryConfig`, to avoid resource lookup and reflection at runtime
 - overall speedup of bootstrapping, as all the required tasks to start a service registry are code generated
@@ -46,18 +41,18 @@ Goal names:
 
 Configuration options:
 
-| Name               | Property                                        | Default                | Description                                                                     |
-|--------------------|-------------------------------------------------|------------------------|---------------------------------------------------------------------------------|
-| `packageName`      | `helidon.codegen.package-name`                  | Inferred from module   | Package to put the generated classes in                                         |
-| `moduleName`       | `helidon.codegen.module-name`                   | Inferred from module   | Name of the JPMS module                                                         |
-| `validate`         | `helidon.inject.application.validate`           | `true`                 | Whether to validate application                                                 |
-| `createMain`       | `helidon.inject.application.main.generate`      | `true`                 | Whether to create application Main class                                        |
-| `mainClassName`    | `helidon.inject.application.main.class.name`    | `ApplicationMain`      | Name of the generated Main class                                                |
-| `createBinding`    | `helidon.inject.application.binding.generate`   | `true`                 | Whether to create application binding                                           |
-| `bindingClassName` | `helidon.inject.application.binding.class.name` | `Application__Binding` | Name of the generated binding class, for test, it is `TestApplication__Binding` |
-| `failOnError`      | `helidon.inject.fail-on-error`                  | `true`                 | Whether to fail when the plugin encounters an error                             |
-| `failOnWarning`    | `helidon.inject.fail-on-warning`                | `false`                | Whether to fail when the plugin encounters a warning                            |
-| `compilerArgs`     |                                                 |                        | Arguments of the Java compiler (both classes are compiled by the plugin)        | 
+| Name               | Property                                        | Default              | Description                                                                     |
+|--------------------|-------------------------------------------------|----------------------|---------------------------------------------------------------------------------|
+| `packageName`      | `helidon.codegen.package-name`                  | Inferred from module | Package to put the generated classes in                                         |
+| `moduleName`       | `helidon.codegen.module-name`                   | Inferred from module | Name of the JPMS module                                                         |
+| `validate`         | `helidon.inject.application.validate`           | `true`               | Whether to validate application                                                 |
+| `createMain`       | `helidon.inject.application.main.generate`      | `true`               | Whether to create application Main class                                        |
+| `mainClassName`    | `helidon.inject.application.main.class.name`    | `ApplicationMain`    | Name of the generated Main class                                                |
+| `createBinding`    | `helidon.inject.application.binding.generate`   | `true`               | Whether to create application binding                                           |
+| `bindingClassName` | `helidon.inject.application.binding.class.name` | `ApplicationBinding` | Name of the generated binding class, for test, it is `TestApplication__Binding` |
+| `failOnError`      | `helidon.inject.fail-on-error`                  | `true`               | Whether to fail when the plugin encounters an error                             |
+| `failOnWarning`    | `helidon.inject.fail-on-warning`                | `false`              | Whether to fail when the plugin encounters a warning                            |
+| `compilerArgs`     |                                                 |                      | Arguments of the Java compiler (both classes are compiled by the plugin)        | 
 
 Configuration example in `pom.xml`:
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
index 2863d8f234d..0325fc9d4be 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/RegistryStartupProvider.java
@@ -16,9 +16,6 @@
 
 package io.helidon.service.registry;
 
-import java.util.List;
-import java.util.Optional;
-
 import io.helidon.Main;
 import io.helidon.common.Weight;
 import io.helidon.common.Weighted;
@@ -31,8 +28,6 @@
  */
 @Weight(Weighted.DEFAULT_WEIGHT) // explicit default weight, this should be the "default" startup class
 public class RegistryStartupProvider implements HelidonStartupProvider {
-    private static final System.Logger LOGGER = System.getLogger(RegistryStartupProvider.class.getName());
-
     /**
      * Default constructor required by {@link java.util.ServiceLoader}.
      *
@@ -57,35 +52,7 @@ public static void registerShutdownHandler(ServiceRegistryManager registryManage
 
     @Override
     public void start(String[] arguments) {
-        var manager = ServiceRegistryManager.create();
-        var registry = manager.registry();
-        registerShutdownHandler(manager);
-
-        for (Double runLevel : runLevels(registry)) {
-            List<Object> all = registry.all(Lookup.builder()
-                                                    .addScope(Service.Singleton.TYPE)
-                                                    .runLevel(runLevel)
-                                                    .build());
-            if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
-                LOGGER.log(System.Logger.Level.DEBUG, "Starting services in run level: " + runLevel + ": ");
-                for (Object o : all) {
-                    LOGGER.log(System.Logger.Level.DEBUG, "\t" + o);
-                }
-            } else if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
-                LOGGER.log(System.Logger.Level.TRACE, "Starting services in run level: " + runLevel);
-            }
-        }
-    }
-
-    private List<Double> runLevels(ServiceRegistry registry) {
-        // child classes will have this method code generated at build time
-        return registry.lookupServices(Lookup.EMPTY)
-                .stream()
-                .map(ServiceInfo::runLevel)
-                .flatMap(Optional::stream)
-                .distinct()
-                .sorted()
-                .toList();
+        ServiceRegistryManager.start();
     }
 
     // higher than default, so we stop server as a service, not through shutdown
diff --git a/service/registry/src/main/java/io/helidon/service/registry/Service.java b/service/registry/src/main/java/io/helidon/service/registry/Service.java
index 5fb6d69d5de..356e81caa98 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Service.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Service.java
@@ -277,8 +277,16 @@ private Service() {
     }
 
     /**
-     * Indicates the desired startup sequence for a service class. This is not used internally by Injection, but is available as a
-     * convenience to the caller in support for a specific startup sequence for service activations.
+     * Indicates the desired startup sequence for a service class.
+     *
+     * Helidon honors run levels only when using one of the start methods on
+     * {@link io.helidon.service.registry.ServiceRegistryManager}:
+     * <ul>
+     *     <li>{@link io.helidon.service.registry.ServiceRegistryManager#start()}</li>
+     *     <li>{@link io.helidon.service.registry.ServiceRegistryManager#start(Binding)}</li>
+     *     <li>{@link io.helidon.service.registry.ServiceRegistryManager#start(Binding, ServiceRegistryConfig)}</li>
+     *     <li>{@link io.helidon.service.registry.ServiceRegistryManager#start(ServiceRegistryConfig)}</li>
+     * </ul>
      */
     @Documented
     @Retention(RetentionPolicy.CLASS)
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
index 4ef720d0966..5702bbb7d4a 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceRegistryManager.java
@@ -23,6 +23,7 @@
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -113,7 +114,7 @@ public static ServiceRegistryManager start(Binding binding, ServiceRegistryConfi
     /**
      * Start the service registry with no generated binding with the provided config.
      * This method honors {@link ServiceRegistryConfig#maxRunLevel()} and {@link ServiceRegistryConfig#runLevels()}
-     * to initialize services that fit.
+     * to initialize services that fit. In case {@code runLevels} are empty, the registry will initialize all run levels.
      * <p>
      * Registers the registry as the {@link io.helidon.service.registry.GlobalServiceRegistry}.
      *
@@ -121,7 +122,22 @@ public static ServiceRegistryManager start(Binding binding, ServiceRegistryConfi
      * @return a new registry manager with initialized registry
      */
     public static ServiceRegistryManager start(ServiceRegistryConfig config) {
-        return start(new NoOpBinding(), config);
+        ServiceRegistryManager manager = start(new NoOpBinding(), config);
+        ServiceRegistry registry = manager.registry();
+        if (config.runLevels().isEmpty()) {
+            double maxRunLevel = config.maxRunLevel();
+
+            List<Double> runLevels = registry.lookupServices(Lookup.EMPTY)
+                    .stream()
+                    .map(ServiceInfo::runLevel)
+                    .flatMap(Optional::stream)
+                    .distinct()
+                    .sorted()
+                    .collect(Collectors.toUnmodifiableList());
+
+            initializeRunLevels(registry, maxRunLevel, runLevels);
+        }
+        return manager;
     }
 
     /**
@@ -143,6 +159,18 @@ public static ServiceRegistryManager start(Binding binding) {
         return boundManager(binding, config, manager);
     }
 
+    /**
+     * Create a new manager with default configuration, and initialize all services that have a
+     * {@link io.helidon.service.registry.Service.RunLevel} defined in ascending order (only singletons are initialized).
+     * <p>
+     * Registers the registry as the {@link io.helidon.service.registry.GlobalServiceRegistry}.
+     *
+     * @return a new registry manager with an initialized registry
+     */
+    public static ServiceRegistryManager start() {
+        return start(ServiceRegistryConfig.create());
+    }
+
     /**
      * Create a new service registry manager with default configuration.
      *
@@ -194,22 +222,14 @@ public void shutdown() {
         }
     }
 
-    private static ServiceRegistryManager boundManager(Binding binding,
-                                                       ServiceRegistryConfig config,
-                                                       ServiceRegistryManager manager) {
-        RegistryStartupProvider.registerShutdownHandler(manager);
-        ServiceRegistry registry = manager.registry(binding);
-        GlobalServiceRegistry.registry(registry);
-
-        double maxRunLevel = config.maxRunLevel();
-        List<Double> runLevels = new ArrayList<>(config.runLevels());
-        Collections.sort(runLevels);
+    private static void initializeRunLevels(ServiceRegistry registry, double maxRunLevel, List<Double> runLevels) {
         for (Double runLevel : runLevels) {
             if (runLevel > maxRunLevel) {
                 // no more
                 break;
             }
 
+            // first all singletons
             List<Object> all = registry.all(Lookup.builder()
                                                     .addScope(Service.Singleton.TYPE)
                                                     .runLevel(runLevel)
@@ -222,7 +242,34 @@ private static ServiceRegistryManager boundManager(Binding binding,
             } else if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
                 LOGGER.log(System.Logger.Level.TRACE, "Starting services in run level: " + runLevel);
             }
+
+            // then all per lookup
+            all = registry.all(Lookup.builder()
+                                       .addScope(Service.PerLookup.TYPE)
+                                       .runLevel(runLevel)
+                                       .build());
+            if (LOGGER.isLoggable(System.Logger.Level.TRACE)) {
+                LOGGER.log(System.Logger.Level.DEBUG, "Starting per lookup services in run level: " + runLevel + ": ");
+                for (Object o : all) {
+                    LOGGER.log(System.Logger.Level.DEBUG, "\t" + o);
+                }
+            } else if (LOGGER.isLoggable(System.Logger.Level.DEBUG)) {
+                LOGGER.log(System.Logger.Level.TRACE, "Starting per lookup services in run level: " + runLevel);
+            }
         }
+    }
+
+    private static ServiceRegistryManager boundManager(Binding binding,
+                                                       ServiceRegistryConfig config,
+                                                       ServiceRegistryManager manager) {
+        RegistryStartupProvider.registerShutdownHandler(manager);
+        ServiceRegistry registry = manager.registry(binding);
+        GlobalServiceRegistry.registry(registry);
+
+        double maxRunLevel = config.maxRunLevel();
+        List<Double> runLevels = new ArrayList<>(config.runLevels());
+        Collections.sort(runLevels);
+        initializeRunLevels(registry, maxRunLevel, runLevels);
 
         return manager;
     }
diff --git a/service/tests/maven-plugin/pom.xml b/service/tests/maven-plugin/pom.xml
index 1f847942cdc..020978f5818 100644
--- a/service/tests/maven-plugin/pom.xml
+++ b/service/tests/maven-plugin/pom.xml
@@ -54,6 +54,12 @@
             <version>${version.plugin.helidon-build-tools}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <!-- here to make sure we have correctly ordered build -->
+            <groupId>io.helidon.service</groupId>
+            <artifactId>helidon-service-maven-plugin</artifactId>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
     <build>

From bf946834c9ce9591c2b2d123bdc45fc1c27adccb Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 20:39:54 +0100
Subject: [PATCH 20/23] Fix versions of plugins and release of java in maven
 invoker tests

---
 .../src/it/projects/test1/pom.xml             | 39 +++++++++++++++++++
 .../src/it/projects/test2/pom.xml             | 39 +++++++++++++++++++
 .../src/it/projects/test3/pom.xml             | 39 +++++++++++++++++++
 3 files changed, 117 insertions(+)

diff --git a/service/tests/maven-plugin/src/it/projects/test1/pom.xml b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
index 475692cf740..9a3e5ad3064 100644
--- a/service/tests/maven-plugin/src/it/projects/test1/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test1/pom.xml
@@ -27,6 +27,13 @@
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 1</name>
 
+    <properties>
+        <maven.compiler.release>21</maven.compiler.release>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <surefire.argLine>-Xmx1024m -Dfile.encoding=UTF-8</surefire.argLine>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
@@ -36,6 +43,38 @@
     </dependencies>
 
     <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-resources-plugin</artifactId>
+                    <version>2.7</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>3.13.0</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-install-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>2.12.4</version>
+                    <configuration>
+                        <argLine>${surefire.argLine}</argLine>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
diff --git a/service/tests/maven-plugin/src/it/projects/test2/pom.xml b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
index 8b2a5732465..748edad6eb6 100644
--- a/service/tests/maven-plugin/src/it/projects/test2/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test2/pom.xml
@@ -27,6 +27,13 @@
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 2</name>
 
+    <properties>
+        <maven.compiler.release>21</maven.compiler.release>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <surefire.argLine>-Xmx1024m -Dfile.encoding=UTF-8</surefire.argLine>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
@@ -36,6 +43,38 @@
     </dependencies>
 
     <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-resources-plugin</artifactId>
+                    <version>2.7</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>3.13.0</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-install-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>2.12.4</version>
+                    <configuration>
+                        <argLine>${surefire.argLine}</argLine>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
diff --git a/service/tests/maven-plugin/src/it/projects/test3/pom.xml b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
index 2abe8151597..0a5a175356c 100644
--- a/service/tests/maven-plugin/src/it/projects/test3/pom.xml
+++ b/service/tests/maven-plugin/src/it/projects/test3/pom.xml
@@ -27,6 +27,13 @@
     <version>@project.version@</version>
     <name>Test Inject Maven Plugin 3</name>
 
+    <properties>
+        <maven.compiler.release>21</maven.compiler.release>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <surefire.argLine>-Xmx1024m -Dfile.encoding=UTF-8</surefire.argLine>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>io.helidon.service</groupId>
@@ -36,6 +43,38 @@
     </dependencies>
 
     <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-resources-plugin</artifactId>
+                    <version>2.7</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>3.13.0</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-install-plugin</artifactId>
+                    <version>2.4</version>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>2.12.4</version>
+                    <configuration>
+                        <argLine>${surefire.argLine}</argLine>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>

From 990ba2c7252710d937c4661f0201440a1980e448 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 21:26:38 +0100
Subject: [PATCH 21/23] Ensure bindings must not fail if no descriptor
 discovered, as there may be a service that requires a dependency, but itself
 is not required by any injection point.

---
 .../io/helidon/service/registry/Bindings.java     | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/service/registry/src/main/java/io/helidon/service/registry/Bindings.java b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
index 4f3eaee232b..82da5daeb12 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/Bindings.java
@@ -161,7 +161,7 @@ private DependencyBinding(CoreServiceRegistry registry, ServiceInfo serviceInfo,
                     .build();
         }
 
-        public List<ServiceInfo> descriptors() {
+        List<ServiceInfo> descriptors() {
             return serviceInfos;
         }
 
@@ -269,19 +269,12 @@ private List managers(List<ServiceInfo> serviceInfos) {
 
         private void discoverBinding() {
             // lookup services, exclude ourselves (when doing chained injection, we lookup by weight)
-            List<ServiceInfo> found = registry.lookupServices(lookup)
+            // we need all service descriptors, as a service may not yield a service
+            // (such as optional suppliers, ServicesFactory etc.), so we use the next one
+            this.serviceInfos = registry.lookupServices(lookup)
                     .stream()
                     .filter(it -> it != serviceInfo)
                     .collect(Collectors.toList());
-            if (found.isEmpty() && (dependency.cardinality() == DependencyCardinality.REQUIRED)) {
-                throw new ServiceRegistryException("There is no service in registry that satisfied this dependency: "
-                                                           + dependency);
-            }
-
-            // we need all service descriptors, as a service may not yield a service
-            // (such as optional suppliers, ServicesFactory etc.), so we use the next one
-
-            this.serviceInfos = found;
         }
 
         private static class DependencySupplier implements Supplier<Object> {

From ef781424cffb969e88234873d61b2f307a21f430 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Tue, 17 Dec 2024 22:58:02 +0100
Subject: [PATCH 22/23] Fixed service supply. Now we try to use all matchin
 service descriptors even for a single instance, as any may return an empty
 optional (if appropriate supplier type), and we would not yield an instance,
 even when we should. As a result the method "explodeFilterAndSort" was going
 through all service manager and collected all instances - which resulted in
 errors if a provider with lower weight was not capable of creating an intance
 because of unsatisfied dependency.

---
 integrations/oci/tls-certificates/pom.xml     |  1 -
 .../OciCertificatesTlsManagerTest.java        |  2 +-
 .../service/registry/ServiceSupplies.java     | 35 ++++++++++++++-----
 3 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/integrations/oci/tls-certificates/pom.xml b/integrations/oci/tls-certificates/pom.xml
index 6e584f9932a..4e8dd495662 100644
--- a/integrations/oci/tls-certificates/pom.xml
+++ b/integrations/oci/tls-certificates/pom.xml
@@ -182,7 +182,6 @@
                         <CA_OCID>SETME</CA_OCID>
                         <SERVER_CERT_OCID>SETME</SERVER_CERT_OCID>
                         <SERVER_KEY_OCID>SETME</SERVER_KEY_OCID>
-
                         <oci.real.usage>false</oci.real.usage>
                     </systemPropertyVariables>
                 </configuration>
diff --git a/integrations/oci/tls-certificates/src/test/java/io/helidon/integrations/oci/tls/certificates/OciCertificatesTlsManagerTest.java b/integrations/oci/tls-certificates/src/test/java/io/helidon/integrations/oci/tls/certificates/OciCertificatesTlsManagerTest.java
index 88ee911e7c7..7ca9df86b2e 100644
--- a/integrations/oci/tls-certificates/src/test/java/io/helidon/integrations/oci/tls/certificates/OciCertificatesTlsManagerTest.java
+++ b/integrations/oci/tls-certificates/src/test/java/io/helidon/integrations/oci/tls/certificates/OciCertificatesTlsManagerTest.java
@@ -74,7 +74,7 @@ void configIsMonitoredForChange() throws Exception {
         assertThat("sanity",
                    caCertDownloadCountBaseline0,
                    equalTo(0));
-        assertThat("santiy",
+        assertThat("sanity",
                    pkDownloadCountBaseLine0,
                    equalTo(0));
 
diff --git a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
index a34521f81c1..94e58e29724 100644
--- a/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
+++ b/service/registry/src/main/java/io/helidon/service/registry/ServiceSupplies.java
@@ -33,6 +33,29 @@ final class ServiceSupplies {
     private ServiceSupplies() {
     }
 
+    private static <T> Optional<ServiceInstance<T>> oneInstance(Lookup lookup,
+                                                                List<ServiceManager<T>> serviceManagers) {
+        // we may have more than one service manager, as the first one(s) may not provide a value
+        traceLookup(lookup, "explode, filter, and sort");
+
+        for (ServiceManager<T> serviceManager : serviceManagers) {
+            Optional<ServiceInstance<T>> thisManager = serviceManager.activator()
+                    .instances(lookup)
+                    .stream()
+                    .flatMap(List::stream)
+                    .map(it -> serviceManager.registryInstance(lookup, it))
+                    .findFirst();
+
+            traceLookupInstance(lookup, serviceManager, thisManager.map(List::of).orElseGet(List::of));
+
+            if (thisManager.isPresent()) {
+                return thisManager;
+            }
+        }
+
+        return Optional.empty();
+    }
+
     private static <T> List<ServiceInstance<T>> explodeFilterAndSort(Lookup lookup,
                                                                      List<ServiceManager<T>> serviceManagers) {
         // this method is called when we resolve instances, so we can safely assume any scope is active
@@ -133,9 +156,7 @@ static class ServiceSupply<T> extends ServiceSupplyBase<T> implements Supplier<T
 
             Supplier<T> supplier;
 
-            supplier = () -> explodeFilterAndSort(lookup, managers)
-                    .stream()
-                    .findFirst()
+            supplier = () -> oneInstance(lookup, managers)
                     .map(ServiceInstance::get)
                     .orElseThrow(() -> new ServiceRegistryException(
                             "Neither of matching services could provide a value. Descriptors: " + managers + ", "
@@ -158,9 +179,7 @@ static class ServiceSupplyOptional<T> extends ServiceSupplyBase<T> implements Su
 
         @Override
         public Optional<T> get() {
-            Optional<ServiceInstance<T>> first = explodeFilterAndSort(super.lookup, super.managers)
-                    .stream()
-                    .findFirst();
+            Optional<ServiceInstance<T>> first = oneInstance(super.lookup, super.managers);
             return first.map(Supplier::get);
         }
     }
@@ -173,9 +192,7 @@ static class ServiceInstanceSupplyOptional<T> extends ServiceSupplyBase<T> imple
 
         @Override
         public Optional<ServiceInstance<T>> get() {
-            return explodeFilterAndSort(super.lookup, super.managers)
-                    .stream()
-                    .findFirst();
+            return oneInstance(super.lookup, super.managers);
         }
     }
 

From 99dd7745fa025de0210aa3c29a7f402d69b2bec3 Mon Sep 17 00:00:00 2001
From: Tomas Langer <tomas.langer@oracle.com>
Date: Wed, 18 Dec 2024 00:05:35 +0100
Subject: [PATCH 23/23] Plugin management for services Maven plugin

---
 applications/parent/pom.xml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/applications/parent/pom.xml b/applications/parent/pom.xml
index a6d26ad323b..714d0b1acd3 100644
--- a/applications/parent/pom.xml
+++ b/applications/parent/pom.xml
@@ -212,6 +212,11 @@
                         </execution>
                     </executions>
                 </plugin>
+                <plugin>
+                    <groupId>io.helidon.service</groupId>
+                    <artifactId>helidon-service-project</artifactId>
+                    <version>${helidon.version}</version>
+                </plugin>
             </plugins>
         </pluginManagement>
     </build>