diff --git a/core-common/src/main/java/org/glassfish/jersey/innate/inject/package-info.java b/core-common/src/main/java/org/glassfish/jersey/innate/inject/package-info.java
new file mode 100644
index 0000000000..b276f3c87d
--- /dev/null
+++ b/core-common/src/main/java/org/glassfish/jersey/innate/inject/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey innate injection related packages. The innate packages will not be opened by JPMS outside of Jersey.
+ * Not for public use.
+ */
+package org.glassfish.jersey.innate.inject;
diff --git a/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/ExternalRegistrables.java b/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/ExternalRegistrables.java
new file mode 100644
index 0000000000..0f0c4179e0
--- /dev/null
+++ b/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/ExternalRegistrables.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.innate.inject.spi;
+
+import javax.ws.rs.RuntimeType;
+import java.util.List;
+
+/**
+ * Provide a list of classes or interfaces the InjectionManager can support.
+ */
+public interface ExternalRegistrables {
+
+    /**
+     * Contract - RuntimeType pair. For a contract applicable on both client and server, use {@code null} as RuntimeType.
+     */
+    public static final class ClassRuntimeTypePair {
+        private final Class<?> contract;
+        private final RuntimeType runtimeType;
+
+        public ClassRuntimeTypePair(Class<?> contract, RuntimeType runtimeType) {
+            this.contract = contract;
+            this.runtimeType = runtimeType;
+        }
+
+        public Class<?> getContract() {
+            return contract;
+        }
+
+        public RuntimeType getRuntimeType() {
+            return runtimeType;
+        }
+    }
+
+    /**
+     * List of contracts that can be registered into Jersey to be passed by the external injection framework.
+     * @return list of contracts allowed to be registered in Jersey.
+     */
+    List<ClassRuntimeTypePair> registrableContracts();
+}
diff --git a/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/package-info.java b/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/package-info.java
new file mode 100644
index 0000000000..5ad36ddc40
--- /dev/null
+++ b/core-common/src/main/java/org/glassfish/jersey/innate/inject/spi/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey innate injection related packages. The innate packages will not be opened by JPMS outside of Jersey.
+ * Not for public use.
+ */
+package org.glassfish.jersey.innate.inject.spi;
diff --git a/core-common/src/main/java/org/glassfish/jersey/innate/package-info.java b/core-common/src/main/java/org/glassfish/jersey/innate/package-info.java
new file mode 100644
index 0000000000..a1835bb74a
--- /dev/null
+++ b/core-common/src/main/java/org/glassfish/jersey/innate/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey innate packages. The innate packages will not be opened by JPMS outside of Jersey.
+ * Not for public use.
+ */
+package org.glassfish.jersey.innate;
diff --git a/core-common/src/main/java/org/glassfish/jersey/internal/inject/Providers.java b/core-common/src/main/java/org/glassfish/jersey/internal/inject/Providers.java
index 2e909a8cb4..72e2f4b935 100644
--- a/core-common/src/main/java/org/glassfish/jersey/internal/inject/Providers.java
+++ b/core-common/src/main/java/org/glassfish/jersey/internal/inject/Providers.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -43,7 +43,9 @@
 import javax.annotation.Priority;
 
 import org.glassfish.jersey.JerseyPriorities;
+import org.glassfish.jersey.innate.inject.spi.ExternalRegistrables;
 import org.glassfish.jersey.internal.LocalizationMessages;
+import org.glassfish.jersey.internal.ServiceFinder;
 import org.glassfish.jersey.model.ContractProvider;
 import org.glassfish.jersey.model.internal.RankedComparator;
 import org.glassfish.jersey.model.internal.RankedProvider;
@@ -103,6 +105,14 @@ private static Map<Class<?>, ProviderRuntime> getExternalProviderInterfaces() {
         interfaces.putAll(JAX_RS_PROVIDER_INTERFACE_WHITELIST);
         interfaces.put(javax.ws.rs.core.Feature.class, ProviderRuntime.BOTH);
         interfaces.put(Binder.class, ProviderRuntime.BOTH);
+
+        try {
+            ServiceFinder<ExternalRegistrables> registerables = ServiceFinder.find(ExternalRegistrables.class, true);
+            registerables.forEach(regs -> regs.registrableContracts()
+                    .forEach(pair -> interfaces.put(pair.getContract(), ProviderRuntime.fromRuntimeType(pair.getRuntimeType()))));
+        } catch (Throwable t) {
+            LOGGER.warning(LocalizationMessages.ERROR_EXTERNAL_REGISTERABLES_IGNORED(t.getMessage()));
+        }
         return interfaces;
     }
 
@@ -119,6 +129,10 @@ private ProviderRuntime(final RuntimeType runtime) {
         public RuntimeType getRuntime() {
             return runtime;
         }
+
+        private static ProviderRuntime fromRuntimeType(RuntimeType type) {
+            return type == null ? BOTH : (type == RuntimeType.SERVER ? SERVER : CLIENT);
+        }
     }
 
     /**
diff --git a/core-common/src/main/resources/org/glassfish/jersey/internal/localization.properties b/core-common/src/main/resources/org/glassfish/jersey/internal/localization.properties
index 285b9de36e..e546e16639 100644
--- a/core-common/src/main/resources/org/glassfish/jersey/internal/localization.properties
+++ b/core-common/src/main/resources/org/glassfish/jersey/internal/localization.properties
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2012, 2024 Oracle and/or its affiliates. All rights reserved.
 # Copyright (c) 2018 Payara Foundation and/or its affiliates.
 #
 # This program and the accompanying materials are made available under the
@@ -39,6 +39,7 @@ error.entity.stream.closed=Entity input stream has already been closed.
 error.entity.provider.basictypes.character.morechars=A single character expected in the entity input stream.
 error.entity.provider.basictypes.constructor=Error converting entity to {0} type by single String constructor.
 error.entity.provider.basictypes.unkwnown=Unsupported basic type {0}.
+error.external.registerables.ignored=Error reading external registrable contracts: {0}.
 error.finding.exception.mapper.type=Could not find exception type for given ExceptionMapper class: {0}.
 error.interceptor.reader.proceed=Last reader interceptor in the chain called the method proceed.
 error.interceptor.writer.proceed=Last writer interceptor in the chain called the method proceed.
diff --git a/docs/src/main/docbook/custom-di.xml b/docs/src/main/docbook/custom-di.xml
index 53a5a645f5..e1a66b5875 100644
--- a/docs/src/main/docbook/custom-di.xml
+++ b/docs/src/main/docbook/custom-di.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2013, 2024 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -60,19 +60,45 @@
     </para>
 
     <para>
-        Relying on Servlet HTTP session concept is not very RESTful. It turns the originally state-less HTTP
-        communication schema into a state-full manner. However, it could serve
-        as a good example that will help me demonstrate implementation of the use cases described above.
-        The following examples should work on top of Jersey Servlet integration module. The approach that will be
-        demonstrated could be further generalized.
-        Below we will show how to make actual Servlet &jee6.servlet.HttpSession; injectable into JAX-RS components
-        and how to make this injection work with a custom inject annotation type. Finally, we will demonstrate
-        how you can write &lit.jee6.servlet.HttpSession;-scoped JAX-RS resources.
+        Since Jersey 2.26, the injection has been abstracted, so that &hk2.link; can be eventually replaced by the CDI or
+        any other injection framework. In the next chapters, we document possibilities provided directly by &hk2.link; and
+        by Jersey abstraction components.
     </para>
 
+    <section xml:id="injection.manager">
+        <title>InjectionManager</title>
+
+        <para>
+            Since Jersey 2.26, Jersey comes with the main abstraction interface to communicate with the DI container, the
+            &jersey.common.internal.inject.InjectionManager;. What is <literal>ServiceLocator</literal> for &hk2.link;, or
+            <literal>BeanManager</literal> for CDI, that's &jersey.common.internal.inject.InjectionManager; for Jersey.
+        </para>
+        <para>
+            &jersey.common.internal.inject.InjectionManager; can be injected into the user provided classes instantiated
+            by Jersey. It can also be obtained programmatically by &jersey.client.InjectionManagerClientProvider;
+            and &lit.jersey.common.InjectionManagerProvider; from Jakarta REST components, such as
+            &jaxrs.core.FeatureContext;, or &jaxrs.ext.MessageBodyReader; and &jaxrs.ext.MessageBodyReader;.
+        </para>
+        <para>
+            Customers used to the &hk2.ServiceLocator; can still use it directly; the &hk2.ServiceLocator; can be obtained
+            either directly by injection, or programmatically as <literal>InjectionManager.getInstance(ServiceLocator.class)</literal>.
+        </para>
+    </section>
+
     <section>
         <title>Implementing Custom Injection Provider</title>
 
+        <para>
+            Relying on Servlet HTTP session concept is not very RESTful. It turns the originally state-less HTTP
+            communication schema into a state-full manner. However, it could serve
+            as a good example that will help me demonstrate implementation of the use cases described above.
+            The following examples should work on top of Jersey Servlet integration module. The approach that will be
+            demonstrated could be further generalized.
+            Below we will show how to make actual Servlet &jee6.servlet.HttpSession; injectable into JAX-RS components
+            and how to make this injection work with a custom inject annotation type. Finally, we will demonstrate
+            how you can write &lit.jee6.servlet.HttpSession;-scoped JAX-RS resources.
+        </para>
+
         <para>
             Jersey implementation allows you to directly inject &jee6.servlet.HttpServletRequest; instance into
             your JAX-RS components.
@@ -89,7 +115,11 @@ public class MyDiResource {
     ...
 
 }</programlisting>
+        </para>
+        <section>
+            <title>Using HK2 classes</title>
 
+            <para>
             To make the above injection work, you will need to define an additional HK2 binding in your
             application &jersey.server.ResourceConfig;.
             Let's start with a custom HK2 &hk2.Factory; implementation that knows how to extract
@@ -145,48 +175,122 @@ public class MyApplication extends ResourceConfig {
             @Override
             protected void configure() {
                 bindFactory(HttpSessionFactory.class).to(HttpSession.class)
-                .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
+                   .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
             }
         });
     }
 }</programlisting>
 
-            Note that we did not define any explicit injection scope for the new injection binding.
-            By default, HK2 factories are bound in a HK2 &hk2.PerLookup; scope, which is in most
-            cases a good choice and it is suitable also in our example.
-        </para>
+                Note that if we did not define any explicit injection scope for the new injection binding,
+                By default, HK2 factories are bound in a HK2 &hk2.PerLookup; scope, which is in most
+                cases a good choice, and it is suitable also in our example.
+            </para>
+
+            <para>
+                To summarize the approach described above, here is a list of steps to follow
+                when implementing custom injection provider in your Jersey application :
+
+                <itemizedlist>
+                    <listitem><simpara>Implement your own HK2 &lit.hk2.Factory; to provide the
+                        injectable instances.</simpara></listitem>
+                    <listitem><simpara>Use the HK2 &lit.hk2.Factory; to define an injection
+                        binding for the injected instance via custom HK2 &lit.hk2.Binder;.</simpara></listitem>
+                    <listitem><simpara>Register the custom HK2 &lit.hk2.Binder; in your application
+                        &lit.jersey.server.ResourceConfig;.</simpara></listitem>
+                </itemizedlist>
+            </para>
+
+            <para>
+                While the &lit.hk2.Factory;-based approach is quite straight-forward and should help you to
+                quickly prototype or even implement final solutions, you should bear in mind, that your
+                implementation does not need to be based on factories. You can for instance bind your own
+                types directly, while still taking advantage of HK2 provided dependency injection.
+                Also, in your implementation you may want to pay more attention to defining or managing
+                injection binding scopes for the sake of performance or correctness of your custom injection
+                extension.
+
+                <important>
+                    <para>
+                        While the individual injection binding implementations vary and depend on your use case,
+                        to enable your custom injection extension in Jersey, you must register your custom HK2 &hk2.Binder;
+                        implementation in your application &jersey.server.ResourceConfig;!
+                    </para>
+                </important>
+            </para>
+        </section>
+        <section>
+            <title>Injection Provider Using Jersey API</title>
+            <para>
+                To make the <literal>HttpSession</literal> injection work without using HK2 API,
+                we will need to create a custom supplier that knows how to extract
+                &lit.jee6.servlet.HttpSession; out of given &lit.jee6.servlet.HttpServletRequest;.
+
+                <programlisting language="java">import java.util.function.Supplier
+    ...
 
-        <para>
-            To summarize the approach described above, here is a list of steps to follow
-            when implementing custom injection provider in your Jersey application :
-
-            <itemizedlist>
-                <listitem><simpara>Implement your own HK2 &lit.hk2.Factory; to provide the
-                    injectable instances.</simpara></listitem>
-                <listitem><simpara>Use the HK2 &lit.hk2.Factory; to define an injection
-                    binding for the injected instance via custom HK2 &lit.hk2.Binder;.</simpara></listitem>
-                <listitem><simpara>Register the custom HK2 &lit.hk2.Binder; in your application
-                    &lit.jersey.server.ResourceConfig;.</simpara></listitem>
-            </itemizedlist>
-        </para>
+public class HttpSessionSupplier implements Supplier&lt;HttpSession&gt; {
 
-        <para>
-            While the &lit.hk2.Factory;-based approach is quite straight-forward and should help you to
-            quickly prototype or even implement final solutions, you should bear in mind, that your
-            implementation does not need to be based on factories. You can for instance bind your own
-            types directly, while still taking advantage of HK2 provided dependency injection.
-            Also, in your implementation you may want to pay more attention to defining or managing
-            injection binding scopes for the sake of performance or correctness of your custom injection
-            extension.
-
-            <important>
-                <para>
-                    While the individual injection binding implementations vary and depend on your use case,
-                    to enable your custom injection extension in Jersey, you must register your custom HK2 &hk2.Binder;
-                    implementation in your application &jersey.server.ResourceConfig;!
-                </para>
-            </important>
-        </para>
+    private final HttpServletRequest request;
+
+    @Inject
+    public HttpSessionSupplier(HttpServletRequest request) {
+        this.request = request;
+    }
+
+    @Override
+    public HttpSession get() {
+        return request.getSession();
+    }
+
+}</programlisting>
+
+                Once implemented, the supplier can be used in a custom Jersey &jersey.common.internal.inject.AbstractBinder;
+                to define the new injection binding for &lit.jee6.servlet.HttpSession;. Finally, the implemented binder
+                can be registered in your &jersey.server.ResourceConfig;:
+
+                <programlisting language="java">import org.glassfish.jersey.internal.inject.AbstractBinder;
+    ...
+public class MyApplication extends ResourceConfig {
+
+    public MyApplication() {
+
+        ...
+
+        register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bindFactory(HttpSessionSupplier.class).to(HttpSession.class)
+                    .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
+            }
+        });
+    }
+}</programlisting>
+                   The default scope for Jersey binder is similarly as for the HK2, the
+                &jersey.common.internal.inject.PerLookup;.
+            </para>
+            <para>
+                To summarize the approach described above, here is a list of steps to follow
+                when implementing custom injection provider in your Jersey application :
+
+                <itemizedlist>
+                    <listitem><simpara>Implement your own Supplier to provide the
+                        injectable instances.</simpara></listitem>
+                    <listitem><simpara>Use the Supplier to define an injection
+                        binding for the injected instance via custom &jersey.common.internal.inject.AbstractBinder;.
+                    </simpara></listitem>
+                    <listitem><simpara>Register the custom &jersey.common.internal.inject.AbstractBinder; in your application
+                        &lit.jersey.server.ResourceConfig;.</simpara></listitem>
+                </itemizedlist>
+
+                <important>
+                    <para>
+                        Similarly to the HK2, to enable your custom injection extension in Jersey,
+                        you must register your custom &jersey.common.internal.inject.AbstractBinder;
+                        implementation in your application &jersey.server.ResourceConfig;!
+                    </para>
+                </important>
+            </para>
+        </section>
     </section>
 
     <section>
@@ -231,6 +335,8 @@ public class MyDiResource {
             use case will help us to avoid use case specific distractions and allow us better focus on
             the important aspects of the job of defining a custom injection annotation.
         </para>
+        <section>
+            <title>Custom Injection Annotation using HK2</title>
 
         <para>
             If you remember from the previous section, to make the injection in the code snippet above work,
@@ -317,6 +423,104 @@ public class MyApplication extends ResourceConfig {
     }
 }</programlisting>
         </para>
+        </section>
+        <section>
+            <title>Custom Injection Annotation using Jersey InjectionResolver</title>
+
+            <para>
+                Jersey also comes with its &jersey.common.internal.inject.InjectionResolver; used to translate into
+                the HK2 &hk2.InjectionResolver; during runtime. The abstraction is important for allowing to support
+                the custom injection annotation in various DI containers. For instance, the abstraction is used when
+                supporting injection using &jaxrs.core.Context; in the CDI container (<literal>jersey-cdi2-se</literal> module).
+            </para>
+            <para>
+                The SessionInjectResolver then looks as follows:
+<programlisting language="java">import javax.inject.Inject;
+
+import javax.servlet.http.HttpSession;
+
+import org.glassfish.jersey.internal.inject.InjectionResolver;
+
+...
+
+public class SessionInjectResolver implements InjectionResolver&lt;SessionInject&gt; {
+
+    private final InjectionManger injectionManager;
+
+    public SessionInjectResolver(InjectionManager) {
+        this.injectionManager = injectionManager;
+    }
+
+    @Override
+    public Object resolve(Injectee injectee) {
+        if (HttpSession.class == injectee.getRequiredType()) {
+            return injectionManager.getInstance(HttpServletRequest.class).getSession();
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isConstructorParameterIndicator() {
+        return false;
+    }
+
+    @Override
+    public boolean isMethodParameterIndicator() {
+        return false;
+    }
+
+    @Override
+    public Class&lt;SessionInject&gt; getAnnotation() {
+        return SessionInject.class;
+    }
+}</programlisting>
+
+                The SessionInjectResolver uses &jersey.common.internal.inject.InjectionManager; described in
+                <xref linkend="injection.manager"/>.
+            </para>
+            <para>
+                Unlike with &hk2.link;, Jersey &jersey.common.internal.inject.InjectionResolver; can only be bound
+                as instance in the &jersey.common.internal.inject.AbstractBinder;. That is why the
+                &jersey.common.internal.inject.InjectionManager; is used in the <literal>InjectionResolver</literal>
+                to resolve the <literal>HttpSession</literal> instance.
+            </para>
+            <para>
+                The &jersey.common.internal.inject.InjectionResolver; can be registered in the with Jersey application
+                &lit.jersey.server.ResourceConfig; as follows:
+
+<programlisting language="java">import javax.ws.rs.core.Feature;
+
+import org.glassfish.jersey.InjectionManagerProvider;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+
+
+import javax.inject.Singleton;
+
+...
+
+public class MyApplication extends ResourceConfig {
+
+public MyApplication() {
+
+    ...
+
+    register(new Feature() {
+        @Override
+        public boolean configure(FeatureContext context) {
+            final InjectionManager injectionManager = InjectionManagerProvider.getInjectionManager(context);
+            context.register(new AbstractBinder() {
+                @Override
+                protected void configure() {
+                    bind(new SessionInjectResolver(injectionManager)).to(HttpSession.class).in(Singleton.class);
+                }
+            });
+            return true;
+        }
+    });
+}</programlisting>
+            </para>
+        </section>
     </section>
 
     <section>
diff --git a/docs/src/main/docbook/jersey.ent b/docs/src/main/docbook/jersey.ent
index 7b08086ac3..978bf72768 100644
--- a/docs/src/main/docbook/jersey.ent
+++ b/docs/src/main/docbook/jersey.ent
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="iso-8859-1" ?>
 <!--
 
-    Copyright (c) 2010, 2023 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2010, 2024 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -50,7 +50,7 @@
 <!ENTITY guava.link "<link xlink:href='https://guava.dev/'>Guava</link>">
 <!ENTITY heroku.uri "https://www.heroku.com">
 <!ENTITY heroku.link "<link xlink:href='&heroku.uri;'>Heroku</link>">
-<!ENTITY hk2.javadoc.uri "https://javaee.github.io/hk2/apidocs/">
+<!ENTITY hk2.javadoc.uri "https://javaee.github.io/hk2/apidocs">
 <!ENTITY hk2.link "<link xlink:href='https://javaee.github.io/hk2/'>HK2</link>">
 <!ENTITY hk2.spring-bridge.link "<link xlink:href='https://javaee.github.io/hk2/spring-bridge/'>The Spring/HK2 Bridge</link>">
 <!ENTITY jaxb.release.uri "https://eclipse-ee4j.github.io/jaxb-ri">
@@ -214,6 +214,7 @@
 <!ENTITY jaxrs.core.Cookie "<link xlink:href='&jaxrs.javadoc.uri;/core/Cookie.html'>Cookie</link>">
 <!ENTITY jaxrs.core.EntityTag "<link xlink:href='&jaxrs.javadoc.uri;/core/EntityTag.html'>EntityTag</link>">
 <!ENTITY jaxrs.core.Feature "<link xlink:href='&jaxrs.javadoc.uri;/core/Feature.html'>Feature</link>">
+<!ENTITY jaxrs.core.FeatureContext "<link xlink:href='&jaxrs.javadoc.uri;/core/FeatureContext.html'>FeatureContext</link>">
 <!ENTITY jaxrs.core.Form "<link xlink:href='&jaxrs.javadoc.uri;/core/Form.html'>Form</link>">
 <!ENTITY jaxrs.core.GenericEntity "<link xlink:href='&jaxrs.javadoc.uri;/core/GenericEntity.html'>GenericEntity&lt;T&gt;</link>">
 <!ENTITY jaxrs.core.GenericType "<link xlink:href='&jaxrs.javadoc.uri;/core/GenericType.html'>GenericType&lt;T&gt;</link>">
@@ -408,7 +409,9 @@
 <!ENTITY jersey.common.CommonProperties.PARAM_CONVERTERS_THROW_IAE "<link xlink:href='&jersey.javadoc.uri.prefix;/CommonProperties.html#PARAM_CONVERTERS_THROW_IAE'>CommonProperties.PARAM_CONVERTERS_THROW_IAE</link>" >
 <!ENTITY jersey.common.internal.inject.DisposableSupplier "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/DisposableSupplier.html'>DisposableSupplier</link>">
 <!ENTITY jersey.common.internal.inject.InjectionManager "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/InjectionManager.html'>InjectionManager</link>">
+<!ENTITY jersey.common.internal.inject.InjectionResolver "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/InjectionResolver.html'>InjectionResolver</link>">
 <!ENTITY jersey.common.internal.inject.AbstractBinder "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/AbstractBinder.html'>AbstractBinder</link>">
+<!ENTITY jersey.common.internal.inject.PerLookup "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/PerLookup.html'>PerLookup</link>">
 <!ENTITY jersey.common.internal.inject.Binder "<link xlink:href='&jersey.javadoc.uri.prefix;/internal/inject/Binder.html'>Binder</link>">
 <!ENTITY jersey.common.ServiceLocatorProvider "<link xlink:href='&jersey.javadoc.uri.prefix;/ServiceLocatorProvider.html'>ServiceLocatorProvider</link>">
 <!ENTITY jersey.common.SslConfigurator "<link xlink:href='&jersey.javadoc.uri.prefix;/SslConfigurator.html'>SslConfigurator</link>">
diff --git a/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Helper.java b/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Helper.java
index 0f731f6c9f..bf3c229f56 100644
--- a/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Helper.java
+++ b/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Helper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -20,8 +20,10 @@
 import java.lang.reflect.Type;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
+import org.glassfish.hk2.api.Factory;
 import org.glassfish.jersey.internal.LocalizationMessages;
 import org.glassfish.jersey.internal.inject.AliasBinding;
 import org.glassfish.jersey.internal.inject.Binding;
@@ -121,14 +123,25 @@ private static void bindBinding(ServiceLocator locator, Binding<?, ?> binding) {
      * @param dc      HK2 Dynamic configuration to bind the object.
      * @param binding Jersey descriptor as a holder of information about an injection point.
      */
-    private static void bindBinding(ServiceLocator locator, DynamicConfiguration dc, Binding<?, ?> binding) {
+    private static <T> void bindBinding(ServiceLocator locator, DynamicConfiguration dc, Binding<T, ?> binding) {
         if (ClassBinding.class.isAssignableFrom(binding.getClass())) {
-            ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((ClassBinding<?>) binding);
-            bindBinding(locator, dc, activeDescriptor, binding.getAliases());
+            final Class<?> implClass = binding.getImplementationType();
+            if (Factory.class.isAssignableFrom(implClass)) {
+                final Class<? extends Factory<T>> factoryClass = (Class<? extends Factory<T>>) implClass;
+                bindFactory(locator, binding, (binder) -> binder.bindFactory(factoryClass));
+            } else {
+                ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((ClassBinding<?>) binding);
+                bindBinding(locator, dc, activeDescriptor, binding.getAliases());
+            }
 
         } else if (InstanceBinding.class.isAssignableFrom(binding.getClass())) {
-            ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((InstanceBinding<?>) binding);
-            bindBinding(locator, dc, activeDescriptor, binding.getAliases());
+            if (Factory.class.isAssignableFrom(binding.getImplementationType())) {
+                final Factory<?> factory = (Factory) ((InstanceBinding<T>) binding).getService();
+                bindFactory(locator, binding, (binder) -> binder.bindFactory(factory));
+            } else {
+                ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((InstanceBinding<?>) binding);
+                bindBinding(locator, dc, activeDescriptor, binding.getAliases());
+            }
 
         } else if (InjectionResolverBinding.class.isAssignableFrom(binding.getClass())) {
             InjectionResolverBinding resolverDescriptor = (InjectionResolverBinding) binding;
@@ -234,6 +247,13 @@ private static void bindSupplierClassBinding(ServiceLocator locator, SupplierCla
         ServiceLocatorUtilities.bind(locator, createBinder(bindConsumer));
     }
 
+    private static <T> void bindFactory(ServiceLocator locator,
+                                        Binding<T, ?> binding,
+                                        Function<AbstractBinder, ServiceBindingBuilder> builder) {
+        ServiceLocatorUtilities
+                .bind(locator, createBinder((binder) -> setupSupplierFactoryBridge(binding, builder.apply(binder))));
+    }
+
     private static void setupSupplierFactoryBridge(Binding<?, ?> binding, ServiceBindingBuilder<?> builder) {
         builder.named(binding.getName());
         binding.getContracts().forEach(builder::to);
diff --git a/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Registrables.java b/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Registrables.java
new file mode 100644
index 0000000000..6231f74a58
--- /dev/null
+++ b/inject/hk2/src/main/java/org/glassfish/jersey/inject/hk2/Hk2Registrables.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.inject.hk2;
+
+import org.glassfish.hk2.utilities.binding.AbstractBinder;
+import org.glassfish.jersey.innate.inject.spi.ExternalRegistrables;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Hk2Registrables implements ExternalRegistrables {
+    @Override
+    public List<ClassRuntimeTypePair> registrableContracts() {
+        List<ClassRuntimeTypePair> list = new ArrayList<>();
+        list.add(new ClassRuntimeTypePair(AbstractBinder.class, null));
+        return list;
+    }
+}
diff --git a/inject/hk2/src/main/resources/META-INF/services/org.glassfish.jersey.innate.inject.spi.ExternalRegistrables b/inject/hk2/src/main/resources/META-INF/services/org.glassfish.jersey.innate.inject.spi.ExternalRegistrables
new file mode 100644
index 0000000000..6f7da1acd0
--- /dev/null
+++ b/inject/hk2/src/main/resources/META-INF/services/org.glassfish.jersey.innate.inject.spi.ExternalRegistrables
@@ -0,0 +1 @@
+org.glassfish.jersey.inject.hk2.Hk2Registrables
\ No newline at end of file
diff --git a/tests/e2e-inject/hk2/pom.xml b/tests/e2e-inject/hk2/pom.xml
index e78ffa8fb8..944a38c04f 100644
--- a/tests/e2e-inject/hk2/pom.xml
+++ b/tests/e2e-inject/hk2/pom.xml
@@ -36,6 +36,11 @@
             <type>pom</type>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-client</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 
diff --git a/tests/e2e-inject/hk2/src/test/java/org/glassfish/jersey/tests/e2e/inject/hk2/HK2FactoryBindingTest.java b/tests/e2e-inject/hk2/src/test/java/org/glassfish/jersey/tests/e2e/inject/hk2/HK2FactoryBindingTest.java
new file mode 100644
index 0000000000..38aa56840b
--- /dev/null
+++ b/tests/e2e-inject/hk2/src/test/java/org/glassfish/jersey/tests/e2e/inject/hk2/HK2FactoryBindingTest.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.tests.e2e.inject.hk2;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.InjectionManagerClientProvider;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.Injectee;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+import org.glassfish.jersey.internal.inject.InjectionResolver;
+import org.glassfish.jersey.process.internal.RequestScoped;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import javax.annotation.Priority;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.ws.rs.Priorities;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.ClientRequestContext;
+import javax.ws.rs.client.ClientRequestFilter;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class HK2FactoryBindingTest {
+
+    public static interface ConfigurationProperties {
+        Map<String, Object> getProperties();
+    }
+
+    public static class ConfigurationPropertiesFactory implements org.glassfish.hk2.api.Factory<ConfigurationProperties> {
+
+        private final Configuration configuration;
+
+        @Inject
+        public ConfigurationPropertiesFactory(Configuration configuration) {
+            this.configuration = configuration;
+        }
+
+        @Override
+        public ConfigurationProperties provide() {
+            return new ConfigurationProperties() {
+                @Override
+                public Map<String, Object> getProperties() {
+                    return configuration.getProperties();
+                }
+            };
+        }
+
+        @Override
+        public void dispose(ConfigurationProperties configurationProperties) {
+
+        }
+    }
+
+    @Priority(Priorities.USER)
+    public static class ConfigurationPropertiesFilter implements ClientRequestFilter {
+        @Inject
+        ConfigurationProperties properties;
+
+        @Override
+        public void filter(ClientRequestContext requestContext) throws IOException {
+            requestContext.abortWith(Response.ok(properties.getProperties().get(PROPERTY_NAME)).build());
+        }
+    }
+
+    private static final String PROPERTY_NAME = "TEST_PROPERTY";
+    private static final String PROPERTY_VALUE = "HELLO_PROPERTY";
+
+    @Test
+    public void testFactoryClassBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bind(ConfigurationPropertiesFactory.class).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    @Test
+    public void testFactoryInstanceBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bind(new ConfigurationPropertiesFactory(config)).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    static final class ConfigurationPropertiesImpl implements ConfigurationProperties {
+        private final Configuration configuration;
+        @Inject
+        public ConfigurationPropertiesImpl(Configuration configuration) {
+            this.configuration = configuration;
+        }
+
+        @Override
+        public Map<String, Object> getProperties() {
+            return configuration.getProperties();
+        }
+    }
+
+    static class ConfigurationPropertiesSupplier implements Supplier<ConfigurationPropertiesImpl> {
+        private final Configuration configuration;
+
+        @Inject
+        ConfigurationPropertiesSupplier(Configuration configuration) {
+            this.configuration = configuration;
+        }
+
+        @Override
+        public ConfigurationPropertiesImpl get() {
+            return new ConfigurationPropertiesImpl(configuration);
+        }
+    }
+
+    @Test
+    public void testSupplierJerseyInstanceBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bindFactory(() -> new ConfigurationPropertiesImpl(config)).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    @Test
+    public void testSupplierJerseyClassBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bindFactory(ConfigurationPropertiesSupplier.class).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    public static interface ConfigurationPropertiesProvider {
+        Map<String, Object> getProperties();
+
+        ConfigurationProperties getConfigurationProperties();
+    }
+
+    public static class ConfigurationPropertiesProviderImpl implements ConfigurationPropertiesProvider {
+        private final Configuration configuration;
+        @Inject
+        public ConfigurationPropertiesProviderImpl(Configuration configuration) {
+            this.configuration = configuration;
+        }
+
+        @Override
+        public Map<String, Object> getProperties() {
+            return configuration.getProperties();
+        }
+
+        @Override
+        public ConfigurationProperties getConfigurationProperties() {
+            return new ConfigurationPropertiesImpl(configuration);
+        }
+    }
+
+    public static class ConfigurationPropertiesProviderSupplier implements Supplier<ConfigurationProperties> {
+        final ConfigurationPropertiesProvider impl;
+
+        @Inject
+        public ConfigurationPropertiesProviderSupplier(ConfigurationPropertiesProvider impl) {
+            this.impl = impl;
+        }
+
+        @Override
+        public ConfigurationProperties get() {
+            return impl.getConfigurationProperties();
+        }
+    }
+
+    public static class ConfigurationProperties2Filter implements ClientRequestFilter {
+        @Inject
+        ConfigurationProperties properties;
+
+        @Override
+        public void filter(ClientRequestContext requestContext) throws IOException {
+            requestContext.abortWith(Response.ok(properties.getProperties().get(PROPERTY_NAME)).build());
+        }
+    }
+
+    @Test
+    public void testSupplierOfProviderClassBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new AbstractBinder() {
+            @Override
+            protected void configure() {
+                bind(ConfigurationPropertiesProviderImpl.class).to(ConfigurationPropertiesProvider.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+                bindFactory(ConfigurationPropertiesProviderSupplier.class).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationProperties2Filter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    @Test
+    public void testFactoryHk2ClassBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new org.glassfish.hk2.utilities.binding.AbstractBinder() {
+            @Override
+            protected void configure() {
+                bindFactory(ConfigurationPropertiesFactory.class).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    @Test
+    public void testFactoryHk2InstanceBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new org.glassfish.hk2.utilities.binding.AbstractBinder() {
+            @Override
+            protected void configure() {
+                bindFactory(new ConfigurationPropertiesFactory(config)).to(ConfigurationProperties.class).proxy(true)
+                        .proxyForSameScope(false).in(RequestScoped.class);
+            }
+        }).register(ConfigurationPropertiesFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    static @interface ConfigurationPropertiesInject {
+
+    }
+
+    static class ConfigurationPropertiesInjectResolver implements InjectionResolver<ConfigurationPropertiesInject> {
+
+        private final InjectionManager injectionManager;
+
+        ConfigurationPropertiesInjectResolver(InjectionManager injectionManager) {
+            this.injectionManager = injectionManager;
+        }
+
+        @Override
+        public Object resolve(Injectee injectee) {
+            if (injectee.getRequiredType() == ConfigurationProperties.class) {
+                return new ConfigurationPropertiesImpl(injectionManager.getInstance(Configuration.class));
+            }
+            return null;
+        }
+
+        @Override
+        public boolean isConstructorParameterIndicator() {
+            return false;
+        }
+
+        @Override
+        public boolean isMethodParameterIndicator() {
+            return false;
+        }
+
+        @Override
+        public Class<ConfigurationPropertiesInject> getAnnotation() {
+            return ConfigurationPropertiesInject.class;
+        }
+    }
+
+    public static class ConfigurationPropertiesInjectFilter implements ClientRequestFilter {
+        @ConfigurationPropertiesInject
+        ConfigurationProperties properties;
+
+        @Override
+        public void filter(ClientRequestContext requestContext) throws IOException {
+            requestContext.abortWith(Response.ok(properties.getProperties().get(PROPERTY_NAME)).build());
+        }
+    }
+
+    @Test
+    public void testInjectionResolverBinding() {
+        ClientConfig config = new ClientConfig();
+        config.property(PROPERTY_NAME, PROPERTY_VALUE);
+        String response = ClientBuilder.newClient(config).register(new Feature() {
+            @Override
+            public boolean configure(FeatureContext context) {
+                final InjectionManager injectionManager = InjectionManagerClientProvider.getInjectionManager(context);
+                context.register(new AbstractBinder() {
+                    @Override
+                    protected void configure() {
+                        bind(new ConfigurationPropertiesInjectResolver(injectionManager))
+                                //.to(ConfigurationProperties.class)
+                                .to(new GenericType<ConfigurationProperties>(){})
+                                .in(Singleton.class);
+                    }
+                });
+                return true;
+            }
+        }).register(ConfigurationPropertiesInjectFilter.class).target("http://test.com").request().get(String.class);
+        Assertions.assertEquals(PROPERTY_VALUE, response);
+    }
+}