diff --git a/CHANGELOG.md b/CHANGELOG.md
index b5ac80b1df861..c563daabcd4c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,28 +21,37 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Support prefix list for remote repository attributes([#16271](https://github.com/opensearch-project/OpenSearch/pull/16271))
 - Add new configuration setting `synonym_analyzer`, to the `synonym` and `synonym_graph` filters, enabling the specification of a custom analyzer for reading the synonym file ([#16488](https://github.com/opensearch-project/OpenSearch/pull/16488)).
 - Add stats for remote publication failure and move download failure stats to remote methods([#16682](https://github.com/opensearch-project/OpenSearch/pull/16682/))
+- Added a precaution to handle extreme date values during sorting to prevent `arithmetic_exception: long overflow` ([#16812](https://github.com/opensearch-project/OpenSearch/pull/16812)).
+- Add search replica stats to segment replication stats API ([#16678](https://github.com/opensearch-project/OpenSearch/pull/16678))
+- Introduce a setting to disable download of full cluster state from remote on term mismatch([#16798](https://github.com/opensearch-project/OpenSearch/pull/16798/))
 
 ### Dependencies
 - Bump `com.google.cloud:google-cloud-core-http` from 2.23.0 to 2.47.0 ([#16504](https://github.com/opensearch-project/OpenSearch/pull/16504))
 - Bump `google-auth-library-oauth2-http` from 1.7.0 to 1.29.0 in /plugins/repository-gcs ([#16520](https://github.com/opensearch-project/OpenSearch/pull/16520))
-- Bump `com.azure:azure-storage-common` from 12.25.1 to 12.27.1 ([#16521](https://github.com/opensearch-project/OpenSearch/pull/16521))
+- Bump `com.azure:azure-storage-common` from 12.25.1 to 12.28.0 ([#16521](https://github.com/opensearch-project/OpenSearch/pull/16521), [#16808](https://github.com/opensearch-project/OpenSearch/pull/16808))
 - Bump `com.google.apis:google-api-services-compute` from v1-rev20240407-2.0.0 to v1-rev20241105-2.0.0 ([#16502](https://github.com/opensearch-project/OpenSearch/pull/16502), [#16548](https://github.com/opensearch-project/OpenSearch/pull/16548), [#16613](https://github.com/opensearch-project/OpenSearch/pull/16613))
 - Bump `com.azure:azure-storage-blob` from 12.23.0 to 12.28.1 ([#16501](https://github.com/opensearch-project/OpenSearch/pull/16501))
 - Bump `org.apache.hadoop:hadoop-minicluster` from 3.4.0 to 3.4.1 ([#16550](https://github.com/opensearch-project/OpenSearch/pull/16550))
-- Bump `org.apache.xmlbeans:xmlbeans` from 5.2.1 to 5.2.2 ([#16612](https://github.com/opensearch-project/OpenSearch/pull/16612))
-- Bump `com.nimbusds:nimbus-jose-jwt` from 9.41.1 to 9.46 ([#16611](https://github.com/opensearch-project/OpenSearch/pull/16611))
+- Bump `org.apache.xmlbeans:xmlbeans` from 5.2.1 to 5.3.0 ([#16612](https://github.com/opensearch-project/OpenSearch/pull/16612), [#16854](https://github.com/opensearch-project/OpenSearch/pull/16854))
+- Bump `com.nimbusds:nimbus-jose-jwt` from 9.41.1 to 9.47 ([#16611](https://github.com/opensearch-project/OpenSearch/pull/16611), [#16807](https://github.com/opensearch-project/OpenSearch/pull/16807))
 - Bump `lycheeverse/lychee-action` from 2.0.2 to 2.1.0 ([#16610](https://github.com/opensearch-project/OpenSearch/pull/16610))
 - Bump `me.champeau.gradle.japicmp` from 0.4.4 to 0.4.5 ([#16614](https://github.com/opensearch-project/OpenSearch/pull/16614))
 - Bump `mockito` from 5.14.1 to 5.14.2, `objenesis` from 3.2 to 3.3 and `bytebuddy` from 1.15.4 to 1.15.10 ([#16655](https://github.com/opensearch-project/OpenSearch/pull/16655))
 - Bump `Netty` from 4.1.114.Final to 4.1.115.Final ([#16661](https://github.com/opensearch-project/OpenSearch/pull/16661))
 - Bump `org.xerial.snappy:snappy-java` from 1.1.10.6 to 1.1.10.7 ([#16665](https://github.com/opensearch-project/OpenSearch/pull/16665))
 - Bump `codecov/codecov-action` from 4 to 5 ([#16667](https://github.com/opensearch-project/OpenSearch/pull/16667))
-- Bump `org.apache.logging.log4j:log4j-core` from 2.24.1 to 2.24.2 ([#16718](https://github.com/opensearch-project/OpenSearch/pull/16718))
+- Bump `org.apache.logging.log4j:log4j-core` from 2.24.1 to 2.24.3 ([#16718](https://github.com/opensearch-project/OpenSearch/pull/16718), [#16858](https://github.com/opensearch-project/OpenSearch/pull/16858))
 - Bump `jackson` from 2.17.2 to 2.18.2 ([#16733](https://github.com/opensearch-project/OpenSearch/pull/16733))
 - Bump `ch.qos.logback:logback-classic` from 1.2.13 to 1.5.12 ([#16716](https://github.com/opensearch-project/OpenSearch/pull/16716))
+- Bump `com.azure:azure-identity` from 1.13.2 to 1.14.2 ([#16778](https://github.com/opensearch-project/OpenSearch/pull/16778))
+- Bump Apache Lucene from 9.12.0 to 9.12.1 ([#16846](https://github.com/opensearch-project/OpenSearch/pull/16846))
+- Bump `com.gradle.develocity` from 3.18.2 to 3.19 ([#16855](https://github.com/opensearch-project/OpenSearch/pull/16855))
+- Bump `org.jline:jline` from 3.27.1 to 3.28.0 ([#16857](https://github.com/opensearch-project/OpenSearch/pull/16857))
+- Bump `com.azure:azure-core` from 1.51.0 to 1.54.1 ([#16856](https://github.com/opensearch-project/OpenSearch/pull/16856))
 
 ### Changed
 - Indexed IP field supports `terms_query` with more than 1025 IP masks [#16391](https://github.com/opensearch-project/OpenSearch/pull/16391)
+- Make entries for dependencies from server/build.gradle to gradle version catalog ([#16707](https://github.com/opensearch-project/OpenSearch/pull/16707))
 
 ### Deprecated
 - Performing update operation with default pipeline or final pipeline is deprecated ([#16712](https://github.com/opensearch-project/OpenSearch/pull/16712))
@@ -62,6 +71,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - [Tiered Caching] Fix bug in cache stats API ([#16560](https://github.com/opensearch-project/OpenSearch/pull/16560))
 - Bound the size of cache in deprecation logger ([16702](https://github.com/opensearch-project/OpenSearch/issues/16702))
 - Ensure consistency of system flag on IndexMetadata after diff is applied ([#16644](https://github.com/opensearch-project/OpenSearch/pull/16644))
+- Skip remote-repositories validations for node-joins when RepositoriesService is not in sync with cluster-state ([#16763](https://github.com/opensearch-project/OpenSearch/pull/16763))
+- Fix _list/shards API failing when closed indices are present ([#16606](https://github.com/opensearch-project/OpenSearch/pull/16606))
+- Fix remote shards balance ([#15335](https://github.com/opensearch-project/OpenSearch/pull/15335))
 - Fix illegal argument exception when creating a PIT ([#16781](https://github.com/opensearch-project/OpenSearch/pull/16781))
 
 ### Security
diff --git a/buildSrc/src/main/groovy/org/opensearch/gradle/plugin/OptionalDependenciesPlugin.groovy b/buildSrc/src/main/groovy/org/opensearch/gradle/plugin/OptionalDependenciesPlugin.groovy
index 2bd8835535881..9b687e1037a08 100644
--- a/buildSrc/src/main/groovy/org/opensearch/gradle/plugin/OptionalDependenciesPlugin.groovy
+++ b/buildSrc/src/main/groovy/org/opensearch/gradle/plugin/OptionalDependenciesPlugin.groovy
@@ -79,7 +79,7 @@ class OptionalDependenciesPlugin implements Plugin<Project> {
 
                                 if (foundDep) {
                                     if (foundDep.optional) {
-                                        foundDep.optional.value = 'true'
+                                        foundDep.optional*.value = 'true'
                                     } else {
                                         foundDep.appendNode(OPTIONAL_IDENTIFIER, 'true')
                                     }
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/docker/DockerSupportService.java b/buildSrc/src/main/java/org/opensearch/gradle/docker/DockerSupportService.java
index 77d7997d6d48d..b75bdcffb257b 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/docker/DockerSupportService.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/docker/DockerSupportService.java
@@ -105,8 +105,7 @@ public DockerAvailability getDockerAvailability() {
             Result lastResult = null;
             Version version = null;
             boolean isVersionHighEnough = false;
-            boolean isComposeAvailable = false;
-            boolean isComposeV2Available = false;
+            DockerComposeAvailability dockerComposeAvailability = null;
 
             // Check if the Docker binary exists
             final Optional<String> dockerBinary = getDockerPath();
@@ -114,7 +113,7 @@ public DockerAvailability getDockerAvailability() {
                 dockerPath = dockerBinary.get();
 
                 // Since we use a multi-stage Docker build, check the Docker version meets minimum requirement
-                lastResult = runCommand(dockerPath, "version", "--format", "{{.Server.Version}}");
+                lastResult = runCommand(execOperations, dockerPath, "version", "--format", "{{.Server.Version}}");
 
                 if (lastResult.isSuccess()) {
                     version = Version.fromString(lastResult.stdout.trim(), Version.Mode.RELAXED);
@@ -123,15 +122,11 @@ public DockerAvailability getDockerAvailability() {
 
                     if (isVersionHighEnough) {
                         // Check that we can execute a privileged command
-                        lastResult = runCommand(dockerPath, "images");
-
+                        lastResult = runCommand(execOperations, dockerPath, "images");
                         // If docker all checks out, see if docker-compose is available and working
-                        Optional<String> composePath = getDockerComposePath();
-                        if (lastResult.isSuccess() && composePath.isPresent()) {
-                            isComposeAvailable = runCommand(composePath.get(), "version").isSuccess();
+                        if (lastResult.isSuccess()) {
+                            dockerComposeAvailability = DockerComposeAvailability.detect(execOperations, dockerPath).orElse(null);
                         }
-
-                        isComposeV2Available = runCommand(dockerPath, "compose", "version").isSuccess();
                     }
                 }
             }
@@ -140,8 +135,7 @@ public DockerAvailability getDockerAvailability() {
 
             this.dockerAvailability = new DockerAvailability(
                 isAvailable,
-                isComposeAvailable,
-                isComposeV2Available,
+                dockerComposeAvailability,
                 isVersionHighEnough,
                 dockerPath,
                 version,
@@ -291,17 +285,6 @@ private Optional<String> getDockerPath() {
         return Arrays.asList(DOCKER_BINARIES).stream().filter(path -> new File(path).exists()).findFirst();
     }
 
-    /**
-     * Searches the entries in {@link #DOCKER_COMPOSE_BINARIES} for the Docker Compose CLI. This method does
-     * not check whether the installation appears usable, see {@link #getDockerAvailability()} instead.
-     *
-     * @return the path to a CLI, if available.
-     */
-    private Optional<String> getDockerComposePath() {
-        // Check if the Docker binary exists
-        return Arrays.asList(DOCKER_COMPOSE_BINARIES).stream().filter(path -> new File(path).exists()).findFirst();
-    }
-
     private void throwDockerRequiredException(final String message) {
         throwDockerRequiredException(message, null);
     }
@@ -321,7 +304,7 @@ private void throwDockerRequiredException(final String message, Exception e) {
      * while running the command, or the process was killed after reaching the 10s timeout,
      * then the exit code will be -1.
      */
-    private Result runCommand(String... args) {
+    private static Result runCommand(ExecOperations execOperations, String... args) {
         if (args.length == 0) {
             throw new IllegalArgumentException("Cannot execute with no command");
         }
@@ -356,14 +339,9 @@ public static class DockerAvailability {
         public final boolean isAvailable;
 
         /**
-         * True if docker-compose is available.
+         * Non-null if docker-compose v1 or v2 is available.
          */
-        public final boolean isComposeAvailable;
-
-        /**
-         * True if docker compose is available.
-         */
-        public final boolean isComposeV2Available;
+        public final DockerComposeAvailability dockerComposeAvailability;
 
         /**
          * True if the installed Docker version is &gt;= 17.05
@@ -387,23 +365,70 @@ public static class DockerAvailability {
 
         DockerAvailability(
             boolean isAvailable,
-            boolean isComposeAvailable,
-            boolean isComposeV2Available,
+            DockerComposeAvailability dockerComposeAvailability,
             boolean isVersionHighEnough,
             String path,
             Version version,
             Result lastCommand
         ) {
             this.isAvailable = isAvailable;
-            this.isComposeAvailable = isComposeAvailable;
-            this.isComposeV2Available = isComposeV2Available;
+            this.dockerComposeAvailability = dockerComposeAvailability;
             this.isVersionHighEnough = isVersionHighEnough;
             this.path = path;
             this.version = version;
             this.lastCommand = lastCommand;
         }
+
+        public boolean isDockerComposeAvailable() {
+            return dockerComposeAvailability != null;
+        }
+    }
+
+    /**
+     * Marker interface for Docker Compose availability
+     */
+    private interface DockerComposeAvailability {
+        /**
+         * Detects Docker Compose V1/V2 availability
+         */
+        private static Optional<DockerComposeAvailability> detect(ExecOperations execOperations, String dockerPath) {
+            Optional<String> composePath = getDockerComposePath();
+            if (composePath.isPresent()) {
+                if (runCommand(execOperations, composePath.get(), "version").isSuccess()) {
+                    return Optional.of(new DockerComposeV1Availability());
+                }
+            }
+
+            if (runCommand(execOperations, dockerPath, "compose", "version").isSuccess()) {
+                return Optional.of(new DockerComposeV2Availability());
+            }
+
+            return Optional.empty();
+        }
+
+        /**
+         * Searches the entries in {@link #DOCKER_COMPOSE_BINARIES} for the Docker Compose CLI. This method does
+         * not check whether the installation appears usable, see {@link #getDockerAvailability()} instead.
+         *
+         * @return the path to a CLI, if available.
+         */
+        private static Optional<String> getDockerComposePath() {
+            // Check if the Docker binary exists
+            return Arrays.asList(DOCKER_COMPOSE_BINARIES).stream().filter(path -> new File(path).exists()).findFirst();
+        }
+
     }
 
+    /**
+     * Docker Compose V1 availability
+     */
+    public static class DockerComposeV1Availability implements DockerComposeAvailability {}
+
+    /**
+     * Docker Compose V2 availability
+     */
+    public static class DockerComposeV2Availability implements DockerComposeAvailability {}
+
     /**
      * This class models the result of running a command. It captures the exit code, standard output and standard error.
      */
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
index f65e231cd2e50..79b5f837c75ce 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
@@ -43,6 +43,7 @@
 import org.opensearch.gradle.SystemPropertyCommandLineArgumentProvider;
 import org.opensearch.gradle.docker.DockerSupportPlugin;
 import org.opensearch.gradle.docker.DockerSupportService;
+import org.opensearch.gradle.docker.DockerSupportService.DockerComposeV2Availability;
 import org.opensearch.gradle.info.BuildParams;
 import org.opensearch.gradle.precommit.TestingConventionsTasks;
 import org.opensearch.gradle.util.GradleUtils;
@@ -171,11 +172,8 @@ public void execute(Task task) {
                 .findFirst();
 
             composeExtension.getExecutable().set(dockerCompose.isPresent() ? dockerCompose.get() : "/usr/bin/docker");
-            if (dockerSupport.get().getDockerAvailability().isComposeV2Available) {
-                composeExtension.getUseDockerComposeV2().set(true);
-            } else if (dockerSupport.get().getDockerAvailability().isComposeAvailable) {
-                composeExtension.getUseDockerComposeV2().set(false);
-            }
+            composeExtension.getUseDockerComposeV2()
+                .set(dockerSupport.get().getDockerAvailability().dockerComposeAvailability instanceof DockerComposeV2Availability);
 
             tasks.named("composeUp").configure(t -> {
                 // Avoid running docker-compose tasks in parallel in CI due to some issues on certain Linux distributions
@@ -232,8 +230,7 @@ private void maybeSkipTask(Provider<DockerSupportService> dockerSupport, TaskPro
 
     private void maybeSkipTask(Provider<DockerSupportService> dockerSupport, Task task) {
         task.onlyIf(spec -> {
-            boolean isComposeAvailable = dockerSupport.get().getDockerAvailability().isComposeV2Available
-                || dockerSupport.get().getDockerAvailability().isComposeAvailable;
+            boolean isComposeAvailable = dockerSupport.get().getDockerAvailability().isDockerComposeAvailable();
             if (isComposeAvailable == false) {
                 LOGGER.info("Task {} requires docker-compose but it is unavailable. Task will be skipped.", task.getPath());
             }
diff --git a/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle b/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
index 3db2a6e7c2733..83bec727b1502 100644
--- a/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
+++ b/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
@@ -17,7 +17,7 @@ repositories {
 }
 
 dependencies {
-  implementation "org.apache.logging.log4j:log4j-core:2.24.2"
+  implementation "org.apache.logging.log4j:log4j-core:2.24.3"
 }
 
 ["0.0.1", "0.0.2"].forEach { v ->
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 2658d2aa8b561..ff0920f9d6057 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,6 +1,6 @@
 [versions]
 opensearch        = "3.0.0"
-lucene            = "9.12.0"
+lucene            = "9.12.1"
 
 bundled_jdk_vendor = "adoptium"
 bundled_jdk = "23.0.1+11"
@@ -34,6 +34,7 @@ jna               = "5.13.0"
 
 netty             = "4.1.115.Final"
 joda              = "2.12.7"
+roaringbitmap     = "1.3.0"
 
 # project reactor
 reactor_netty     = "1.1.23"
@@ -83,3 +84,52 @@ opentelemetrysemconv  = "1.27.0-alpha"
 # arrow dependencies
 arrow                 = "17.0.0"
 flatbuffers           = "2.0.0"
+
+[libraries]
+hdrhistogram = { group = "org.hdrhistogram", name = "HdrHistogram", version.ref = "hdrhistogram" }
+jakartaannotation = { group = "jakarta.annotation", name = "jakarta.annotation-api", version.ref = "jakarta_annotation" }
+jodatime = { group = "joda-time", name = "joda-time", version.ref = "joda" }
+jna = { group = "net.java.dev.jna", name = "jna", version.ref = "jna" }
+jtscore = { group = "org.locationtech.jts", name = "jts-core", version.ref = "jts" }
+jzlib = { group = "com.jcraft", name = "jzlib", version.ref = "jzlib" }
+log4japi = { group = "org.apache.logging.log4j", name = "log4j-api", version.ref = "log4j" }
+log4jjul = { group = "org.apache.logging.log4j", name = "log4j-jul", version.ref = "log4j" }
+log4jcore = { group = "org.apache.logging.log4j", name = "log4j-core", version.ref = "log4j" }
+lucene-core = { group = "org.apache.lucene", name = "lucene-core", version.ref = "lucene" }
+lucene-analysis-common = { group = "org.apache.lucene", name = "lucene-analysis-common", version.ref = "lucene" }
+lucene-backward-codecs = { group = "org.apache.lucene", name = "lucene-backward-codecs", version.ref = "lucene" }
+lucene-grouping = { group = "org.apache.lucene", name = "lucene-grouping", version.ref = "lucene" }
+lucene-highlighter = { group = "org.apache.lucene", name = "lucene-highlighter", version.ref = "lucene" }
+lucene-join = { group = "org.apache.lucene", name = "lucene-join", version.ref = "lucene" }
+lucene-memory = { group = "org.apache.lucene", name = "lucene-memory", version.ref = "lucene" }
+lucene-misc = { group = "org.apache.lucene", name = "lucene-misc", version.ref = "lucene" }
+lucene-queries = { group = "org.apache.lucene", name = "lucene-queries", version.ref = "lucene" }
+lucene-queryparser = { group = "org.apache.lucene", name = "lucene-queryparser", version.ref = "lucene" }
+lucene-sandbox = { group = "org.apache.lucene", name = "lucene-sandbox", version.ref = "lucene" }
+lucene-spatial-extras = { group = "org.apache.lucene", name = "lucene-spatial-extras", version.ref = "lucene" }
+lucene-spatial3d = { group = "org.apache.lucene", name = "lucene-spatial3d", version.ref = "lucene" }
+lucene-suggest = { group = "org.apache.lucene", name = "lucene-suggest", version.ref = "lucene" }
+protobuf = { group = "com.google.protobuf", name = "protobuf-java", version.ref = "protobuf" }
+reactivestreams = { group = "io.projectreactor", name = "reactor-core", version.ref = "reactor" }
+reactorcore = { group = "org.reactivestreams", name = "reactive-streams", version.ref = "reactivestreams" }
+roaringbitmap = { group = "org.roaringbitmap", name = "RoaringBitmap", version.ref = "roaringbitmap" }
+spatial4j = { group = "org.locationtech.spatial4j", name = "spatial4j", version.ref = "spatial4j" }
+tdigest = { group = "com.tdunning", name = "t-digest", version.ref = "tdigest" }
+
+[bundles]
+lucene = [
+    "lucene-core",
+    "lucene-analysis-common",
+    "lucene-backward-codecs",
+    "lucene-grouping",
+    "lucene-highlighter",
+    "lucene-join",
+    "lucene-memory",
+    "lucene-misc",
+    "lucene-queries",
+    "lucene-queryparser",
+    "lucene-sandbox",
+    "lucene-spatial-extras",
+    "lucene-spatial3d",
+    "lucene-suggest"
+]
diff --git a/libs/core/licenses/lucene-core-9.12.0.jar.sha1 b/libs/core/licenses/lucene-core-9.12.0.jar.sha1
deleted file mode 100644
index e55f896dedb63..0000000000000
--- a/libs/core/licenses/lucene-core-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fdb055d569bb20bfce9618fe2b01c29bab7f290c
\ No newline at end of file
diff --git a/libs/core/licenses/lucene-core-9.12.1.jar.sha1 b/libs/core/licenses/lucene-core-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..2521c91a81d64
--- /dev/null
+++ b/libs/core/licenses/lucene-core-9.12.1.jar.sha1
@@ -0,0 +1 @@
+91447c90c1180122142773b5baddaf8547124794
\ No newline at end of file
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index ec0a18dbbf882..62c9cb36727b2 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -113,8 +113,8 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_2_17_2 = new Version(2170299, org.apache.lucene.util.Version.LUCENE_9_11_1);
     public static final Version V_2_18_0 = new Version(2180099, org.apache.lucene.util.Version.LUCENE_9_12_0);
     public static final Version V_2_18_1 = new Version(2180199, org.apache.lucene.util.Version.LUCENE_9_12_0);
-    public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_12_0);
     public static final Version V_2_19_0 = new Version(2190099, org.apache.lucene.util.Version.LUCENE_9_12_0);
+    public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_12_1);
     public static final Version CURRENT = V_3_0_0;
 
     public static Version fromId(int id) {
diff --git a/modules/lang-expression/licenses/lucene-expressions-9.12.0.jar.sha1 b/modules/lang-expression/licenses/lucene-expressions-9.12.0.jar.sha1
deleted file mode 100644
index 476049a66cc08..0000000000000
--- a/modules/lang-expression/licenses/lucene-expressions-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5ba843374a0aab3dfe0b11cb28b251844d85bf5b
\ No newline at end of file
diff --git a/modules/lang-expression/licenses/lucene-expressions-9.12.1.jar.sha1 b/modules/lang-expression/licenses/lucene-expressions-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..9e0a5c2d7df21
--- /dev/null
+++ b/modules/lang-expression/licenses/lucene-expressions-9.12.1.jar.sha1
@@ -0,0 +1 @@
+667ee99f31c8e42eac70b0adcf8deb4232935430
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.0.jar.sha1 b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.0.jar.sha1
deleted file mode 100644
index 31398b27708a3..0000000000000
--- a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a9232b6a4882979118d3281b98dfdb6e0e1cb5ca
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.1.jar.sha1 b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..acb73de8b5dc9
--- /dev/null
+++ b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.12.1.jar.sha1
@@ -0,0 +1 @@
+abaef4767ad64289e62abdd4606bf6ed2ddea0fd
\ No newline at end of file
diff --git a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.0.jar.sha1 b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.0.jar.sha1
deleted file mode 100644
index fa4c9d2d09d6e..0000000000000
--- a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a3a6950ffc22e76a082e1b3cefb022b9f7870d29
\ No newline at end of file
diff --git a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.1.jar.sha1 b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..916778086a6bd
--- /dev/null
+++ b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.12.1.jar.sha1
@@ -0,0 +1 @@
+635c41143b896f402589d29e33695dcfabae9cc5
\ No newline at end of file
diff --git a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.0.jar.sha1 b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.0.jar.sha1
deleted file mode 100644
index 576b924286d2d..0000000000000
--- a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e71f85b72ed3939039ba8897b28b065dd11918b9
\ No newline at end of file
diff --git a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.1.jar.sha1 b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..9c057370df5d1
--- /dev/null
+++ b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.12.1.jar.sha1
@@ -0,0 +1 @@
+e265410a6a4d9cd23b2e9c73321e6bd307bc1422
\ No newline at end of file
diff --git a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.0.jar.sha1 b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.0.jar.sha1
deleted file mode 100644
index c8c146bbd0d25..0000000000000
--- a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6baa3ae7ab20d6e644cf0bedb271c50a44c0e259
\ No newline at end of file
diff --git a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.1.jar.sha1 b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..30db9fc8d69e2
--- /dev/null
+++ b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.12.1.jar.sha1
@@ -0,0 +1 @@
+3787b8edc0cfad21998abc6aeb9d2cbf152b4b26
\ No newline at end of file
diff --git a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.0.jar.sha1 b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.0.jar.sha1
deleted file mode 100644
index 54ea0b19f2a7b..0000000000000
--- a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f183e1e8b1eaaa4dec444774a285bb8b66518522
\ No newline at end of file
diff --git a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.1.jar.sha1 b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..96f8d70e6ee53
--- /dev/null
+++ b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.12.1.jar.sha1
@@ -0,0 +1 @@
+e935f600bf153c46f5725198ca9352c32025f274
\ No newline at end of file
diff --git a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.0.jar.sha1 b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.0.jar.sha1
deleted file mode 100644
index 5442a40f5bba2..0000000000000
--- a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b81a609934e65d12ab9d2d84bc2ea6f56a360e57
\ No newline at end of file
diff --git a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.1.jar.sha1 b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..d6d5f1c2609ff
--- /dev/null
+++ b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.12.1.jar.sha1
@@ -0,0 +1 @@
+c4e1c94b1adbd1cb9dbdc0d3c2d2c33beabfc777
\ No newline at end of file
diff --git a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.0.jar.sha1 b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.0.jar.sha1
deleted file mode 100644
index 60fd4015cfde0..0000000000000
--- a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bec069f286b45f20b743c81e84202369cd0467e7
\ No newline at end of file
diff --git a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.1.jar.sha1 b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..661f3062458e2
--- /dev/null
+++ b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.12.1.jar.sha1
@@ -0,0 +1 @@
+d8e4716dab6d829e7b37a8b185cbd242650aeb9e
\ No newline at end of file
diff --git a/plugins/ingest-attachment/build.gradle b/plugins/ingest-attachment/build.gradle
index 4f30ea9ea7e22..2948ca12904f5 100644
--- a/plugins/ingest-attachment/build.gradle
+++ b/plugins/ingest-attachment/build.gradle
@@ -89,7 +89,7 @@ dependencies {
   api "org.apache.poi:poi:${versions.poi}"
   api "org.apache.poi:poi-ooxml-lite:${versions.poi}"
   api "commons-codec:commons-codec:${versions.commonscodec}"
-  api 'org.apache.xmlbeans:xmlbeans:5.2.2'
+  api 'org.apache.xmlbeans:xmlbeans:5.3.0'
   api 'org.apache.commons:commons-collections4:4.4'
   // MS Office
   api "org.apache.poi:poi-scratchpad:${versions.poi}"
diff --git a/plugins/ingest-attachment/licenses/xmlbeans-5.2.2.jar.sha1 b/plugins/ingest-attachment/licenses/xmlbeans-5.2.2.jar.sha1
deleted file mode 100644
index 613c1028dbd6d..0000000000000
--- a/plugins/ingest-attachment/licenses/xmlbeans-5.2.2.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-586ffe10ae9864e19e85c24bd060790a70586f72
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/xmlbeans-5.3.0.jar.sha1 b/plugins/ingest-attachment/licenses/xmlbeans-5.3.0.jar.sha1
new file mode 100644
index 0000000000000..4dbb0149da890
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/xmlbeans-5.3.0.jar.sha1
@@ -0,0 +1 @@
+f93c3ba820d7240b7fec4ec5bc35e7223cc6fc1f
\ No newline at end of file
diff --git a/plugins/repository-azure/build.gradle b/plugins/repository-azure/build.gradle
index efcd01d2bad5e..aebdd3e3b7f63 100644
--- a/plugins/repository-azure/build.gradle
+++ b/plugins/repository-azure/build.gradle
@@ -44,10 +44,10 @@ opensearchplugin {
 }
 
 dependencies {
-  api 'com.azure:azure-core:1.51.0'
+  api 'com.azure:azure-core:1.54.1'
   api 'com.azure:azure-json:1.3.0'
   api 'com.azure:azure-xml:1.1.0'
-  api 'com.azure:azure-storage-common:12.27.1'
+  api 'com.azure:azure-storage-common:12.28.0'
   api 'com.azure:azure-core-http-netty:1.15.5'
   api "io.netty:netty-codec-dns:${versions.netty}"
   api "io.netty:netty-codec-socks:${versions.netty}"
@@ -57,7 +57,7 @@ dependencies {
   api "io.netty:netty-transport-native-unix-common:${versions.netty}"
   implementation project(':modules:transport-netty4')
   api 'com.azure:azure-storage-blob:12.28.1'
-  api 'com.azure:azure-identity:1.13.2'
+  api 'com.azure:azure-identity:1.14.2'
   // Start of transitive dependencies for azure-identity
   api 'com.microsoft.azure:msal4j-persistence-extension:1.3.0'
   api "net.java.dev.jna:jna-platform:${versions.jna}"
diff --git a/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1 b/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1
deleted file mode 100644
index 7200f59af2f9a..0000000000000
--- a/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ff5d0aedf75ca45ec0ace24673f790d2f7a57096
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-1.54.1.jar.sha1 b/plugins/repository-azure/licenses/azure-core-1.54.1.jar.sha1
new file mode 100644
index 0000000000000..9246d0dd8443a
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-core-1.54.1.jar.sha1
@@ -0,0 +1 @@
+9ae0cc4a8ff02a0146510ec9e1c06ab48950a66b
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-identity-1.13.2.jar.sha1 b/plugins/repository-azure/licenses/azure-identity-1.13.2.jar.sha1
deleted file mode 100644
index 7c98a9ccba592..0000000000000
--- a/plugins/repository-azure/licenses/azure-identity-1.13.2.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-50a1daef3eb5c6ab2e1351a3e3f5a7649a8fe464
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-identity-1.14.2.jar.sha1 b/plugins/repository-azure/licenses/azure-identity-1.14.2.jar.sha1
new file mode 100644
index 0000000000000..7ffc775aea847
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-identity-1.14.2.jar.sha1
@@ -0,0 +1 @@
+85c45e2add38742009a9c5070d2a9d8f192cf8db
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-storage-common-12.27.1.jar.sha1 b/plugins/repository-azure/licenses/azure-storage-common-12.27.1.jar.sha1
deleted file mode 100644
index d7602da1418d1..0000000000000
--- a/plugins/repository-azure/licenses/azure-storage-common-12.27.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c477c5d8c0f2076da1c5345c1097be6a319fe7c4
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-storage-common-12.28.0.jar.sha1 b/plugins/repository-azure/licenses/azure-storage-common-12.28.0.jar.sha1
new file mode 100644
index 0000000000000..ed932cd0a07e9
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-storage-common-12.28.0.jar.sha1
@@ -0,0 +1 @@
+3c5b7de96c68947ab74cc7925b27ca2b9f6b91d0
\ No newline at end of file
diff --git a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
index 970388498ee26..c7eae3eaa220b 100644
--- a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
+++ b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
@@ -88,6 +88,7 @@
 
 import fixture.azure.AzureHttpHandler;
 import reactor.core.scheduler.Schedulers;
+import reactor.netty.http.HttpResources;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.opensearch.repositories.azure.AzureRepository.Repository.CONTAINER_SETTING;
@@ -142,6 +143,7 @@ public void tearDown() throws Exception {
 
     @AfterClass
     public static void shutdownSchedulers() {
+        HttpResources.disposeLoopsAndConnections();
         Schedulers.shutdownNow();
     }
 
diff --git a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureRepositorySettingsTests.java b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureRepositorySettingsTests.java
index 3356e5174592a..0433a13baec2c 100644
--- a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureRepositorySettingsTests.java
+++ b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureRepositorySettingsTests.java
@@ -49,6 +49,7 @@
 import java.util.List;
 
 import reactor.core.scheduler.Schedulers;
+import reactor.netty.http.HttpResources;
 
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
@@ -57,6 +58,7 @@
 public class AzureRepositorySettingsTests extends OpenSearchTestCase {
     @AfterClass
     public static void shutdownSchedulers() {
+        HttpResources.disposeLoopsAndConnections();
         Schedulers.shutdownNow();
     }
 
diff --git a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureStorageServiceTests.java b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureStorageServiceTests.java
index ea74a49e593cf..324a20c9030c6 100644
--- a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureStorageServiceTests.java
+++ b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureStorageServiceTests.java
@@ -58,6 +58,7 @@
 import java.util.Map;
 
 import reactor.core.scheduler.Schedulers;
+import reactor.netty.http.HttpResources;
 
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.emptyString;
@@ -69,6 +70,7 @@
 public class AzureStorageServiceTests extends OpenSearchTestCase {
     @AfterClass
     public static void shutdownSchedulers() {
+        HttpResources.disposeLoopsAndConnections();
         Schedulers.shutdownNow();
     }
 
diff --git a/release-notes/opensearch.release-notes-1.3.20.md b/release-notes/opensearch.release-notes-1.3.20.md
new file mode 100644
index 0000000000000..b3cc89fb37985
--- /dev/null
+++ b/release-notes/opensearch.release-notes-1.3.20.md
@@ -0,0 +1,15 @@
+## 2024-12-10 Version 1.3.20 Release Notes
+
+### Dependencies
+- Bump `icu4j` from 62.1 to 62.2 ([#15469](https://github.com/opensearch-project/OpenSearch/pull/15469))
+- Bump `org.bouncycastle:bc-fips` from 1.0.2.4 to 1.0.2.5 ([#13446](https://github.com/opensearch-project/OpenSearch/pull/13446))
+- Bump `Netty` from 4.1.112.Final to 4.1.115.Final ([#16661](https://github.com/opensearch-project/OpenSearch/pull/16661))
+- Bump `avro` from 1.11.3 to 1.11.4 ([#16773](https://github.com/opensearch-project/OpenSearch/pull/16773))
+- Bump `commonsio` to 2.16.0 ([#16780](https://github.com/opensearch-project/OpenSearch/pull/16780))
+- Bump `protobuf-java` to 3.25.5 ([#16792](https://github.com/opensearch-project/OpenSearch/pull/16792))
+- Bump `snappy-java` to 1.1.10.7 ([#16792](https://github.com/opensearch-project/OpenSearch/pull/16792))
+- Bump `mime4j-core` to 0.8.11 ([#16810](https://github.com/opensearch-project/OpenSearch/pull/16810))
+
+### Fixed
+- Update help output for _cat ([#14722](https://github.com/opensearch-project/OpenSearch/pull/14722))
+- Bugfix to guard against stack overflow errors caused by very large reg-ex input ([#16101](https://github.com/opensearch-project/OpenSearch/pull/16101))
diff --git a/server/build.gradle b/server/build.gradle
index f1679ccfbec30..8dd23491ccd69 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -74,60 +74,46 @@ dependencies {
   compileOnly project(':libs:opensearch-plugin-classloader')
   testRuntimeOnly project(':libs:opensearch-plugin-classloader')
 
-  // lucene
-  api "org.apache.lucene:lucene-core:${versions.lucene}"
-  api "org.apache.lucene:lucene-analysis-common:${versions.lucene}"
-  api "org.apache.lucene:lucene-backward-codecs:${versions.lucene}"
-  api "org.apache.lucene:lucene-grouping:${versions.lucene}"
-  api "org.apache.lucene:lucene-highlighter:${versions.lucene}"
-  api "org.apache.lucene:lucene-join:${versions.lucene}"
-  api "org.apache.lucene:lucene-memory:${versions.lucene}"
-  api "org.apache.lucene:lucene-misc:${versions.lucene}"
-  api "org.apache.lucene:lucene-queries:${versions.lucene}"
-  api "org.apache.lucene:lucene-queryparser:${versions.lucene}"
-  api "org.apache.lucene:lucene-sandbox:${versions.lucene}"
-  api "org.apache.lucene:lucene-spatial-extras:${versions.lucene}"
-  api "org.apache.lucene:lucene-spatial3d:${versions.lucene}"
-  api "org.apache.lucene:lucene-suggest:${versions.lucene}"
+  api libs.bundles.lucene
 
   // utilities
   api project(":libs:opensearch-cli")
 
   // time handling, remove with java 8 time
-  api "joda-time:joda-time:${versions.joda}"
+  api libs.jodatime
 
   // percentiles aggregation
-  api "com.tdunning:t-digest:${versions.tdigest}"
+  api libs.tdigest
   // percentile ranks aggregation
-  api "org.hdrhistogram:HdrHistogram:${versions.hdrhistogram}"
+  api libs.hdrhistogram
 
   // lucene spatial
-  api "org.locationtech.spatial4j:spatial4j:${versions.spatial4j}", optional
-  api "org.locationtech.jts:jts-core:${versions.jts}", optional
+  api libs.spatial4j, optional
+  api libs.jtscore, optional
 
   // logging
-  api "org.apache.logging.log4j:log4j-api:${versions.log4j}"
-  api "org.apache.logging.log4j:log4j-jul:${versions.log4j}"
-  api "org.apache.logging.log4j:log4j-core:${versions.log4j}", optional
-  annotationProcessor "org.apache.logging.log4j:log4j-core:${versions.log4j}"
+  api libs.log4japi
+  api libs.log4jjul
+  api libs.log4jcore, optional
+  annotationProcessor libs.log4jcore
   annotationProcessor project(':libs:opensearch-common')
 
   // jna
-  api "net.java.dev.jna:jna:${versions.jna}"
+  api libs.jna
 
   // jcraft
-  api "com.jcraft:jzlib:${versions.jzlib}"
+  api libs.jzlib
 
   // reactor
-  api "io.projectreactor:reactor-core:${versions.reactor}"
-  api "org.reactivestreams:reactive-streams:${versions.reactivestreams}"
+  api libs.reactorcore
+  api libs.reactivestreams
 
   // protobuf
-  api "com.google.protobuf:protobuf-java:${versions.protobuf}"
-  api "jakarta.annotation:jakarta.annotation-api:${versions.jakarta_annotation}"
+  api libs.protobuf
+  api libs.jakartaannotation
 
   // https://mvnrepository.com/artifact/org.roaringbitmap/RoaringBitmap
-  implementation 'org.roaringbitmap:RoaringBitmap:1.3.0'
+  api libs.roaringbitmap
 
   testImplementation(project(":test:framework")) {
     // tests use the locally compiled version of server
diff --git a/server/licenses/lucene-analysis-common-9.12.0.jar.sha1 b/server/licenses/lucene-analysis-common-9.12.0.jar.sha1
deleted file mode 100644
index fd952034f3742..0000000000000
--- a/server/licenses/lucene-analysis-common-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-4c2503cfaba37249e20ea877555cb52ee89d1ae1
\ No newline at end of file
diff --git a/server/licenses/lucene-analysis-common-9.12.1.jar.sha1 b/server/licenses/lucene-analysis-common-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..2b9a8cf6e43fd
--- /dev/null
+++ b/server/licenses/lucene-analysis-common-9.12.1.jar.sha1
@@ -0,0 +1 @@
+86836497e35c1ab33259d9864ceb280c0016075e
\ No newline at end of file
diff --git a/server/licenses/lucene-backward-codecs-9.12.0.jar.sha1 b/server/licenses/lucene-backward-codecs-9.12.0.jar.sha1
deleted file mode 100644
index 2993134edd610..0000000000000
--- a/server/licenses/lucene-backward-codecs-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-68fe98c94e9644a584ea1bf525e68d9406fc61ec
\ No newline at end of file
diff --git a/server/licenses/lucene-backward-codecs-9.12.1.jar.sha1 b/server/licenses/lucene-backward-codecs-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..89d6ddbec3eec
--- /dev/null
+++ b/server/licenses/lucene-backward-codecs-9.12.1.jar.sha1
@@ -0,0 +1 @@
+d0e79d06a0ed021663737e4df777ab7b80cd28c4
\ No newline at end of file
diff --git a/server/licenses/lucene-core-9.12.0.jar.sha1 b/server/licenses/lucene-core-9.12.0.jar.sha1
deleted file mode 100644
index e55f896dedb63..0000000000000
--- a/server/licenses/lucene-core-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fdb055d569bb20bfce9618fe2b01c29bab7f290c
\ No newline at end of file
diff --git a/server/licenses/lucene-core-9.12.1.jar.sha1 b/server/licenses/lucene-core-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..2521c91a81d64
--- /dev/null
+++ b/server/licenses/lucene-core-9.12.1.jar.sha1
@@ -0,0 +1 @@
+91447c90c1180122142773b5baddaf8547124794
\ No newline at end of file
diff --git a/server/licenses/lucene-grouping-9.12.0.jar.sha1 b/server/licenses/lucene-grouping-9.12.0.jar.sha1
deleted file mode 100644
index 48388974bb38f..0000000000000
--- a/server/licenses/lucene-grouping-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ccf99f8db57aa97b2c1f95c5cc2a11156a043921
\ No newline at end of file
diff --git a/server/licenses/lucene-grouping-9.12.1.jar.sha1 b/server/licenses/lucene-grouping-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..61d7ff62ac3cc
--- /dev/null
+++ b/server/licenses/lucene-grouping-9.12.1.jar.sha1
@@ -0,0 +1 @@
+e4bc3d0aa7eec4f41b4f350de0263a8d5625d2b3
\ No newline at end of file
diff --git a/server/licenses/lucene-highlighter-9.12.0.jar.sha1 b/server/licenses/lucene-highlighter-9.12.0.jar.sha1
deleted file mode 100644
index 3d457579da892..0000000000000
--- a/server/licenses/lucene-highlighter-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e93429f66fbcd3b58d81f01223d6ce5688047296
\ No newline at end of file
diff --git a/server/licenses/lucene-highlighter-9.12.1.jar.sha1 b/server/licenses/lucene-highlighter-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..57fc10a58b806
--- /dev/null
+++ b/server/licenses/lucene-highlighter-9.12.1.jar.sha1
@@ -0,0 +1 @@
+2eeedfcec47dd65969f36e88931ed452291dd43e
\ No newline at end of file
diff --git a/server/licenses/lucene-join-9.12.0.jar.sha1 b/server/licenses/lucene-join-9.12.0.jar.sha1
deleted file mode 100644
index c5f6d16598a60..0000000000000
--- a/server/licenses/lucene-join-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-14c802d6955eaf11107375a2ada8fe8ec53b3e01
\ No newline at end of file
diff --git a/server/licenses/lucene-join-9.12.1.jar.sha1 b/server/licenses/lucene-join-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..8d46f20c39974
--- /dev/null
+++ b/server/licenses/lucene-join-9.12.1.jar.sha1
@@ -0,0 +1 @@
+3c5e9ff2925a8373ae0d35c1d0a7b2465cebec9f
\ No newline at end of file
diff --git a/server/licenses/lucene-memory-9.12.0.jar.sha1 b/server/licenses/lucene-memory-9.12.0.jar.sha1
deleted file mode 100644
index e7ac44089c006..0000000000000
--- a/server/licenses/lucene-memory-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ffe090339540876b40df792aee51a42af6b3f37f
\ No newline at end of file
diff --git a/server/licenses/lucene-memory-9.12.1.jar.sha1 b/server/licenses/lucene-memory-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..55de1c9322aa3
--- /dev/null
+++ b/server/licenses/lucene-memory-9.12.1.jar.sha1
@@ -0,0 +1 @@
+e80eecfb1dcc324140387c8357c81e12c2a01937
\ No newline at end of file
diff --git a/server/licenses/lucene-misc-9.12.0.jar.sha1 b/server/licenses/lucene-misc-9.12.0.jar.sha1
deleted file mode 100644
index afb546be4e032..0000000000000
--- a/server/licenses/lucene-misc-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ad17704ee90eb926b6d3105f7027485cdadbecd9
\ No newline at end of file
diff --git a/server/licenses/lucene-misc-9.12.1.jar.sha1 b/server/licenses/lucene-misc-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..86982eb1c900c
--- /dev/null
+++ b/server/licenses/lucene-misc-9.12.1.jar.sha1
@@ -0,0 +1 @@
+4e65d01d1c23f3f49dc325d552701bbefafee7ee
\ No newline at end of file
diff --git a/server/licenses/lucene-queries-9.12.0.jar.sha1 b/server/licenses/lucene-queries-9.12.0.jar.sha1
deleted file mode 100644
index e24756e38dad2..0000000000000
--- a/server/licenses/lucene-queries-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3ac2a62b0b55c5725bb65f0c5454f9f8a401cf43
\ No newline at end of file
diff --git a/server/licenses/lucene-queries-9.12.1.jar.sha1 b/server/licenses/lucene-queries-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..f2087ec8eb623
--- /dev/null
+++ b/server/licenses/lucene-queries-9.12.1.jar.sha1
@@ -0,0 +1 @@
+14f24315041b686683dba4bc679ca7dc6a505906
\ No newline at end of file
diff --git a/server/licenses/lucene-queryparser-9.12.0.jar.sha1 b/server/licenses/lucene-queryparser-9.12.0.jar.sha1
deleted file mode 100644
index e93e00a063dd0..0000000000000
--- a/server/licenses/lucene-queryparser-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-55959399373876f4c184944315458dc6b88fbd81
\ No newline at end of file
diff --git a/server/licenses/lucene-queryparser-9.12.1.jar.sha1 b/server/licenses/lucene-queryparser-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..489e6719da342
--- /dev/null
+++ b/server/licenses/lucene-queryparser-9.12.1.jar.sha1
@@ -0,0 +1 @@
+aa6df09a99f8881d843e9863aa1713dc9f3ed24f
\ No newline at end of file
diff --git a/server/licenses/lucene-sandbox-9.12.0.jar.sha1 b/server/licenses/lucene-sandbox-9.12.0.jar.sha1
deleted file mode 100644
index a3fd8446e0dbc..0000000000000
--- a/server/licenses/lucene-sandbox-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f65882536d681c11a1cbc920e5679201101e3603
\ No newline at end of file
diff --git a/server/licenses/lucene-sandbox-9.12.1.jar.sha1 b/server/licenses/lucene-sandbox-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..c1d613e23f1fe
--- /dev/null
+++ b/server/licenses/lucene-sandbox-9.12.1.jar.sha1
@@ -0,0 +1 @@
+1a66485629d60779f039fc26360f4374ef1496e7
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial-extras-9.12.0.jar.sha1 b/server/licenses/lucene-spatial-extras-9.12.0.jar.sha1
deleted file mode 100644
index b0f11fb667faf..0000000000000
--- a/server/licenses/lucene-spatial-extras-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9d00cc7cc2279822ef6740f0677cafacfb439fa8
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial-extras-9.12.1.jar.sha1 b/server/licenses/lucene-spatial-extras-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..c38b794ce9948
--- /dev/null
+++ b/server/licenses/lucene-spatial-extras-9.12.1.jar.sha1
@@ -0,0 +1 @@
+0a7379410eff21676472adc8ea76a57891ec83c2
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial3d-9.12.0.jar.sha1 b/server/licenses/lucene-spatial3d-9.12.0.jar.sha1
deleted file mode 100644
index 858eee25ac191..0000000000000
--- a/server/licenses/lucene-spatial3d-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e3092632ca1d4427d3ebb2c866ac89d90f5b61ec
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial3d-9.12.1.jar.sha1 b/server/licenses/lucene-spatial3d-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..bc327a8cec830
--- /dev/null
+++ b/server/licenses/lucene-spatial3d-9.12.1.jar.sha1
@@ -0,0 +1 @@
+d2fdea4edabb1f616f494999651c43abfd0aa124
\ No newline at end of file
diff --git a/server/licenses/lucene-suggest-9.12.0.jar.sha1 b/server/licenses/lucene-suggest-9.12.0.jar.sha1
deleted file mode 100644
index 973a7726d845d..0000000000000
--- a/server/licenses/lucene-suggest-9.12.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e1c6636499317ebe498f3490a1ec8b86b8a363dd
\ No newline at end of file
diff --git a/server/licenses/lucene-suggest-9.12.1.jar.sha1 b/server/licenses/lucene-suggest-9.12.1.jar.sha1
new file mode 100644
index 0000000000000..961f6da619149
--- /dev/null
+++ b/server/licenses/lucene-suggest-9.12.1.jar.sha1
@@ -0,0 +1 @@
+0660e0996ec7653fe0c13c608137e264645eecac
\ No newline at end of file
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java
index 32d5b3db85629..a7cb4847b45e5 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java
@@ -8,9 +8,15 @@
 
 package org.opensearch.action.admin.cluster.shards;
 
+import org.opensearch.action.admin.indices.alias.IndicesAliasesRequest;
+import org.opensearch.action.admin.indices.datastream.DataStreamTestCase;
 import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.action.admin.indices.stats.ShardStats;
+import org.opensearch.action.pagination.PageParams;
+import org.opensearch.client.Requests;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.action.ActionFuture;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
@@ -20,15 +26,19 @@
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
 
 import static org.opensearch.cluster.routing.UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING;
 import static org.opensearch.common.unit.TimeValue.timeValueMillis;
 import static org.opensearch.search.SearchService.NO_TIMEOUT;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(numDataNodes = 0, scope = OpenSearchIntegTestCase.Scope.TEST)
-public class TransportCatShardsActionIT extends OpenSearchIntegTestCase {
+public class TransportCatShardsActionIT extends DataStreamTestCase {
 
     public void testCatShardsWithSuccessResponse() throws InterruptedException {
         internalCluster().startClusterManagerOnlyNodes(1);
@@ -125,4 +135,334 @@ public void onFailure(Exception e) {
         latch.await();
     }
 
+    public void testListShardsWithHiddenIndex() throws Exception {
+        final int numShards = 1;
+        final int numReplicas = 1;
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(2);
+        createIndex(
+            "test-hidden-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .put(IndexMetadata.SETTING_INDEX_HIDDEN, true)
+                .build()
+        );
+        ensureGreen();
+
+        // Verify result for a default query: "_list/shards"
+        CatShardsRequest listShardsRequest = getListShardsTransportRequest(Strings.EMPTY_ARRAY, 100);
+        ActionFuture<CatShardsResponse> listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-hidden-idx", 2, true);
+
+        // Verify result when hidden index is explicitly queried: "_list/shards"
+        listShardsRequest = getListShardsTransportRequest(new String[] { "test-hidden-idx" }, 100);
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-hidden-idx", 2, true);
+
+        // Verify result when hidden index is queried with wildcard: "_list/shards*"
+        // Since the ClusterStateAction underneath is invoked with lenientExpandOpen IndicesOptions,
+        // Wildcards for hidden indices should not get resolved.
+        listShardsRequest = getListShardsTransportRequest(new String[] { "test-hidden-idx*" }, 100);
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertEquals(0, listShardsResponse.get().getResponseShards().size());
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-hidden-idx", 0, false);
+    }
+
+    public void testListShardsWithClosedIndex() throws Exception {
+        final int numShards = 1;
+        final int numReplicas = 1;
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(2);
+        createIndex(
+            "test-closed-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        ensureGreen();
+
+        // close index "test-closed-idx"
+        client().admin().indices().close(Requests.closeIndexRequest("test-closed-idx")).get();
+        ensureGreen();
+
+        // Verify result for a default query: "_list/shards"
+        CatShardsRequest listShardsRequest = getListShardsTransportRequest(Strings.EMPTY_ARRAY, 100);
+        ActionFuture<CatShardsResponse> listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-closed-idx", 2, false);
+
+        // Verify result when closed index is explicitly queried: "_list/shards"
+        listShardsRequest = getListShardsTransportRequest(new String[] { "test-closed-idx" }, 100);
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-closed-idx", 2, false);
+
+        // Verify result when closed index is queried with wildcard: "_list/shards*"
+        // Since the ClusterStateAction underneath is invoked with lenientExpandOpen IndicesOptions,
+        // Wildcards for closed indices should not get resolved.
+        listShardsRequest = getListShardsTransportRequest(new String[] { "test-closed-idx*" }, 100);
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), "test-closed-idx", 0, false);
+    }
+
+    public void testListShardsWithClosedAndHiddenIndices() throws InterruptedException, ExecutionException {
+        final int numIndices = 4;
+        final int numShards = 1;
+        final int numReplicas = 2;
+        final int pageSize = 100;
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(3);
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-2",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-closed-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-hidden-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .put(IndexMetadata.SETTING_INDEX_HIDDEN, true)
+                .build()
+        );
+        // close index "test-closed-idx"
+        client().admin().indices().close(Requests.closeIndexRequest("test-closed-idx")).get();
+        ensureGreen();
+
+        // Verifying response for default queries: /_list/shards
+        // all the shards should be part of response, however stats should not be displayed for closed index
+        CatShardsRequest listShardsRequest = getListShardsTransportRequest(Strings.EMPTY_ARRAY, pageSize);
+        ActionFuture<CatShardsResponse> listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertTrue(listShardsResponse.get().getResponseShards().stream().anyMatch(shard -> shard.getIndexName().equals("test-closed-idx")));
+        assertTrue(listShardsResponse.get().getResponseShards().stream().anyMatch(shard -> shard.getIndexName().equals("test-hidden-idx")));
+        assertEquals(numIndices * numShards * (numReplicas + 1), listShardsResponse.get().getResponseShards().size());
+        assertFalse(
+            Arrays.stream(listShardsResponse.get().getIndicesStatsResponse().getShards())
+                .anyMatch(shardStats -> shardStats.getShardRouting().getIndexName().equals("test-closed-idx"))
+        );
+        assertEquals(
+            (numIndices - 1) * numShards * (numReplicas + 1),
+            listShardsResponse.get().getIndicesStatsResponse().getShards().length
+        );
+
+        // Verifying responses when hidden indices are explicitly queried: /_list/shards/test-hidden-idx
+        // Shards for hidden index should appear in response along with stats
+        listShardsRequest.setIndices(List.of("test-hidden-idx").toArray(new String[0]));
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertTrue(listShardsResponse.get().getResponseShards().stream().allMatch(shard -> shard.getIndexName().equals("test-hidden-idx")));
+        assertTrue(
+            Arrays.stream(listShardsResponse.get().getIndicesStatsResponse().getShards())
+                .allMatch(shardStats -> shardStats.getShardRouting().getIndexName().equals("test-hidden-idx"))
+        );
+        assertEquals(
+            listShardsResponse.get().getResponseShards().size(),
+            listShardsResponse.get().getIndicesStatsResponse().getShards().length
+        );
+
+        // Verifying responses when hidden indices are queried with wildcards: /_list/shards/test-hidden-idx*
+        // Shards for hidden index should not appear in response with stats.
+        listShardsRequest.setIndices(List.of("test-hidden-idx*").toArray(new String[0]));
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertEquals(0, listShardsResponse.get().getResponseShards().size());
+        assertEquals(0, listShardsResponse.get().getIndicesStatsResponse().getShards().length);
+
+        // Explicitly querying for closed index: /_list/shards/test-closed-idx
+        // should output closed shards without stats.
+        listShardsRequest.setIndices(List.of("test-closed-idx").toArray(new String[0]));
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertTrue(listShardsResponse.get().getResponseShards().stream().anyMatch(shard -> shard.getIndexName().equals("test-closed-idx")));
+        assertEquals(0, listShardsResponse.get().getIndicesStatsResponse().getShards().length);
+
+        // Querying for closed index with wildcards: /_list/shards/test-closed-idx*
+        // should not output any closed shards.
+        listShardsRequest.setIndices(List.of("test-closed-idx*").toArray(new String[0]));
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertEquals(0, listShardsResponse.get().getResponseShards().size());
+        assertEquals(0, listShardsResponse.get().getIndicesStatsResponse().getShards().length);
+    }
+
+    public void testListShardsWithClosedIndicesAcrossPages() throws InterruptedException, ExecutionException {
+        final int numIndices = 4;
+        final int numShards = 1;
+        final int numReplicas = 2;
+        final int pageSize = numShards * (numReplicas + 1);
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(3);
+        createIndex(
+            "test-open-idx-1",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-closed-idx-1",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-open-idx-2",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-closed-idx-2",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .put(IndexMetadata.SETTING_INDEX_HIDDEN, true)
+                .build()
+        );
+        // close index "test-closed-idx-1"
+        client().admin().indices().close(Requests.closeIndexRequest("test-closed-idx-1")).get();
+        ensureGreen();
+        // close index "test-closed-idx-2"
+        client().admin().indices().close(Requests.closeIndexRequest("test-closed-idx-2")).get();
+        ensureGreen();
+
+        // Verifying response for default queries: /_list/shards
+        List<ShardRouting> responseShardRouting = new ArrayList<>();
+        List<ShardStats> responseShardStats = new ArrayList<>();
+        String nextToken = null;
+        CatShardsRequest listShardsRequest;
+        ActionFuture<CatShardsResponse> listShardsResponse;
+        do {
+            listShardsRequest = getListShardsTransportRequest(Strings.EMPTY_ARRAY, nextToken, pageSize);
+            listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+            nextToken = listShardsResponse.get().getPageToken().getNextToken();
+            responseShardRouting.addAll(listShardsResponse.get().getResponseShards());
+            responseShardStats.addAll(List.of(listShardsResponse.get().getIndicesStatsResponse().getShards()));
+        } while (nextToken != null);
+
+        assertTrue(responseShardRouting.stream().anyMatch(shard -> shard.getIndexName().equals("test-closed-idx-1")));
+        assertTrue(responseShardRouting.stream().anyMatch(shard -> shard.getIndexName().equals("test-closed-idx-2")));
+        assertEquals(numIndices * numShards * (numReplicas + 1), responseShardRouting.size());
+        // ShardsStats should only appear for 2 open indices
+        assertFalse(
+            responseShardStats.stream().anyMatch(shardStats -> shardStats.getShardRouting().getIndexName().contains("test-closed-idx"))
+        );
+        assertEquals(2 * numShards * (numReplicas + 1), responseShardStats.size());
+    }
+
+    public void testListShardsWithDataStream() throws Exception {
+        final int numDataNodes = 3;
+        String dataStreamName = "logs-test";
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(numDataNodes);
+        // Create an index template for data streams.
+        createDataStreamIndexTemplate("data-stream-template", List.of("logs-*"));
+        // Create data streams matching the "logs-*" index pattern.
+        createDataStream(dataStreamName);
+        ensureGreen();
+        // Verifying default query's result. Data stream should have created a hidden backing index in the
+        // background and all the corresponding shards should appear in the response along with stats.
+        CatShardsRequest listShardsRequest = getListShardsTransportRequest(Strings.EMPTY_ARRAY, numDataNodes * numDataNodes);
+        ActionFuture<CatShardsResponse> listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), dataStreamName, numDataNodes + 1, true);
+        // Verifying result when data stream is directly queried. Again, all the shards with stats should appear
+        listShardsRequest = getListShardsTransportRequest(new String[] { dataStreamName }, numDataNodes * numDataNodes);
+        listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertSingleIndexResponseShards(listShardsResponse.get(), dataStreamName, numDataNodes + 1, true);
+    }
+
+    public void testListShardsWithAliases() throws Exception {
+        final int numShards = 1;
+        final int numReplicas = 1;
+        final String aliasName = "test-alias";
+        internalCluster().startClusterManagerOnlyNodes(1);
+        internalCluster().startDataOnlyNodes(3);
+        createIndex(
+            "test-closed-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .build()
+        );
+        createIndex(
+            "test-hidden-idx",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, numShards)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicas)
+                .put(IndexMetadata.SETTING_INDEX_HIDDEN, true)
+                .build()
+        );
+        ensureGreen();
+
+        // Point test alias to both the indices (one being hidden while the other is closed)
+        final IndicesAliasesRequest request = new IndicesAliasesRequest().origin("allowed");
+        request.addAliasAction(IndicesAliasesRequest.AliasActions.add().index("test-closed-idx").alias(aliasName));
+        assertAcked(client().admin().indices().aliases(request).actionGet());
+
+        request.addAliasAction(IndicesAliasesRequest.AliasActions.add().index("test-hidden-idx").alias(aliasName));
+        assertAcked(client().admin().indices().aliases(request).actionGet());
+
+        // close index "test-closed-idx"
+        client().admin().indices().close(Requests.closeIndexRequest("test-closed-idx")).get();
+        ensureGreen();
+
+        // Verifying result when an alias is explicitly queried.
+        CatShardsRequest listShardsRequest = getListShardsTransportRequest(new String[] { aliasName }, 100);
+        ActionFuture<CatShardsResponse> listShardsResponse = client().execute(CatShardsAction.INSTANCE, listShardsRequest);
+        assertTrue(
+            listShardsResponse.get()
+                .getResponseShards()
+                .stream()
+                .allMatch(shard -> shard.getIndexName().equals("test-hidden-idx") || shard.getIndexName().equals("test-closed-idx"))
+        );
+        assertTrue(
+            Arrays.stream(listShardsResponse.get().getIndicesStatsResponse().getShards())
+                .allMatch(shardStats -> shardStats.getShardRouting().getIndexName().equals("test-hidden-idx"))
+        );
+        assertEquals(4, listShardsResponse.get().getResponseShards().size());
+        assertEquals(2, listShardsResponse.get().getIndicesStatsResponse().getShards().length);
+    }
+
+    private void assertSingleIndexResponseShards(
+        CatShardsResponse catShardsResponse,
+        String indexNamePattern,
+        final int totalNumShards,
+        boolean shardStatsExist
+    ) {
+        assertTrue(catShardsResponse.getResponseShards().stream().allMatch(shard -> shard.getIndexName().contains(indexNamePattern)));
+        assertEquals(totalNumShards, catShardsResponse.getResponseShards().size());
+        if (shardStatsExist) {
+            assertTrue(
+                Arrays.stream(catShardsResponse.getIndicesStatsResponse().getShards())
+                    .allMatch(shardStats -> shardStats.getShardRouting().getIndexName().contains(indexNamePattern))
+            );
+        }
+        assertEquals(shardStatsExist ? totalNumShards : 0, catShardsResponse.getIndicesStatsResponse().getShards().length);
+    }
+
+    private CatShardsRequest getListShardsTransportRequest(String[] indices, final int pageSize) {
+        return getListShardsTransportRequest(indices, null, pageSize);
+    }
+
+    private CatShardsRequest getListShardsTransportRequest(String[] indices, String nextToken, final int pageSize) {
+        CatShardsRequest listShardsRequest = new CatShardsRequest();
+        listShardsRequest.setCancelAfterTimeInterval(NO_TIMEOUT);
+        listShardsRequest.setIndices(indices);
+        listShardsRequest.setPageParams(new PageParams(nextToken, PageParams.PARAM_ASC_SORT_VALUE, pageSize));
+        return listShardsRequest;
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/discovery/DiscoveryDisruptionIT.java b/server/src/internalClusterTest/java/org/opensearch/discovery/DiscoveryDisruptionIT.java
index 70124c8c46700..377f99cd8b791 100644
--- a/server/src/internalClusterTest/java/org/opensearch/discovery/DiscoveryDisruptionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/discovery/DiscoveryDisruptionIT.java
@@ -33,12 +33,21 @@
 package org.opensearch.discovery;
 
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
 import org.opensearch.cluster.coordination.JoinHelper;
+import org.opensearch.cluster.coordination.PersistedStateRegistry;
 import org.opensearch.cluster.coordination.PublicationTransportHandler;
+import org.opensearch.cluster.metadata.RepositoriesMetadata;
+import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Randomness;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.Repository;
+import org.opensearch.repositories.RepositoryMissingException;
+import org.opensearch.repositories.fs.ReloadableFsRepository;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.disruption.NetworkDisruption;
 import org.opensearch.test.disruption.ServiceDisruptionScheme;
@@ -46,10 +55,15 @@
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportService;
+import org.junit.Assert;
 
+import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING;
@@ -250,4 +264,142 @@ public void testNodeNotReachableFromClusterManager() throws Exception {
         ensureStableCluster(3);
     }
 
+    /**
+     * Tests the scenario where-in a cluster-state containing new repository meta-data as part of a node-join from a
+     * repository-configured node fails on a commit stag and has a master switch. This would lead to master nodes
+     * doing another round of node-joins with the new cluster-state as the previous attempt had a successful publish.
+     */
+    public void testElectClusterManagerRemotePublicationConfigurationNodeJoinCommitFails() throws Exception {
+        final String remoteStateRepoName = "remote-state-repo";
+        final String remoteRoutingTableRepoName = "routing-table-repo";
+
+        Settings remotePublicationSettings = buildRemotePublicationNodeAttributes(
+            remoteStateRepoName,
+            ReloadableFsRepository.TYPE,
+            remoteRoutingTableRepoName,
+            ReloadableFsRepository.TYPE
+        );
+        internalCluster().startClusterManagerOnlyNodes(3);
+        internalCluster().startDataOnlyNodes(3);
+
+        String clusterManagerNode = internalCluster().getClusterManagerName();
+        List<String> nonClusterManagerNodes = Arrays.stream(internalCluster().getNodeNames())
+            .filter(node -> !node.equals(clusterManagerNode))
+            .collect(Collectors.toList());
+
+        ensureStableCluster(6);
+
+        MockTransportService clusterManagerTransportService = (MockTransportService) internalCluster().getInstance(
+            TransportService.class,
+            clusterManagerNode
+        );
+        logger.info("Blocking Cluster Manager Commit Request on all nodes");
+        // This is to allow the new node to have commit failures on the nodes in the send path itself. This will lead to the
+        // nodes have a successful publish operation but failed commit operation. This will come into play once the new node joins
+        nonClusterManagerNodes.forEach(node -> {
+            TransportService targetTransportService = internalCluster().getInstance(TransportService.class, node);
+            clusterManagerTransportService.addSendBehavior(targetTransportService, (connection, requestId, action, request, options) -> {
+                if (action.equals(PublicationTransportHandler.COMMIT_STATE_ACTION_NAME)) {
+                    logger.info("--> preventing {} request", PublicationTransportHandler.COMMIT_STATE_ACTION_NAME);
+                    throw new FailedToCommitClusterStateException("Blocking Commit");
+                }
+                connection.sendRequest(requestId, action, request, options);
+            });
+        });
+
+        logger.info("Starting Node with remote publication settings");
+        // Start a node with remote-publication repositories configured. This will lead to the active cluster-manager create
+        // a new cluster-state event with the new node-join along with new repositories setup in the cluster meta-data.
+        internalCluster().startDataOnlyNodes(1, remotePublicationSettings, Boolean.TRUE);
+
+        // Checking if publish succeeded in the nodes before shutting down the blocked cluster-manager
+        assertBusy(() -> {
+            String randomNode = nonClusterManagerNodes.get(Randomness.get().nextInt(nonClusterManagerNodes.size()));
+            PersistedStateRegistry registry = internalCluster().getInstance(PersistedStateRegistry.class, randomNode);
+
+            ClusterState state = registry.getPersistedState(PersistedStateRegistry.PersistedStateType.LOCAL).getLastAcceptedState();
+            RepositoriesMetadata repositoriesMetadata = state.metadata().custom(RepositoriesMetadata.TYPE);
+            Boolean isRemoteStateRepoConfigured = Boolean.FALSE;
+            Boolean isRemoteRoutingTableRepoConfigured = Boolean.FALSE;
+
+            assertNotNull(repositoriesMetadata);
+            assertNotNull(repositoriesMetadata.repositories());
+
+            for (RepositoryMetadata repo : repositoriesMetadata.repositories()) {
+                if (repo.name().equals(remoteStateRepoName)) {
+                    isRemoteStateRepoConfigured = Boolean.TRUE;
+                } else if (repo.name().equals(remoteRoutingTableRepoName)) {
+                    isRemoteRoutingTableRepoConfigured = Boolean.TRUE;
+                }
+            }
+            // Asserting that the metadata is present in the persisted cluster-state
+            assertTrue(isRemoteStateRepoConfigured);
+            assertTrue(isRemoteRoutingTableRepoConfigured);
+
+            RepositoriesService repositoriesService = internalCluster().getInstance(RepositoriesService.class, randomNode);
+
+            isRemoteStateRepoConfigured = isRepoPresentInRepositoryService(repositoriesService, remoteStateRepoName);
+            isRemoteRoutingTableRepoConfigured = isRepoPresentInRepositoryService(repositoriesService, remoteRoutingTableRepoName);
+
+            // Asserting that the metadata is not present in the repository service.
+            Assert.assertFalse(isRemoteStateRepoConfigured);
+            Assert.assertFalse(isRemoteRoutingTableRepoConfigured);
+        });
+
+        logger.info("Stopping current Cluster Manager");
+        // We stop the current cluster-manager whose outbound paths were blocked. This is to force a new election onto nodes
+        // we had the new cluster-state published but not commited.
+        internalCluster().stopCurrentClusterManagerNode();
+
+        // We expect that the repositories validations are skipped in this case and node-joins succeeds as expected. The
+        // repositories validations are skipped because even though the cluster-state is updated in the persisted registry,
+        // the repository service will not be updated as the commit attempt failed.
+        ensureStableCluster(6);
+
+        String randomNode = nonClusterManagerNodes.get(Randomness.get().nextInt(nonClusterManagerNodes.size()));
+
+        // Checking if the final cluster-state is updated.
+        RepositoriesMetadata repositoriesMetadata = internalCluster().getInstance(ClusterService.class, randomNode)
+            .state()
+            .metadata()
+            .custom(RepositoriesMetadata.TYPE);
+
+        Boolean isRemoteStateRepoConfigured = Boolean.FALSE;
+        Boolean isRemoteRoutingTableRepoConfigured = Boolean.FALSE;
+
+        for (RepositoryMetadata repo : repositoriesMetadata.repositories()) {
+            if (repo.name().equals(remoteStateRepoName)) {
+                isRemoteStateRepoConfigured = Boolean.TRUE;
+            } else if (repo.name().equals(remoteRoutingTableRepoName)) {
+                isRemoteRoutingTableRepoConfigured = Boolean.TRUE;
+            }
+        }
+
+        Assert.assertTrue("RemoteState Repo is not set in RepositoriesMetadata", isRemoteStateRepoConfigured);
+        Assert.assertTrue("RemoteRoutingTable Repo is not set in RepositoriesMetadata", isRemoteRoutingTableRepoConfigured);
+
+        RepositoriesService repositoriesService = internalCluster().getInstance(RepositoriesService.class, randomNode);
+
+        isRemoteStateRepoConfigured = isRepoPresentInRepositoryService(repositoriesService, remoteStateRepoName);
+        isRemoteRoutingTableRepoConfigured = isRepoPresentInRepositoryService(repositoriesService, remoteRoutingTableRepoName);
+
+        Assert.assertTrue("RemoteState Repo is not set in RepositoryService", isRemoteStateRepoConfigured);
+        Assert.assertTrue("RemoteRoutingTable Repo is not set in RepositoryService", isRemoteRoutingTableRepoConfigured);
+
+        logger.info("Stopping current Cluster Manager");
+    }
+
+    private Boolean isRepoPresentInRepositoryService(RepositoriesService repositoriesService, String repoName) {
+        try {
+            Repository remoteStateRepo = repositoriesService.repository(repoName);
+            if (Objects.nonNull(remoteStateRepo)) {
+                return Boolean.TRUE;
+            }
+        } catch (RepositoryMissingException e) {
+            return Boolean.FALSE;
+        }
+
+        return Boolean.FALSE;
+    }
+
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java
index a1b512c326ac5..f660695af9965 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java
@@ -8,14 +8,20 @@
 
 package org.opensearch.indices.replication;
 
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsResponse;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.index.SegmentReplicationPerGroupStats;
+import org.opensearch.index.SegmentReplicationShardStats;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.After;
 import org.junit.Before;
 
 import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class SearchReplicaReplicationIT extends SegmentReplicationBaseIT {
@@ -82,4 +88,47 @@ public void testReplication() throws Exception {
         waitForSearchableDocs(docCount, primary, replica);
     }
 
+    public void testSegmentReplicationStatsResponseWithSearchReplica() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+        final List<String> nodes = internalCluster().startDataOnlyNodes(2);
+        createIndex(
+            INDEX_NAME,
+            Settings.builder()
+                .put("number_of_shards", 1)
+                .put("number_of_replicas", 0)
+                .put("number_of_search_only_replicas", 1)
+                .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+                .build()
+        );
+        ensureGreen(INDEX_NAME);
+
+        final int docCount = 5;
+        for (int i = 0; i < docCount; i++) {
+            client().prepareIndex(INDEX_NAME).setId(Integer.toString(i)).setSource("field", "value" + i).execute().get();
+        }
+        refresh(INDEX_NAME);
+        waitForSearchableDocs(docCount, nodes);
+
+        SegmentReplicationStatsResponse segmentReplicationStatsResponse = dataNodeClient().admin()
+            .indices()
+            .prepareSegmentReplicationStats(INDEX_NAME)
+            .setDetailed(true)
+            .execute()
+            .actionGet();
+
+        // Verify the number of indices
+        assertEquals(1, segmentReplicationStatsResponse.getReplicationStats().size());
+        // Verify total shards
+        assertEquals(2, segmentReplicationStatsResponse.getTotalShards());
+        // Verify the number of primary shards
+        assertEquals(1, segmentReplicationStatsResponse.getReplicationStats().get(INDEX_NAME).size());
+
+        SegmentReplicationPerGroupStats perGroupStats = segmentReplicationStatsResponse.getReplicationStats().get(INDEX_NAME).get(0);
+        Set<SegmentReplicationShardStats> replicaStats = perGroupStats.getReplicaStats();
+        // Verify the number of replica stats
+        assertEquals(1, replicaStats.size());
+        for (SegmentReplicationShardStats replicaStat : replicaStats) {
+            assertNotNull(replicaStat.getCurrentReplicationState());
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
index 7b36b7a10f4f2..01efa96a7369e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
@@ -18,6 +18,8 @@
 import org.opensearch.action.support.HandledTransportAction;
 import org.opensearch.action.support.TimeoutTaskCancellationUtility;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.breaker.ResponseLimitBreachedException;
 import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.inject.Inject;
@@ -27,6 +29,7 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.TransportService;
 
+import java.util.List;
 import java.util.Objects;
 
 import static org.opensearch.common.breaker.ResponseLimitSettings.LimitEntity.SHARDS;
@@ -98,9 +101,6 @@ public void onResponse(ClusterStateResponse clusterStateResponse) {
                             shardsRequest.getPageParams(),
                             clusterStateResponse
                         );
-                        String[] indices = Objects.isNull(paginationStrategy)
-                            ? shardsRequest.getIndices()
-                            : paginationStrategy.getRequestedIndices().toArray(new String[0]);
                         catShardsResponse.setNodes(clusterStateResponse.getState().getNodes());
                         catShardsResponse.setResponseShards(
                             Objects.isNull(paginationStrategy)
@@ -108,8 +108,12 @@ public void onResponse(ClusterStateResponse clusterStateResponse) {
                                 : paginationStrategy.getRequestedEntities()
                         );
                         catShardsResponse.setPageToken(Objects.isNull(paginationStrategy) ? null : paginationStrategy.getResponseToken());
+
+                        String[] indices = Objects.isNull(paginationStrategy)
+                            ? shardsRequest.getIndices()
+                            : filterClosedIndices(clusterStateResponse.getState(), paginationStrategy.getRequestedIndices());
                         // For paginated queries, if strategy outputs no shards to be returned, avoid fetching IndicesStats.
-                        if (shouldSkipIndicesStatsRequest(paginationStrategy)) {
+                        if (shouldSkipIndicesStatsRequest(paginationStrategy, indices)) {
                             catShardsResponse.setIndicesStatsResponse(IndicesStatsResponse.getEmptyResponse());
                             cancellableListener.onResponse(catShardsResponse);
                             return;
@@ -166,7 +170,19 @@ private void validateRequestLimit(
         }
     }
 
-    private boolean shouldSkipIndicesStatsRequest(ShardPaginationStrategy paginationStrategy) {
-        return Objects.nonNull(paginationStrategy) && paginationStrategy.getRequestedEntities().isEmpty();
+    private boolean shouldSkipIndicesStatsRequest(ShardPaginationStrategy paginationStrategy, String[] indices) {
+        return Objects.nonNull(paginationStrategy) && (indices == null || indices.length == 0);
+    }
+
+    /**
+     * Will be used by paginated query (_list/shards) to filter out closed indices (only consider OPEN) before fetching
+     * IndicesStats. Since pagination strategy always passes concrete indices to TransportIndicesStatsAction,
+     * the default behaviour of StrictExpandOpenAndForbidClosed leads to errors if closed indices are encountered.
+     */
+    private String[] filterClosedIndices(ClusterState clusterState, List<String> strategyIndices) {
+        return strategyIndices.stream().filter(index -> {
+            IndexMetadata metadata = clusterState.metadata().indices().get(index);
+            return metadata != null && metadata.getState().equals(IndexMetadata.State.CLOSE) == false;
+        }).toArray(String[]::new);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsAction.java b/server/src/main/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsAction.java
index fc97d67c6c3af..44408c5043fcf 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsAction.java
@@ -21,7 +21,6 @@
 import org.opensearch.core.action.support.DefaultShardOperationFailedException;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.index.IndexService;
 import org.opensearch.index.SegmentReplicationPerGroupStats;
 import org.opensearch.index.SegmentReplicationPressureService;
 import org.opensearch.index.SegmentReplicationShardStats;
@@ -38,7 +37,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Transport action for shard segment replication operation. This transport action does not actually
@@ -96,11 +97,11 @@ protected SegmentReplicationStatsResponse newResponse(
     ) {
         String[] shards = request.shards();
         final List<Integer> shardsToFetch = Arrays.stream(shards).map(Integer::valueOf).collect(Collectors.toList());
-
         // organize replica responses by allocationId.
         final Map<String, SegmentReplicationState> replicaStats = new HashMap<>();
         // map of index name to list of replication group stats.
         final Map<String, List<SegmentReplicationPerGroupStats>> primaryStats = new HashMap<>();
+
         for (SegmentReplicationShardStatsResponse response : responses) {
             if (response != null) {
                 if (response.getReplicaStats() != null) {
@@ -109,6 +110,7 @@ protected SegmentReplicationStatsResponse newResponse(
                         replicaStats.putIfAbsent(shardRouting.allocationId().getId(), response.getReplicaStats());
                     }
                 }
+
                 if (response.getPrimaryStats() != null) {
                     final ShardId shardId = response.getPrimaryStats().getShardId();
                     if (shardsToFetch.isEmpty() || shardsToFetch.contains(shardId.getId())) {
@@ -126,15 +128,20 @@ protected SegmentReplicationStatsResponse newResponse(
                 }
             }
         }
-        // combine the replica stats to the shard stat entry in each group.
-        for (Map.Entry<String, List<SegmentReplicationPerGroupStats>> entry : primaryStats.entrySet()) {
-            for (SegmentReplicationPerGroupStats group : entry.getValue()) {
-                for (SegmentReplicationShardStats replicaStat : group.getReplicaStats()) {
-                    replicaStat.setCurrentReplicationState(replicaStats.getOrDefault(replicaStat.getAllocationId(), null));
-                }
-            }
-        }
-        return new SegmentReplicationStatsResponse(totalShards, successfulShards, failedShards, primaryStats, shardFailures);
+
+        Map<String, List<SegmentReplicationPerGroupStats>> replicationStats = primaryStats.entrySet()
+            .stream()
+            .collect(
+                Collectors.toMap(
+                    Map.Entry::getKey,
+                    entry -> entry.getValue()
+                        .stream()
+                        .map(groupStats -> updateGroupStats(groupStats, replicaStats))
+                        .collect(Collectors.toList())
+                )
+            );
+
+        return new SegmentReplicationStatsResponse(totalShards, successfulShards, failedShards, replicationStats, shardFailures);
     }
 
     @Override
@@ -144,9 +151,8 @@ protected SegmentReplicationStatsRequest readRequestFrom(StreamInput in) throws
 
     @Override
     protected SegmentReplicationShardStatsResponse shardOperation(SegmentReplicationStatsRequest request, ShardRouting shardRouting) {
-        IndexService indexService = indicesService.indexServiceSafe(shardRouting.shardId().getIndex());
-        IndexShard indexShard = indexService.getShard(shardRouting.shardId().id());
         ShardId shardId = shardRouting.shardId();
+        IndexShard indexShard = indicesService.indexServiceSafe(shardId.getIndex()).getShard(shardId.id());
 
         if (indexShard.indexSettings().isSegRepEnabledOrRemoteNode() == false) {
             return null;
@@ -156,11 +162,7 @@ protected SegmentReplicationShardStatsResponse shardOperation(SegmentReplication
             return new SegmentReplicationShardStatsResponse(pressureService.getStatsForShard(indexShard));
         }
 
-        // return information about only on-going segment replication events.
-        if (request.activeOnly()) {
-            return new SegmentReplicationShardStatsResponse(targetService.getOngoingEventSegmentReplicationState(shardId));
-        }
-        return new SegmentReplicationShardStatsResponse(targetService.getSegmentReplicationState(shardId));
+        return new SegmentReplicationShardStatsResponse(getSegmentReplicationState(shardId, request.activeOnly()));
     }
 
     @Override
@@ -181,4 +183,83 @@ protected ClusterBlockException checkRequestBlock(
     ) {
         return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, concreteIndices);
     }
+
+    private SegmentReplicationPerGroupStats updateGroupStats(
+        SegmentReplicationPerGroupStats groupStats,
+        Map<String, SegmentReplicationState> replicaStats
+    ) {
+        // Update the SegmentReplicationState for each of the replicas
+        Set<SegmentReplicationShardStats> updatedReplicaStats = groupStats.getReplicaStats()
+            .stream()
+            .peek(replicaStat -> replicaStat.setCurrentReplicationState(replicaStats.getOrDefault(replicaStat.getAllocationId(), null)))
+            .collect(Collectors.toSet());
+
+        // Compute search replica stats
+        Set<SegmentReplicationShardStats> searchReplicaStats = computeSearchReplicaStats(groupStats.getShardId(), replicaStats);
+
+        // Combine ReplicaStats and SearchReplicaStats
+        Set<SegmentReplicationShardStats> combinedStats = Stream.concat(updatedReplicaStats.stream(), searchReplicaStats.stream())
+            .collect(Collectors.toSet());
+
+        return new SegmentReplicationPerGroupStats(groupStats.getShardId(), combinedStats, groupStats.getRejectedRequestCount());
+    }
+
+    private Set<SegmentReplicationShardStats> computeSearchReplicaStats(
+        ShardId shardId,
+        Map<String, SegmentReplicationState> replicaStats
+    ) {
+        return replicaStats.values()
+            .stream()
+            .filter(segmentReplicationState -> segmentReplicationState.getShardRouting().shardId().equals(shardId))
+            .filter(segmentReplicationState -> segmentReplicationState.getShardRouting().isSearchOnly())
+            .map(segmentReplicationState -> {
+                ShardRouting shardRouting = segmentReplicationState.getShardRouting();
+                SegmentReplicationShardStats segmentReplicationStats = computeSegmentReplicationShardStats(shardRouting);
+                segmentReplicationStats.setCurrentReplicationState(segmentReplicationState);
+                return segmentReplicationStats;
+            })
+            .collect(Collectors.toSet());
+    }
+
+    SegmentReplicationShardStats computeSegmentReplicationShardStats(ShardRouting shardRouting) {
+        ShardId shardId = shardRouting.shardId();
+        SegmentReplicationState completedSegmentReplicationState = targetService.getlatestCompletedEventSegmentReplicationState(shardId);
+        SegmentReplicationState ongoingSegmentReplicationState = targetService.getOngoingEventSegmentReplicationState(shardId);
+
+        return new SegmentReplicationShardStats(
+            shardRouting.allocationId().getId(),
+            0,
+            calculateBytesRemainingToReplicate(ongoingSegmentReplicationState),
+            0,
+            getCurrentReplicationLag(ongoingSegmentReplicationState),
+            getLastCompletedReplicationLag(completedSegmentReplicationState)
+        );
+    }
+
+    private SegmentReplicationState getSegmentReplicationState(ShardId shardId, boolean isActiveOnly) {
+        if (isActiveOnly) {
+            return targetService.getOngoingEventSegmentReplicationState(shardId);
+        } else {
+            return targetService.getSegmentReplicationState(shardId);
+        }
+    }
+
+    private long calculateBytesRemainingToReplicate(SegmentReplicationState ongoingSegmentReplicationState) {
+        if (ongoingSegmentReplicationState == null) {
+            return 0;
+        }
+        return ongoingSegmentReplicationState.getIndex()
+            .fileDetails()
+            .stream()
+            .mapToLong(index -> index.length() - index.recovered())
+            .sum();
+    }
+
+    private long getCurrentReplicationLag(SegmentReplicationState ongoingSegmentReplicationState) {
+        return ongoingSegmentReplicationState != null ? ongoingSegmentReplicationState.getTimer().time() : 0;
+    }
+
+    private long getLastCompletedReplicationLag(SegmentReplicationState completedSegmentReplicationState) {
+        return completedSegmentReplicationState != null ? completedSegmentReplicationState.getTimer().time() : 0;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/term/TransportGetTermVersionAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/term/TransportGetTermVersionAction.java
index 1cab739a20838..22861e0ba5c31 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/term/TransportGetTermVersionAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/term/TransportGetTermVersionAction.java
@@ -98,7 +98,7 @@ private GetTermVersionResponse buildResponse(GetTermVersionRequest request, Clus
         ClusterStateTermVersion termVersion = new ClusterStateTermVersion(state);
         if (discovery instanceof Coordinator) {
             Coordinator coordinator = (Coordinator) discovery;
-            if (coordinator.isRemotePublicationEnabled()) {
+            if (coordinator.canDownloadFullStateFromRemote()) {
                 return new GetTermVersionResponse(termVersion, coordinator.isRemotePublicationEnabled());
             }
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 6fee2037501e7..ef0f49b8ae394 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -1906,4 +1906,12 @@ public boolean isRemotePublicationEnabled() {
         }
         return false;
     }
+
+    public boolean canDownloadFullStateFromRemote() {
+        if (remoteClusterStateService != null) {
+            return remoteClusterStateService.isRemotePublicationEnabled() && remoteClusterStateService.canDownloadFromRemoteForReadAPI();
+        }
+        return false;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
index a05938c176678..7999faece52ca 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
@@ -247,11 +247,17 @@ void balance() {
         final Map<String, Integer> nodePrimaryShardCount = calculateNodePrimaryShardCount(remoteRoutingNodes);
         int totalPrimaryShardCount = nodePrimaryShardCount.values().stream().reduce(0, Integer::sum);
 
-        totalPrimaryShardCount += routingNodes.unassigned().getNumPrimaries();
-        int avgPrimaryPerNode = (totalPrimaryShardCount + routingNodes.size() - 1) / routingNodes.size();
+        int unassignedRemotePrimaryShardCount = 0;
+        for (ShardRouting shard : routingNodes.unassigned()) {
+            if (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getShardPool(shard, allocation)) && shard.primary()) {
+                unassignedRemotePrimaryShardCount++;
+            }
+        }
+        totalPrimaryShardCount += unassignedRemotePrimaryShardCount;
+        final int avgPrimaryPerNode = (totalPrimaryShardCount + remoteRoutingNodes.size() - 1) / remoteRoutingNodes.size();
 
-        ArrayDeque<RoutingNode> sourceNodes = new ArrayDeque<>();
-        ArrayDeque<RoutingNode> targetNodes = new ArrayDeque<>();
+        final ArrayDeque<RoutingNode> sourceNodes = new ArrayDeque<>();
+        final ArrayDeque<RoutingNode> targetNodes = new ArrayDeque<>();
         for (RoutingNode node : remoteRoutingNodes) {
             if (nodePrimaryShardCount.get(node.nodeId()) > avgPrimaryPerNode) {
                 sourceNodes.add(node);
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index d0b6f812e9ee2..6489f3cb33ce0 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -233,6 +233,13 @@ public ClusterState state() {
         return clusterState;
     }
 
+    /**
+     * Returns true if the appliedClusterState is not null
+     */
+    public boolean isStateInitialised() {
+        return this.state.get() != null;
+    }
+
     /**
      * Returns true if the appliedClusterState is not null
      */
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index 1a79161d223e2..b4f2250f6dec9 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -183,6 +183,13 @@ public ClusterState state() {
         return clusterApplierService.state();
     }
 
+    /**
+     * Returns true if the state in appliedClusterState is not null
+     */
+    public boolean isStateInitialised() {
+        return clusterApplierService.isStateInitialised();
+    }
+
     /**
      * The state that is persisted to store but may not be applied to cluster.
      * @return ClusterState
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 04a19e32c4ebc..007a68b8eaa29 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -738,6 +738,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 RemoteClusterStateCleanupManager.REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING,
                 RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING,
                 RemoteClusterStateService.REMOTE_PUBLICATION_SETTING,
+                RemoteClusterStateService.REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API,
+
                 INDEX_METADATA_UPLOAD_TIMEOUT_SETTING,
                 GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING,
                 METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING,
diff --git a/server/src/main/java/org/opensearch/common/time/DateUtils.java b/server/src/main/java/org/opensearch/common/time/DateUtils.java
index 7ab395a1117e7..e5a019b58f7da 100644
--- a/server/src/main/java/org/opensearch/common/time/DateUtils.java
+++ b/server/src/main/java/org/opensearch/common/time/DateUtils.java
@@ -272,6 +272,30 @@ public static Instant clampToNanosRange(Instant instant) {
         return instant;
     }
 
+    static final Instant INSTANT_LONG_MIN_VALUE = Instant.ofEpochMilli(Long.MIN_VALUE);
+    static final Instant INSTANT_LONG_MAX_VALUE = Instant.ofEpochMilli(Long.MAX_VALUE);
+
+    /**
+     * Clamps the given {@link Instant} to the valid epoch millisecond range.
+     *
+     * - If the input is before {@code Long.MIN_VALUE}, it returns {@code Instant.ofEpochMilli(Long.MIN_VALUE)}.
+     * - If the input is after {@code Long.MAX_VALUE}, it returns {@code Instant.ofEpochMilli(Long.MAX_VALUE)}.
+     * - Otherwise, it returns the input as-is.
+     *
+     * @param instant the {@link Instant} to clamp
+     * @return the clamped {@link Instant}
+     * @throws NullPointerException if the input is {@code null}
+     */
+    public static Instant clampToMillisRange(Instant instant) {
+        if (instant.isBefore(INSTANT_LONG_MIN_VALUE)) {
+            return INSTANT_LONG_MIN_VALUE;
+        }
+        if (instant.isAfter(INSTANT_LONG_MAX_VALUE)) {
+            return INSTANT_LONG_MAX_VALUE;
+        }
+        return instant;
+    }
+
     /**
      * convert a long value to a java time instant
      * the long value resembles the nanoseconds since the epoch
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
index c5fc6d5cae6a7..e7eac0ae67714 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
@@ -129,6 +129,7 @@ public class RemoteClusterStateService implements Closeable {
      * Gates the functionality of remote publication.
      */
     public static final String REMOTE_PUBLICATION_SETTING_KEY = "cluster.remote_store.publication.enabled";
+    public static final String REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API_KEY = "cluster.remote_state.download.serve_read_api.enabled";
 
     public static final Setting<Boolean> REMOTE_PUBLICATION_SETTING = Setting.boolSetting(
         REMOTE_PUBLICATION_SETTING_KEY,
@@ -137,6 +138,13 @@ public class RemoteClusterStateService implements Closeable {
         Property.Dynamic
     );
 
+    public static final Setting<Boolean> REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API = Setting.boolSetting(
+        REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API_KEY,
+        true,
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
     /**
      * Used to specify if cluster state metadata should be published to remote store
      */
@@ -235,6 +243,9 @@ public static RemoteClusterStateValidationMode parseString(String mode) {
         + "indices, coordination metadata updated : [{}], settings metadata updated : [{}], templates metadata "
         + "updated : [{}], custom metadata updated : [{}], indices routing updated : [{}]";
     private volatile AtomicBoolean isPublicationEnabled;
+
+    private volatile AtomicBoolean downloadFromRemoteForReadAPI;
+
     private final String remotePathPrefix;
 
     private final RemoteClusterStateCache remoteClusterStateCache;
@@ -281,6 +292,8 @@ public RemoteClusterStateService(
                 && RemoteStoreNodeAttribute.isRemoteRoutingTableConfigured(settings)
         );
         clusterSettings.addSettingsUpdateConsumer(REMOTE_PUBLICATION_SETTING, this::setRemotePublicationSetting);
+        this.downloadFromRemoteForReadAPI = new AtomicBoolean(clusterSettings.get(REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API));
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_STATE_DOWNLOAD_TO_SERVE_READ_API, this::setRemoteDownloadForReadAPISetting);
         this.remotePathPrefix = CLUSTER_REMOTE_STORE_STATE_PATH_PREFIX.get(settings);
         this.remoteRoutingTableService = RemoteRoutingTableServiceFactory.getService(
             repositoriesService,
@@ -1124,6 +1137,14 @@ private void setRemotePublicationSetting(boolean remotePublicationSetting) {
         }
     }
 
+    private void setRemoteDownloadForReadAPISetting(boolean remoteDownloadForReadAPISetting) {
+        this.downloadFromRemoteForReadAPI.set(remoteDownloadForReadAPISetting);
+    }
+
+    public boolean canDownloadFromRemoteForReadAPI() {
+        return this.downloadFromRemoteForReadAPI.get();
+    }
+
     // Package private for unit test
     RemoteRoutingTableService getRemoteRoutingTableService() {
         return this.remoteRoutingTableService;
diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index 7fbb38c47572c..effee53d7cf63 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -122,7 +122,7 @@ public enum Resolution {
         MILLISECONDS(CONTENT_TYPE, NumericType.DATE) {
             @Override
             public long convert(Instant instant) {
-                return instant.toEpochMilli();
+                return clampToValidRange(instant).toEpochMilli();
             }
 
             @Override
@@ -132,7 +132,7 @@ public Instant toInstant(long value) {
 
             @Override
             public Instant clampToValidRange(Instant instant) {
-                return instant;
+                return DateUtils.clampToMillisRange(instant);
             }
 
             @Override
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
index c1c041ce01198..fb97cf40d90d6 100644
--- a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
@@ -21,6 +21,7 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.RepositoryException;
+import org.opensearch.repositories.RepositoryMissingException;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.util.ArrayList;
@@ -183,6 +184,20 @@ public RepositoriesMetadata updateRepositoriesMetadata(DiscoveryNode joiningNode
                 boolean repositoryAlreadyPresent = false;
                 for (RepositoryMetadata existingRepositoryMetadata : existingRepositories.repositories()) {
                     if (newRepositoryMetadata.name().equals(existingRepositoryMetadata.name())) {
+                        try {
+                            // This is to handle cases where-in the during a previous node-join attempt if the publish operation succeeded
+                            // but the commit operation failed, the cluster-state may have the repository metadata which is not applied
+                            // into the repository service. This may lead to assertion failures down the line.
+                            repositoriesService.get().repository(newRepositoryMetadata.name());
+                        } catch (RepositoryMissingException e) {
+                            logger.warn(
+                                "Skipping repositories metadata checks: Remote repository [{}] is in the cluster state but not present "
+                                    + "in the repository service.",
+                                newRepositoryMetadata.name()
+                            );
+                            break;
+                        }
+
                         try {
                             // This will help in handling two scenarios -
                             // 1. When a fresh cluster is formed and a node tries to join the cluster, the repository
diff --git a/server/src/main/java/org/opensearch/repositories/RepositoriesService.java b/server/src/main/java/org/opensearch/repositories/RepositoriesService.java
index 9aec81536dbd0..49065be0abb25 100644
--- a/server/src/main/java/org/opensearch/repositories/RepositoriesService.java
+++ b/server/src/main/java/org/opensearch/repositories/RepositoriesService.java
@@ -80,6 +80,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -904,6 +905,12 @@ public void ensureValidSystemRepositoryUpdate(RepositoryMetadata newRepositoryMe
                 Settings newRepositoryMetadataSettings = newRepositoryMetadata.settings();
                 Settings currentRepositoryMetadataSettings = currentRepositoryMetadata.settings();
 
+                assert Objects.nonNull(repository) : String.format(
+                    Locale.ROOT,
+                    "repository [%s] not present in RepositoryService",
+                    currentRepositoryMetadata.name()
+                );
+
                 List<String> restrictedSettings = repository.getRestrictedSystemRepositorySettings()
                     .stream()
                     .map(setting -> setting.getKey())
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
index a82c05dab0b44..998ae5e4791b7 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
@@ -2994,7 +2994,12 @@ public String startVerification() {
      */
     private BlobContainer testContainer(String seed) {
         BlobPath testBlobPath;
-        if (prefixModeVerification == true) {
+
+        if (prefixModeVerification == true
+            && (clusterService.isStateInitialised() == false
+                || clusterService.state().nodes().getMinNodeVersion().onOrAfter(Version.V_2_17_0))) {
+            // During the remote store node bootstrap, the cluster state is not initialised
+            // Otherwise, the cluster state is initialised and available with the min node version information
             PathInput pathInput = PathInput.builder().basePath(basePath()).indexUUID(seed).build();
             testBlobPath = PathType.HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         } else {
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsActionTests.java
new file mode 100644
index 0000000000000..ea455d607f058
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/replication/TransportSegmentReplicationStatsActionTests.java
@@ -0,0 +1,595 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.replication;
+
+import org.opensearch.Version;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardIterator;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardsIterator;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.support.DefaultShardOperationFailedException;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.index.IndexService;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.SegmentReplicationPerGroupStats;
+import org.opensearch.index.SegmentReplicationPressureService;
+import org.opensearch.index.SegmentReplicationShardStats;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.replication.SegmentReplicationState;
+import org.opensearch.indices.replication.SegmentReplicationTargetService;
+import org.opensearch.indices.replication.common.ReplicationLuceneIndex;
+import org.opensearch.indices.replication.common.ReplicationTimer;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.transport.TransportService;
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class TransportSegmentReplicationStatsActionTests extends OpenSearchTestCase {
+    @Mock
+    private ClusterService clusterService;
+    @Mock
+    private TransportService transportService;
+    @Mock
+    private IndicesService indicesService;
+    @Mock
+    private SegmentReplicationTargetService targetService;
+    @Mock
+    private ActionFilters actionFilters;
+    @Mock
+    private IndexNameExpressionResolver indexNameExpressionResolver;
+    @Mock
+    private SegmentReplicationPressureService pressureService;
+    @Mock
+    private IndexShard indexShard;
+    @Mock
+    private IndexService indexService;
+
+    private TransportSegmentReplicationStatsAction action;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.openMocks(this);
+        super.setUp();
+        action = new TransportSegmentReplicationStatsAction(
+            clusterService,
+            transportService,
+            indicesService,
+            targetService,
+            actionFilters,
+            indexNameExpressionResolver,
+            pressureService
+        );
+    }
+
+    public void testShardReturnsAllTheShardsForTheIndex() {
+        SegmentReplicationStatsRequest segmentReplicationStatsRequest = mock(SegmentReplicationStatsRequest.class);
+        String[] concreteIndices = new String[] { "test-index" };
+        ClusterState clusterState = mock(ClusterState.class);
+        RoutingTable routingTables = mock(RoutingTable.class);
+        ShardsIterator shardsIterator = mock(ShardIterator.class);
+
+        when(clusterState.routingTable()).thenReturn(routingTables);
+        when(routingTables.allShardsIncludingRelocationTargets(any())).thenReturn(shardsIterator);
+        assertEquals(shardsIterator, action.shards(clusterState, segmentReplicationStatsRequest, concreteIndices));
+    }
+
+    public void testShardOperationWithPrimaryShard() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.primary()).thenReturn(true);
+        when(indicesService.indexServiceSafe(shardId.getIndex())).thenReturn(indexService);
+        when(indexService.getShard(shardId.id())).thenReturn(indexShard);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettingsWithSegRepEnabled());
+
+        SegmentReplicationShardStatsResponse response = action.shardOperation(request, shardRouting);
+
+        assertNotNull(response);
+        verify(pressureService).getStatsForShard(any());
+    }
+
+    public void testShardOperationWithReplicaShard() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+        request.activeOnly(false);
+        SegmentReplicationState completedSegmentReplicationState = mock(SegmentReplicationState.class);
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.primary()).thenReturn(false);
+        when(indicesService.indexServiceSafe(shardId.getIndex())).thenReturn(indexService);
+        when(indexService.getShard(shardId.id())).thenReturn(indexShard);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettingsWithSegRepEnabled());
+        when(targetService.getSegmentReplicationState(shardId)).thenReturn(completedSegmentReplicationState);
+
+        SegmentReplicationShardStatsResponse response = action.shardOperation(request, shardRouting);
+
+        assertNotNull(response);
+        assertNull(response.getPrimaryStats());
+        assertNotNull(response.getReplicaStats());
+        verify(targetService).getSegmentReplicationState(shardId);
+    }
+
+    public void testShardOperationWithReplicaShardActiveOnly() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+        request.activeOnly(true);
+        SegmentReplicationState onGoingSegmentReplicationState = mock(SegmentReplicationState.class);
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.primary()).thenReturn(false);
+        when(indicesService.indexServiceSafe(shardId.getIndex())).thenReturn(indexService);
+        when(indexService.getShard(shardId.id())).thenReturn(indexShard);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettingsWithSegRepEnabled());
+        when(targetService.getOngoingEventSegmentReplicationState(shardId)).thenReturn(onGoingSegmentReplicationState);
+
+        SegmentReplicationShardStatsResponse response = action.shardOperation(request, shardRouting);
+
+        assertNotNull(response);
+        assertNull(response.getPrimaryStats());
+        assertNotNull(response.getReplicaStats());
+        verify(targetService).getOngoingEventSegmentReplicationState(shardId);
+    }
+
+    public void testComputeBytesRemainingToReplicateWhenCompletedAndOngoingStateNotNull() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        SegmentReplicationState completedSegmentReplicationState = mock(SegmentReplicationState.class);
+        SegmentReplicationState onGoingSegmentReplicationState = mock(SegmentReplicationState.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        AllocationId allocationId = AllocationId.newInitializing();
+        ReplicationTimer replicationTimerCompleted = mock(ReplicationTimer.class);
+        ReplicationTimer replicationTimerOngoing = mock(ReplicationTimer.class);
+        long time1 = 10;
+        long time2 = 15;
+        ReplicationLuceneIndex replicationLuceneIndex = new ReplicationLuceneIndex();
+        replicationLuceneIndex.addFileDetail("name1", 10, false);
+        replicationLuceneIndex.addFileDetail("name2", 15, false);
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.allocationId()).thenReturn(allocationId);
+        when(targetService.getlatestCompletedEventSegmentReplicationState(shardId)).thenReturn(completedSegmentReplicationState);
+        when(targetService.getOngoingEventSegmentReplicationState(shardId)).thenReturn(onGoingSegmentReplicationState);
+        when(completedSegmentReplicationState.getTimer()).thenReturn(replicationTimerCompleted);
+        when(onGoingSegmentReplicationState.getTimer()).thenReturn(replicationTimerOngoing);
+        when(replicationTimerOngoing.time()).thenReturn(time1);
+        when(replicationTimerCompleted.time()).thenReturn(time2);
+        when(onGoingSegmentReplicationState.getIndex()).thenReturn(replicationLuceneIndex);
+
+        SegmentReplicationShardStats segmentReplicationShardStats = action.computeSegmentReplicationShardStats(shardRouting);
+
+        assertNotNull(segmentReplicationShardStats);
+        assertEquals(25, segmentReplicationShardStats.getBytesBehindCount());
+        assertEquals(10, segmentReplicationShardStats.getCurrentReplicationLagMillis());
+        assertEquals(15, segmentReplicationShardStats.getLastCompletedReplicationTimeMillis());
+
+        verify(targetService).getlatestCompletedEventSegmentReplicationState(shardId);
+        verify(targetService).getOngoingEventSegmentReplicationState(shardId);
+    }
+
+    public void testCalculateBytesRemainingToReplicateWhenNoCompletedState() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        SegmentReplicationState onGoingSegmentReplicationState = mock(SegmentReplicationState.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        AllocationId allocationId = AllocationId.newInitializing();
+        ReplicationTimer replicationTimerOngoing = mock(ReplicationTimer.class);
+        long time1 = 10;
+        ReplicationLuceneIndex replicationLuceneIndex = new ReplicationLuceneIndex();
+        replicationLuceneIndex.addFileDetail("name1", 10, false);
+        replicationLuceneIndex.addFileDetail("name2", 15, false);
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.allocationId()).thenReturn(allocationId);
+        when(targetService.getOngoingEventSegmentReplicationState(shardId)).thenReturn(onGoingSegmentReplicationState);
+        when(onGoingSegmentReplicationState.getTimer()).thenReturn(replicationTimerOngoing);
+        when(replicationTimerOngoing.time()).thenReturn(time1);
+        when(onGoingSegmentReplicationState.getIndex()).thenReturn(replicationLuceneIndex);
+
+        SegmentReplicationShardStats segmentReplicationShardStats = action.computeSegmentReplicationShardStats(shardRouting);
+
+        assertNotNull(segmentReplicationShardStats);
+        assertEquals(25, segmentReplicationShardStats.getBytesBehindCount());
+        assertEquals(10, segmentReplicationShardStats.getCurrentReplicationLagMillis());
+        assertEquals(0, segmentReplicationShardStats.getLastCompletedReplicationTimeMillis());
+
+        verify(targetService).getlatestCompletedEventSegmentReplicationState(shardId);
+        verify(targetService).getOngoingEventSegmentReplicationState(shardId);
+    }
+
+    public void testCalculateBytesRemainingToReplicateWhenNoOnGoingState() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        SegmentReplicationState completedSegmentReplicationState = mock(SegmentReplicationState.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        AllocationId allocationId = AllocationId.newInitializing();
+        ReplicationTimer replicationTimerCompleted = mock(ReplicationTimer.class);
+        long time2 = 15;
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.allocationId()).thenReturn(allocationId);
+        when(targetService.getlatestCompletedEventSegmentReplicationState(shardId)).thenReturn(completedSegmentReplicationState);
+        when(completedSegmentReplicationState.getTimer()).thenReturn(replicationTimerCompleted);
+        when(replicationTimerCompleted.time()).thenReturn(time2);
+
+        SegmentReplicationShardStats segmentReplicationShardStats = action.computeSegmentReplicationShardStats(shardRouting);
+
+        assertNotNull(segmentReplicationShardStats);
+        assertEquals(0, segmentReplicationShardStats.getBytesBehindCount());
+        assertEquals(0, segmentReplicationShardStats.getCurrentReplicationLagMillis());
+        assertEquals(15, segmentReplicationShardStats.getLastCompletedReplicationTimeMillis());
+
+        verify(targetService).getlatestCompletedEventSegmentReplicationState(shardId);
+        verify(targetService).getOngoingEventSegmentReplicationState(shardId);
+    }
+
+    public void testCalculateBytesRemainingToReplicateWhenNoCompletedAndOngoingState() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        AllocationId allocationId = AllocationId.newInitializing();
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(shardRouting.allocationId()).thenReturn(allocationId);
+
+        SegmentReplicationShardStats segmentReplicationShardStats = action.computeSegmentReplicationShardStats(shardRouting);
+
+        assertNotNull(segmentReplicationShardStats);
+        assertEquals(0, segmentReplicationShardStats.getBytesBehindCount());
+        assertEquals(0, segmentReplicationShardStats.getCurrentReplicationLagMillis());
+        assertEquals(0, segmentReplicationShardStats.getLastCompletedReplicationTimeMillis());
+
+        verify(targetService).getlatestCompletedEventSegmentReplicationState(shardId);
+        verify(targetService).getOngoingEventSegmentReplicationState(shardId);
+    }
+
+    public void testNewResponseWhenAllReplicasReturnResponseCombinesTheResults() {
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+        List<DefaultShardOperationFailedException> shardFailures = new ArrayList<>();
+        String[] shards = { "0", "1" };
+        request.shards(shards);
+
+        int totalShards = 6;
+        int successfulShards = 6;
+        int failedShard = 0;
+        String allocIdOne = "allocIdOne";
+        String allocIdTwo = "allocIdTwo";
+        String allocIdThree = "allocIdThree";
+        String allocIdFour = "allocIdFour";
+        String allocIdFive = "allocIdFive";
+        String allocIdSix = "allocIdSix";
+
+        ShardId shardId0 = mock(ShardId.class);
+        ShardRouting primary0 = mock(ShardRouting.class);
+        ShardRouting replica0 = mock(ShardRouting.class);
+        ShardRouting searchReplica0 = mock(ShardRouting.class);
+
+        ShardId shardId1 = mock(ShardId.class);
+        ShardRouting primary1 = mock(ShardRouting.class);
+        ShardRouting replica1 = mock(ShardRouting.class);
+        ShardRouting searchReplica1 = mock(ShardRouting.class);
+
+        when(shardId0.getId()).thenReturn(0);
+        when(shardId0.getIndexName()).thenReturn("test-index-1");
+        when(primary0.shardId()).thenReturn(shardId0);
+        when(replica0.shardId()).thenReturn(shardId0);
+        when(searchReplica0.shardId()).thenReturn(shardId0);
+
+        when(shardId1.getId()).thenReturn(1);
+        when(shardId1.getIndexName()).thenReturn("test-index-1");
+        when(primary1.shardId()).thenReturn(shardId1);
+        when(replica1.shardId()).thenReturn(shardId1);
+        when(searchReplica1.shardId()).thenReturn(shardId1);
+
+        AllocationId allocationIdOne = mock(AllocationId.class);
+        AllocationId allocationIdTwo = mock(AllocationId.class);
+        AllocationId allocationIdThree = mock(AllocationId.class);
+        AllocationId allocationIdFour = mock(AllocationId.class);
+        AllocationId allocationIdFive = mock(AllocationId.class);
+        AllocationId allocationIdSix = mock(AllocationId.class);
+
+        when(allocationIdOne.getId()).thenReturn(allocIdOne);
+        when(allocationIdTwo.getId()).thenReturn(allocIdTwo);
+        when(allocationIdThree.getId()).thenReturn(allocIdThree);
+        when(allocationIdFour.getId()).thenReturn(allocIdFour);
+        when(allocationIdFive.getId()).thenReturn(allocIdFive);
+        when(allocationIdSix.getId()).thenReturn(allocIdSix);
+        when(primary0.allocationId()).thenReturn(allocationIdOne);
+        when(replica0.allocationId()).thenReturn(allocationIdTwo);
+        when(searchReplica0.allocationId()).thenReturn(allocationIdThree);
+        when(primary1.allocationId()).thenReturn(allocationIdFour);
+        when(replica1.allocationId()).thenReturn(allocationIdFive);
+        when(searchReplica1.allocationId()).thenReturn(allocationIdSix);
+
+        when(primary0.isSearchOnly()).thenReturn(false);
+        when(replica0.isSearchOnly()).thenReturn(false);
+        when(searchReplica0.isSearchOnly()).thenReturn(true);
+        when(primary1.isSearchOnly()).thenReturn(false);
+        when(replica1.isSearchOnly()).thenReturn(false);
+        when(searchReplica1.isSearchOnly()).thenReturn(true);
+
+        Set<SegmentReplicationShardStats> segmentReplicationShardStats0 = new HashSet<>();
+        SegmentReplicationShardStats segmentReplicationShardStatsOfReplica0 = new SegmentReplicationShardStats(allocIdTwo, 0, 0, 0, 0, 0);
+        segmentReplicationShardStats0.add(segmentReplicationShardStatsOfReplica0);
+
+        Set<SegmentReplicationShardStats> segmentReplicationShardStats1 = new HashSet<>();
+        SegmentReplicationShardStats segmentReplicationShardStatsOfReplica1 = new SegmentReplicationShardStats(allocIdFive, 0, 0, 0, 0, 0);
+        segmentReplicationShardStats1.add(segmentReplicationShardStatsOfReplica1);
+
+        SegmentReplicationPerGroupStats segmentReplicationPerGroupStats0 = new SegmentReplicationPerGroupStats(
+            shardId0,
+            segmentReplicationShardStats0,
+            0
+        );
+
+        SegmentReplicationPerGroupStats segmentReplicationPerGroupStats1 = new SegmentReplicationPerGroupStats(
+            shardId1,
+            segmentReplicationShardStats1,
+            0
+        );
+
+        SegmentReplicationState segmentReplicationState0 = mock(SegmentReplicationState.class);
+        SegmentReplicationState searchReplicaSegmentReplicationState0 = mock(SegmentReplicationState.class);
+        SegmentReplicationState segmentReplicationState1 = mock(SegmentReplicationState.class);
+        SegmentReplicationState searchReplicaSegmentReplicationState1 = mock(SegmentReplicationState.class);
+
+        when(segmentReplicationState0.getShardRouting()).thenReturn(replica0);
+        when(searchReplicaSegmentReplicationState0.getShardRouting()).thenReturn(searchReplica0);
+        when(segmentReplicationState1.getShardRouting()).thenReturn(replica1);
+        when(searchReplicaSegmentReplicationState1.getShardRouting()).thenReturn(searchReplica1);
+
+        List<SegmentReplicationShardStatsResponse> responses = List.of(
+            new SegmentReplicationShardStatsResponse(segmentReplicationPerGroupStats0),
+            new SegmentReplicationShardStatsResponse(segmentReplicationState0),
+            new SegmentReplicationShardStatsResponse(searchReplicaSegmentReplicationState0),
+            new SegmentReplicationShardStatsResponse(segmentReplicationPerGroupStats1),
+            new SegmentReplicationShardStatsResponse(segmentReplicationState1),
+            new SegmentReplicationShardStatsResponse(searchReplicaSegmentReplicationState1)
+        );
+
+        SegmentReplicationStatsResponse response = action.newResponse(
+            request,
+            totalShards,
+            successfulShards,
+            failedShard,
+            responses,
+            shardFailures,
+            ClusterState.EMPTY_STATE
+        );
+
+        List<SegmentReplicationPerGroupStats> responseStats = response.getReplicationStats().get("test-index-1");
+        SegmentReplicationPerGroupStats primStats0 = responseStats.get(0);
+        Set<SegmentReplicationShardStats> replicaStats0 = primStats0.getReplicaStats();
+        assertEquals(2, replicaStats0.size());
+        for (SegmentReplicationShardStats replicaStat : replicaStats0) {
+            if (replicaStat.getAllocationId().equals(allocIdTwo)) {
+                assertEquals(segmentReplicationState0, replicaStat.getCurrentReplicationState());
+            }
+
+            if (replicaStat.getAllocationId().equals(allocIdThree)) {
+                assertEquals(searchReplicaSegmentReplicationState0, replicaStat.getCurrentReplicationState());
+            }
+        }
+
+        SegmentReplicationPerGroupStats primStats1 = responseStats.get(1);
+        Set<SegmentReplicationShardStats> replicaStats1 = primStats1.getReplicaStats();
+        assertEquals(2, replicaStats1.size());
+        for (SegmentReplicationShardStats replicaStat : replicaStats1) {
+            if (replicaStat.getAllocationId().equals(allocIdFive)) {
+                assertEquals(segmentReplicationState1, replicaStat.getCurrentReplicationState());
+            }
+
+            if (replicaStat.getAllocationId().equals(allocIdSix)) {
+                assertEquals(searchReplicaSegmentReplicationState1, replicaStat.getCurrentReplicationState());
+            }
+        }
+    }
+
+    public void testNewResponseWhenShardsToFetchEmptyAndResponsesContainsNull() {
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+        List<DefaultShardOperationFailedException> shardFailures = new ArrayList<>();
+        String[] shards = {};
+        request.shards(shards);
+
+        int totalShards = 3;
+        int successfulShards = 3;
+        int failedShard = 0;
+        String allocIdOne = "allocIdOne";
+        String allocIdTwo = "allocIdTwo";
+        ShardId shardIdOne = mock(ShardId.class);
+        ShardId shardIdTwo = mock(ShardId.class);
+        ShardId shardIdThree = mock(ShardId.class);
+        ShardRouting shardRoutingOne = mock(ShardRouting.class);
+        ShardRouting shardRoutingTwo = mock(ShardRouting.class);
+        ShardRouting shardRoutingThree = mock(ShardRouting.class);
+        when(shardIdOne.getId()).thenReturn(1);
+        when(shardIdTwo.getId()).thenReturn(2);
+        when(shardIdThree.getId()).thenReturn(3);
+        when(shardRoutingOne.shardId()).thenReturn(shardIdOne);
+        when(shardRoutingTwo.shardId()).thenReturn(shardIdTwo);
+        when(shardRoutingThree.shardId()).thenReturn(shardIdThree);
+        AllocationId allocationId = mock(AllocationId.class);
+        when(allocationId.getId()).thenReturn(allocIdOne);
+        when(shardRoutingTwo.allocationId()).thenReturn(allocationId);
+        when(shardIdOne.getIndexName()).thenReturn("test-index");
+
+        Set<SegmentReplicationShardStats> segmentReplicationShardStats = new HashSet<>();
+        SegmentReplicationShardStats segmentReplicationShardStatsOfReplica = new SegmentReplicationShardStats(allocIdOne, 0, 0, 0, 0, 0);
+        segmentReplicationShardStats.add(segmentReplicationShardStatsOfReplica);
+        SegmentReplicationPerGroupStats segmentReplicationPerGroupStats = new SegmentReplicationPerGroupStats(
+            shardIdOne,
+            segmentReplicationShardStats,
+            0
+        );
+
+        SegmentReplicationState segmentReplicationState = mock(SegmentReplicationState.class);
+        SegmentReplicationShardStats segmentReplicationShardStatsFromSearchReplica = mock(SegmentReplicationShardStats.class);
+        when(segmentReplicationShardStatsFromSearchReplica.getAllocationId()).thenReturn("alloc2");
+        when(segmentReplicationState.getShardRouting()).thenReturn(shardRoutingTwo);
+
+        List<SegmentReplicationShardStatsResponse> responses = new ArrayList<>();
+        responses.add(null);
+        responses.add(new SegmentReplicationShardStatsResponse(segmentReplicationPerGroupStats));
+        responses.add(new SegmentReplicationShardStatsResponse(segmentReplicationState));
+
+        SegmentReplicationStatsResponse response = action.newResponse(
+            request,
+            totalShards,
+            successfulShards,
+            failedShard,
+            responses,
+            shardFailures,
+            ClusterState.EMPTY_STATE
+        );
+
+        List<SegmentReplicationPerGroupStats> responseStats = response.getReplicationStats().get("test-index");
+        SegmentReplicationPerGroupStats primStats = responseStats.get(0);
+        Set<SegmentReplicationShardStats> segRpShardStatsSet = primStats.getReplicaStats();
+
+        for (SegmentReplicationShardStats segRpShardStats : segRpShardStatsSet) {
+            if (segRpShardStats.getAllocationId().equals(allocIdOne)) {
+                assertEquals(segmentReplicationState, segRpShardStats.getCurrentReplicationState());
+            }
+
+            if (segRpShardStats.getAllocationId().equals(allocIdTwo)) {
+                assertEquals(segmentReplicationShardStatsFromSearchReplica, segRpShardStats);
+            }
+        }
+    }
+
+    public void testShardOperationWithSegRepDisabled() {
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        ShardId shardId = new ShardId(new Index("test-index", "test-uuid"), 0);
+        SegmentReplicationStatsRequest request = new SegmentReplicationStatsRequest();
+
+        when(shardRouting.shardId()).thenReturn(shardId);
+        when(indicesService.indexServiceSafe(shardId.getIndex())).thenReturn(indexService);
+        when(indexService.getShard(shardId.id())).thenReturn(indexShard);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettingsWithSegRepDisabled());
+
+        SegmentReplicationShardStatsResponse response = action.shardOperation(request, shardRouting);
+
+        assertNull(response);
+    }
+
+    public void testGlobalBlockCheck() {
+        ClusterBlock writeClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            true,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_WRITE)
+        );
+
+        ClusterBlock readClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            true,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_READ)
+        );
+
+        ClusterBlocks.Builder builder = ClusterBlocks.builder();
+        builder.addGlobalBlock(writeClusterBlock);
+        ClusterState metadataWriteBlockedState = ClusterState.builder(ClusterState.EMPTY_STATE).blocks(builder).build();
+        assertNull(action.checkGlobalBlock(metadataWriteBlockedState, new SegmentReplicationStatsRequest()));
+
+        builder = ClusterBlocks.builder();
+        builder.addGlobalBlock(readClusterBlock);
+        ClusterState metadataReadBlockedState = ClusterState.builder(ClusterState.EMPTY_STATE).blocks(builder).build();
+        assertNotNull(action.checkGlobalBlock(metadataReadBlockedState, new SegmentReplicationStatsRequest()));
+    }
+
+    public void testIndexBlockCheck() {
+        ClusterBlock writeClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            true,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_WRITE)
+        );
+
+        ClusterBlock readClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            true,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_READ)
+        );
+
+        String indexName = "test";
+        ClusterBlocks.Builder builder = ClusterBlocks.builder();
+        builder.addIndexBlock(indexName, writeClusterBlock);
+        ClusterState metadataWriteBlockedState = ClusterState.builder(ClusterState.EMPTY_STATE).blocks(builder).build();
+        assertNull(action.checkRequestBlock(metadataWriteBlockedState, new SegmentReplicationStatsRequest(), new String[] { indexName }));
+
+        builder = ClusterBlocks.builder();
+        builder.addIndexBlock(indexName, readClusterBlock);
+        ClusterState metadataReadBlockedState = ClusterState.builder(ClusterState.EMPTY_STATE).blocks(builder).build();
+        assertNotNull(action.checkRequestBlock(metadataReadBlockedState, new SegmentReplicationStatsRequest(), new String[] { indexName }));
+    }
+
+    private IndexSettings createIndexSettingsWithSegRepEnabled() {
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2)
+            .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .build();
+
+        return new IndexSettings(IndexMetadata.builder("test").settings(settings).build(), settings);
+    }
+
+    private IndexSettings createIndexSettingsWithSegRepDisabled() {
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.DOCUMENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2)
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .build();
+        return new IndexSettings(IndexMetadata.builder("test").settings(settings).build(), settings);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
index f6fb203bfe1a9..9590e5615d451 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
@@ -55,6 +55,7 @@
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.RepositoryMissingException;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
@@ -1378,6 +1379,72 @@ public void testJoinRemoteStoreClusterWithRemotePublicationNodeInMixedMode() {
         JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
     }
 
+    public void testUpdatesClusterStateWithRepositoryMetadataNotInSync() throws Exception {
+        Map<String, String> newNodeAttributes = new HashMap<>();
+        newNodeAttributes.putAll(remoteStateNodeAttributes(CLUSTER_STATE_REPO));
+        newNodeAttributes.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+
+        final AllocationService allocationService = mock(AllocationService.class);
+        when(allocationService.adaptAutoExpandReplicas(any())).then(invocationOnMock -> invocationOnMock.getArguments()[0]);
+        final RerouteService rerouteService = (reason, priority, listener) -> listener.onResponse(null);
+        RepositoriesService repositoriesService = mock(RepositoriesService.class);
+        when(repositoriesService.repository(any())).thenThrow(RepositoryMissingException.class);
+        final RemoteStoreNodeService remoteStoreNodeService = new RemoteStoreNodeService(new SetOnce<>(repositoriesService)::get, null);
+
+        final JoinTaskExecutor joinTaskExecutor = new JoinTaskExecutor(
+            Settings.EMPTY,
+            allocationService,
+            logger,
+            rerouteService,
+            remoteStoreNodeService
+        );
+
+        final DiscoveryNode clusterManagerNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            newNodeAttributes,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final RepositoryMetadata clusterStateRepo = buildRepositoryMetadata(clusterManagerNode, CLUSTER_STATE_REPO);
+        final RepositoryMetadata routingTableRepo = buildRepositoryMetadata(clusterManagerNode, ROUTING_TABLE_REPO);
+        List<RepositoryMetadata> repositoriesMetadata = new ArrayList<>() {
+            {
+                add(clusterStateRepo);
+                add(routingTableRepo);
+            }
+        };
+
+        final ClusterState clusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(
+                DiscoveryNodes.builder()
+                    .add(clusterManagerNode)
+                    .localNodeId(clusterManagerNode.getId())
+                    .clusterManagerNodeId(clusterManagerNode.getId())
+            )
+            .metadata(Metadata.builder().putCustom(RepositoriesMetadata.TYPE, new RepositoriesMetadata(repositoriesMetadata)))
+            .build();
+
+        final DiscoveryNode joiningNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            newNodeAttributes,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final ClusterStateTaskExecutor.ClusterTasksResult<JoinTaskExecutor.Task> result = joinTaskExecutor.execute(
+            clusterState,
+            List.of(new JoinTaskExecutor.Task(joiningNode, "test"))
+        );
+        assertThat(result.executionResults.entrySet(), hasSize(1));
+        final ClusterStateTaskExecutor.TaskResult taskResult = result.executionResults.values().iterator().next();
+        assertTrue(taskResult.isSuccess());
+        validatePublicationRepositoryMetadata(result.resultingState, clusterManagerNode);
+
+    }
+
     private void validateRepositoryMetadata(ClusterState updatedState, DiscoveryNode existingNode, int expectedRepositories)
         throws Exception {
 
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsBalancerBaseTestCase.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsBalancerBaseTestCase.java
index 6a03a1f79bcde..a7f18aabf8436 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsBalancerBaseTestCase.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsBalancerBaseTestCase.java
@@ -194,7 +194,7 @@ public AllocationService createRemoteCapableAllocationService() {
     }
 
     public AllocationService createRemoteCapableAllocationService(String excludeNodes) {
-        Settings settings = Settings.builder().put("cluster.routing.allocation.exclude.node_id", excludeNodes).build();
+        Settings settings = Settings.builder().put("cluster.routing.allocation.exclude._id", excludeNodes).build();
         return new MockAllocationService(
             randomAllocationDeciders(settings, EMPTY_CLUSTER_SETTINGS, random()),
             new TestGatewayAllocator(),
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsRebalanceShardsTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsRebalanceShardsTests.java
index e1c0a7eff1f6e..e55a9de160114 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsRebalanceShardsTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteShardsRebalanceShardsTests.java
@@ -25,25 +25,51 @@ public class RemoteShardsRebalanceShardsTests extends RemoteShardsBalancerBaseTe
      * Post rebalance primaries should be balanced across all the nodes.
      */
     public void testShardAllocationAndRebalance() {
-        int localOnlyNodes = 20;
-        int remoteCapableNodes = 40;
-        int localIndices = 40;
-        int remoteIndices = 80;
+        final int localOnlyNodes = 20;
+        final int remoteCapableNodes = 40;
+        final int halfRemoteCapableNodes = remoteCapableNodes / 2;
+        final int localIndices = 40;
+        final int remoteIndices = 80;
         ClusterState clusterState = createInitialCluster(localOnlyNodes, remoteCapableNodes, localIndices, remoteIndices);
-        AllocationService service = this.createRemoteCapableAllocationService();
+        final StringBuilder excludeNodes = new StringBuilder();
+        for (int i = 0; i < halfRemoteCapableNodes; i++) {
+            excludeNodes.append(getNodeId(i, true));
+            if (i != (remoteCapableNodes / 2 - 1)) {
+                excludeNodes.append(", ");
+            }
+        }
+        AllocationService service = this.createRemoteCapableAllocationService(excludeNodes.toString());
         clusterState = allocateShardsAndBalance(clusterState, service);
         RoutingNodes routingNodes = clusterState.getRoutingNodes();
         RoutingAllocation allocation = getRoutingAllocation(clusterState, routingNodes);
 
-        final Map<String, Integer> nodePrimariesCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, true);
-        final Map<String, Integer> nodeReplicaCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, false);
+        Map<String, Integer> nodePrimariesCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, true);
+        Map<String, Integer> nodeReplicaCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, false);
         int avgPrimariesPerNode = getTotalShardCountAcrossNodes(nodePrimariesCounter) / remoteCapableNodes;
 
-        // Primary and replica are balanced post first reroute
+        // Primary and replica are balanced after first allocating unassigned
+        for (RoutingNode node : routingNodes) {
+            if (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getNodePool(node))) {
+                if (Integer.parseInt(node.nodeId().split("-")[4]) < halfRemoteCapableNodes) {
+                    assertEquals(0, (int) nodePrimariesCounter.getOrDefault(node.nodeId(), 0));
+                } else {
+                    assertEquals(avgPrimariesPerNode * 2, (int) nodePrimariesCounter.get(node.nodeId()));
+                }
+                assertTrue(nodeReplicaCounter.getOrDefault(node.nodeId(), 0) >= 0);
+            }
+        }
+
+        // Remove exclude constraint and rebalance
+        service = this.createRemoteCapableAllocationService();
+        clusterState = allocateShardsAndBalance(clusterState, service);
+        routingNodes = clusterState.getRoutingNodes();
+        allocation = getRoutingAllocation(clusterState, routingNodes);
+        nodePrimariesCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, true);
+        nodeReplicaCounter = getShardCounterPerNodeForRemoteCapablePool(clusterState, allocation, false);
         for (RoutingNode node : routingNodes) {
             if (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getNodePool(node))) {
-                assertInRange(nodePrimariesCounter.get(node.nodeId()), avgPrimariesPerNode, remoteCapableNodes - 1);
-                assertTrue(nodeReplicaCounter.get(node.nodeId()) >= 0);
+                assertEquals(avgPrimariesPerNode, (int) nodePrimariesCounter.get(node.nodeId()));
+                assertTrue(nodeReplicaCounter.getOrDefault(node.nodeId(), 0) >= 0);
             }
         }
     }
diff --git a/server/src/test/java/org/opensearch/common/time/DateUtilsTests.java b/server/src/test/java/org/opensearch/common/time/DateUtilsTests.java
index 98a79f3ca38dc..cb691f2177f6d 100644
--- a/server/src/test/java/org/opensearch/common/time/DateUtilsTests.java
+++ b/server/src/test/java/org/opensearch/common/time/DateUtilsTests.java
@@ -260,4 +260,21 @@ public void testRoundYear() {
         long startOf1996 = Year.of(1996).atDay(1).atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli();
         assertThat(DateUtils.roundYear(endOf1996), is(startOf1996));
     }
+
+    public void testClampToMillisRange() {
+        Instant normalInstant = Instant.now();
+        assertEquals(normalInstant, DateUtils.clampToMillisRange(normalInstant));
+
+        Instant beforeMinInstant = DateUtils.INSTANT_LONG_MIN_VALUE.minusMillis(1);
+        assertEquals(DateUtils.INSTANT_LONG_MIN_VALUE, DateUtils.clampToMillisRange(beforeMinInstant));
+
+        Instant afterMaxInstant = DateUtils.INSTANT_LONG_MAX_VALUE.plusMillis(1);
+        assertEquals(DateUtils.INSTANT_LONG_MAX_VALUE, DateUtils.clampToMillisRange(afterMaxInstant));
+
+        assertEquals(DateUtils.INSTANT_LONG_MIN_VALUE, DateUtils.clampToMillisRange(DateUtils.INSTANT_LONG_MIN_VALUE));
+
+        assertEquals(DateUtils.INSTANT_LONG_MAX_VALUE, DateUtils.clampToMillisRange(DateUtils.INSTANT_LONG_MAX_VALUE));
+
+        assertThrows(NullPointerException.class, () -> DateUtils.clampToMillisRange(null));
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
index 98bcaa3a1a46b..9032e2cdaed16 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
@@ -156,7 +156,6 @@ public void testIgnoreMalformedLegacy() throws IOException {
             "failed to parse date field [2016-03-99] with format [strict_date_optional_time||epoch_millis]"
         );
         testIgnoreMalformedForValue("-2147483648", "Invalid value for Year (valid values -999999999 - 999999999): -2147483648");
-        testIgnoreMalformedForValue("-522000000", "long overflow");
     }
 
     public void testIgnoreMalformed() throws IOException {
@@ -170,7 +169,6 @@ public void testIgnoreMalformed() throws IOException {
             "failed to parse date field [2016-03-99] with format [strict_date_time_no_millis||strict_date_optional_time||epoch_millis]"
         );
         testIgnoreMalformedForValue("-2147483648", "Invalid value for Year (valid values -999999999 - 999999999): -2147483648");
-        testIgnoreMalformedForValue("-522000000", "long overflow");
     }
 
     private void testIgnoreMalformedForValue(String value, String expectedCause) throws IOException {
diff --git a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
index 15b16f4610062..52091d571ee72 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
@@ -31,20 +31,32 @@
 
 package org.opensearch.index.mapper;
 
+import org.apache.lucene.document.Field;
 import org.apache.lucene.document.LongPoint;
 import org.apache.lucene.document.NumericDocValuesField;
 import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.document.StoredField;
+import org.apache.lucene.document.StringField;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.MultiReader;
 import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.IndexSortSortedNumericDocValuesRangeQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.search.Sort;
+import org.apache.lucene.search.SortField;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.store.Directory;
 import org.opensearch.Version;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -71,8 +83,12 @@
 import org.joda.time.DateTimeZone;
 
 import java.io.IOException;
+import java.time.Instant;
 import java.time.ZoneOffset;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.apache.lucene.document.LongPoint.pack;
@@ -490,4 +506,187 @@ public void testParseSourceValueNanos() throws IOException {
         MappedFieldType nullValueMapper = fieldType(Resolution.NANOSECONDS, "strict_date_time||epoch_millis", nullValueDate);
         assertEquals(Collections.singletonList(nullValueDate), fetchSourceValue(nullValueMapper, null));
     }
+
+    public void testDateResolutionForOverflow() throws IOException {
+        Directory dir = newDirectory();
+        IndexWriter w = new IndexWriter(dir, new IndexWriterConfig(null));
+
+        DateFieldType ft = new DateFieldType(
+            "test_date",
+            true,
+            true,
+            true,
+            DateFormatter.forPattern("yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis||strict_date_optional_time"),
+            Resolution.MILLISECONDS,
+            null,
+            Collections.emptyMap()
+        );
+
+        List<String> dates = Arrays.asList(
+            null,
+            "2020-01-01T00:00:00Z",
+            null,
+            "2021-01-01T00:00:00Z",
+            "+292278994-08-17T07:12:55.807Z",
+            null,
+            "-292275055-05-16T16:47:04.192Z"
+        );
+
+        int numNullDates = 0;
+        long minDateValue = Long.MAX_VALUE;
+        long maxDateValue = Long.MIN_VALUE;
+
+        for (int i = 0; i < dates.size(); i++) {
+            ParseContext.Document doc = new ParseContext.Document();
+            String dateStr = dates.get(i);
+
+            if (dateStr != null) {
+                long timestamp = Resolution.MILLISECONDS.convert(DateFormatters.from(ft.dateTimeFormatter().parse(dateStr)).toInstant());
+                doc.add(new LongPoint(ft.name(), timestamp));
+                doc.add(new SortedNumericDocValuesField(ft.name(), timestamp));
+                doc.add(new StoredField(ft.name(), timestamp));
+                doc.add(new StoredField("id", i));
+                minDateValue = Math.min(minDateValue, timestamp);
+                maxDateValue = Math.max(maxDateValue, timestamp);
+            } else {
+                numNullDates++;
+                doc.add(new StoredField("id", i));
+            }
+            w.addDocument(doc);
+        }
+
+        DirectoryReader reader = DirectoryReader.open(w);
+        IndexSearcher searcher = new IndexSearcher(reader);
+
+        Settings indexSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .build();
+        QueryShardContext context = new QueryShardContext(
+            0,
+            new IndexSettings(IndexMetadata.builder("foo").settings(indexSettings).build(), indexSettings),
+            BigArrays.NON_RECYCLING_INSTANCE,
+            null,
+            null,
+            null,
+            null,
+            null,
+            xContentRegistry(),
+            writableRegistry(),
+            null,
+            null,
+            () -> nowInMillis,
+            null,
+            null,
+            () -> true,
+            null
+        );
+
+        Query rangeQuery = ft.rangeQuery(
+            "-292275055-05-16T16:47:04.192Z",
+            "+292278994-08-17T07:12:55.807Z",
+            true,
+            true,
+            null,
+            null,
+            null,
+            context
+        );
+
+        TopDocs topDocs = searcher.search(rangeQuery, dates.size());
+        assertEquals("Number of non-null date documents", dates.size() - numNullDates, topDocs.totalHits.value);
+
+        for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
+            org.apache.lucene.document.Document doc = reader.document(scoreDoc.doc);
+            IndexableField dateField = doc.getField(ft.name());
+            if (dateField != null) {
+                long dateValue = dateField.numericValue().longValue();
+                assertTrue(
+                    "Date value " + dateValue + " should be within valid range",
+                    dateValue >= minDateValue && dateValue <= maxDateValue
+                );
+            }
+        }
+
+        DateFieldType ftWithNullValue = new DateFieldType(
+            "test_date",
+            true,
+            true,
+            true,
+            DateFormatter.forPattern("yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis||strict_date_optional_time"),
+            Resolution.MILLISECONDS,
+            "2020-01-01T00:00:00Z",
+            Collections.emptyMap()
+        );
+
+        Query nullValueQuery = ftWithNullValue.termQuery("2020-01-01T00:00:00Z", context);
+        topDocs = searcher.search(nullValueQuery, dates.size());
+        assertEquals("Documents matching the 2020-01-01 date", 1, topDocs.totalHits.value);
+
+        IOUtils.close(reader, w, dir);
+    }
+
+    public void testDateFieldTypeWithNulls() throws IOException {
+        DateFieldType ft = new DateFieldType(
+            "domainAttributes.dueDate",
+            true,
+            true,
+            true,
+            DateFormatter.forPattern("yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis||date_optional_time"),
+            Resolution.MILLISECONDS,
+            null,
+            Collections.emptyMap()
+        );
+
+        Directory dir = newDirectory();
+        IndexWriter w = new IndexWriter(dir, new IndexWriterConfig(null));
+
+        int nullDocs = 3500;
+        int datedDocs = 50;
+
+        for (int i = 0; i < nullDocs; i++) {
+            ParseContext.Document doc = new ParseContext.Document();
+            doc.add(new StringField("domainAttributes.firmId", "12345678910111213", Field.Store.YES));
+            w.addDocument(doc);
+        }
+
+        for (int i = 1; i <= datedDocs; i++) {
+            ParseContext.Document doc = new ParseContext.Document();
+            String dateStr = String.format(Locale.ROOT, "2022-03-%02dT15:40:58.324", (i % 30) + 1);
+            long timestamp = Resolution.MILLISECONDS.convert(DateFormatters.from(ft.dateTimeFormatter().parse(dateStr)).toInstant());
+            doc.add(new StringField("domainAttributes.firmId", "12345678910111213", Field.Store.YES));
+            doc.add(new LongPoint(ft.name(), timestamp));
+            doc.add(new SortedNumericDocValuesField(ft.name(), timestamp));
+            doc.add(new StoredField(ft.name(), timestamp));
+            w.addDocument(doc);
+        }
+
+        DirectoryReader reader = DirectoryReader.open(w);
+        IndexSearcher searcher = new IndexSearcher(reader);
+
+        BooleanQuery.Builder queryBuilder = new BooleanQuery.Builder();
+        queryBuilder.add(new TermQuery(new Term("domainAttributes.firmId", "12345678910111213")), BooleanClause.Occur.MUST);
+
+        Sort sort = new Sort(new SortField(ft.name(), SortField.Type.DOC, false));
+
+        for (int i = 0; i < 100; i++) {
+            TopDocs topDocs = searcher.search(queryBuilder.build(), nullDocs + datedDocs, sort);
+            assertEquals("Total hits should match total documents", nullDocs + datedDocs, topDocs.totalHits.value);
+            for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
+                org.apache.lucene.document.Document doc = reader.document(scoreDoc.doc);
+                IndexableField dateField = doc.getField(ft.name());
+                if (dateField != null) {
+                    long dateValue = dateField.numericValue().longValue();
+                    Instant dateInstant = Instant.ofEpochMilli(dateValue);
+                    assertTrue(
+                        "Date should be in March 2022",
+                        dateInstant.isAfter(Instant.parse("2022-03-01T00:00:00Z"))
+                            && dateInstant.isBefore(Instant.parse("2022-04-01T00:00:00Z"))
+                    );
+                }
+            }
+        }
+        IOUtils.close(reader, w, dir);
+    }
 }
diff --git a/settings.gradle b/settings.gradle
index 035fe69eda7e9..a24da40069b90 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -10,7 +10,7 @@
  */
 
 plugins {
-  id "com.gradle.develocity" version "3.18.2"
+  id "com.gradle.develocity" version "3.19"
 }
 
 ext.disableBuildCache = hasProperty('DISABLE_BUILD_CACHE') || System.getenv().containsKey('DISABLE_BUILD_CACHE')
diff --git a/test/fixtures/hdfs-fixture/build.gradle b/test/fixtures/hdfs-fixture/build.gradle
index f531a3c6ade5a..d645171d9f8e4 100644
--- a/test/fixtures/hdfs-fixture/build.gradle
+++ b/test/fixtures/hdfs-fixture/build.gradle
@@ -77,9 +77,9 @@ dependencies {
   api "ch.qos.logback:logback-core:1.5.12"
   api "ch.qos.logback:logback-classic:1.5.12"
   api "org.jboss.xnio:xnio-nio:3.8.16.Final"
-  api 'org.jline:jline:3.27.1'
+  api 'org.jline:jline:3.28.0'
   api 'org.apache.commons:commons-configuration2:2.11.0'
-  api 'com.nimbusds:nimbus-jose-jwt:9.46'
+  api 'com.nimbusds:nimbus-jose-jwt:9.47'
   api ('org.apache.kerby:kerb-admin:2.1.0') {
     exclude group: "org.jboss.xnio"
     exclude group: "org.jline"
diff --git a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
index fa5fb736f518f..7b2c653e9bdb2 100644
--- a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
@@ -2322,10 +2322,24 @@ public List<String> startNodes(int numOfNodes, Settings settings) {
         return startNodes(Collections.nCopies(numOfNodes, settings).toArray(new Settings[0]));
     }
 
+    /**
+     * Starts multiple nodes with the given settings and returns their names
+     */
+    public List<String> startNodes(int numOfNodes, Settings settings, Boolean waitForNodeJoin) {
+        return startNodes(waitForNodeJoin, Collections.nCopies(numOfNodes, settings).toArray(new Settings[0]));
+    }
+
     /**
      * Starts multiple nodes with the given settings and returns their names
      */
     public synchronized List<String> startNodes(Settings... extraSettings) {
+        return startNodes(false, extraSettings);
+    }
+
+    /**
+     * Starts multiple nodes with the given settings and returns their names
+     */
+    public synchronized List<String> startNodes(Boolean waitForNodeJoin, Settings... extraSettings) {
         final int newClusterManagerCount = Math.toIntExact(Stream.of(extraSettings).filter(DiscoveryNode::isClusterManagerNode).count());
         final int defaultMinClusterManagerNodes;
         if (autoManageClusterManagerNodes) {
@@ -2377,7 +2391,7 @@ public synchronized List<String> startNodes(Settings... extraSettings) {
             nodes.add(nodeAndClient);
         }
         startAndPublishNodesAndClients(nodes);
-        if (autoManageClusterManagerNodes) {
+        if (autoManageClusterManagerNodes && !waitForNodeJoin) {
             validateClusterFormed();
         }
         return nodes.stream().map(NodeAndClient::getName).collect(Collectors.toList());
@@ -2422,6 +2436,10 @@ public List<String> startDataOnlyNodes(int numNodes, Settings settings) {
         return startNodes(numNodes, Settings.builder().put(onlyRole(settings, DiscoveryNodeRole.DATA_ROLE)).build());
     }
 
+    public List<String> startDataOnlyNodes(int numNodes, Settings settings, Boolean ignoreNodeJoin) {
+        return startNodes(numNodes, Settings.builder().put(onlyRole(settings, DiscoveryNodeRole.DATA_ROLE)).build(), ignoreNodeJoin);
+    }
+
     public List<String> startSearchOnlyNodes(int numNodes) {
         return startSearchOnlyNodes(numNodes, Settings.EMPTY);
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index 1ee856d3092f0..1c26ea4ca2c91 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -214,6 +214,8 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import reactor.util.annotation.NonNull;
+
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
 import static org.opensearch.common.unit.TimeValue.timeValueMillis;
@@ -2915,6 +2917,43 @@ protected static Settings buildRemoteStoreNodeAttributes(
         return settings.build();
     }
 
+    protected Settings buildRemotePublicationNodeAttributes(
+        @NonNull String remoteStateRepoName,
+        @NonNull String remoteStateRepoType,
+        @NonNull String routingTableRepoName,
+        @NonNull String routingTableRepoType
+    ) {
+        String remoteStateRepositoryTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            remoteStateRepoName
+        );
+        String routingTableRepositoryTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            routingTableRepoName
+        );
+        String remoteStateRepositorySettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            remoteStateRepoName
+        );
+        String routingTableRepositorySettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            routingTableRepoName
+        );
+
+        return Settings.builder()
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, remoteStateRepoName)
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, routingTableRepoName)
+            .put(remoteStateRepositoryTypeAttributeKey, remoteStateRepoType)
+            .put(routingTableRepositoryTypeAttributeKey, routingTableRepoType)
+            .put(remoteStateRepositorySettingsAttributeKeyPrefix + "location", randomRepoPath().toAbsolutePath())
+            .put(routingTableRepositorySettingsAttributeKeyPrefix + "location", randomRepoPath().toAbsolutePath())
+            .build();
+    }
+
     public static String resolvePath(IndexId indexId, String shardId) {
         PathType pathType = PathType.fromCode(indexId.getShardPathType());
         RemoteStorePathStrategy.SnapshotShardPathInput shardPathInput = new RemoteStorePathStrategy.SnapshotShardPathInput.Builder()