diff --git a/redis.conf b/redis.conf
index 97f81809dcd..1795bc1a0a9 100644
--- a/redis.conf
+++ b/redis.conf
@@ -364,6 +364,15 @@ rdb-del-sync-files no
 # Note that you must specify a directory here, not a file name.
 dir ./
 
+# Redis can try to load an RDB dump produced by a future version of Redis/Valkey.
+# This can only work on a best-effort basis, because future RDB versions may
+# contain information that's not known to the current version. If no new features
+# are used, it may be possible to import the data produced by a later version,
+# but loading is aborted if unknown information is encountered. Possible values
+# are 'strict' and 'relaxed'. This also applies to replication and the RESTORE
+# command.
+rdb-version-check relaxed
+
 ################################# REPLICATION #################################
 
 # Master-Replica replication. Use replicaof to make a Redis instance a copy of
diff --git a/src/Makefile b/src/Makefile
index 691d5434e20..9b5c408c565 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -245,7 +245,7 @@ endif
 
 REDIS_SERVER_NAME=redis-server$(PROG_SUFFIX)
 REDIS_SENTINEL_NAME=redis-sentinel$(PROG_SUFFIX)
-REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crcspeed.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o lolwut.o lolwut5.o lolwut6.o acl.o gopher.o tracking.o connection.o tls.o sha256.o timeout.o setcpuaffinity.o mt19937-64.o
+REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crcspeed.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o lolwut.o lolwut5.o lolwut6.o acl.o gopher.o tracking.o connection.o tls.o sha256.o timeout.o setcpuaffinity.o mt19937-64.o rdb_downgrade_compat.o
 REDIS_CLI_NAME=redis-cli$(PROG_SUFFIX)
 REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o zmalloc.o release.o ae.o crcspeed.o crc64.o siphash.o crc16.o mt19937-64.o
 REDIS_BENCHMARK_NAME=redis-benchmark$(PROG_SUFFIX)
diff --git a/src/cluster.c b/src/cluster.c
index d2740bb58a9..903e893a9ef 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -31,6 +31,7 @@
 #include "server.h"
 #include "cluster.h"
 #include "endianconv.h"
+#include "rdb_downgrade_compat.h"
 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -171,13 +172,30 @@ int clusterLoadConfig(char *filename) {
             n = createClusterNode(argv[0],0);
             clusterAddNode(n);
         }
-        /* Address and port */
-        if ((p = strrchr(argv[1],':')) == NULL) {
+        /* Address and port. The format is ip:port[,hostname] */
+        int aux_argc;
+        sds *aux_argv = sdssplitlen(argv[1],sdslen(argv[1]),",",1,&aux_argc);
+        if (aux_argv == NULL) {
+            sdsfreesplitres(argv,argc);
+            goto fmterr;
+        }
+
+        if (aux_argc > 1) {
+            if (sdslen(aux_argv[1]) > 0) {
+                sdsfree(n->hostname);
+                n->hostname = sdsnew(aux_argv[1]);
+            } else {
+                if (n->hostname) sdsclear(n->hostname);
+            }
+        }
+
+        if ((p = strrchr(aux_argv[0],':')) == NULL) {
+            sdsfreesplitres(aux_argv,aux_argc);
             sdsfreesplitres(argv,argc);
             goto fmterr;
         }
         *p = '\0';
-        memcpy(n->ip,argv[1],strlen(argv[1])+1);
+        memcpy(n->ip,aux_argv[0],strlen(aux_argv[0])+1);
         char *port = p+1;
         char *busp = strchr(port,'@');
         if (busp) {
@@ -189,6 +207,10 @@ int clusterLoadConfig(char *filename) {
          * In this case we set it to the default offset of 10000 from the
          * base port. */
         n->cport = busp ? atoi(busp) : n->port + CLUSTER_PORT_INCR;
+        sdsfreesplitres(aux_argv,aux_argc);
+
+        /* The plaintext port for client in a TLS cluster (n->pport) is not
+         * stored in nodes.conf. It is received later over the bus protocol. */
 
         /* Parse flags */
         p = s = argv[2];
@@ -786,6 +808,7 @@ clusterNode *createClusterNode(char *nodename, int flags) {
     node->data_received = 0;
     node->fail_time = 0;
     node->link = NULL;
+    node->hostname = NULL;
     memset(node->ip,0,sizeof(node->ip));
     node->port = 0;
     node->cport = 0;
@@ -956,6 +979,7 @@ void freeClusterNode(clusterNode *n) {
     if (n->link) freeClusterLink(n->link);
     listRelease(n->fail_reports);
     zfree(n->slaves);
+    if (n->hostname) sdsfree(n->hostname);
     zfree(n);
 }
 
@@ -1752,12 +1776,12 @@ int clusterProcessPacket(clusterLink *link) {
 
         explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
         explen += (sizeof(clusterMsgDataGossip)*count);
-        if (totlen != explen) return 1;
+        if (totlen < explen) return 1;
     } else if (type == CLUSTERMSG_TYPE_FAIL) {
         uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
 
         explen += sizeof(clusterMsgDataFail);
-        if (totlen != explen) return 1;
+        if (totlen < explen) return 1;
     } else if (type == CLUSTERMSG_TYPE_PUBLISH) {
         uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
 
@@ -1777,7 +1801,7 @@ int clusterProcessPacket(clusterLink *link) {
         uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
 
         explen += sizeof(clusterMsgDataUpdate);
-        if (totlen != explen) return 1;
+        if (totlen < explen) return 1;
     } else if (type == CLUSTERMSG_TYPE_MODULE) {
         uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
 
@@ -4123,11 +4147,15 @@ sds clusterGenNodeDescription(clusterNode *node) {
     sds ci;
 
     /* Node coordinates */
-    ci = sdscatprintf(sdsempty(),"%.40s %s:%d@%d ",
+    ci = sdscatprintf(sdsempty(),"%.40s %s:%d@%d",
         node->name,
         node->ip,
         node->port,
         node->cport);
+    if (node->hostname && sdslen(node->hostname) > 0) {
+        ci = sdscatfmt(ci,",%s",node->hostname);
+    }
+    ci = sdscat(ci," ");
 
     /* Flags */
     ci = representClusterNodeFlags(ci, node->flags);
@@ -4944,7 +4972,7 @@ void createDumpPayload(rio *payload, robj *o, robj *key) {
  * instance and that the checksum is ok.
  * If the DUMP payload looks valid C_OK is returned, otherwise C_ERR
  * is returned. */
-int verifyDumpPayload(unsigned char *p, size_t len) {
+int verifyDumpPayload(unsigned char *p, size_t len, int *rdbverptr) {
     unsigned char *footer;
     uint16_t rdbver;
     uint64_t crc;
@@ -4955,12 +4983,18 @@ int verifyDumpPayload(unsigned char *p, size_t len) {
 
     /* Verify RDB version */
     rdbver = (footer[1] << 8) | footer[0];
-    if (rdbver > RDB_VERSION) return C_ERR;
+    if ((rdbver >= RDB_FOREIGN_VERSION_MIN && rdbver <= RDB_FOREIGN_VERSION_MAX) ||
+        (rdbver > RDB_VERSION && server.rdb_version_check == RDB_VERSION_CHECK_STRICT)) {
+        return C_ERR;
+    }
 
     /* Verify CRC64 */
     crc = crc64(0,p,len-8);
     memrev64ifbe(&crc);
-    return (memcmp(&crc,footer+2,8) == 0) ? C_OK : C_ERR;
+    if (memcmp(&crc,footer+2,8) != 0) return C_ERR;
+
+    if (rdbverptr) *rdbverptr = rdbver;
+    return C_OK;
 }
 
 /* DUMP keyname
@@ -4988,7 +5022,7 @@ void dumpCommand(client *c) {
 void restoreCommand(client *c) {
     long long ttl, lfu_freq = -1, lru_idle = -1, lru_clock = -1;
     rio payload;
-    int j, type, replace = 0, absttl = 0;
+    int j, type, rdbver, replace = 0, absttl = 0;
     robj *obj;
 
     /* Parse additional options */
@@ -5041,7 +5075,7 @@ void restoreCommand(client *c) {
     }
 
     /* Verify RDB version and data checksum. */
-    if (verifyDumpPayload(c->argv[3]->ptr,sdslen(c->argv[3]->ptr)) == C_ERR)
+    if (verifyDumpPayload(c->argv[3]->ptr,sdslen(c->argv[3]->ptr),&rdbver) == C_ERR)
     {
         addReplyError(c,"DUMP payload version or checksum are wrong");
         return;
@@ -5049,7 +5083,7 @@ void restoreCommand(client *c) {
 
     rioInitWithBuffer(&payload,c->argv[3]->ptr);
     if (((type = rdbLoadObjectType(&payload)) == -1) ||
-        ((obj = rdbLoadObject(type,&payload,key->ptr)) == NULL))
+        ((obj = rdbLoadObjectCompat(type,&payload,key->ptr,NULL,rdbver)) == NULL))
     {
         addReplyError(c,"Bad data format");
         return;
diff --git a/src/cluster.h b/src/cluster.h
index 84e08f607a6..64f1c7afd21 100644
--- a/src/cluster.h
+++ b/src/cluster.h
@@ -137,6 +137,7 @@ typedef struct clusterNode {
     int cport;                  /* Latest known cluster port of this node. */
     clusterLink *link;          /* TCP/IP link with this node */
     list *fail_reports;         /* List of nodes signaling this as failing */
+    sds hostname;
 } clusterNode;
 
 typedef struct clusterState {
diff --git a/src/config.c b/src/config.c
index 03104f56c0d..c0f23aa9250 100644
--- a/src/config.c
+++ b/src/config.c
@@ -113,6 +113,12 @@ configEnum oom_score_adj_enum[] = {
     {NULL, 0}
 };
 
+configEnum rdb_version_check_enum[] = {
+        {"strict",  RDB_VERSION_CHECK_STRICT}, // strict: Reject future RDB versions.
+        {"relaxed", RDB_VERSION_CHECK_RELAXED}, // relaxed: Try parsing future RDB versions and fail only when an unknown RDB opcode or type is encountered.
+        {NULL,      0}
+};
+
 /* Output buffer limits presets. */
 clientBufferLimitsConfig clientBufferLimitsDefaults[CLIENT_TYPE_OBUF_COUNT] = {
     {0, 0, 0}, /* normal */
@@ -2327,6 +2333,7 @@ standardConfig configs[] = {
     createEnumConfig("maxmemory-policy", NULL, MODIFIABLE_CONFIG, maxmemory_policy_enum, server.maxmemory_policy, MAXMEMORY_NO_EVICTION, NULL, NULL),
     createEnumConfig("appendfsync", NULL, MODIFIABLE_CONFIG, aof_fsync_enum, server.aof_fsync, AOF_FSYNC_EVERYSEC, NULL, NULL),
     createEnumConfig("oom-score-adj", NULL, MODIFIABLE_CONFIG, oom_score_adj_enum, server.oom_score_adj, OOM_SCORE_ADJ_NO, NULL, updateOOMScoreAdj),
+    createEnumConfig("rdb-version-check", NULL, MODIFIABLE_CONFIG, rdb_version_check_enum, server.rdb_version_check, RDB_VERSION_CHECK_RELAXED, NULL, NULL),
 
     /* Integer configs */
     createIntConfig("databases", NULL, IMMUTABLE_CONFIG, 1, INT_MAX, server.dbnum, 16, INTEGER_CONFIG, NULL, NULL),
diff --git a/src/help.h b/src/help.h
index 57b2e0b3cab..069bb08e327 100644
--- a/src/help.h
+++ b/src/help.h
@@ -974,7 +974,7 @@ struct commandHelp {
     8,
     "1.0.0" },
     { "SET",
-    "key value [EX seconds|PX milliseconds|KEEPTTL] [NX|XX]",
+    "key value [EX seconds|PX milliseconds|EXAT unix-time-seconds|PXAT unix-time-milliseconds|KEEPTTL] [NX|XX]",
     "Set the string value of a key",
     1,
     "1.0.0" },
diff --git a/src/listpack.c b/src/listpack.c
index 6c111e83e02..86b9489170a 100644
--- a/src/listpack.c
+++ b/src/listpack.c
@@ -383,6 +383,22 @@ uint32_t lpCurrentEncodedSize(unsigned char *p) {
     return 0;
 }
 
+/* Return the number of bytes needed to encode the type and optional string
+ * length of the listpack element pointed to by 'p'. */
+static uint32_t lpCurrentEncodedSizeBytes(unsigned char *p) {
+    if (LP_ENCODING_IS_7BIT_UINT(p[0])) return 1;
+    if (LP_ENCODING_IS_6BIT_STR(p[0])) return 1;
+    if (LP_ENCODING_IS_13BIT_INT(p[0])) return 1;
+    if (LP_ENCODING_IS_16BIT_INT(p[0])) return 1;
+    if (LP_ENCODING_IS_24BIT_INT(p[0])) return 1;
+    if (LP_ENCODING_IS_32BIT_INT(p[0])) return 1;
+    if (LP_ENCODING_IS_64BIT_INT(p[0])) return 1;
+    if (LP_ENCODING_IS_12BIT_STR(p[0])) return 2;
+    if (LP_ENCODING_IS_32BIT_STR(p[0])) return 5;
+    if (p[0] == LP_EOF) return 1;
+    return 0;
+}
+
 /* Skip the current entry returning the next. It is invalid to call this
  * function if the current element is the EOF element at the end of the
  * listpack, however, while this function is used to implement lpNext(),
@@ -752,6 +768,59 @@ uint32_t lpBytes(unsigned char *lp) {
     return lpGetTotalBytes(lp);
 }
 
+/* Validate a listpack entry and advance 'pp' to the next entry. */
+static int lpValidateNext(unsigned char *lp, unsigned char **pp, size_t lpbytes) {
+    unsigned char *p = *pp;
+    if (!p || p < lp + LP_HDR_SIZE || p > lp + lpbytes - 1) return 0;
+
+    if (*p == LP_EOF) {
+        if (p != lp + lpbytes - 1) return 0;
+        *pp = NULL;
+        return 1;
+    }
+
+    size_t offset = p - lp;
+    uint32_t lenbytes = lpCurrentEncodedSizeBytes(p);
+    if (!lenbytes || lenbytes > lpbytes - offset - 1) return 0;
+
+    unsigned long entrylen = lpCurrentEncodedSize(p);
+    unsigned long encoded_backlen = lpEncodeBacklen(NULL, entrylen);
+    if (entrylen > lpbytes - offset - 1 ||
+        encoded_backlen > lpbytes - offset - entrylen - 1) {
+        return 0;
+    }
+
+    p += entrylen + encoded_backlen;
+    if (lpDecodeBacklen(p - 1) != entrylen) return 0;
+
+    *pp = p;
+    return 1;
+}
+
+/* Validate the listpack header and, when 'deep' is non-zero, every entry.
+ * The callback is invoked only after an entry has passed bounds validation. */
+int lpValidateIntegrity(unsigned char *lp, size_t size, int deep,
+                        listpackValidateEntryCB entry_cb, void *cb_userdata) {
+    if (size < LP_HDR_SIZE + 1) return 0;
+    if (lpGetTotalBytes(lp) != size) return 0;
+    if (lp[size - 1] != LP_EOF) return 0;
+    if (!deep) return 1;
+
+    uint32_t count = 0;
+    uint32_t numele = lpGetNumElements(lp);
+    unsigned char *p = lp + LP_HDR_SIZE;
+    while (p && p[0] != LP_EOF) {
+        unsigned char *entry = p;
+        if (!lpValidateNext(lp, &p, size)) return 0;
+        if (entry_cb && !entry_cb(entry, numele, cb_userdata)) return 0;
+        count++;
+    }
+
+    if (p != lp + size - 1) return 0;
+    if (numele != LP_HDR_NUMELE_UNKNOWN && numele != count) return 0;
+    return 1;
+}
+
 /* Seek the specified element and returns the pointer to the seeked element.
  * Positive indexes specify the zero-based element to seek from the head to
  * the tail, negative indexes specify elements starting from the tail, where
@@ -800,4 +869,3 @@ unsigned char *lpSeek(unsigned char *lp, long index) {
         return ele;
     }
 }
-
diff --git a/src/listpack.h b/src/listpack.h
index af67b4b411f..3c66c3ad4dc 100644
--- a/src/listpack.h
+++ b/src/listpack.h
@@ -35,6 +35,7 @@
 #ifndef __LISTPACK_H
 #define __LISTPACK_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #define LP_INTBUF_SIZE 21 /* 20 digits of -2^63 + 1 null term = 21. */
@@ -57,5 +58,9 @@ unsigned char *lpNext(unsigned char *lp, unsigned char *p);
 unsigned char *lpPrev(unsigned char *lp, unsigned char *p);
 uint32_t lpBytes(unsigned char *lp);
 unsigned char *lpSeek(unsigned char *lp, long index);
+typedef int (*listpackValidateEntryCB)(unsigned char *p, unsigned int head_count,
+                                      void *userdata);
+int lpValidateIntegrity(unsigned char *lp, size_t size, int deep,
+                        listpackValidateEntryCB entry_cb, void *cb_userdata);
 
 #endif
diff --git a/src/rdb.c b/src/rdb.c
index 1227bb34bdc..87891096efd 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -32,9 +32,11 @@
 #include "zipmap.h"
 #include "endianconv.h"
 #include "stream.h"
+#include "rdb_downgrade_compat.h"  /* RDB downgrade compatibility */
 
 #include <math.h>
 #include <fcntl.h>
+#include <stdbool.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/resource.h>
@@ -2132,22 +2134,34 @@ int rdbLoadRio(rio *rdb, int rdbflags, rdbSaveInfo *rsi) {
     int type, rdbver;
     redisDb *db = server.db+0;
     char buf[1024];
+    bool is_valkey_magic;
 
     rdb->update_cksum = rdbLoadProgressCallback;
     rdb->max_processing_chunk = server.loading_process_events_interval_bytes;
     if (rioRead(rdb,buf,9) == 0) goto eoferr;
     buf[9] = '\0';
-    if (memcmp(buf,"REDIS",5) != 0) {
-        serverLog(LL_WARNING,"Wrong signature trying to load DB from file");
+    if (memcmp(buf, "REDIS0", 6) == 0) {
+        is_valkey_magic = false;
+    } else if (memcmp(buf, "VALKEY", 6) == 0) {
+        is_valkey_magic = true;
+    } else {
+        serverLog(LL_WARNING, "Wrong signature trying to load DB from file");
         errno = EINVAL;
         return C_ERR;
     }
-    rdbver = atoi(buf+5);
-    if (rdbver < 1 || rdbver > RDB_VERSION) {
+    rdbver = atoi(buf + 6);
+    if (rdbver < 1 ||
+        (rdbver >= RDB_FOREIGN_VERSION_MIN && !is_valkey_magic) ||
+        (rdbver > RDB_VERSION && server.rdb_version_check == RDB_VERSION_CHECK_STRICT)) {
         serverLog(LL_WARNING,"Can't handle RDB format version %d",rdbver);
         errno = EINVAL;
         return C_ERR;
     }
+    
+    /* Log compatibility mode for higher versions */
+    if (rdbver > RDB_VERSION) {
+        serverLog(LL_NOTICE,"Loading RDB version %d with downgrade compatibility (current version: %d)", rdbver, RDB_VERSION);
+    }
 
     /* Key-specific attributes, set by opcodes before the key type. */
     long long lru_idle = -1, lfu_freq = -1, expiretime = -1, now = mstime();
@@ -2160,6 +2174,13 @@ int rdbLoadRio(rio *rdb, int rdbflags, rdbSaveInfo *rsi) {
         /* Read type. */
         if ((type = rdbLoadType(rdb)) == -1) goto eoferr;
 
+        const char *unsupported = rdbDowngradeUnsupportedTypeReason(type);
+        if (unsupported) {
+            serverLog(LL_WARNING, "Cannot downgrade %s to Redis 6.0", unsupported);
+            errno = EINVAL;
+            return C_ERR;
+        }
+
         /* Handle special types. */
         if (type == RDB_OPCODE_EXPIRETIME) {
             /* EXPIRETIME: load an expire associated with the next key
@@ -2213,6 +2234,9 @@ int rdbLoadRio(rio *rdb, int rdbflags, rdbSaveInfo *rsi) {
             dictExpand(db->dict,db_size);
             dictExpand(db->expires,expires_size);
             continue; /* Read next opcode. */
+        } else if (type == RDB_OPCODE_SLOT_INFO) {
+            if (rdbLoadSlotInfoCompat(rdb) == C_ERR) goto eoferr;
+            continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_AUX) {
             /* AUX: generic string-string fields. Use to add state to RDB
              * which is backward compatible. Implementations of RDB loading
@@ -2246,9 +2270,10 @@ int rdbLoadRio(rio *rdb, int rdbflags, rdbSaveInfo *rsi) {
                         "Can't load Lua script from RDB file! "
                         "BODY: %s", (char*)auxval->ptr);
                 }
-            } else if (!strcasecmp(auxkey->ptr,"redis-ver")) {
-                serverLog(LL_NOTICE,"Loading RDB produced by version %s",
-                    (char*)auxval->ptr);
+            } else if (!strcasecmp(auxkey->ptr, "redis-ver")) {
+                serverLog(LL_NOTICE, "Loading RDB produced by Redis version %s", (char *)auxval->ptr);
+            } else if (!strcasecmp(auxkey->ptr, "valkey-ver")) {
+                serverLog(LL_NOTICE, "Loading RDB produced by Valkey version %s", (char *)auxval->ptr);
             } else if (!strcasecmp(auxkey->ptr,"ctime")) {
                 time_t age = time(NULL)-strtol(auxval->ptr,NULL,10);
                 if (age < 0) age = 0;
@@ -2331,8 +2356,8 @@ int rdbLoadRio(rio *rdb, int rdbflags, rdbSaveInfo *rsi) {
         /* Read key */
         if ((key = rdbGenericLoadStringObject(rdb,RDB_LOAD_SDS,NULL)) == NULL)
             goto eoferr;
-        /* Read value */
-        if ((val = rdbLoadObject(type,rdb,key)) == NULL) {
+        /* Read value with compatibility support for higher RDB versions */
+        if ((val = rdbLoadObjectCompat(type,rdb,key,NULL,rdbver)) == NULL) {
             sdsfree(key);
             goto eoferr;
         }
diff --git a/src/rdb.h b/src/rdb.h
index f22fbecd102..cd37f26c803 100644
--- a/src/rdb.h
+++ b/src/rdb.h
@@ -37,9 +37,23 @@
 #include "server.h"
 
 /* The current RDB version. When the format changes in a way that is no longer
- * backward compatible this number gets incremented. */
+ * backward compatible this number gets incremented.
+ *
+ * RDB 11 is the last open-source Redis RDB version, used by Valkey 7.x and 8.x.
+ *
+ * RDB 12-79 are reserved for non-open-source Redis formats.
+ *
+ * Valkey 9.x uses RDB version 80 to avoid collisions with those formats.
+ *
+ * In an RDB file/stream, we also check the magic string REDIS or VALKEY but in
+ * the DUMP/RESTORE format, there is only the RDB version number and no magic
+ * string. */
 #define RDB_VERSION 9
 
+/* Reserved range for foreign (unsupported, non-OSS) RDB format. */
+#define RDB_FOREIGN_VERSION_MIN 12
+#define RDB_FOREIGN_VERSION_MAX 79
+
 /* Defines related to the dump file format. To store 32 bits lengths for short
  * keys requires a lot of space, so we check the most significant 2 bits of
  * the first byte to interpreter the length:
@@ -91,12 +105,26 @@
 #define RDB_TYPE_HASH_ZIPLIST  13
 #define RDB_TYPE_LIST_QUICKLIST 14
 #define RDB_TYPE_STREAM_LISTPACKS 15
+/* RDB 11 types for downgrade compatibility */
+#define RDB_TYPE_HASH_LISTPACK 16
+#define RDB_TYPE_ZSET_LISTPACK 17
+#define RDB_TYPE_LIST_QUICKLIST_2   18
+#define RDB_TYPE_STREAM_LISTPACKS_2 19
+#define RDB_TYPE_SET_LISTPACK  20
+#define RDB_TYPE_STREAM_LISTPACKS_3 21
+#define RDB_TYPE_HASH_2 22 /* Hash with field-level expiration, RDB 80 (9.0). */
 /* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
 
 /* Test if a type is an object type. */
-#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15))
+/* RDB_TYPE_HASH_2 is intentionally excluded because Redis 6.0 cannot
+ * represent hash-field expiration semantics. */
+#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 21))
 
 /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
+#define RDB_OPCODE_SLOT_IMPORT 243     /* Slot import state (Valkey 9.0). */
+#define RDB_OPCODE_SLOT_INFO 244       /* Slot size hints, safe to ignore. */
+#define RDB_OPCODE_FUNCTION2 245       /* Function library data. */
+#define RDB_OPCODE_FUNCTION_PRE_GA 246 /* Pre-GA function library data. */
 #define RDB_OPCODE_MODULE_AUX 247   /* Module auxiliary data. */
 #define RDB_OPCODE_IDLE       248   /* LRU idle time. */
 #define RDB_OPCODE_FREQ       249   /* LFU frequency. */
diff --git a/src/rdb_downgrade_compat.c b/src/rdb_downgrade_compat.c
new file mode 100644
index 00000000000..bbb00be52d0
--- /dev/null
+++ b/src/rdb_downgrade_compat.c
@@ -0,0 +1,978 @@
+/*
+ * RDB Downgrade Compatibility Implementation
+ *
+ * This module provides compatibility functions to enable Redis 6.0
+ * to load compatible RDB files from newer versions (Redis 7.x RDB v10/v11 and
+ * Valkey 8.x/9.x RDB v11/v80) that use supported object types and listpack
+ * encoding instead of ziplist encoding.
+ *
+ */
+
+#include "rdb_downgrade_compat.h"
+#include "server.h"
+#include "rdb.h"
+#include "listpack.h"
+#include "quicklist.h"
+#include "ziplist.h"
+#include "sds.h"
+#include "endianconv.h"
+#include <time.h>
+
+/* Listpack format constants for Redis 6.2 compatibility */
+#define LP_HDR_SIZE                                                            \
+  6 /* Listpack header size: 4 bytes total + 2 bytes num-elements */
+#define LP_EOF 0xFF /* Listpack EOF marker */
+
+/* When rdbLoadObject() returns NULL, the err flag is
+ * set to hold the type of error that occurred */
+#define RDB_LOAD_ERR_EMPTY_KEY 1 /* Error of empty key */
+#define RDB_LOAD_ERR_OTHER 2     /* Any other errors */
+
+/* Downgrade monitoring statistics */
+struct rdbDowngradeStats rdb_downgrade_stats = {0};
+
+/* Get data structure type as a string */
+const char *getDataStructureType(int rdbtype) {
+    switch (rdbtype) {
+        case RDB_TYPE_HASH_ZIPLIST:
+        case RDB_TYPE_HASH_LISTPACK:
+            return "hash";
+        case RDB_TYPE_LIST_ZIPLIST:
+        case RDB_TYPE_LIST_QUICKLIST_2:
+            return "list";
+        case RDB_TYPE_SET_LISTPACK:
+            return "set";
+        case RDB_TYPE_ZSET_ZIPLIST:
+        case RDB_TYPE_ZSET_LISTPACK:
+            return "sortedset";
+        default:
+            return "unknown";
+    }
+}
+
+/* Update downgrade statistics with enhanced per-data-structure tracking */
+void rdbDowngradeStatsUpdateWithType(int success, size_t bytes, const char *key, int rdbtype) {
+    rdb_downgrade_stats.keys_attempted++;
+    
+    
+    if (success) {
+        rdb_downgrade_stats.keys_succeeded++;
+        rdb_downgrade_stats.bytes_converted += bytes;
+        rdb_downgrade_stats.keys_converted++;
+        serverLog(LL_VERBOSE, "RDB downgrade success: key=%s, type=%s, bytes=%zu, total_keys=%llu",
+                  key ? key : "unknown", getDataStructureType(rdbtype), bytes, rdb_downgrade_stats.keys_converted);
+    } else {
+        rdb_downgrade_stats.keys_failed++;
+        serverLog(LL_WARNING, "RDB downgrade failed: key=%s, type=%s, total_failures=%llu",
+                  key ? key : "unknown", getDataStructureType(rdbtype), rdb_downgrade_stats.keys_failed);
+    }
+    rdb_downgrade_stats.last_conversion_time = time(NULL);
+}
+
+/* Update downgrade statistics with version check to prevent false positives */
+void rdbDowngradeStatsUpdateWithTypeAndVersion(int success, size_t bytes, const char *key, int rdbtype, int rdbver) {
+    /* Only increment statistics for RDB versions that actually require downgrade conversion */
+    if (rdbver < RDB_VERSION_REDIS_70) {
+        serverLog(LL_DEBUG, "RDB compatibility: Skipping statistics update for RDB v%d key=%s (no conversion needed)", rdbver, key);
+        return;
+    }
+    
+    /* Call original function for versions that do require conversion */
+    rdbDowngradeStatsUpdateWithType(success, bytes, key, rdbtype);
+}
+
+
+
+/* Generate statistics info string for INFO command */
+sds rdbDowngradeStatsInfoString(void) {
+    return sdscatprintf(sdsempty(),
+        "# RDBDowngradeStats\r\n"
+        "rdb_downgrade_keys_attempted:%llu\r\n"
+        "rdb_downgrade_keys_succeeded:%llu\r\n"
+        "rdb_downgrade_keys_failed:%llu\r\n"
+        "rdb_downgrade_bytes_converted:%llu\r\n"
+        "rdb_downgrade_last_conversion_time:%ld\r\n",
+        rdb_downgrade_stats.keys_attempted,
+        rdb_downgrade_stats.keys_succeeded,
+        rdb_downgrade_stats.keys_failed,
+        rdb_downgrade_stats.bytes_converted,
+        rdb_downgrade_stats.last_conversion_time);
+}
+
+/* Check if this RDB type requires listpack to ziplist conversion */
+int requiresListpackConversion(int rdbtype, int rdbver) {
+    /* For RDB versions below 10, no conversion is needed */
+    if (rdbver < RDB_VERSION_REDIS_70) return 0;
+
+    switch (rdbtype) {
+        /* These types contain listpack data and need conversion to ziplist */
+        case RDB_TYPE_HASH_LISTPACK:
+        case RDB_TYPE_ZSET_LISTPACK:
+        case RDB_TYPE_LIST_QUICKLIST_2:
+        case RDB_TYPE_STREAM_LISTPACKS_2:
+        case RDB_TYPE_SET_LISTPACK:
+        case RDB_TYPE_STREAM_LISTPACKS_3:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+/* Return an explanation for newer data that cannot be represented by Redis
+ * 6.0 without losing semantics. */
+const char *rdbDowngradeUnsupportedTypeReason(int type) {
+    switch (type) {
+        case RDB_TYPE_HASH_2:
+            return "hash-field expiration data";
+        case RDB_OPCODE_SLOT_IMPORT:
+            return "active atomic slot migration state";
+        case RDB_OPCODE_FUNCTION2:
+        case RDB_OPCODE_FUNCTION_PRE_GA:
+            return "function library data";
+        default:
+            return NULL;
+    }
+}
+
+/* RDB_OPCODE_SLOT_INFO contains optional allocation hints. Redis 6.0 does
+ * not use them, but consuming the three lengths keeps the stream aligned. */
+int rdbLoadSlotInfoCompat(rio *rdb) {
+    if (rdbLoadLen(rdb, NULL) == RDB_LENERR ||
+        rdbLoadLen(rdb, NULL) == RDB_LENERR ||
+        rdbLoadLen(rdb, NULL) == RDB_LENERR) {
+        return C_ERR;
+    }
+    return C_OK;
+}
+
+/* Enhanced listpack detection specifically for RDB v11 compatibility */
+int isListpackEncoded(unsigned char *data, size_t len) {
+    if (!data || len < LISTPACK_MIN_VALID_SIZE || len > MAX_LISTPACK_SIZE) {
+        return 0;
+    }
+    
+    /* For RDB v11 compatibility, we need to be more aggressive in detecting listpacks
+     * since Valkey consistently uses listpack format for RDB v11 */
+    
+    /* Basic listpack header check */
+    if (len < 6) return 0; /* Need at least 6 bytes for header */
+    
+    uint32_t total_bytes;
+    uint16_t num_elements;
+    
+    /* Safe header extraction */
+    memcpy(&total_bytes, data, 4);
+    memcpy(&num_elements, data + 4, 2);
+    
+    /* Convert from little endian if needed */
+    total_bytes = intrev32ifbe(total_bytes);
+    num_elements = intrev16ifbe(num_elements);
+    
+    /* First check: does it look like a valid listpack? */
+    if (total_bytes == len &&
+        total_bytes >= LISTPACK_MIN_VALID_SIZE &&
+        total_bytes <= MAX_LISTPACK_SIZE &&
+        len > 0 && data[len-1] == LP_EOF) {
+        
+        /* This looks like a valid listpack */
+        return 1;
+    }
+    
+    /* Second check: does it look like a ziplist? */
+    if (len >= 10) {
+        uint32_t zl_bytes, zl_tail_offset;
+        uint16_t zl_length;
+        
+        memcpy(&zl_bytes, data, 4);
+        memcpy(&zl_tail_offset, data + 4, 4);
+        memcpy(&zl_length, data + 8, 2);
+        
+        zl_bytes = intrev32ifbe(zl_bytes);
+        zl_tail_offset = intrev32ifbe(zl_tail_offset);
+        zl_length = intrev16ifbe(zl_length);
+        
+        /* If it looks like a valid ziplist, it's not a listpack */
+        if (zl_bytes == len && zl_tail_offset < len &&
+            len > 10 && data[len-1] == 0xFF) { /* ziplist EOF marker */
+            return 0;
+        }
+    }
+    
+    /* For RDB v11, if it doesn't look like a ziplist and has basic listpack structure, assume listpack */
+    if (total_bytes == len && num_elements < MAX_CONVERSION_ELEMENTS) {
+        return 1;
+    }
+    
+    return 0;
+}
+
+
+/* Convert listpack to ziplist format with comprehensive error handling */
+unsigned char *listpackToZiplist(unsigned char *lp) {
+    if (!lp) {
+        serverLog(LL_WARNING, "RDB compatibility: listpackToZiplist called with NULL pointer");
+        return NULL;
+    }
+    
+    /* Basic safety checks before calling any listpack functions */
+    if ((unsigned char *)lp < (unsigned char *)0x1000) {
+        serverLog(LL_WARNING, "listpackToZiplist: invalid listpack pointer");
+        return NULL;
+    }
+    
+    /* Get listpack size safely */
+    size_t lp_size = lpBytes(lp);
+    if (lp_size > MAX_LISTPACK_SIZE || lp_size < LISTPACK_MIN_VALID_SIZE) {
+        serverLog(LL_WARNING, "listpackToZiplist: invalid listpack size (%zu bytes)", lp_size);
+        return NULL;
+    }
+    
+    /* Get element count safely */
+    uint32_t num_elements = lpLength(lp);
+    if (num_elements > MAX_CONVERSION_ELEMENTS) {
+        serverLog(LL_WARNING, "listpackToZiplist: too many elements (%u)", num_elements);
+        return NULL;
+    }
+    
+    /* Create new ziplist */
+    unsigned char *zl = ziplistNew();
+    if (!zl) {
+        serverLog(LL_WARNING, "listpackToZiplist: failed to create ziplist");
+        return NULL;
+    }
+    
+    /* If empty listpack, return empty ziplist */
+    if (num_elements == 0) {
+        return zl;
+    }
+    
+    /* Get first element safely */
+    unsigned char *p = lpFirst(lp);
+    if (!p) {
+        serverLog(LL_WARNING, "listpackToZiplist: failed to get first element");
+        zfree(zl);
+        return NULL;
+    }
+    
+    uint32_t processed = 0;
+    
+    while (p && processed < num_elements) {
+        int64_t slen;
+        unsigned char intbuf[32];
+        unsigned char *sval;
+        unsigned char *new_zl;
+        
+        /* Bounds check */
+        if (p < lp || p >= lp + lp_size - 1) {
+            serverLog(LL_WARNING, "listpackToZiplist: element pointer out of bounds");
+            goto error_cleanup;
+        }
+        
+        /* Get element value safely */
+        sval = lpGet(p, &slen, intbuf);
+        
+        if (sval) {
+            /* String value - validate size */
+            if (slen > (int64_t)server.proto_max_bulk_len) {
+                serverLog(LL_WARNING, "listpackToZiplist: string element too large (%lld bytes)", (long long)slen);
+                goto error_cleanup;
+            }
+            
+            new_zl = ziplistPush(zl, sval, (size_t)slen, ZIPLIST_TAIL);
+        } else {
+            /* Integer value - use the buffer directly */
+            new_zl = ziplistPush(zl, intbuf, (size_t)slen, ZIPLIST_TAIL);
+        }
+        
+        if (!new_zl) {
+            serverLog(LL_WARNING, "listpackToZiplist: failed to add element %u", processed);
+            goto error_cleanup;
+        }
+        
+        zl = new_zl;
+        processed++;
+        
+        /* Get next element safely */
+        unsigned char *next_p = lpNext(lp, p);
+        if (!next_p && processed < num_elements) {
+            serverLog(LL_WARNING, "listpackToZiplist: unexpected end of listpack at element %u", processed);
+            goto error_cleanup;
+        }
+        
+        p = next_p;
+        
+        /* Safety check for infinite loops */
+        if (processed >= MAX_CONVERSION_ELEMENTS) {
+            serverLog(LL_WARNING, "listpackToZiplist: conversion element limit exceeded");
+            goto error_cleanup;
+        }
+    }
+    
+    /* Verify we processed all elements */
+    if (processed != num_elements) {
+        serverLog(LL_WARNING, "listpackToZiplist: element count mismatch (expected %u, got %u)",
+                  num_elements, processed);
+        goto error_cleanup;
+    }
+    
+    /* Final ziplist validation */
+    if (ziplistLen(zl) != num_elements) {
+        serverLog(LL_WARNING, "listpackToZiplist: final ziplist length mismatch");
+        goto error_cleanup;
+    }
+    
+    return zl;
+    
+error_cleanup:
+    if (zl) {
+        zfree(zl);
+    }
+    return NULL;
+}
+
+/* Enhanced object loading with compatibility for higher RDB versions */
+robj *rdbLoadObjectCompat(int rdbtype, rio *rdb, sds key, int *error, int rdbver) {
+    /* Performance and error tracking */
+    mstime_t start_time = mstime();
+    int conversion_attempted = 0;
+    size_t original_size = 0, converted_size = 0;
+    
+    /* Validate inputs to prevent corruption */
+    if (!rdb || !key) {
+        serverLog(LL_WARNING, "RDB compatibility: Invalid arguments - rdb=%p, key=%s", (void*)rdb, key);
+        if (error) *error = RDB_LOAD_ERR_OTHER;
+        return NULL;
+    }
+    
+    /* For RDB versions below 10, use original loading logic */
+    if (rdbver < RDB_VERSION_REDIS_70) {
+        serverLog(LL_DEBUG, "RDB compatibility: Using standard loader for RDB v%d key=%s", rdbver, key);
+        return rdbLoadObject(rdbtype, rdb, key);
+    }
+    
+    /* Newer stream encodings add metadata that Redis 6.0 cannot store but can
+     * safely consume and discard. */
+    if (rdbtype == RDB_TYPE_STREAM_LISTPACKS_2 ||
+        rdbtype == RDB_TYPE_STREAM_LISTPACKS_3) {
+        serverLog(LL_VERBOSE, "RDB compatibility: Processing stream type %d for key=%s", rdbtype, key);
+        return rdbLoadStreamCompat(rdb, key, error, rdbtype);
+    }
+    
+    /* Initialize variables */
+    robj *o = NULL;
+    unsigned char *encoded = NULL;
+    size_t encoded_len = 0;
+    
+    /* Initialize error state */
+    if (error) *error = RDB_LOAD_ERR_OTHER;
+    
+    /* Log compatibility layer activation */
+    serverLog(LL_VERBOSE, "RDB compatibility: Processing RDB v%d key=%s type=%s", rdbver, key, getDataStructureType(rdbtype));
+    
+    /* Handle compatibility conversion for supported types */
+    if (requiresListpackConversion(rdbtype, rdbver) != 0) {
+        
+        /* Special handling for LIST_QUICKLIST_2 which has different structure */
+        if (rdbtype == RDB_TYPE_LIST_QUICKLIST_2) {
+            serverLog(LL_VERBOSE, "RDB compatibility: Processing LIST_QUICKLIST_2 for key=%s, type=%s (RDB v%d)", key, getDataStructureType(rdbtype), rdbver);
+            
+            uint64_t len;
+            if ((len = rdbLoadLen(rdb,NULL)) == RDB_LENERR) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load quicklist length for key=%s", key);
+                goto error_cleanup;
+            }
+            if (len == 0) {
+                if (error) *error = RDB_LOAD_ERR_EMPTY_KEY;
+                return NULL;
+            }
+
+            o = createQuicklistObject();
+            if (!o) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to create quicklist object for key=%s", key);
+                goto error_cleanup;
+            }
+            
+            quicklistSetOptions(o->ptr, server.list_max_ziplist_size, server.list_compress_depth);
+            size_t total_original_size = 0;
+            size_t total_converted_size = 0;
+
+            while (len--) {
+                uint64_t container;
+                if ((container = rdbLoadLen(rdb, NULL)) == RDB_LENERR) {
+                    serverLog(LL_WARNING, "RDB compatibility: Failed to load quicklist container type for key=%s", key);
+                    decrRefCount(o);
+                    goto error_cleanup;
+                }
+
+                if (container != QUICKLIST_NODE_CONTAINER_PACKED && container != QUICKLIST_NODE_CONTAINER_PLAIN) {
+                    serverLog(LL_WARNING, "RDB compatibility: Invalid quicklist container type %llu for key=%s", (unsigned long long)container, key);
+                    decrRefCount(o);
+                    goto error_cleanup;
+                }
+
+                size_t node_encoded_len;
+                unsigned char *node_encoded =
+                    rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN,&node_encoded_len);
+                if (!node_encoded) {
+                    serverLog(LL_WARNING, "RDB compatibility: Failed to load quicklist node for key=%s", key);
+                    decrRefCount(o);
+                    goto error_cleanup;
+                }
+                
+                original_size = node_encoded_len;
+                total_original_size += original_size;
+                conversion_attempted = 1;
+
+                unsigned char *zl = NULL;
+                if (container == QUICKLIST_NODE_CONTAINER_PLAIN) {
+                    zl = ziplistNew();
+                    zl = ziplistPush(zl, node_encoded, node_encoded_len, ZIPLIST_TAIL);
+                    zfree(node_encoded);
+                    node_encoded = NULL;
+                } else { /* QUICKLIST_NODE_CONTAINER_PACKED */
+                    zl = ziplistNew();
+                    if (!quicklistConvertAndValidateIntegrity(node_encoded, node_encoded_len, &zl)) {
+                        serverLog(LL_WARNING, "RDB compatibility: listpack to ziplist conversion failed for quicklist node key=%s", key);
+                        zfree(node_encoded);
+                        zfree(zl);
+                        decrRefCount(o);
+                        goto error_cleanup;
+                    }
+                    zfree(node_encoded);
+                    node_encoded = NULL;
+                }
+
+                if (ziplistLen(zl) > 0) {
+                    total_converted_size += ziplistBlobLen(zl);
+                    quicklistAppendZiplist(o->ptr, zl);
+                } else {
+                    zfree(zl);
+                }
+            }
+
+            if (quicklistCount(o->ptr) == 0) {
+                serverLog(LL_WARNING, "RDB compatibility: Created empty quicklist for key=%s", key);
+            }
+            
+            if (conversion_attempted) {
+                rdbDowngradeStatsUpdateWithTypeAndVersion(1, total_converted_size, key, rdbtype, rdbver);
+                serverLog(LL_VERBOSE, "RDB compatibility: Successfully converted listpack to ziplist for key=%s, type=%s (RDB v%d, %zu->%zu bytes)",
+                          key, getDataStructureType(rdbtype), rdbver, total_original_size, total_converted_size);
+            }
+            
+            mstime_t elapsed = mstime() - start_time;
+            serverLog(LL_VERBOSE, "RDB compatibility: Successfully processed LIST_QUICKLIST_2 key=%s, type=%s in %lldms", key, getDataStructureType(rdbtype), elapsed);
+            
+            if (error) *error = 0;
+            return o;
+        } else if (rdbtype == RDB_TYPE_HASH_ZIPLIST ||
+                   rdbtype == RDB_TYPE_ZSET_ZIPLIST ||
+                   rdbtype == RDB_TYPE_LIST_ZIPLIST ||
+                   rdbtype == RDB_TYPE_HASH_LISTPACK ||
+                   rdbtype == RDB_TYPE_ZSET_LISTPACK ||
+                   rdbtype == RDB_TYPE_SET_LISTPACK) {
+            
+            conversion_attempted = 1;
+            serverLog(LL_DEBUG, "RDB compatibility: Attempting conversion for key=%s, type=%s", key, getDataStructureType(rdbtype));
+            
+            /* Load the raw data with comprehensive error handling */
+            encoded = rdbGenericLoadStringObject(rdb, RDB_LOAD_PLAIN, &encoded_len);
+            if (!encoded) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load raw data for key=%s", key);
+                goto error_cleanup;
+            }
+            
+            original_size = encoded_len;
+            serverLog(LL_DEBUG, "RDB compatibility: Loaded raw data size=%zu for key=%s", encoded_len, key);
+            
+            /* Comprehensive data validation */
+            if (encoded_len == 0) {
+                serverLog(LL_WARNING, "RDB compatibility: Empty data for key=%s", key);
+                goto error_cleanup;
+            }
+            
+            if (encoded_len > MAX_LISTPACK_SIZE) {
+                serverLog(LL_WARNING, "RDB compatibility: Data too large (%zu bytes) for key=%s, max=%d",
+                          encoded_len, key, MAX_LISTPACK_SIZE);
+                goto error_cleanup;
+            }
+            
+            /* Detect and convert listpack data */
+            if (isListpackEncoded(encoded, encoded_len)) {
+                serverLog(LL_VERBOSE, "RDB compatibility: Detected listpack encoding for key=%s, type=%s, converting...", key, getDataStructureType(rdbtype));
+                
+                /* Convert listpack to ziplist */
+                unsigned char *zl = listpackToZiplist(encoded);
+                if (!zl) {
+                    serverLog(LL_WARNING, "RDB compatibility: Listpack to ziplist conversion failed for key=%s, type=%s", key, getDataStructureType(rdbtype));
+                    goto error_cleanup;
+                }
+                
+                /* Validate converted ziplist */
+                size_t zl_len = ziplistBlobLen(zl);
+                if (zl_len == 0 || zl_len > MAX_LISTPACK_SIZE) {
+                    serverLog(LL_WARNING, "RDB compatibility: Invalid ziplist size (%zu) for key=%s", zl_len, key);
+                    zfree(zl);
+                    goto error_cleanup;
+                }
+                
+                /* Successfully converted */
+                zfree(encoded);
+                encoded = zl;
+                encoded_len = zl_len;
+                converted_size = zl_len;
+                
+                serverLog(LL_VERBOSE, "RDB compatibility: Successfully converted listpack to ziplist for key=%s, type=%s (RDB v%d, %zu->%zu bytes)",
+                          key, getDataStructureType(rdbtype), rdbver, original_size, converted_size);
+            } else {
+                /* Data is already in ziplist format */
+                serverLog(LL_DEBUG, "RDB compatibility: Data already in ziplist format for key=%s, type=%s", key, getDataStructureType(rdbtype));
+                converted_size = encoded_len;
+            }
+            
+            /* Create object with comprehensive safety checks */
+            if (!encoded || encoded_len == 0) {
+                serverLog(LL_WARNING, "RDB compatibility: No data to create object for key=%s", key);
+                goto error_cleanup;
+            }
+            
+            /* Create object with the data - object takes ownership of encoded */
+            o = createObject(OBJ_STRING, encoded);
+            if (!o) {
+                serverLog(LL_WARNING, "RDB compatibility: Object creation failed for key=%s", key);
+                goto error_cleanup;
+            }
+            
+            /* From this point, encoded is owned by the object */
+            encoded = NULL; /* Prevent double-free */
+            
+            /* Set the correct object type and encoding with comprehensive validation */
+            switch (rdbtype) {
+                case RDB_TYPE_HASH_ZIPLIST:
+                case RDB_TYPE_HASH_LISTPACK:
+                    o->type = OBJ_HASH;
+                    o->encoding = OBJ_ENCODING_ZIPLIST;
+                    
+                    /* Validate hash structure integrity */
+                    
+                    /* Convert to hash table if too large for ziplist */
+                    if (hashTypeLength(o) > server.hash_max_ziplist_entries) {
+                        serverLog(LL_DEBUG, "RDB compatibility: Converting hash to HT encoding for key=%s (size=%lu)",
+                                  key, hashTypeLength(o));
+                        hashTypeConvert(o, OBJ_ENCODING_HT);
+                    }
+                    break;
+                    
+                case RDB_TYPE_ZSET_ZIPLIST:
+                case RDB_TYPE_ZSET_LISTPACK:
+                    o->type = OBJ_ZSET;
+                    o->encoding = OBJ_ENCODING_ZIPLIST;
+                    
+                    /* Validate sorted set structure integrity */
+                    
+                    /* Convert to skiplist if too large for ziplist */
+                    if (zsetLength(o) > server.zset_max_ziplist_entries) {
+                        serverLog(LL_DEBUG, "RDB compatibility: Converting zset to skiplist encoding for key=%s (size=%lu)",
+                                  key, zsetLength(o));
+                        zsetConvert(o, OBJ_ENCODING_SKIPLIST);
+                    }
+                    break;
+                    
+                case RDB_TYPE_LIST_ZIPLIST:
+                    o->type = OBJ_LIST;
+                    o->encoding = OBJ_ENCODING_ZIPLIST;
+                    
+                    /* Validate list structure integrity */
+                    
+                    /* Convert to quicklist as Redis 6.0 expects */
+                    serverLog(LL_DEBUG, "RDB compatibility: Converting list to quicklist encoding for key=%s", key);
+                    listTypeConvert(o, OBJ_ENCODING_QUICKLIST);
+                    break;
+                    
+                case RDB_TYPE_SET_LISTPACK: {
+                    /* Set with listpack encoding - convert to regular set */
+                    /* Create hash table and populate from converted ziplist */
+                    unsigned char *zl = (unsigned char *)o->ptr;
+                    dict *set_dict = dictCreate(&setDictType, NULL);
+                    if (!set_dict) {
+                        serverLog(LL_WARNING, "RDB compatibility: Failed to create set dict for key=%s", key);
+                        zfree(zl);
+                        zfree(o);
+                        o = NULL;
+                        goto error_cleanup;
+                    }
+
+                    /* Transfer the object to the destination encoding before
+                     * any error path can decrement its reference count. Keep
+                     * the source ziplist separately until conversion ends. */
+                    o->type = OBJ_SET;
+                    o->encoding = OBJ_ENCODING_HT;
+                    o->ptr = set_dict;
+
+                    /* Parse ziplist and add elements to set */
+                    unsigned char *p = ziplistIndex(zl, 0);
+                    while (p) {
+                        unsigned char *vstr;
+                        unsigned int vlen;
+                        long long vlong;
+                        
+                        if (ziplistGet(p, &vstr, &vlen, &vlong)) {
+                            sds element;
+                            if (vstr) {
+                                element = sdsnewlen(vstr, vlen);
+                            } else {
+                                element = sdsfromlonglong(vlong);
+                            }
+                            
+                            if (dictAdd(set_dict, element, NULL) != DICT_OK) {
+                                serverLog(LL_WARNING, "RDB compatibility: Duplicate set element for key=%s", key);
+                                sdsfree(element);
+                                zfree(zl);
+                                decrRefCount(o);
+                                o = NULL;
+                                goto error_cleanup;
+                            }
+                        }
+                        p = ziplistNext(zl, p);
+                    }
+                    
+                    zfree(zl);
+                    break;
+                }
+                    
+                default:
+                    serverLog(LL_WARNING, "RDB compatibility: Unexpected RDB type %s for key=%s", getDataStructureType(rdbtype), key);
+                    decrRefCount(o);
+                    goto error_cleanup;
+            }
+            
+            /* Update statistics for successful conversion */
+            if (conversion_attempted) {
+                rdbDowngradeStatsUpdateWithTypeAndVersion(1, converted_size, key, rdbtype, rdbver);
+            }
+            
+            /* Log successful completion with timing */
+            mstime_t elapsed = mstime() - start_time;
+            serverLog(LL_VERBOSE, "RDB compatibility: Successfully processed key=%s, type=%s in %lldms", key, getDataStructureType(rdbtype), elapsed);
+            
+            /* Clear error and return successfully created object */
+            if (error) *error = 0;
+            return o;
+        }
+    }
+    
+    /* For other cases, fall back to original rdbLoadObject */
+    serverLog(LL_DEBUG, "RDB compatibility: Using standard loader fallback for key=%s, type=%s rdb_v%d",
+              key, getDataStructureType(rdbtype), rdbver);
+    
+    mstime_t fallback_elapsed = mstime() - start_time;
+    serverLog(LL_DEBUG, "RDB compatibility: Fallback completed for key=%s in %lldms", key, fallback_elapsed);
+    
+    return rdbLoadObject(rdbtype, rdb, key);
+
+error_cleanup:
+    /* Comprehensive error cleanup with statistics tracking */
+    if (encoded) {
+        zfree(encoded);
+        encoded = NULL;
+    }
+    
+    /* Update failure statistics */
+    if (conversion_attempted) {
+        rdbDowngradeStatsUpdateWithTypeAndVersion(0, original_size, key, rdbtype, rdbver);
+    }
+    
+    mstime_t error_elapsed = mstime() - start_time;
+    serverLog(LL_WARNING, "RDB compatibility: Failed to process key=%s, type=%s after %lldms", key, getDataStructureType(rdbtype), error_elapsed);
+    
+    if (error) *error = RDB_LOAD_ERR_OTHER;
+    return NULL;
+}
+
+/* Load RDB stream types 19 and 21. Redis 6.0 keeps the stream entries, group
+ * IDs and pending-entry ownership, while newer informational metadata is
+ * consumed and discarded because the older stream structs cannot store it. */
+robj *rdbLoadStreamCompat(rio *rdb, sds key, int *error, int rdbtype) {
+    robj *o = NULL;
+    stream *s = NULL;
+    
+    serverLog(LL_VERBOSE, "RDB compatibility: Loading stream type %d for key=%s", rdbtype, key);
+    
+    if (error) *error = RDB_LOAD_ERR_OTHER;
+    
+    /* Create stream object */
+    o = createStreamObject();
+    if (!o) {
+        serverLog(LL_WARNING, "RDB compatibility: Failed to create stream object for key=%s", key);
+        return NULL;
+    }
+    s = o->ptr;
+    
+    /* Load listpacks count */
+    uint64_t listpacks = rdbLoadLen(rdb, NULL);
+    if (listpacks == RDB_LENERR) {
+        serverLog(LL_WARNING, "RDB compatibility: Failed to load listpacks count for stream key=%s", key);
+        decrRefCount(o);
+        return NULL;
+    }
+    
+    /* Load all listpacks */
+    while (listpacks--) {
+        /* Load master ID */
+        sds nodekey = rdbGenericLoadStringObject(rdb, RDB_LOAD_SDS, NULL);
+        if (!nodekey) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load stream master ID for key=%s", key);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        if (sdslen(nodekey) != sizeof(streamID)) {
+            serverLog(LL_WARNING, "RDB compatibility: Invalid stream node key size for key=%s", key);
+            sdsfree(nodekey);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        /* Load listpack */
+        size_t lp_size;
+        unsigned char *lp = rdbGenericLoadStringObject(rdb, RDB_LOAD_PLAIN, &lp_size);
+        if (!lp) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load stream listpack for key=%s", key);
+            sdsfree(nodekey);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        /* Validate listpack */
+        
+        /* Check if listpack is empty */
+        unsigned char *first = lpFirst(lp);
+        if (!first) {
+            serverLog(LL_WARNING, "RDB compatibility: Empty listpack in stream for key=%s", key);
+            sdsfree(nodekey);
+            zfree(lp);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        /* Insert into radix tree */
+        if (!raxTryInsert(s->rax, (unsigned char*)nodekey, sizeof(streamID), lp, NULL)) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to insert listpack into stream radix tree for key=%s", key);
+            sdsfree(nodekey);
+            zfree(lp);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        sdsfree(nodekey);
+    }
+    
+    /* Load stream metadata */
+    s->length = rdbLoadLen(rdb, NULL);
+    s->last_id.ms = rdbLoadLen(rdb, NULL);
+    s->last_id.seq = rdbLoadLen(rdb, NULL);
+
+    /* Stream type 19 added first ID, maximal deleted ID, and entries-added.
+     * Redis 6.0 has no matching fields, so consume the values to preserve
+     * alignment and retain the representable stream state. */
+    if (rdbtype == RDB_TYPE_STREAM_LISTPACKS_2 ||
+        rdbtype == RDB_TYPE_STREAM_LISTPACKS_3) {
+        for (int i = 0; i < 5; i++) {
+            if (rdbLoadLen(rdb, NULL) == RDB_LENERR) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load extended stream metadata for key=%s", key);
+                decrRefCount(o);
+                return NULL;
+            }
+        }
+    }
+    
+    if (rioGetReadError(rdb)) {
+        serverLog(LL_WARNING, "RDB compatibility: Failed to load stream metadata for key=%s", key);
+        decrRefCount(o);
+        return NULL;
+    }
+    
+    /* Load consumer groups */
+    uint64_t cgroups_count = rdbLoadLen(rdb, NULL);
+    if (cgroups_count == RDB_LENERR) {
+        serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer groups count for stream key=%s", key);
+        decrRefCount(o);
+        return NULL;
+    }
+    
+    while (cgroups_count--) {
+        /* Load consumer group name and ID */
+        streamID cg_id;
+        sds cgname = rdbGenericLoadStringObject(rdb, RDB_LOAD_SDS, NULL);
+        if (!cgname) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer group name for stream key=%s", key);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        cg_id.ms = rdbLoadLen(rdb, NULL);
+        cg_id.seq = rdbLoadLen(rdb, NULL);
+        if (rioGetReadError(rdb)) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer group ID for stream key=%s", key);
+            sdsfree(cgname);
+            decrRefCount(o);
+            return NULL;
+        }
+
+        /* Stream type 19 added the consumer group's entries-read counter. */
+        if (rdbtype == RDB_TYPE_STREAM_LISTPACKS_2 ||
+            rdbtype == RDB_TYPE_STREAM_LISTPACKS_3) {
+            if (rdbLoadLen(rdb, NULL) == RDB_LENERR) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer group offset for stream key=%s", key);
+                sdsfree(cgname);
+                decrRefCount(o);
+                return NULL;
+            }
+        }
+        
+        /* Create consumer group */
+        streamCG *cgroup = streamCreateCG(s, cgname, sdslen(cgname), &cg_id);
+        if (!cgroup) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to create consumer group for stream key=%s", key);
+            sdsfree(cgname);
+            decrRefCount(o);
+            return NULL;
+        }
+        sdsfree(cgname);
+        
+        /* Load global PEL */
+        uint64_t pel_size = rdbLoadLen(rdb, NULL);
+        if (pel_size == RDB_LENERR) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load PEL size for stream key=%s", key);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        while (pel_size--) {
+            unsigned char rawid[sizeof(streamID)];
+            if (rioRead(rdb, rawid, sizeof(rawid)) == 0) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load PEL ID for stream key=%s", key);
+                decrRefCount(o);
+                return NULL;
+            }
+            
+            streamNACK *nack = streamCreateNACK(NULL);
+            nack->delivery_time = rdbLoadMillisecondTime(rdb, RDB_VERSION);
+            nack->delivery_count = rdbLoadLen(rdb, NULL);
+            if (rioGetReadError(rdb)) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load NACK data for stream key=%s", key);
+                decrRefCount(o);
+                streamFreeNACK(nack);
+                return NULL;
+            }
+            
+            if (!raxTryInsert(cgroup->pel, rawid, sizeof(rawid), nack, NULL)) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to insert PEL entry for stream key=%s", key);
+                decrRefCount(o);
+                streamFreeNACK(nack);
+                return NULL;
+            }
+        }
+        
+        /* Load consumers with active_time compatibility */
+        uint64_t consumers_num = rdbLoadLen(rdb, NULL);
+        if (consumers_num == RDB_LENERR) {
+            serverLog(LL_WARNING, "RDB compatibility: Failed to load consumers count for stream key=%s", key);
+            decrRefCount(o);
+            return NULL;
+        }
+        
+        while (consumers_num--) {
+            sds cname = rdbGenericLoadStringObject(rdb, RDB_LOAD_SDS, NULL);
+            if (!cname) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer name for stream key=%s", key);
+                decrRefCount(o);
+                return NULL;
+            }
+            
+            streamConsumer *consumer = streamLookupConsumer(cgroup, cname, SLC_NONE);
+            sdsfree(cname);
+            
+            /* Load seen_time */
+            consumer->seen_time = rdbLoadMillisecondTime(rdb, RDB_VERSION);
+            if (rioGetReadError(rdb)) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer seen_time for stream key=%s", key);
+                decrRefCount(o);
+                return NULL;
+            }
+            
+            /* Stream type 21 added active_time. Redis 6.0 only stores
+             * seen_time, so consume and discard the additional timestamp. */
+            if (rdbtype == RDB_TYPE_STREAM_LISTPACKS_3) {
+                long long active_time = rdbLoadMillisecondTime(rdb, RDB_VERSION);
+                if (rioGetReadError(rdb)) {
+                    serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer active_time for stream key=%s", key);
+                    decrRefCount(o);
+                    return NULL;
+                }
+                
+                serverLog(LL_DEBUG, "RDB compatibility: Read and discarded active_time=%lld for consumer in stream key=%s", active_time, key);
+            }
+            
+            /* Load consumer PEL */
+            uint64_t consumer_pel_size = rdbLoadLen(rdb, NULL);
+            if (consumer_pel_size == RDB_LENERR) {
+                serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer PEL size for stream key=%s", key);
+                decrRefCount(o);
+                return NULL;
+            }
+            
+            while (consumer_pel_size--) {
+                unsigned char rawid[sizeof(streamID)];
+                if (rioRead(rdb, rawid, sizeof(rawid)) == 0) {
+                    serverLog(LL_WARNING, "RDB compatibility: Failed to load consumer PEL ID for stream key=%s", key);
+                    decrRefCount(o);
+                    return NULL;
+                }
+                
+                streamNACK *nack = raxFind(cgroup->pel, rawid, sizeof(rawid));
+                if (nack == raxNotFound) {
+                    serverLog(LL_WARNING, "RDB compatibility: Consumer PEL entry not found in global PEL for stream key=%s", key);
+                    decrRefCount(o);
+                    return NULL;
+                }
+                
+                nack->consumer = consumer;
+                if (!raxTryInsert(consumer->pel, rawid, sizeof(rawid), nack, NULL)) {
+                    serverLog(LL_WARNING, "RDB compatibility: Failed to insert consumer PEL entry for stream key=%s", key);
+                    decrRefCount(o);
+                    return NULL;
+                }
+            }
+        }
+    }
+    
+    serverLog(LL_NOTICE, "RDB compatibility: Successfully loaded stream type %d for key=%s", rdbtype, key);
+    
+    if (error) *error = 0;
+    return o;
+}
+
+/* callback for listpackValidateIntegrity.
+ * The listpack element pointed by 'p' will be converted and stored into ziplist. */
+static int _listpackEntryConvertAndValidate(unsigned char *p, unsigned int head_count, void *userdata) {
+    UNUSED(head_count);
+    unsigned char *str;
+    int64_t vlen;
+    unsigned char intbuf[LP_INTBUF_SIZE];
+    unsigned char **zl = (unsigned char**)userdata;
+
+    str = lpGet(p, &vlen, intbuf);
+    *zl = ziplistPush(*zl, str, vlen, ZIPLIST_TAIL);
+    return 1;
+}
+
+/* Validate the integrity of the data structure while converting it to
+ * ziplist and storing it at 'zl'.
+ * The function is safe to call on non-validated listpacks, it returns 0
+ * when encounter an integrity validation issue. */
+int quicklistConvertAndValidateIntegrity(unsigned char *lp, size_t size,
+                                         unsigned char **zl) {
+    return lpValidateIntegrity(lp, size, 1,
+                               _listpackEntryConvertAndValidate, zl);
+}
diff --git a/src/rdb_downgrade_compat.h b/src/rdb_downgrade_compat.h
new file mode 100644
index 00000000000..d47fc02f6f5
--- /dev/null
+++ b/src/rdb_downgrade_compat.h
@@ -0,0 +1,67 @@
+/*
+ * RDB Downgrade Compatibility Header
+ *
+ * This header provides compatibility functions to enable Redis 6.x
+ * to load compatible RDB files from newer versions (Redis 7.x RDB v10/v11 and
+ * Valkey 8.x/9.x RDB v11/v80) that use supported object types and listpack
+ * encoding instead of ziplist encoding.
+ */
+
+#ifndef __RDB_DOWNGRADE_COMPAT_H
+#define __RDB_DOWNGRADE_COMPAT_H
+
+#include "server.h"
+#include "listpack.h"
+#include "ziplist.h"
+#include "rio.h"
+#include <time.h>
+
+/* RDB versions we want to support for downgrade compatibility */
+#define RDB_VERSION_REDIS_70 10  /* Redis 7.0 */
+#define RDB_VERSION_VALKEY_80 11 /* Redis7.2/Valkey 7.2/8.0+ */
+
+#define QUICKLIST_NODE_CONTAINER_PLAIN 1
+#define QUICKLIST_NODE_CONTAINER_PACKED 2
+
+/* Internal constants for safety limits */
+#define MAX_LISTPACK_SIZE (1024 * 1024 * 16) /* 16MB max listpack size */
+#define MAX_CONVERSION_ELEMENTS                                                \
+  65535 /* Max elements in conversion (fits in uint16_t) */
+#define LISTPACK_MIN_VALID_SIZE 7 /* Minimum valid listpack size */
+
+/* Listpack to Ziplist conversion functions */
+unsigned char *listpackToZiplist(unsigned char *lp);
+int isListpackEncoded(unsigned char *data, size_t len);
+int quicklistConvertAndValidateIntegrity(unsigned char *lp, size_t size,
+                                         unsigned char **zl);
+
+/* Enhanced object loading with compatibility */
+robj *rdbLoadObjectCompat(int rdbtype, rio *rdb, sds key, int *error,
+                          int rdbver);
+
+/* Load newer stream encodings while discarding metadata Redis 6 cannot store. */
+robj *rdbLoadStreamCompat(rio *rdb, sds key, int *error, int rdbtype);
+
+/* Version compatibility checks */
+int requiresListpackConversion(int rdbtype, int rdbver);
+const char *rdbDowngradeUnsupportedTypeReason(int type);
+int rdbLoadSlotInfoCompat(rio *rdb);
+
+/* Production monitoring and statistics */
+struct rdbDowngradeStats {
+  unsigned long long keys_attempted;
+  unsigned long long keys_succeeded;
+  unsigned long long keys_failed;
+  unsigned long long bytes_converted;
+  unsigned long long keys_converted;
+  time_t last_conversion_time;
+};
+
+extern struct rdbDowngradeStats rdb_downgrade_stats;
+
+/* Statistics and monitoring functions */
+void rdbDowngradeStatsUpdateWithType(int success, size_t bytes, const char *key,
+                                     int rdbtype);
+sds rdbDowngradeStatsInfoString(void);
+
+#endif /* __RDB_DOWNGRADE_COMPAT_H */
diff --git a/src/redis-check-rdb.c b/src/redis-check-rdb.c
index 7a6a2caabef..d44e99db829 100644
--- a/src/redis-check-rdb.c
+++ b/src/redis-check-rdb.c
@@ -30,7 +30,9 @@
 #include "mt19937-64.h"
 #include "server.h"
 #include "rdb.h"
+#include "rdb_downgrade_compat.h"
 
+#include <stdbool.h>
 #include <stdarg.h>
 #include <sys/time.h>
 #include <unistd.h>
@@ -187,6 +189,7 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
     char buf[1024];
     long long expiretime, now = mstime();
     static rio rdb; /* Pointed by global struct riostate. */
+    bool is_valkey_magic;
 
     int closefile = (fp == NULL);
     if (fp == NULL && (fp = fopen(rdbfilename,"r")) == NULL) return 1;
@@ -196,15 +199,26 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
     rdb.update_cksum = rdbLoadProgressCallback;
     if (rioRead(&rdb,buf,9) == 0) goto eoferr;
     buf[9] = '\0';
-    if (memcmp(buf,"REDIS",5) != 0) {
+    if (memcmp(buf, "REDIS0", 6) == 0) {
+        is_valkey_magic = false;
+    } else if (memcmp(buf, "VALKEY", 6) == 0) {
+        is_valkey_magic = true;
+    } else {
         rdbCheckError("Wrong signature trying to load DB from file");
         goto err;
     }
-    rdbver = atoi(buf+5);
-    if (rdbver < 1 || rdbver > RDB_VERSION) {
+    rdbver = atoi(buf + 6);
+    if (rdbver < 1 ||
+        (rdbver >= RDB_FOREIGN_VERSION_MIN && !is_valkey_magic) ||
+        (rdbver > RDB_VERSION && server.rdb_version_check == RDB_VERSION_CHECK_STRICT)) {
         rdbCheckError("Can't handle RDB format version %d",rdbver);
         goto err;
     }
+    
+    /* Log compatibility mode for higher versions */
+    if (rdbver > RDB_VERSION) {
+        rdbCheckInfo("RDB version %d detected, using downgrade compatibility (current version: %d)", rdbver, RDB_VERSION);
+    }
 
     expiretime = -1;
     startLoadingFile(fp, rdbfilename, RDBFLAGS_NONE);
@@ -215,6 +229,12 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
         rdbstate.doing = RDB_CHECK_DOING_READ_TYPE;
         if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
 
+        const char *unsupported = rdbDowngradeUnsupportedTypeReason(type);
+        if (unsupported) {
+            rdbCheckError("Cannot downgrade %s to Redis 6.0", unsupported);
+            goto err;
+        }
+
         /* Handle special types. */
         if (type == RDB_OPCODE_EXPIRETIME) {
             rdbstate.doing = RDB_CHECK_DOING_READ_EXPIRE;
@@ -261,6 +281,9 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
             if ((expires_size = rdbLoadLen(&rdb,NULL)) == RDB_LENERR)
                 goto eoferr;
             continue; /* Read type again. */
+        } else if (type == RDB_OPCODE_SLOT_INFO) {
+            if (rdbLoadSlotInfoCompat(&rdb) == C_ERR) goto eoferr;
+            continue; /* Read type again. */
         } else if (type == RDB_OPCODE_AUX) {
             /* AUX: generic string-string fields. Use to add state to RDB
              * which is backward compatible. Implementations of RDB loading
@@ -307,7 +330,7 @@ int redis_check_rdb(char *rdbfilename, FILE *fp) {
         rdbstate.keys++;
         /* Read value */
         rdbstate.doing = RDB_CHECK_DOING_READ_OBJECT_VALUE;
-        if ((val = rdbLoadObject(type,&rdb,key->ptr)) == NULL) goto eoferr;
+        if ((val = rdbLoadObjectCompat(type,&rdb,key->ptr,NULL,rdbver)) == NULL) goto eoferr;
         /* Check if the key already expired. */
         if (expiretime != -1 && expiretime < now)
             rdbstate.already_expired++;
diff --git a/src/server.c b/src/server.c
index 5f335905e53..d9c446751fb 100644
--- a/src/server.c
+++ b/src/server.c
@@ -34,6 +34,7 @@
 #include "latency.h"
 #include "atomicvar.h"
 #include "mt19937-64.h"
+#include "rdb_downgrade_compat.h"
 
 #include <time.h>
 #include <signal.h>
@@ -4164,6 +4165,7 @@ sds genRedisInfoString(const char *section) {
         info = sdscatfmt(info,
             "# Server\r\n"
             "redis_version:%s\r\n"
+            "rdb_version:%i\r\n"
             "redis_git_sha1:%s\r\n"
             "redis_git_dirty:%i\r\n"
             "redis_build_id:%s\r\n"
@@ -4185,6 +4187,7 @@ sds genRedisInfoString(const char *section) {
             "config_file:%s\r\n"
             "io_threads_active:%i\r\n",
             REDIS_VERSION,
+            RDB_VERSION,
             redisGitSHA1(),
             strtol(redisGitDirty(),NULL,10) > 0,
             redisBuildIdString(),
@@ -4443,6 +4446,11 @@ sds genRedisInfoString(const char *section) {
                 (intmax_t)eta
             );
         }
+        
+        /* Add RDB downgrade compatibility statistics */
+        sds rdb_compat_info = rdbDowngradeStatsInfoString();
+        info = sdscat(info, rdb_compat_info);
+        sdsfree(rdb_compat_info);
     }
 
     /* Stats */
@@ -4718,17 +4726,25 @@ sds genRedisInfoString(const char *section) {
         }
     }
 
+    /* RDB Downgrade Stats (standalone section) */
+   if (allsections || !strcasecmp(section,"RDBDowngradeStats")) {
+       if (sections++) info = sdscat(info,"\r\n");
+       sds rdb_compat_info = rdbDowngradeStatsInfoString();
+       info = sdscat(info, rdb_compat_info);
+       sdsfree(rdb_compat_info);
+   }
+
     /* Get info from modules.
      * if user asked for "everything" or "modules", or a specific section
      * that's not found yet. */
-    if (everything || modules ||
-        (!allsections && !defsections && sections==0)) {
-        info = modulesCollectInfo(info,
-                                  everything || modules ? NULL: section,
-                                  0, /* not a crash report */
-                                  sections);
-    }
-    return info;
+   if (everything || modules ||
+       (!allsections && !defsections && sections==0)) {
+       info = modulesCollectInfo(info,
+                                 everything || modules ? NULL: section,
+                                 0, /* not a crash report */
+                                 sections);
+   }
+   return info;
 }
 
 void infoCommand(client *c) {
diff --git a/src/server.h b/src/server.h
index 8bd00f80c56..ccdc4a2e11e 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1055,6 +1055,9 @@ typedef struct redisTLSContextConfig {
  * Global server state
  *----------------------------------------------------------------------------*/
 
+typedef enum { RDB_VERSION_CHECK_STRICT = 0,
+    RDB_VERSION_CHECK_RELAXED } rdb_version_check_type;
+
 struct clusterState;
 
 /* AIX defines hz to __hz, we don't use this define and in order to allow
@@ -1197,6 +1200,7 @@ struct redisServer {
     long long stat_io_writes_processed; /* Number of write events processed by IO / Main threads */
     _Atomic long long stat_total_reads_processed; /* Total number of read events processed */
     _Atomic long long stat_total_writes_processed; /* Total number of write events processed */
+    long long stat_dump_payload_sanitizations; /* Number of payload sanitizations on RDB load */
     /* The following two are used to track instantaneous metrics, like
      * number of operations per second, network traffic. */
     struct {
@@ -1213,6 +1217,7 @@ struct redisServer {
     int active_expire_effort;       /* From 1 (default) to 10, active effort. */
     int active_defrag_enabled;
     int jemalloc_bg_thread;         /* Enable jemalloc background thread */
+    int rdb_version_check;          /* Try to load RDB produced by a future version. */
     size_t active_defrag_ignore_bytes; /* minimum amount of fragmentation waste to start active defrag */
     int active_defrag_threshold_lower; /* minimum percentage of fragmentation to start active defrag */
     int active_defrag_threshold_upper; /* maximum percentage of fragmentation at which we use maximum effort */
diff --git a/src/t_string.c b/src/t_string.c
index 9d2d17d61d3..65371f675d5 100644
--- a/src/t_string.c
+++ b/src/t_string.c
@@ -70,18 +70,32 @@ static int checkStringLength(client *c, long long size, long long append) {
 #define OBJ_SET_EX (1<<2)          /* Set if time in seconds is given */
 #define OBJ_SET_PX (1<<3)          /* Set if time in ms in given */
 #define OBJ_SET_KEEPTTL (1<<4)     /* Set and keep the ttl */
+#define OBJ_SET_EXAT (1<<5)        /* Set if absolute time in seconds is given */
+#define OBJ_SET_PXAT (1<<6)        /* Set if absolute time in ms is given */
 
 void setGenericCommand(client *c, int flags, robj *key, robj *val, robj *expire, int unit, robj *ok_reply, robj *abort_reply) {
     long long milliseconds = 0; /* initialized to avoid any harmness warning */
+    long long when = 0;
 
     if (expire) {
         if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != C_OK)
             return;
-        if (milliseconds <= 0) {
+        if (milliseconds <= 0 ||
+            (unit == UNIT_SECONDS && milliseconds > LLONG_MAX / 1000))
+        {
             addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
             return;
         }
         if (unit == UNIT_SECONDS) milliseconds *= 1000;
+        when = milliseconds;
+        if (!(flags & OBJ_SET_EXAT) && !(flags & OBJ_SET_PXAT)) {
+            long long now = mstime();
+            if (milliseconds > LLONG_MAX - now) {
+                addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
+                return;
+            }
+            when += now;
+        }
     }
 
     if ((flags & OBJ_SET_NX && lookupKeyWrite(c->db,key) != NULL) ||
@@ -92,14 +106,15 @@ void setGenericCommand(client *c, int flags, robj *key, robj *val, robj *expire,
     }
     genericSetKey(c,c->db,key,val,flags & OBJ_SET_KEEPTTL,1);
     server.dirty++;
-    if (expire) setExpire(c,c->db,key,mstime()+milliseconds);
+    if (expire) setExpire(c,c->db,key,when);
     notifyKeyspaceEvent(NOTIFY_STRING,"set",key,c->db->id);
     if (expire) notifyKeyspaceEvent(NOTIFY_GENERIC,
         "expire",key,c->db->id);
     addReply(c, ok_reply ? ok_reply : shared.ok);
 }
 
-/* SET key value [NX] [XX] [KEEPTTL] [EX <seconds>] [PX <milliseconds>] */
+/* SET key value [NX] [XX] [KEEPTTL] [EX <seconds>] [PX <milliseconds>]
+ *     [EXAT <seconds-timestamp>] [PXAT <milliseconds-timestamp>] */
 void setCommand(client *c) {
     int j;
     robj *expire = NULL;
@@ -121,13 +136,16 @@ void setCommand(client *c) {
         {
             flags |= OBJ_SET_XX;
         } else if (!strcasecmp(c->argv[j]->ptr,"KEEPTTL") &&
-                   !(flags & OBJ_SET_EX) && !(flags & OBJ_SET_PX))
+                   !(flags & OBJ_SET_EX) && !(flags & OBJ_SET_PX) &&
+                   !(flags & OBJ_SET_EXAT) && !(flags & OBJ_SET_PXAT))
         {
             flags |= OBJ_SET_KEEPTTL;
         } else if ((a[0] == 'e' || a[0] == 'E') &&
                    (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                    !(flags & OBJ_SET_KEEPTTL) &&
-                   !(flags & OBJ_SET_PX) && next)
+                   !(flags & OBJ_SET_PX) &&
+                   !(flags & OBJ_SET_EXAT) &&
+                   !(flags & OBJ_SET_PXAT) && next)
         {
             flags |= OBJ_SET_EX;
             unit = UNIT_SECONDS;
@@ -136,12 +154,40 @@ void setCommand(client *c) {
         } else if ((a[0] == 'p' || a[0] == 'P') &&
                    (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                    !(flags & OBJ_SET_KEEPTTL) &&
-                   !(flags & OBJ_SET_EX) && next)
+                   !(flags & OBJ_SET_EX) &&
+                   !(flags & OBJ_SET_EXAT) &&
+                   !(flags & OBJ_SET_PXAT) && next)
         {
             flags |= OBJ_SET_PX;
             unit = UNIT_MILLISECONDS;
             expire = next;
             j++;
+        } else if ((a[0] == 'e' || a[0] == 'E') &&
+                   (a[1] == 'x' || a[1] == 'X') &&
+                   (a[2] == 'a' || a[2] == 'A') &&
+                   (a[3] == 't' || a[3] == 'T') && a[4] == '\0' &&
+                   !(flags & OBJ_SET_KEEPTTL) &&
+                   !(flags & OBJ_SET_EX) &&
+                   !(flags & OBJ_SET_PX) &&
+                   !(flags & OBJ_SET_PXAT) && next)
+        {
+            flags |= OBJ_SET_EXAT;
+            unit = UNIT_SECONDS;
+            expire = next;
+            j++;
+        } else if ((a[0] == 'p' || a[0] == 'P') &&
+                   (a[1] == 'x' || a[1] == 'X') &&
+                   (a[2] == 'a' || a[2] == 'A') &&
+                   (a[3] == 't' || a[3] == 'T') && a[4] == '\0' &&
+                   !(flags & OBJ_SET_KEEPTTL) &&
+                   !(flags & OBJ_SET_EX) &&
+                   !(flags & OBJ_SET_PX) &&
+                   !(flags & OBJ_SET_EXAT) && next)
+        {
+            flags |= OBJ_SET_PXAT;
+            unit = UNIT_MILLISECONDS;
+            expire = next;
+            j++;
         } else {
             addReply(c,shared.syntaxerr);
             return;
@@ -729,4 +775,3 @@ void stralgoLCS(client *c) {
     if (objb) decrRefCount(objb);
     return;
 }
-
diff --git a/tests/assets/encodings-rdb-valkey-11.rdb b/tests/assets/encodings-rdb-valkey-11.rdb
new file mode 100644
index 00000000000..29b909c1a9d
Binary files /dev/null and b/tests/assets/encodings-rdb-valkey-11.rdb differ
diff --git a/tests/assets/encodings-rdb-version-10.rdb b/tests/assets/encodings-rdb-version-10.rdb
new file mode 100644
index 00000000000..4e9428f1141
Binary files /dev/null and b/tests/assets/encodings-rdb-version-10.rdb differ
diff --git a/tests/assets/encodings-rdb-version-11.rdb b/tests/assets/encodings-rdb-version-11.rdb
new file mode 100644
index 00000000000..5459b3c78a2
Binary files /dev/null and b/tests/assets/encodings-rdb-version-11.rdb differ
diff --git a/tests/assets/encodings-rdb-version-9.rdb b/tests/assets/encodings-rdb-version-9.rdb
new file mode 100644
index 00000000000..a23d916e649
Binary files /dev/null and b/tests/assets/encodings-rdb-version-9.rdb differ
diff --git a/tests/assets/encodings-rdb-version-987.rdb b/tests/assets/encodings-rdb-version-987.rdb
new file mode 100644
index 00000000000..23576715977
Binary files /dev/null and b/tests/assets/encodings-rdb-version-987.rdb differ
diff --git a/tests/assets/encodings-rdb987.rdb b/tests/assets/encodings-rdb987.rdb
new file mode 100644
index 00000000000..23576715977
Binary files /dev/null and b/tests/assets/encodings-rdb987.rdb differ
diff --git a/tests/assets/redis-6.0.16-no-patch.rdb b/tests/assets/redis-6.0.16-no-patch.rdb
new file mode 100644
index 00000000000..5896bddf618
Binary files /dev/null and b/tests/assets/redis-6.0.16-no-patch.rdb differ
diff --git a/tests/assets/redis-6.0.16-with-patch.rdb b/tests/assets/redis-6.0.16-with-patch.rdb
new file mode 100644
index 00000000000..5896bddf618
Binary files /dev/null and b/tests/assets/redis-6.0.16-with-patch.rdb differ
diff --git a/tests/assets/redis-6.2.7-no-patch.rdb b/tests/assets/redis-6.2.7-no-patch.rdb
new file mode 100644
index 00000000000..10a9ee346b7
Binary files /dev/null and b/tests/assets/redis-6.2.7-no-patch.rdb differ
diff --git a/tests/assets/redis-6.2.7-with-patch.rdb b/tests/assets/redis-6.2.7-with-patch.rdb
new file mode 100644
index 00000000000..ce8ac7bc96d
Binary files /dev/null and b/tests/assets/redis-6.2.7-with-patch.rdb differ
diff --git a/tests/assets/redis-7.0.15-no-patch.rdb b/tests/assets/redis-7.0.15-no-patch.rdb
new file mode 100644
index 00000000000..35e466cbb80
Binary files /dev/null and b/tests/assets/redis-7.0.15-no-patch.rdb differ
diff --git a/tests/assets/redis-7.0.15-with-patch.rdb b/tests/assets/redis-7.0.15-with-patch.rdb
new file mode 100644
index 00000000000..6dbe4f5fe50
Binary files /dev/null and b/tests/assets/redis-7.0.15-with-patch.rdb differ
diff --git a/tests/assets/valkey-8.0.4-no-patch.rdb b/tests/assets/valkey-8.0.4-no-patch.rdb
new file mode 100644
index 00000000000..c9479f1faf5
Binary files /dev/null and b/tests/assets/valkey-8.0.4-no-patch.rdb differ
diff --git a/tests/assets/valkey-9.0.0-no-patch.rdb b/tests/assets/valkey-9.0.0-no-patch.rdb
new file mode 100644
index 00000000000..0beeb52a823
Binary files /dev/null and b/tests/assets/valkey-9.0.0-no-patch.rdb differ
diff --git a/tests/assets/valkey-9.1.0-function.rdb b/tests/assets/valkey-9.1.0-function.rdb
new file mode 100644
index 00000000000..60d5de2c5ce
Binary files /dev/null and b/tests/assets/valkey-9.1.0-function.rdb differ
diff --git a/tests/assets/valkey-9.1.0-hfe.rdb b/tests/assets/valkey-9.1.0-hfe.rdb
new file mode 100644
index 00000000000..0b226713008
Binary files /dev/null and b/tests/assets/valkey-9.1.0-hfe.rdb differ
diff --git a/tests/assets/valkey-9.1.0-no-patch.rdb b/tests/assets/valkey-9.1.0-no-patch.rdb
new file mode 100644
index 00000000000..592dd450140
Binary files /dev/null and b/tests/assets/valkey-9.1.0-no-patch.rdb differ
diff --git a/tests/assets/valkey-9.1.0-slot-import.rdb b/tests/assets/valkey-9.1.0-slot-import.rdb
new file mode 100644
index 00000000000..b9b58f601d0
Binary files /dev/null and b/tests/assets/valkey-9.1.0-slot-import.rdb differ
diff --git a/tests/assets/valkey-9.1.0-stream.rdb b/tests/assets/valkey-9.1.0-stream.rdb
new file mode 100644
index 00000000000..4c558c8152f
Binary files /dev/null and b/tests/assets/valkey-9.1.0-stream.rdb differ
diff --git a/tests/integration/rdb-downgrade-integration.tcl b/tests/integration/rdb-downgrade-integration.tcl
new file mode 100644
index 00000000000..67fab5591ef
--- /dev/null
+++ b/tests/integration/rdb-downgrade-integration.tcl
@@ -0,0 +1,1410 @@
+tags {"rdb downgrade integration"} {
+
+# Test loading RDB version 9 encodings
+set server_path [tmpdir "server.rdb-v9-encodings"]
+exec cp tests/assets/encodings-rdb-version-9.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load RDB v9 encodings and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_match "a*" [r get compressible]
+
+        # Verify hash keys
+        assert_equal [r type hash] "hash"
+        assert_equal [r hget hash a] "1"
+        assert_equal [r hget hash eee] "5000000000"
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hget hash_zipped a] "1"
+
+        # Verify set keys
+        assert_equal [r type set] "set"
+        assert [r sismember set "1"]
+        assert [r sismember set "a"]
+        assert_equal [r type set_zipped_1] "set"
+        assert [r sismember set_zipped_1 "1"]
+        assert_equal [r type set_zipped_2] "set"
+        assert [r sismember set_zipped_2 "100000"]
+        assert_equal [r type set_zipped_3] "set"
+        assert [r sismember set_zipped_3 "1000000000"]
+
+        # Verify list keys
+        assert_equal [r type list] "list"
+        assert [expr {[r llen list] > 0}]
+        assert_equal [r type list_zipped] "list"
+        assert [expr {[r llen list_zipped] > 0}]
+
+        # Verify zset keys
+        assert_equal [r type zset] "zset"
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zscore zset_zipped a] "1"
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading RDB version 10 encodings
+set server_path [tmpdir "server.rdb-v10-encodings"]
+exec cp tests/assets/encodings-rdb-version-10.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load RDB v10 encodings and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_match "a*" [r get compressible]
+
+        # Verify hash keys and values
+        assert_equal [r type hash] "hash"
+        assert_equal [r hget hash a] "1"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash eee] "5000000000"
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped c] "3"
+
+        # Verify set keys and members
+        assert_equal [r type set] "set"
+        assert [r sismember set "1"]
+        assert [r sismember set "a"]
+        assert [r sismember set "6000000000"]
+        assert_equal [r type set_zipped_1] "set"
+        assert [r sismember set_zipped_1 "1"]
+        assert_equal [r type set_zipped_2] "set"
+        assert [r sismember set_zipped_2 "100000"]
+        assert_equal [r type set_zipped_3] "set"
+        assert [r sismember set_zipped_3 "1000000000"]
+
+        # Verify list keys and elements
+        assert_equal [r type list] "list"
+        assert [expr {[r llen list] > 0}]
+        assert_equal [r lindex list 0] "1"
+        assert_equal [r type list_zipped] "list"
+        assert [expr {[r llen list_zipped] > 0}]
+        assert_equal [r lindex list_zipped 0] "1"
+
+        # Verify zset keys and scores
+        assert_equal [r type zset] "zset"
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading RDB version 11 encodings
+set server_path [tmpdir "server.rdb-v11-encodings"]
+exec cp tests/assets/encodings-rdb-version-11.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load RDB v11 encodings and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_match "a*" [r get compressible]
+
+        # Verify hash structures and specific fields
+        assert_equal [r type hash] "hash"
+        assert_equal [r hget hash a] "1"
+        assert_equal [r hget hash aa] "10"
+        assert_equal [r hget hash aaa] "100"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        # Verify set structures and memberships
+        assert_equal [r type set] "set"
+        assert [r sismember set "1"]
+        assert [r sismember set "2"]
+        assert [r sismember set "a"]
+        assert [r sismember set "6000000000"]
+        assert_equal [r type set_zipped_1] "set"
+        assert [r sismember set_zipped_1 "1"]
+        assert_equal [r type set_zipped_2] "set"
+        assert [r sismember set_zipped_2 "100000"]
+        assert_equal [r type set_zipped_3] "set"
+        assert [r sismember set_zipped_3 "1000000000"]
+
+        # Verify list structures and elements
+        assert_equal [r type list] "list"
+        assert [expr {[r llen list] > 0}]
+        assert_equal [r lindex list 0] "1"
+        assert_equal [r lindex list 3] "a"
+        assert_equal [r type list_zipped] "list"
+        assert [expr {[r llen list_zipped] > 0}]
+        assert_equal [r lindex list_zipped 0] "1"
+
+        # Verify sorted set structures and scores
+        assert_equal [r type zset] "zset"
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset cccc] "123456789"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading RDB version 11 from Valkey encodings
+set server_path [tmpdir "server.rdb-v11-valkey-encodings"]
+exec cp tests/assets/encodings-rdb-valkey-11.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load RDB v11 from Valkey encodings and verify keys" {
+        r select 0
+
+        # Verify string keys from Valkey RDB
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_match "a*" [r get compressible]
+
+        # Verify hash keys from Valkey
+        assert_equal [r type hash] "hash"
+        assert_equal [r hget hash a] "1"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash eee] "5000000000"
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped c] "3"
+
+        # Verify set keys from Valkey
+        assert_equal [r type set] "set"
+        assert [r sismember set "1"]
+        assert [r sismember set "a"]
+        assert_equal [r type set_zipped_1] "set"
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "4"]
+
+        # Verify list keys from Valkey
+        assert_equal [r type list] "list"
+        assert [expr {[r llen list] > 0}]
+        assert_equal [r lindex list 0] "1"
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r lindex list_zipped 2] "3"
+
+        # Verify zset keys from Valkey
+        assert_equal [r type zset] "zset"
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zscore zset_zipped b] "2"
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading RDB version 987 (future version) - should succeed with default settings
+set server_path [tmpdir "server.rdb-v987"]
+exec cp tests/assets/encodings-rdb-version-987.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "RDB v987 future version loading with relaxed check" {
+        r select 0
+
+        # Verify all keys from future version RDB are loaded correctly
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_match "a*" [r get compressible]
+
+        # Verify hash keys from future version
+        assert_equal [r type hash] "hash"
+        assert_equal [r hget hash a] "1"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash eee] "5000000000"
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        # Verify set keys from future version
+        assert_equal [r type set] "set"
+        assert [r sismember set "1"]
+        assert [r sismember set "a"]
+        assert [r sismember set "6000000000"]
+        assert_equal [r type set_zipped_1] "set"
+        assert [r sismember set_zipped_1 "1"]
+        assert_equal [r type set_zipped_2] "set"
+        assert [r sismember set_zipped_2 "100000"]
+        assert_equal [r type set_zipped_3] "set"
+        assert [r sismember set_zipped_3 "1000000000"]
+
+        # Verify list keys from future version
+        assert_equal [r type list] "list"
+        assert_equal [r lindex list 0] "1"
+        assert_equal [r lindex list 3] "a"
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r lindex list_zipped 0] "1"
+
+        # Verify zset keys from future version
+        assert_equal [r type zset] "zset"
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify RDBDowngradeStats for future version
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+# Test loading Redis 6.0.16 no-patch RDB
+set server_path [tmpdir "server.redis-6.0.16-no-patch"]
+exec cp tests/assets/redis-6.0.16-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 6.0.16 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Redis 6.0.16 with-patch RDB
+set server_path [tmpdir "server.redis-6.0.16-with-patch"]
+exec cp tests/assets/redis-6.0.16-with-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 6.0.16 with-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (patch version should show downgrade activity)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Redis 6.2.7 no-patch RDB
+set server_path [tmpdir "server.redis-6.2.7-no-patch"]
+exec cp tests/assets/redis-6.2.7-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 6.2.7 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Redis 6.2.7 with-patch RDB
+set server_path [tmpdir "server.redis-6.2.7-with-patch"]
+exec cp tests/assets/redis-6.2.7-with-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 6.2.7 with-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (patch version should show downgrade activity)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Redis 7.0.15 no-patch RDB
+set server_path [tmpdir "server.redis-7.0.15-no-patch"]
+exec cp tests/assets/redis-7.0.15-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 7.0.15 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Redis 7.0.15 with-patch RDB
+set server_path [tmpdir "server.redis-7.0.15-with-patch"]
+exec cp tests/assets/redis-7.0.15-with-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Redis 7.0.15 with-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (patch version should show downgrade activity)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Valkey 8.0.4 no-patch RDB
+set server_path [tmpdir "server.valkey-8.0.4-no-patch"]
+exec cp tests/assets/valkey-8.0.4-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Valkey 8.0.4 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (Valkey RDB should trigger downgrade)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Valkey 9.0.0 no-patch RDB
+set server_path [tmpdir "server.valkey-9.0.0-no-patch"]
+exec cp tests/assets/valkey-9.0.0-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Valkey 9.0.0 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (Valkey RDB should trigger downgrade)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading Valkey 9.1.0 no-patch RDB
+set server_path [tmpdir "server.valkey-9.1.0-no-patch"]
+exec cp tests/assets/valkey-9.1.0-no-patch.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Valkey 9.1.0 no-patch RDB and verify keys" {
+        r select 0
+
+        # Verify string keys
+        assert_equal [r get string] "Hello World"
+        assert_equal [r get number] "10"
+        assert_equal [r get a] "1"
+        set compressible_value [r get compressible]
+        assert_match "a*" $compressible_value
+        assert_equal [string length $compressible_value] 130
+
+        # Verify sorted sets
+        assert_equal [r type zset] "zset"
+        assert_equal [r zcard zset] 12
+        assert_equal [r zscore zset a] "1"
+        assert_equal [r zscore zset aa] "10"
+        assert_equal [r zscore zset aaa] "100"
+        assert_equal [r zscore zset aaaa] "1000"
+        assert_equal [r zscore zset b] "2"
+        assert_equal [r zscore zset bb] "20"
+        assert_equal [r zscore zset bbb] "200"
+        assert_equal [r zscore zset bbbb] "5000000000"
+        assert_equal [r zscore zset c] "3"
+        assert_equal [r zscore zset cc] "30"
+        assert_equal [r zscore zset ccc] "300"
+        assert_equal [r zscore zset cccc] "123456789"
+
+        assert_equal [r type zset_zipped] "zset"
+        assert_equal [r zcard zset_zipped] 3
+        assert_equal [r zscore zset_zipped a] "1"
+        assert_equal [r zscore zset_zipped b] "2"
+        assert_equal [r zscore zset_zipped c] "3"
+
+        # Verify sets
+        assert_equal [r type set_zipped_1] "set"
+        assert_equal [r scard set_zipped_1] 4
+        assert [r sismember set_zipped_1 "1"]
+        assert [r sismember set_zipped_1 "2"]
+        assert [r sismember set_zipped_1 "3"]
+        assert [r sismember set_zipped_1 "4"]
+
+        assert_equal [r type set_zipped_2] "set"
+        assert_equal [r scard set_zipped_2] 6
+        assert [r sismember set_zipped_2 "100000"]
+        assert [r sismember set_zipped_2 "200000"]
+        assert [r sismember set_zipped_2 "300000"]
+        assert [r sismember set_zipped_2 "400000"]
+        assert [r sismember set_zipped_2 "500000"]
+        assert [r sismember set_zipped_2 "600000"]
+
+        assert_equal [r type set_zipped_3] "set"
+        assert_equal [r scard set_zipped_3] 6
+        assert [r sismember set_zipped_3 "1000000000000"]
+        assert [r sismember set_zipped_3 "2000000000000"]
+        assert [r sismember set_zipped_3 "3000000000000"]
+        assert [r sismember set_zipped_3 "4000000000000"]
+        assert [r sismember set_zipped_3 "5000000000000"]
+        assert [r sismember set_zipped_3 "6000000000000"]
+
+        assert_equal [r type set] "set"
+        assert_equal [r scard set] 4
+        assert [r sismember set "6000000000"]
+        assert [r sismember set "a"]
+        assert [r sismember set "b"]
+        assert [r sismember set "c"]
+
+        # Verify lists (LPUSH order is reversed)
+        assert_equal [r type list_zipped] "list"
+        assert_equal [r llen list_zipped] 6
+        assert_equal [r lindex list_zipped 0] "c"
+        assert_equal [r lindex list_zipped 1] "b"
+        assert_equal [r lindex list_zipped 2] "a"
+        assert_equal [r lindex list_zipped 3] "3"
+        assert_equal [r lindex list_zipped 4] "2"
+        assert_equal [r lindex list_zipped 5] "1"
+
+        assert_equal [r type list] "list"
+        assert_equal [r llen list] 7
+        assert_equal [r lindex list 0] "c"
+        assert_equal [r lindex list 1] "b"
+        assert_equal [r lindex list 2] "a"
+        assert_equal [r lindex list 3] "3"
+        assert_equal [r lindex list 4] "2"
+        assert_equal [r lindex list 5] "1"
+        assert_equal [r lindex list 6] "6000000000"
+
+        # Verify hashes
+        assert_equal [r type hash_zipped] "hash"
+        assert_equal [r hlen hash_zipped] 3
+        assert_equal [r hget hash_zipped a] "1"
+        assert_equal [r hget hash_zipped b] "2"
+        assert_equal [r hget hash_zipped c] "3"
+
+        assert_equal [r type hash] "hash"
+        assert_equal [r hlen hash] 10
+        assert_equal [r hget hash a] "10"
+        assert_equal [r hget hash aa] "100"
+        assert_equal [r hget hash b] "2"
+        assert_equal [r hget hash bb] "20"
+        assert_equal [r hget hash bbb] "200"
+        assert_equal [r hget hash c] "3"
+        assert_equal [r hget hash cc] "30"
+        assert_equal [r hget hash ccc] "300"
+        assert_equal [r hget hash ddd] "400"
+        assert_equal [r hget hash eee] "5000000000"
+
+        # Verify total key count
+        assert_equal [r dbsize] 14
+
+        # Verify RDBDowngradeStats (Valkey RDB should trigger downgrade)
+        set info [r info RDBDowngradeStats]
+        assert_match "*rdb_downgrade_keys_attempted:*" $info
+        assert_match "*rdb_downgrade_keys_succeeded:*" $info
+        assert_match "*rdb_downgrade_bytes_converted:*" $info
+    }
+}
+
+# Test loading a Valkey 9.1 stream with extended metadata, a consumer group,
+# and a pending entry.
+set server_path [tmpdir "server.valkey-9.1.0-stream"]
+exec cp tests/assets/valkey-9.1.0-stream.rdb $server_path/dump.rdb
+start_server [list overrides [list "dir" $server_path "dbfilename" "dump.rdb"]] {
+    test "Load Valkey 9.1.0 stream RDB and preserve representable state" {
+        r select 0
+        assert_equal 2 [r xlen mystream]
+
+        set entries [r xrange mystream - +]
+        assert_equal 2 [llength $entries]
+        assert_equal "1-0" [lindex [lindex $entries 0] 0]
+        assert_equal {field value1} [lindex [lindex $entries 0] 1]
+        assert_equal "2-0" [lindex [lindex $entries 1] 0]
+        assert_equal {field value2} [lindex [lindex $entries 1] 1]
+
+        set pending [r xpending mystream mygroup - + 10]
+        assert_equal 1 [llength $pending]
+        assert_equal "1-0" [lindex [lindex $pending 0] 0]
+        assert_equal "Alice" [lindex [lindex $pending 0] 1]
+    }
+}
+
+foreach {feature fixture reason} {
+    "hash-field expiration" "valkey-9.1.0-hfe.rdb" "hash-field expiration data"
+    "function libraries" "valkey-9.1.0-function.rdb" "function library data"
+    "atomic slot migration" "valkey-9.1.0-slot-import.rdb" "active atomic slot migration state"
+} {
+    test "Reject Valkey 9.1.0 $feature with a downgrade compatibility error" {
+        set status [catch {
+            exec src/redis-check-rdb tests/assets/$fixture 2>@1
+        } output]
+        assert_equal 1 $status
+        assert_match "*Cannot downgrade $reason to Redis 6.0*" $output
+    }
+}
+
+} ;# tags
diff --git a/tests/integration/rdb.tcl b/tests/integration/rdb.tcl
index 58dc6c9684e..4204b81aeaa 100644
--- a/tests/integration/rdb.tcl
+++ b/tests/integration/rdb.tcl
@@ -1,13 +1,21 @@
+# Helper function to start a server and kill it, just to check the error
+# logged.
+set defaults {}
+proc start_server_and_kill_it {overrides code} {
+    upvar defaults defaults srv srv server_path server_path
+    set config [concat $defaults $overrides]
+    set srv [start_server [list overrides $config keep_persistence true]]
+    uplevel 1 $code
+    kill_server $srv
+}
+
 set server_path [tmpdir "server.rdb-encoding-test"]
 
 # Copy RDB with different encodings in server path
 exec cp tests/assets/encodings.rdb $server_path
+exec cp tests/assets/encodings-rdb987.rdb $server_path
 
-start_server [list overrides [list "dir" $server_path "dbfilename" "encodings.rdb"]] {
-  test "RDB encoding loading test" {
-    r select 0
-    csvdump r
-  } {"0","compressible","string","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+set csv_dump {"0","compressible","string","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 "0","hash","hash","a","1","aa","10","aaa","100","b","2","bb","20","bbb","200","c","3","cc","30","ccc","300","ddd","400","eee","5000000000",
 "0","hash_zipped","hash","a","1","b","2","c","3",
 "0","list","list","1","2","3","a","b","c","100000","6000000000","1","2","3","a","b","c","100000","6000000000","1","2","3","a","b","c","100000","6000000000",
@@ -21,6 +29,34 @@ start_server [list overrides [list "dir" $server_path "dbfilename" "encodings.rd
 "0","zset","zset","a","1","b","2","c","3","aa","10","bb","20","cc","30","aaa","100","bbb","200","ccc","300","aaaa","1000","cccc","123456789","bbbb","5000000000",
 "0","zset_zipped","zset","a","1","b","2","c","3",
 }
+
+start_server [list overrides [list "dir" $server_path "dbfilename" "encodings.rdb"]] {
+  test "RDB encoding loading test" {
+    r select 0
+    csvdump r
+  } $csv_dump
+}
+
+start_server_and_kill_it [list "dir" $server_path \
+                               "dbfilename" "encodings-rdb987.rdb" \
+                               "rdb-version-check" "strict"] {
+    test "RDB future version loading, strict version check" {
+        wait_for_condition 50 100 {
+            [string match {*Fatal error loading*} \
+                 [exec tail -1 < [dict get $srv stdout]]]
+        } else {
+            fail "Server started even if RDB version check failed"
+        }
+    }
+}
+
+start_server [list overrides [list "dir" $server_path \
+                                  "dbfilename" "encodings-rdb987.rdb" \
+                                  "rdb-version-check" "relaxed"]] {
+    test "RDB future version loading, relaxed version check" {
+        r select 0
+        csvdump r
+    } $csv_dump
 }
 
 set server_path [tmpdir "server.rdb-startup-test"]
@@ -58,17 +94,6 @@ start_server [list overrides [list "dir" $server_path] keep_persistence true] {
     }
 }
 
-# Helper function to start a server and kill it, just to check the error
-# logged.
-set defaults {}
-proc start_server_and_kill_it {overrides code} {
-    upvar defaults defaults srv srv server_path server_path
-    set config [concat $defaults $overrides]
-    set srv [start_server [list overrides $config keep_persistence true]]
-    uplevel 1 $code
-    kill_server $srv
-}
-
 # Make the RDB file unreadable
 file attributes [file join $server_path dump.rdb] -permissions 0222
 
diff --git a/tests/integration/replication-downgrade-compat.tcl b/tests/integration/replication-downgrade-compat.tcl
new file mode 100644
index 00000000000..28fdc541144
--- /dev/null
+++ b/tests/integration/replication-downgrade-compat.tcl
@@ -0,0 +1,41 @@
+start_server {tags {"repl downgrade"}} {
+    set replica [srv 0 client]
+    start_server {tags {"repl downgrade"}} {
+        set master [srv 0 client]
+        set master_host [srv 0 host]
+        set master_port [srv 0 port]
+
+        test {Configure the Redis 6.0 downgrade target as a replica} {
+            $replica replicaof $master_host $master_port
+            wait_for_condition 50 100 {
+                [string match {*master_link_status:up*} [$replica info replication]]
+            } else {
+                fail "Replication did not start"
+            }
+            $replica config resetstat
+        }
+
+        foreach {option clock_unit} {
+            EXAT seconds
+            PXAT milliseconds
+        } {
+            test "Replica applies Valkey-compatible SET $option propagation" {
+                set key "set-[string tolower $option]"
+                set value "value-$option"
+                set expire_at [expr {[clock $clock_unit] + ($clock_unit eq "seconds" ? 100 : 100000)}]
+
+                assert_equal OK [$master set $key $value $option $expire_at]
+                assert_equal 1 [$master wait 1 5000]
+                assert_equal $value [$replica get $key]
+
+                set master_ttl [$master pttl $key]
+                set replica_ttl [$replica pttl $key]
+                assert_range $master_ttl 90000 100000
+                assert_range $replica_ttl 90000 100000
+                assert {abs($master_ttl - $replica_ttl) <= 2000}
+                assert_equal up [s -1 master_link_status]
+                assert_equal 0 [s -1 unexpected_error_replies]
+            }
+        }
+    }
+}
diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
index 37af46947d7..c26ccb7c4bb 100644
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@@ -42,6 +42,7 @@ set ::all_tests {
     integration/replication-3
     integration/replication-4
     integration/replication-psync
+    integration/replication-downgrade-compat
     integration/aof
     integration/rdb
     integration/convert-zipmap-hash-on-load
@@ -50,6 +51,7 @@ set ::all_tests {
     integration/psync2-reg
     integration/psync2-pingoff
     integration/redis-cli
+    integration/rdb-downgrade-integration
     unit/pubsub
     unit/slowlog
     unit/scripting
@@ -70,6 +72,7 @@ set ::all_tests {
     unit/tracking
     unit/oom-score-adj
     unit/shutdown
+    unit/rdb-downgrade-compat
 }
 # Index to the next test to run in the ::all_tests list.
 set ::next_test 0
diff --git a/tests/unit/dump.tcl b/tests/unit/dump.tcl
index a9def92067b..76237883b57 100644
--- a/tests/unit/dump.tcl
+++ b/tests/unit/dump.tcl
@@ -93,6 +93,72 @@ start_server {tags {"dump"}} {
         set e
     } {*syntax*}
 
+    test {RESTORE key with future RDB version, strict version check} {
+        r config set rdb-version-check strict
+        #              str len  "bar"      RDB 222 CRC64 checksum
+        #               |   |     |         |       |
+        set bar_dump "\x00\x03\x62\x61\x72\xde\x00\x0fYUza\xd3\xec\xe0"
+        assert_error {ERR DUMP payload version or checksum are wrong} {r restore foo 0 $bar_dump replace}
+    }
+
+    test {RESTORE key with future RDB version, relaxed version check} {
+        r config set rdb-version-check relaxed
+        #               |type|len|           |  RDB  |      CRC64        |
+        #               |str | 3 |   "bar"   |  222  |     checksum      |
+        r restore foo 0 "\x00\x03\x62\x61\x72\xde\x00\x0fYUza\xd3\xec\xe0" replace
+        r config set rdb-version-check strict
+        assert_equal {bar} [r get foo]
+    }
+
+    test {RESTORE future listpack encodings with relaxed version check} {
+        r config set rdb-version-check relaxed
+
+        r restore review_hash 0 [binary decode hex \
+            1016160000000600816102010181620202018163020301ff500077b14e27930cd9aa] replace
+        assert_equal 1 [r hget review_hash a]
+        assert_equal 2 [r hget review_hash b]
+        assert_equal 3 [r hget review_hash c]
+
+        r restore review_zset 0 [binary decode hex \
+            1116160000000600816102010181620202018163020301ff5000e131b5549ef85262] replace
+        assert_equal {a 1 b 2 c 3} [r zrange review_zset 0 -1 withscores]
+
+        r restore review_list 0 [binary decode hex \
+            12010210100000000300816102816202816302ff50000732709d0b61356a] replace
+        assert_equal {a b c} [r lrange review_list 0 -1]
+
+        r restore review_set 0 [binary decode hex \
+            141b1b000000030085616c706861068462657461058567616d6d6106ff50009e2fb81907794154] replace
+        assert_equal {alpha beta gamma} [lsort [r smembers review_set]]
+
+        r restore review_stream 0 [binary decode hex \
+            1501100000000000000001000000000000000036360000000f00020100010101856669656c640600010201000100018676616c7565310704010201010100018676616c756532070401ff020200010000000200500032468fb0b472991a] replace
+        assert_equal 2 [r xlen review_stream]
+        assert_equal {field value1} [lindex [lindex [r xrange review_stream - +] 0] 1]
+
+        r config set rdb-version-check strict
+    }
+
+    test {RESTORE rejects corrupt future quicklist listpacks without crashing} {
+        r config set rdb-version-check relaxed
+        assert_error {ERR Bad data format} {
+            r restore corrupt_list 0 [binary decode hex \
+                120102100f0000000300816102816202816302ff50005341f9b674016405] replace
+        }
+        assert_equal PONG [r ping]
+        r config set rdb-version-check strict
+    }
+
+    test {RESTORE rejects duplicate future set elements without crashing} {
+        r config set rdb-version-check relaxed
+        assert_error {ERR Bad data format} {
+            r restore duplicate_set 0 [binary decode hex \
+                141b1b000000030085616c7068610684626574610585616c70686106ff5000c60672c52d24304e] replace
+        }
+        assert_equal PONG [r ping]
+        r config set rdb-version-check strict
+    }
+
     test {DUMP of non existing key returns nil} {
         r dump nonexisting_key
     } {}
diff --git a/tests/unit/expire.tcl b/tests/unit/expire.tcl
index 8bcdc16b7d0..688ceb24705 100644
--- a/tests/unit/expire.tcl
+++ b/tests/unit/expire.tcl
@@ -209,19 +209,17 @@ start_server {tags {"expire"}} {
         set e
     } {*not an integer*}
 
-    test {SET - use EX/PX option, TTL should not be reseted after loadaof} {
+    test {SET - use EX/PX/EXAT/PXAT option, TTL should not be reset after loadaof} {
         r config set appendonly yes
-        r set foo bar EX 100
+        r set foo-ex bar EX 100
+        r set foo-px bar PX 100000
+        r set foo-exat bar EXAT [expr {[clock seconds] + 100}]
+        r set foo-pxat bar PXAT [expr {[clock milliseconds] + 100000}]
         after 2000
         r debug loadaof
-        set ttl [r ttl foo]
-        assert {$ttl <= 98 && $ttl > 90}
-
-        r set foo bar PX 100000
-        after 2000
-        r debug loadaof
-        set ttl [r ttl foo]
-        assert {$ttl <= 98 && $ttl > 90}
+        foreach key {foo-ex foo-px foo-exat foo-pxat} {
+            assert_range [r ttl $key] 90 98
+        }
     }
 
     test {SET command will remove expire} {
diff --git a/tests/unit/rdb-downgrade-compat.tcl b/tests/unit/rdb-downgrade-compat.tcl
new file mode 100644
index 00000000000..b98613e0223
--- /dev/null
+++ b/tests/unit/rdb-downgrade-compat.tcl
@@ -0,0 +1,595 @@
+start_server {tags {"rdb" "downgrade" "compatibility"} keep_persistence true} {
+    test {RDB version compatibility check - current version} {
+        # Test that current RDB version is supported
+        set version [r config get save]
+        # Current version should be compatible
+        r set test_key "test_value"
+
+        # Debug: Check RDB file after save
+        r bgsave
+        waitForBgsave r
+
+        set config_dir [lindex [r config get dir] 1]
+        set config_dbfilename [lindex [r config get dbfilename] 1]
+        set rdb_path "$config_dir/$config_dbfilename"
+
+        if {[file exists $rdb_path]} {
+            set rdb_size [file size $rdb_path]
+            puts "DEBUG WORKING TEST: RDB file size: $rdb_size bytes"
+            catch {
+                set hexdump [exec hexdump -C $rdb_path | head -5]
+                puts "DEBUG WORKING TEST: RDB file hexdump:"
+                puts $hexdump
+            }
+        }
+
+        r debug reload nosave
+        r get test_key
+    } {test_value}
+
+    test {RDB downgrade compatibility - basic functionality} {
+        # Create some test data that would use ziplist encoding
+        r del test_hash test_zset test_list
+
+        # Small hash (should use ziplist/listpack encoding)
+        r hmset test_hash field1 value1 field2 value2 field3 value3
+
+        # Small sorted set (should use ziplist/listpack encoding)
+        r zadd test_zset 1.0 member1 2.0 member2 3.0 member3
+
+        # List data
+        r rpush test_list item1 item2 item3
+
+        # Verify the data is there
+        list [r hget test_hash field1] [r zscore test_zset member2] [r lindex test_list 1]
+    } {value1 2 item2}
+
+    test {RDB downgrade compatibility - hash encoding preservation} {
+        r del small_hash large_hash
+
+        # Small hash that should use ziplist encoding
+        for {set i 1} {$i <= 10} {incr i} {
+            r hset small_hash "field$i" "value$i"
+        }
+
+        # Verify encoding (should be ziplist for small hashes)
+        set encoding [r object encoding small_hash]
+
+        # The encoding should be ziplist for small hashes
+        expr {$encoding eq "ziplist" || $encoding eq "listpack"}
+    } {1}
+
+    test {RDB downgrade compatibility - sorted set encoding preservation} {
+        r del small_zset
+
+        # Small sorted set that should use ziplist encoding
+        for {set i 1} {$i <= 10} {incr i} {
+            r zadd small_zset $i "member$i"
+        }
+
+        # Verify encoding (should be ziplist for small sorted sets)
+        set encoding [r object encoding small_zset]
+
+        # The encoding should be ziplist for small sorted sets
+        expr {$encoding eq "ziplist" || $encoding eq "listpack"}
+    } {1}
+
+    test {RDB downgrade compatibility - list encoding after operations} {
+        r del test_list
+
+        # Create a list
+        r rpush test_list a b c d e
+
+        # Lists should use quicklist encoding in Redis 6.2
+        set encoding [r object encoding test_list]
+
+        # Verify we can perform operations
+        r lpop test_list
+        r llen test_list
+    } {4}
+
+    test {RDB downgrade compatibility - data integrity after save/load cycle} {
+        # Test with only string key first (like working test)
+        r set simple_test "simple_value"
+
+        set config_dir [lindex [r config get dir] 1]
+        set config_dbfilename [lindex [r config get dbfilename] 1]
+        set rdb_path "$config_dir/$config_dbfilename"
+
+        puts "DEBUG: Keys before save: [r keys *]"
+
+        r bgsave
+        waitForBgsave r
+
+        if {[file exists $rdb_path]} {
+            set rdb_size [file size $rdb_path]
+            puts "DEBUG: RDB file size: $rdb_size bytes"
+        }
+
+        r debug reload nosave
+
+        # Return the results
+        r get simple_test
+    } {simple_value}
+
+    test {RDB downgrade compatibility - mixed data types preservation} {
+        r del mixed_key1 mixed_key2 mixed_key3 mixed_key4
+
+        # String
+        r set mixed_key1 "test string value"
+
+        # Hash with various field types
+        r hmset mixed_key2 str_field "string_value" num_field 12345
+
+        # Sorted set with different scores
+        r zadd mixed_key3 -1.5 negative 0 zero 1.5 positive 100 large
+
+        # List with mixed content
+        r rpush mixed_key4 "text" "123" "more text"
+
+        # Save and reload
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify all types are preserved correctly
+        list [r get mixed_key1] [r hmget mixed_key2 str_field num_field] [r zscore mixed_key3 zero] [r lindex mixed_key4 1]
+    } {{test string value} {string_value 12345} 0 123}
+
+    test {RDB downgrade compatibility - large data structures} {
+        r del large_hash large_zset
+
+        # Create larger structures that might trigger encoding changes
+        for {set i 1} {$i <= 100} {incr i} {
+            r hset large_hash "field$i" "value$i"
+            r zadd large_zset $i "member$i"
+        }
+
+        # These should automatically convert to hash table / skiplist encodings
+        # but the compatibility layer should handle loading them correctly
+
+        # Save and reload
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify some data points
+        list [r hget large_hash field50] [r zscore large_zset member75] [r hlen large_hash] [r zcard large_zset]
+    } {value50 75 100 100}
+
+    test {RDB downgrade compatibility - empty collections handling} {
+        r del empty_hash empty_zset empty_list
+
+        # Create empty collections
+        r hset empty_hash temp_field temp_value
+        r hdel empty_hash temp_field
+
+        r zadd empty_zset 1 temp_member
+        r zrem empty_zset temp_member
+
+        r rpush empty_list temp_item
+        r lpop empty_list
+
+        # These operations should leave empty collections
+        # Save and reload to test empty collection handling
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify collections exist and are empty (or don't exist)
+        list [r hlen empty_hash] [r zcard empty_zset] [r llen empty_list]
+    } {0 0 0}
+
+    test {RDB downgrade compatibility - special values handling} {
+        r del special_values
+
+        # Test special numeric values and edge cases
+        r hmset special_values \
+            int_zero 0 \
+            int_positive 12345 \
+            int_negative -6789 \
+            str_numeric "98765" \
+            str_empty "" \
+            str_special "special chars: @#$%^&*()" \
+            str_unicode "测试 unicode ñáéíóú"
+
+        # Save and reload
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify special values are preserved
+        list [r hget special_values int_zero] [r hget special_values int_negative] [r hget special_values str_empty] [r hexists special_values str_unicode]
+    } {0 -6789 {} 1}
+
+    test {RDB downgrade compatibility - Valkey 8.0 RDB v11 Hash conversion} {
+        r del valkey80_hash_test
+
+        # Simulate loading from Valkey 8.0 RDB v11 by creating hash data
+        # that would use listpack encoding in newer versions
+        r hmset valkey80_hash_test \
+            field1 "value1" \
+            field2 "value2" \
+            field3 "value3" \
+            numeric_field 12345 \
+            unicode_field "test Valkey"
+
+        # Force save/reload cycle to test conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify hash data integrity and proper encoding handling
+        list [r hget valkey80_hash_test field1] \
+             [r hget valkey80_hash_test numeric_field] \
+             [r hget valkey80_hash_test unicode_field] \
+             [r hlen valkey80_hash_test] \
+             [r hexists valkey80_hash_test field3]
+    } {value1 12345 {test Valkey} 5 1}
+
+    test {RDB downgrade compatibility - Valkey 8.0 RDB v11 SortedSet conversion} {
+        r del valkey80_zset_test
+
+        # Create sorted set that would use listpack in Valkey 8.0
+        r zadd valkey80_zset_test 1.0 "member1"
+        r zadd valkey80_zset_test 2.5 "member2"
+        r zadd valkey80_zset_test -1.5 "negative_score"
+        r zadd valkey80_zset_test 0 "zero_score"
+        r zadd valkey80_zset_test 3.14159 "pi_score"
+
+        # Test save/reload cycle
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify sorted set integrity
+        list [r zscore valkey80_zset_test member1] \
+             [r zscore valkey80_zset_test negative_score] \
+             [r zscore valkey80_zset_test pi_score] \
+             [r zcard valkey80_zset_test] \
+             [r zrank valkey80_zset_test zero_score]
+    } {1 -1.5 3.1415899999999999 5 1}
+
+    test {RDB downgrade compatibility - Valkey 8.0 RDB v11 List conversion} {
+        r del valkey80_list_test
+
+        # Create list that would be stored as listpack in Valkey 8.0
+        r rpush valkey80_list_test "first_item"
+        r rpush valkey80_list_test "second_item"
+        r rpush valkey80_list_test "unicode_test"
+        r rpush valkey80_list_test "123456"
+        r lpush valkey80_list_test "prepended_item"
+
+        # Test conversion through save/reload
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify list integrity and order
+        list [r llen valkey80_list_test] \
+             [r lindex valkey80_list_test 0] \
+             [r lindex valkey80_list_test 2] \
+             [r lindex valkey80_list_test -1] \
+             [r lrange valkey80_list_test 1 3]
+    } {5 prepended_item second_item 123456 {first_item second_item unicode_test}}
+
+    test {RDB downgrade compatibility - Redis 7.2 RDB v11 Hash conversion} {
+        r del redis72_hash_test
+
+        # Create hash similar to what Redis 7.2 would generate
+        r hmset redis72_hash_test \
+            key1 "redis_7_2_value" \
+            key2 42 \
+            key3 "special_chars_!@#$%^&*()" \
+            empty_value "" \
+            large_value [string repeat "x" 100]
+
+        # Save and reload to test Redis 7.2 compatibility
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify all hash fields are preserved
+        list [r hget redis72_hash_test key1] \
+             [r hget redis72_hash_test key2] \
+             [r hget redis72_hash_test empty_value] \
+             [string length [r hget redis72_hash_test large_value]] \
+             [r hexists redis72_hash_test key3]
+    } {redis_7_2_value 42 {} 100 1}
+
+    test {RDB downgrade compatibility - Redis 7.2 RDB v11 SortedSet conversion} {
+        r del redis72_zset_test
+
+        # Create sorted set with Redis 7.2 characteristics
+        r zadd redis72_zset_test 100.0 "high_score"
+        r zadd redis72_zset_test 0.1 "low_score"
+        r zadd redis72_zset_test -50.5 "negative"
+        r zadd redis72_zset_test 1e-10 "tiny_score"
+        r zadd redis72_zset_test 1e10 "huge_score"
+
+        # Test precision preservation through conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify score precision and ordering
+        list [r zscore redis72_zset_test high_score] \
+             [r zscore redis72_zset_test tiny_score] \
+             [r zscore redis72_zset_test huge_score] \
+             [r zcount redis72_zset_test -inf +inf] \
+             [r zrange redis72_zset_test 0 0]
+    } {100 1e-10 10000000000 5 negative}
+
+    test {RDB downgrade compatibility - Redis 7.2 RDB v11 List conversion} {
+        r del redis72_list_test
+
+        # Create complex list structure
+        r rpush redis72_list_test "item_1"
+        r rpush redis72_list_test "item_2"
+        r rpush redis72_list_test [string repeat "y" 200]
+        r rpush redis72_list_test ""
+        r rpush redis72_list_test "final_item"
+
+        # Test list conversion from Redis 7.2
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify list structure and content
+        list [r llen redis72_list_test] \
+             [r lindex redis72_list_test 0] \
+             [string length [r lindex redis72_list_test 2]] \
+             [r lindex redis72_list_test 3] \
+             [r lindex redis72_list_test -1]
+    } {5 item_1 200 {} final_item}
+
+    test {RDB downgrade compatibility - Redis 7.0 RDB v10 Hash conversion} {
+        r del redis70_hash_test
+
+        # Create hash representing Redis 7.0 data
+        for {set i 1} {$i <= 20} {incr i} {
+            r hset redis70_hash_test "field_$i" "value_$i"
+        }
+        r hset redis70_hash_test special_field "Redis_7.0_data"
+        r hset redis70_hash_test binary_data [binary format "a*" "\x00\x01\x02\x03"]
+
+        # Test Redis 7.0 RDB v10 compatibility
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify hash integrity
+        list [r hlen redis70_hash_test] \
+             [r hget redis70_hash_test field_10] \
+             [r hget redis70_hash_test special_field] \
+             [r hexists redis70_hash_test field_20] \
+             [string length [r hget redis70_hash_test binary_data]]
+    } {22 value_10 Redis_7.0_data 1 4}
+
+    test {RDB downgrade compatibility - Redis 7.0 RDB v10 SortedSet conversion} {
+        r del redis70_zset_test
+
+        # Create sorted set with various score types
+        r zadd redis70_zset_test 0 "zero"
+        r zadd redis70_zset_test 1.5 "one_half"
+        r zadd redis70_zset_test -10 "negative_ten"
+        r zadd redis70_zset_test 999999999 "large_int"
+        r zadd redis70_zset_test 0.000001 "small_decimal"
+
+        # Add members until we have good coverage
+        for {set i 1} {$i <= 10} {incr i} {
+            r zadd redis70_zset_test $i "member_$i"
+        }
+
+        # Test Redis 7.0 conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify sorted set functionality
+        list [r zcard redis70_zset_test] \
+             [r zscore redis70_zset_test zero] \
+             [r zscore redis70_zset_test large_int] \
+             [r zrank redis70_zset_test zero] \
+             [r zrevrank redis70_zset_test large_int]
+    } {15 0 999999999 1 0}
+
+    test {RDB downgrade compatibility - Redis 7.0 RDB v10 List conversion} {
+        r del redis70_list_test
+
+        # Create list with mixed data types
+        r lpush redis70_list_test "first"
+        r rpush redis70_list_test "second"
+        r rpush redis70_list_test 12345
+        r rpush redis70_list_test ""
+        r rpush redis70_list_test "last_item"
+
+        # Add more items to test larger lists
+        for {set i 1} {$i <= 15} {incr i} {
+            r rpush redis70_list_test "bulk_item_$i"
+        }
+
+        # Test Redis 7.0 list conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify list operations work correctly
+        list [r llen redis70_list_test] \
+             [r lindex redis70_list_test 0] \
+             [r lindex redis70_list_test 2] \
+             [r lindex redis70_list_test -1] \
+             [r lrange redis70_list_test 5 7]
+    } {20 first 12345 bulk_item_15 {bulk_item_1 bulk_item_2 bulk_item_3}}
+
+    test {RDB downgrade compatibility - Mixed version compatibility stress test} {
+        r del mixed_version_hash mixed_version_zset mixed_version_list
+
+        # Create complex data structures that test all conversion paths
+        # Hash with various data types
+        r hmset mixed_version_hash \
+            string_field "test_string" \
+            int_field 42 \
+            float_as_string "3.14159" \
+            unicode "mixed_version_test" \
+            empty "" \
+            large_text [string repeat "mixed_test" 50]
+
+        # Sorted set with edge case scores
+        r zadd mixed_version_zset 1.0 "normal"
+        r zadd mixed_version_zset 0.0 "zero"
+        r zadd mixed_version_zset -1.0 "negative"
+        r zadd mixed_version_zset 1e-15 "tiny"
+        r zadd mixed_version_zset 1e15 "huge"
+
+        # List with mixed content
+        r rpush mixed_version_list "string"
+        r rpush mixed_version_list "12345"
+        r rpush mixed_version_list ""
+        r rpush mixed_version_list [string repeat "z" 1000]
+
+        # Test comprehensive conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Verify all data types maintained integrity
+        list [r hget mixed_version_hash unicode] \
+             [string length [r hget mixed_version_hash large_text]] \
+             [r zscore mixed_version_zset tiny] \
+             [r zscore mixed_version_zset huge] \
+             [r llen mixed_version_list] \
+             [string length [r lindex mixed_version_list -1]]
+    } {mixed_version_test 500 1.0000000000000001e-15 1000000000000000 4 1000}
+
+    test {RDB downgrade compatibility - INFO command statistics format} {
+        # Clear any existing statistics and create test data
+        r del info_test_hash info_test_zset info_test_list
+
+        # Create small data structures that will trigger conversions
+        r hmset info_test_hash field1 value1 field2 value2
+        r zadd info_test_zset 1.0 member1 2.0 member2
+        r rpush info_test_list item1 item2 item3
+
+        # Force a save/reload cycle to trigger conversion statistics
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Get INFO output and verify RDBDowngradeStats section exists
+        set info_output [r info RDBDowngradeStats]
+
+        # Verify the section header is present
+        set has_section [string match "*# RDBDowngradeStats*" $info_output]
+
+        # Verify all expected field names are present
+        set expected_fields {
+            rdb_downgrade_keys_attempted
+            rdb_downgrade_keys_succeeded
+            rdb_downgrade_keys_failed
+        }
+
+        set all_fields_present 1
+        foreach field $expected_fields {
+            if {![string match "*$field:*" $info_output]} {
+                set all_fields_present 0
+                puts "Missing field: $field"
+            }
+        }
+
+        list $has_section $all_fields_present
+    } {1 1}
+
+    test {RDB downgrade compatibility - Statistics field format validation} {
+        # Create minimal test data to ensure statistics are generated
+        r del format_test_key
+        r hmset format_test_key test_field test_value
+
+        # Trigger conversion
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Get INFO statistics output
+        set info_output [r info RDBDowngradeStats]
+
+        # Verify the format of each statistics line (field_name:numeric_value)
+        set format_correct 1
+        set lines [split $info_output "\n"]
+
+        foreach line $lines {
+            set line [string trim $line]
+            # Skip empty lines and comments
+            if {$line eq "" || [string match "#*" $line]} {
+                continue
+            }
+
+            # Check if line matches expected format: field_name:number
+            if {![regexp {^rdb_downgrade_[a-z_]+:\d+$} $line]} {
+                set format_correct 0
+                puts "Invalid format line: $line"
+            }
+        }
+
+        # Also verify that we have the expected number of statistics fields
+        set field_count 0
+        foreach line $lines {
+            set line [string trim $line]
+            if {[string match "rdb_downgrade_*" $line]} {
+                incr field_count
+            }
+        }
+
+        # We should have exactly 5 statistics fields
+        list $format_correct [expr {$field_count == 5}]
+    } {1 1}
+
+    test {RDB downgrade compatibility - Backward compatibility of existing statistics functions} {
+        # Clear test data
+        r del compat_test_hash compat_test_list
+
+        # Create test structures
+        r hmset compat_test_hash cf1 cv1 cf2 cv2
+        r rpush compat_test_list ci1 ci2 ci3
+
+        # Trigger conversion to ensure statistics are populated
+        r bgsave
+        waitForBgsave r
+        r debug reload nosave
+
+        # Get INFO output using the new section name
+        set info_output [r info RDBDowngradeStats]
+
+        # Verify that legacy field names are still present for backward compatibility
+        set legacy_fields_present 1
+        set legacy_fields {
+            rdb_downgrade_keys_attempted
+            rdb_downgrade_keys_succeeded
+            rdb_downgrade_keys_failed
+        }
+
+        foreach field $legacy_fields {
+            if {![string match "*$field:*" $info_output]} {
+                set legacy_fields_present 0
+                puts "Missing legacy field: $field"
+            }
+        }
+
+        # Verify that values are numeric and non-negative
+        proc extract_stat {info_text field_name} {
+            if {[regexp "${field_name}:(\\d+)" $info_text match value]} {
+                return $value
+            }
+            return -1
+        }
+
+        set total_conv [extract_stat $info_output "rdb_downgrade_keys_attempted"]
+        set successful_conv [extract_stat $info_output "rdb_downgrade_keys_succeeded"]
+        set failed_conv [extract_stat $info_output "rdb_downgrade_keys_failed"]
+
+        set values_valid [expr {$total_conv >= 0 && $successful_conv >= 0 && $failed_conv >= 0}]
+
+        list $legacy_fields_present $values_valid
+    } {1 1}
+
+}
\ No newline at end of file
diff --git a/tests/unit/type/string.tcl b/tests/unit/type/string.tcl
index b70a3317e9b..00e17d86711 100644
--- a/tests/unit/type/string.tcl
+++ b/tests/unit/type/string.tcl
@@ -408,6 +408,30 @@ start_server {tags {"string"}} {
         assert {$ttl <= 10 && $ttl > 5}
     }
 
+    foreach {option clock_unit} {
+        EXAT seconds
+        PXAT milliseconds
+    } {
+        test "Extended SET $option option" {
+            r del foo
+            set expire_at [expr {[clock $clock_unit] + ($clock_unit eq "seconds" ? 10 : 10000)}]
+            assert_equal OK [r set foo bar $option $expire_at]
+            assert_equal bar [r get foo]
+            assert_range [r pttl foo] 5000 10000
+        }
+    }
+
+    foreach {option expire_at} {
+        EXAT 9223372036854776
+        PX 9223372036854775807
+    } {
+        test "Extended SET $option rejects expiration overflow" {
+            r del foo
+            assert_error {*invalid expire time*} {r set foo bar $option $expire_at}
+            assert_equal 0 [r exists foo]
+        }
+    }
+
     test {Extended SET using multiple options at once} {
         r set foo val
         assert {[r set foo bar xx px 10000] eq {OK}}