update doc

Author: sonus21

build.gradle

@@ -83,7 +83,7 @@ ext {
 
 subprojects {
     group = "com.github.sonus21"
-    version = "4.0.0-RELEASE"
+    version = "4.0.0-RC1"
 
     dependencies {
         // https://mvnrepository.com/artifact/org.springframework/spring-messaging

docs/CHANGELOG.md

@@ -8,10 +8,36 @@ layout: default
 
 All notable user-facing changes to this project are documented in this file.
 
+## Release [4.0.0.RC1] 18-Mar-2026
+
+{: .highlight}
+This is a release candidate for 4.0.0. It targets Spring Boot 4.x and Spring Framework 7.x.
+Please test thoroughly before using in production.
+
+### Features
+* **Spring Boot 4.x support** — compatible with Spring Boot 4.0.1 and above.
+* **Spring Framework 7.x support** — built against Spring Framework 7.0.3, taking
+  advantage of the updated messaging and context APIs.
+* **Java 21 baseline** — Java 21 is now the minimum supported runtime.
+* **Jackson 3.x support** — updated serialization layer to use Jackson 3.x
+  (`tools.jackson` packages).
+* **Lettuce 7.x support** — Redis client updated to Lettuce 7.2.x.
+* `GenericMessageConverter` now supports generic envelope types such as `Event<T>`.
+  The type parameter is resolved from the runtime class of the corresponding field
+  value, enabling transparent round-trip serialization without requiring a custom
+  message converter.
+
+### Migration Notes
+* Requires Java 21+.
+* Requires Spring Boot 4.x / Spring Framework 7.x. Not backward compatible with
+  Spring Boot 3.x — use the 3.x release line for older Spring Boot versions.
+* Jackson package namespace changed from `com.fasterxml.jackson` to `tools.jackson`
+  in Jackson 3.x. Update any custom `ObjectMapper` configuration accordingly.
+
 ## Release [3.4.0] 22-July-2025
 ### Fixes
-* Improved unique message enqueuing to reject duplicates upfront rather than during 
-  processing. #259 
+* Improved unique message enqueuing to reject duplicates upfront rather than during
+  processing. #259
 
 
 ## Release [3.3.0] 29-June-2025

docs/configuration/configuration.md

@@ -172,36 +172,76 @@ public class BootstrapController {
 
 ## Message Converter Configuration
 
-To customize message conversion, set the property 
-`rqueue.message.converter.provider.class` to the fully qualified name of your provider 
-class. This class must implement the `MessageConverterProvider` interface and return 
+To customize message conversion, set the property
+`rqueue.message.converter.provider.class` to the fully qualified name of your provider
+class. This class must implement the `MessageConverterProvider` interface and return
 a Spring `MessageConverter`.
 
 {: .note}
-Your custom provider must implement 
+Your custom provider must implement
 `com.github.sonus21.rqueue.converter.MessageConverterProvider`.
 
 ```java
 class MyMessageConverterProvider implements MessageConverterProvider {
 
   @Override
   public MessageConverter getConverter() {
-    // here any message converter can be returned except null 
+    // here any message converter can be returned except null
     return new MyMessageConverter();
   }
 }
 ```
 
-The `DefaultRqueueMessageConverter` handles serialization for most use cases, but it 
-may fail if classes are not shared between producing and consuming applications. To 
-avoid shared dependencies, consider using JSON-based converters like 
-`com.github.sonus21.rqueue.converter.JsonMessageConverter` or Spring's 
-`JacksonJsonMessageConverter`. These serialize payloads into JSON, improving 
+The `DefaultRqueueMessageConverter` handles serialization for most use cases, but it
+may fail if classes are not shared between producing and consuming applications. To
+avoid shared dependencies, consider using JSON-based converters like
+`com.github.sonus21.rqueue.converter.JsonMessageConverter` or Spring's
+`JacksonJsonMessageConverter`. These serialize payloads into JSON, improving
 interoperability.
 
-Other serialization formats like MessagePack or Protocol Buffers (ProtoBuf) can also 
+Other serialization formats like MessagePack or Protocol Buffers (ProtoBuf) can also
 be implemented based on your requirements.
 
+### Generic Envelope Types
+
+`GenericMessageConverter` (used by the default converter) supports **single-level
+generic envelope types** such as `Event<T>`. The type parameter is resolved at
+serialization time by inspecting the runtime class of the field value that corresponds
+to `T`.
+
+```java
+// A generic envelope type
+public class Event<T> {
+  private String id;
+  private T payload;
+  // getters/setters ...
+}
+
+// Enqueue
+Event<Order> event = new Event<>("evt-123", order);
+rqueueMessageEnqueuer.enqueue("order-queue", event);
+
+// Consume
+@RqueueListener(value = "order-queue")
+public void onEvent(Event<Order> event) { ... }
+```
+
+The serialized form encodes both the envelope class and the type parameter:
+
+```
+{"msg":"...","name":"com.example.Event#com.example.Order"}
+```
+
+**Constraints:**
+
+- The type parameter `T` must be a **non-generic** concrete class (e.g. `Order`, not
+  `List<Order>`).
+- At least one field of type `T` on the envelope class must be **non-null** at
+  serialization time, so the runtime type can be determined.
+- For `List<T>`, items must also be non-generic concrete classes. Envelopes like
+  `List<Event<Order>>` are not supported.
+- Multi-level nesting (e.g. `Wrapper<Event<T>>`) is not supported.
+
 ## Additional Configuration
 
 - **`rqueue.retry.per.poll`**: Determines how many times a polled message is retried