This is an automated email from the ASF dual-hosted git repository.

chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git


The following commit(s) were added to refs/heads/main by this push:
     new 5a2252d33 fix(cpp): validate polymorphic smart pointer reads (#3887)
5a2252d33 is described below

commit 5a2252d33802d42649b7004f939de5d9c7ea5234
Author: Shawn Yang <[email protected]>
AuthorDate: Mon Jul 27 10:33:46 2026 +0800

    fix(cpp): validate polymorphic smart pointer reads (#3887)
    
    ## Why?
    
    
    
    ## What does this PR do?
    
    
    
    ## Related issues
    
    
    
    ## AI Contribution Checklist
    
    
    
    - [ ] Substantial AI assistance was used in this PR: `yes` / `no`
    - [ ] If `yes`, I included a completed [AI Contribution
    
Checklist](https://github.com/apache/fory/blob/main/AI_POLICY.md#9-contributor-checklist-for-ai-assisted-prs)
    in this PR description and the required `AI Usage Disclosure`.
    - [ ] If `yes`, my PR description includes the required `ai_review`
    summary and screenshot evidence or equivalent persisted links of the
    final clean AI review results from both fresh reviewers described in
    `AI_POLICY.md`, the Fory-guided reviewer and the independent general
    reviewer, on the current PR diff or current HEAD after the latest code
    changes.
    
    
    
    ## Does this PR introduce any user-facing change?
    
    
    
    - [ ] Does this PR introduce any public API change?
    - [ ] Does this PR introduce any binary protocol compatibility change?
    
    ## Benchmark
---
 cpp/fory/meta/field_info.h                         |  11 +-
 cpp/fory/serialization/collection_serializer.h     | 264 ++++------
 .../serialization/collection_serializer_test.cc    |  18 +
 cpp/fory/serialization/fory.h                      |   2 +-
 cpp/fory/serialization/map_serializer.h            | 128 ++++-
 cpp/fory/serialization/map_serializer_test.cc      |  67 +++
 cpp/fory/serialization/ref_resolver.h              |  36 +-
 cpp/fory/serialization/serializer.h                |  25 +
 .../serialization/smart_ptr_serializer_test.cc     | 583 +++++++++++++++++++++
 cpp/fory/serialization/smart_ptr_serializers.h     | 216 ++++++--
 cpp/fory/serialization/type_info.h                 |  15 +-
 cpp/fory/serialization/type_resolver.h             | 116 ++++
 cpp/fory/serialization/weak_ptr_serializer.h       |  23 +-
 cpp/fory/serialization/weak_ptr_serializer_test.cc |  44 ++
 docs/guide/cpp/custom-serializers.md               |   2 +-
 docs/guide/cpp/polymorphism.md                     |  25 +-
 16 files changed, 1320 insertions(+), 255 deletions(-)

diff --git a/cpp/fory/meta/field_info.h b/cpp/fory/meta/field_info.h
index 91b723153..bacaf47f1 100644
--- a/cpp/fory/meta/field_info.h
+++ b/cpp/fory/meta/field_info.h
@@ -649,6 +649,12 @@ constexpr auto concat_tuples_from_tuple(const Tuple 
&tuple) {
   ::fory::meta::details::wrap_tuple(decltype(::fory::meta::fory_field_info(    
\
       ::std::declval<FORY_BASE_TYPE(arg)>()))::entries),
 
+#define FORY_BASE_TYPE_ARG(arg)                                                
\
+  FORY_PP_IF(FORY_PP_IS_BASE(arg))                                             
\
+  (FORY_BASE_TYPE_ARG_IMPL(arg), FORY_PP_EMPTY())
+#define FORY_BASE_TYPE_ARG_IMPL(arg)                                           
\
+  ::fory::meta::Identity<FORY_BASE_TYPE(arg)>{},
+
 #define FORY_BASE_SIZE_ADD(arg)                                                
\
   FORY_PP_IF(FORY_PP_IS_BASE(arg))                                             
\
   (+decltype(::fory::meta::fory_field_info(                                    
\
@@ -684,7 +690,7 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple) 
{
             ::std::tuple{FORY_PP_FOREACH(FORY_BASE_CONFIG_ARG, __VA_ARGS__)}); 
\
     static inline constexpr auto FieldConfigEntries = ::std::tuple{            
\
         FORY_PP_FOREACH(FORY_FIELD_INFO_CONFIG_FUNC, __VA_ARGS__)};            
\
-    static constexpr bool has_config = true;                                   
\
+    [[maybe_unused]] static constexpr bool has_config = true;                  
\
     static inline constexpr auto entries =                                     
\
         ::fory::meta::concat_tuples(BaseConfigEntries, FieldConfigEntries);    
\
     using FieldConfigEntriesType = ::std::decay_t<decltype(entries)>;          
\
@@ -694,6 +700,8 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple) 
{
         ::fory::meta::concat_arrays(BaseNames, FieldNames);                    
\
     using BasePtrsType = decltype(::fory::meta::concat_tuples_from_tuple(      
\
         ::std::tuple{FORY_PP_FOREACH(FORY_BASE_PTRS_ARG, __VA_ARGS__)}));      
\
+    using DirectBaseTypes = decltype(::std::tuple{                             
\
+        FORY_PP_FOREACH(FORY_BASE_TYPE_ARG, __VA_ARGS__)});                    
\
     static constexpr BasePtrsType base_ptrs() {                                
\
       return ::fory::meta::concat_tuples_from_tuple(                           
\
           ::std::tuple{FORY_PP_FOREACH(FORY_BASE_PTRS_ARG, __VA_ARGS__)});     
\
@@ -744,6 +752,7 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple) 
{
     [[maybe_unused]] static constexpr bool has_config = false;                 
\
     [[maybe_unused]] static inline constexpr auto entries = ::std::tuple{};    
\
     [[maybe_unused]] static constexpr ::std::size_t field_count = 0;           
\
+    using DirectBaseTypes = ::std::tuple<>;                                    
\
     using PtrsType = decltype(::std::tuple{});                                 
\
     static constexpr PtrsType ptrs() { return {}; }                            
\
     static const PtrsType &ptrs_ref() {                                        
\
diff --git a/cpp/fory/serialization/collection_serializer.h 
b/cpp/fory/serialization/collection_serializer.h
index 91ec2899d..6074b147a 100644
--- a/cpp/fory/serialization/collection_serializer.h
+++ b/cpp/fory/serialization/collection_serializer.h
@@ -26,6 +26,7 @@
 #include <cstring>
 #include <deque>
 #include <forward_list>
+#include <functional>
 #include <limits>
 #include <list>
 #include <set>
@@ -207,6 +208,16 @@ inline void write_collection_data_fast(const Container 
&coll, WriteContext &ctx,
   }
 }
 
+template <typename T, typename Elem>
+FORY_ALWAYS_INLINE const T &collection_value(const Elem &elem) {
+  if constexpr (std::is_same_v<std::decay_t<Elem>,
+                               std::reference_wrapper<const T>>) {
+    return elem.get();
+  } else {
+    return elem;
+  }
+}
+
 /// write collection data for polymorphic or shared-ref elements.
 template <typename T, typename Container>
 inline void write_collection_data_slow(const Container &coll, WriteContext 
&ctx,
@@ -220,6 +231,8 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
 
   constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
   constexpr bool elem_is_shared_ref = is_shared_ref_v<T>;
+  constexpr bool elem_is_smart_ptr =
+      is_std_shared_ptr_v<T> || is_std_unique_ptr_v<T>;
 
   using ElemType = nullable_element_t<T>;
   bool is_elem_declared =
@@ -231,7 +244,8 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
   std::type_index first_type{typeid(void)};
   bool first_type_set = false;
 
-  for (const auto &elem : coll) {
+  for (const auto &raw_elem : coll) {
+    const T &elem = collection_value<T>(raw_elem);
     // Check for nulls
     if constexpr (is_nullable_v<T>) {
       if (is_null_value(elem)) {
@@ -283,6 +297,8 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
   ctx.write_uint8(bitmap);
 
   // write element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
+  const TypeInfo *elem_type_info = nullptr;
+  Harness::WriteDataFn elem_writer = nullptr;
   if (is_same_type && !(bitmap & COLL_DECL_ELEMENT_TYPE)) {
     if constexpr (elem_is_polymorphic) {
       // write concrete type info for polymorphic elements
@@ -291,12 +307,16 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
         ctx.set_error(std::move(type_info_res).error());
         return;
       }
+      elem_type_info = type_info_res.value();
       auto write_res =
-          ctx.write_any_type_info(type_info_res.value()->type_id, first_type);
+          ctx.write_any_type_info(elem_type_info->type_id, first_type);
       if (FORY_PREDICT_FALSE(!write_res.ok())) {
         ctx.set_error(std::move(write_res).error());
         return;
       }
+      if constexpr (elem_is_smart_ptr) {
+        elem_writer = elem_type_info->harness.write_data_fn;
+      }
     } else {
       Serializer<ElemType>::write_type_info(ctx);
     }
@@ -310,13 +330,24 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
     // All elements have same type - type info written once above
     if (tracking_refs) {
       // Track refs - write ref flag per element per xlang spec
-      for (const auto &elem : coll) {
-        Serializer<T>::write(elem, ctx, RefMode::Tracking, false, 
has_generics);
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
+        if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+          Serializer<T>::write_with_data(elem, ctx, RefMode::Tracking,
+                                         elem_writer, has_generics);
+        } else {
+          Serializer<T>::write(elem, ctx, RefMode::Tracking, false,
+                               has_generics);
+        }
       }
     } else if (!has_null) {
       // No nulls, no ref tracking - write data directly without null flag
-      for (const auto &elem : coll) {
-        if constexpr (is_nullable_v<T>) {
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
+        if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+          Serializer<T>::write_with_data(elem, ctx, RefMode::None, elem_writer,
+                                         has_generics);
+        } else if constexpr (is_nullable_v<T>) {
           using Inner = nullable_element_t<T>;
           Serializer<Inner>::write_data(deref_nullable(elem), ctx);
         } else if constexpr (elem_is_shared_ref) {
@@ -332,25 +363,35 @@ inline void write_collection_data_slow(const Container 
&coll, WriteContext &ctx,
       }
     } else {
       // Has null elements - write with null flag
-      for (const auto &elem : coll) {
-        Serializer<T>::write(elem, ctx, RefMode::NullOnly, false, 
has_generics);
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
+        if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+          Serializer<T>::write_with_data(elem, ctx, RefMode::NullOnly,
+                                         elem_writer, has_generics);
+        } else {
+          Serializer<T>::write(elem, ctx, RefMode::NullOnly, false,
+                               has_generics);
+        }
       }
     }
   } else {
     // Heterogeneous types - write type info per element
     if (tracking_refs) {
       // Track refs - write ref flag + type info per element
-      for (const auto &elem : coll) {
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
         Serializer<T>::write(elem, ctx, RefMode::Tracking, true, has_generics);
       }
     } else if (!has_null) {
       // No nulls - write without null flag (RefMode::None)
-      for (const auto &elem : coll) {
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
         Serializer<T>::write(elem, ctx, RefMode::None, true, has_generics);
       }
     } else {
       // Has null elements - write with null flag (RefMode::NullOnly)
-      for (const auto &elem : coll) {
+      for (const auto &raw_elem : coll) {
+        const T &elem = collection_value<T>(raw_elem);
         Serializer<T>::write(elem, ctx, RefMode::NullOnly, true, has_generics);
       }
     }
@@ -461,6 +502,8 @@ inline Container read_collection_data_slow(ReadContext 
&ctx, uint32_t length) {
   }
 
   constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
+  constexpr bool elem_is_smart_ptr =
+      is_std_shared_ptr_v<T> || is_std_unique_ptr_v<T>;
 
   uint8_t bitmap = ctx.read_uint8(ctx.error());
   if (FORY_PREDICT_FALSE(ctx.has_error())) {
@@ -476,13 +519,30 @@ inline Container read_collection_data_slow(ReadContext 
&ctx, uint32_t length) {
   bool is_decl_type = (bitmap & COLL_DECL_ELEMENT_TYPE) != 0;
   bool is_same_type = (bitmap & COLL_IS_SAME_TYPE) != 0;
 
+  if constexpr (elem_is_polymorphic) {
+    if (FORY_PREDICT_FALSE(is_same_type && is_decl_type)) {
+      ctx.set_error(Error::invalid_data(
+          "Polymorphic collection elements require concrete type "
+          "information"));
+      return result;
+    }
+  }
+
   // Read element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
   const TypeInfo *elem_type_info = nullptr;
+  Harness::ReadAsFn elem_reader = nullptr;
   if (is_same_type && !is_decl_type) {
     elem_type_info = ctx.read_any_type_info(ctx.error());
     if (FORY_PREDICT_FALSE(ctx.has_error())) {
       return result;
     }
+    if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+      elem_reader = resolve_polymorphic_reader<nullable_element_t<T>>(
+          ctx, elem_type_info);
+      if (FORY_PREDICT_FALSE(ctx.has_error())) {
+        return result;
+      }
+    }
   }
 
   if (FORY_PREDICT_FALSE(!reserve_collection(result, ctx, length))) {
@@ -498,9 +558,15 @@ inline Container read_collection_data_slow(ReadContext 
&ctx, uint32_t length) {
         }
         if constexpr (elem_is_polymorphic) {
           // Use RefMode::Tracking to read ref flag per element
-          auto elem = Serializer<T>::read_with_type_info(ctx, 
RefMode::Tracking,
-                                                         *elem_type_info);
-          collection_insert(result, std::move(elem));
+          if constexpr (elem_is_smart_ptr) {
+            auto elem = Serializer<T>::template read_with_type_info<true>(
+                ctx, RefMode::Tracking, *elem_type_info, elem_reader);
+            collection_insert(result, std::move(elem));
+          } else {
+            auto elem = Serializer<T>::read_with_type_info(
+                ctx, RefMode::Tracking, *elem_type_info);
+            collection_insert(result, std::move(elem));
+          }
         } else {
           auto elem = Serializer<T>::read(ctx, RefMode::Tracking, false);
           collection_insert(result, std::move(elem));
@@ -512,9 +578,15 @@ inline Container read_collection_data_slow(ReadContext 
&ctx, uint32_t length) {
           return result;
         }
         if constexpr (elem_is_polymorphic) {
-          auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
-                                                         *elem_type_info);
-          collection_insert(result, std::move(elem));
+          if constexpr (elem_is_smart_ptr) {
+            auto elem = Serializer<T>::template read_with_type_info<true>(
+                ctx, RefMode::None, *elem_type_info, elem_reader);
+            collection_insert(result, std::move(elem));
+          } else {
+            auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
+                                                           *elem_type_info);
+            collection_insert(result, std::move(elem));
+          }
         } else {
           auto elem = Serializer<T>::read(ctx, RefMode::None, false);
           collection_insert(result, std::move(elem));
@@ -535,9 +607,15 @@ inline Container read_collection_data_slow(ReadContext 
&ctx, uint32_t length) {
           // For sets, skip null elements
         } else {
           if constexpr (elem_is_polymorphic) {
-            auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
-                                                           *elem_type_info);
-            collection_insert(result, std::move(elem));
+            if constexpr (elem_is_smart_ptr) {
+              auto elem = Serializer<T>::template read_with_type_info<true>(
+                  ctx, RefMode::None, *elem_type_info, elem_reader);
+              collection_insert(result, std::move(elem));
+            } else {
+              auto elem = Serializer<T>::read_with_type_info(ctx, 
RefMode::None,
+                                                             *elem_type_info);
+              collection_insert(result, std::move(elem));
+            }
           } else {
             auto elem = Serializer<T>::read(ctx, RefMode::None, false);
             collection_insert(result, std::move(elem));
@@ -1787,6 +1865,14 @@ struct Serializer<std::forward_list<T, Alloc>> {
       temp.push_back(std::cref(elem));
     }
 
+    // Dispatch to fast or slow path based on element type characteristics
+    constexpr bool is_fast_path = !is_polymorphic_v<T> && !is_shared_ref_v<T>;
+
+    if constexpr (!is_fast_path) {
+      write_collection_data_slow<T>(temp, ctx, has_generics);
+      return;
+    }
+
     // write length
     ctx.write_var_uint32(static_cast<uint32_t>(temp.size()));
 
@@ -1794,9 +1880,6 @@ struct Serializer<std::forward_list<T, Alloc>> {
       return;
     }
 
-    // Dispatch to fast or slow path based on element type characteristics
-    constexpr bool is_fast_path = !is_polymorphic_v<T> && !is_shared_ref_v<T>;
-
     if constexpr (is_fast_path) {
       // Check for null elements
       bool has_null = false;
@@ -1874,141 +1957,6 @@ struct Serializer<std::forward_list<T, Alloc>> {
           }
         }
       }
-    } else {
-      // Slow path for polymorphic or shared-ref elements
-      constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
-      constexpr bool elem_is_shared_ref = is_shared_ref_v<T>;
-
-      using ElemType = nullable_element_t<T>;
-      bool is_elem_declared =
-          has_generics && !need_type_for_collection_elem<ElemType>();
-
-      // Scan collection to determine header flags
-      bool has_null = false;
-      bool is_same_type = true;
-      std::type_index first_type{typeid(void)};
-      bool first_type_set = false;
-
-      for (const auto &elem_ref : temp) {
-        const auto &elem = elem_ref.get();
-        // Check for nulls
-        if constexpr (is_nullable_v<T>) {
-          if (is_null_value(elem)) {
-            has_null = true;
-            continue;
-          }
-        }
-        // Check runtime types for polymorphic elements
-        if constexpr (elem_is_polymorphic) {
-          if (is_same_type) {
-            auto concrete_id = get_concrete_type_id(elem);
-            if (!first_type_set) {
-              first_type = concrete_id;
-              first_type_set = true;
-            } else if (concrete_id != first_type) {
-              is_same_type = false;
-            }
-          }
-        }
-      }
-
-      // If all polymorphic elements are null, treat as heterogeneous
-      if constexpr (elem_is_polymorphic) {
-        if (is_same_type && !first_type_set) {
-          is_same_type = false;
-        }
-      }
-
-      // Build header bitmap
-      uint8_t bitmap = 0;
-      if (has_null) {
-        bitmap |= COLL_HAS_NULL;
-      }
-      if (is_elem_declared && !elem_is_polymorphic) {
-        bitmap |= COLL_DECL_ELEMENT_TYPE;
-      }
-      if (is_same_type) {
-        bitmap |= COLL_IS_SAME_TYPE;
-      }
-      // Only set TRACKING_REF if element is shared ref AND global ref tracking
-      // is enabled
-      if constexpr (elem_is_shared_ref) {
-        if (ctx.track_ref()) {
-          bitmap |= COLL_TRACKING_REF;
-        }
-      }
-
-      // write header
-      ctx.write_uint8(bitmap);
-
-      // write element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
-      if (is_same_type && !(bitmap & COLL_DECL_ELEMENT_TYPE)) {
-        if constexpr (elem_is_polymorphic) {
-          auto type_info_res = ctx.type_resolver().get_type_info(first_type);
-          if (FORY_PREDICT_FALSE(!type_info_res.ok())) {
-            ctx.set_error(std::move(type_info_res).error());
-            return;
-          }
-          auto write_res = ctx.write_any_type_info(
-              type_info_res.value()->type_id, first_type);
-          if (FORY_PREDICT_FALSE(!write_res.ok())) {
-            ctx.set_error(std::move(write_res).error());
-            return;
-          }
-        } else {
-          Serializer<ElemType>::write_type_info(ctx);
-        }
-      }
-
-      // write elements
-      if (is_same_type) {
-        if (!has_null) {
-          if constexpr (elem_is_shared_ref) {
-            for (const auto &elem_ref : temp) {
-              Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly,
-                                   false, has_generics);
-            }
-          } else {
-            for (const auto &elem_ref : temp) {
-              const auto &elem = elem_ref.get();
-              if constexpr (is_nullable_v<T>) {
-                using Inner = nullable_element_t<T>;
-                Serializer<Inner>::write_data(deref_nullable(elem), ctx);
-              } else {
-                if constexpr (is_generic_type_v<T>) {
-                  Serializer<T>::write_data_generic(elem, ctx, has_generics);
-                } else {
-                  Serializer<T>::write_data(elem, ctx);
-                }
-              }
-            }
-          }
-        } else {
-          for (const auto &elem_ref : temp) {
-            Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly, false,
-                                 has_generics);
-          }
-        }
-      } else {
-        if (!has_null) {
-          if constexpr (elem_is_shared_ref) {
-            for (const auto &elem_ref : temp) {
-              Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly, 
true,
-                                   has_generics);
-            }
-          } else {
-            for (const auto &elem_ref : temp) {
-              Serializer<T>::write(elem_ref.get(), ctx, RefMode::None, true,
-                                   has_generics);
-            }
-          }
-        } else {
-          for (const auto &elem_ref : temp) {
-            Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly, true,
-                                 has_generics);
-          }
-        }
-      }
     }
   }
 
diff --git a/cpp/fory/serialization/collection_serializer_test.cc 
b/cpp/fory/serialization/collection_serializer_test.cc
index c40f717e3..c6a5c6ce0 100644
--- a/cpp/fory/serialization/collection_serializer_test.cc
+++ b/cpp/fory/serialization/collection_serializer_test.cc
@@ -83,6 +83,24 @@ void register_types(Fory &fory) {
 // Polymorphic Vector Tests
 // ============================================================================
 
+TEST(CollectionSerializerTest, RejectsMissingConcreteType) {
+  Config config;
+  ReadContext ctx(config, std::make_unique<TypeResolver>());
+  Buffer buffer;
+  buffer.write_uint8(COLL_IS_SAME_TYPE | COLL_DECL_ELEMENT_TYPE);
+  ctx.attach(buffer);
+
+  using Values = std::vector<std::shared_ptr<Animal>>;
+  auto result =
+      read_collection_data_slow<std::shared_ptr<Animal>, Values>(ctx, 1);
+
+  EXPECT_TRUE(result.empty());
+  ASSERT_TRUE(ctx.has_error());
+  EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidData);
+  EXPECT_NE(ctx.error().message().find("concrete type information"),
+            std::string::npos);
+}
+
 TEST(CollectionSerializerTest, VectorPolymorphicHeterogeneousElements) {
   auto fory = create_fory();
   register_types(fory);
diff --git a/cpp/fory/serialization/fory.h b/cpp/fory/serialization/fory.h
index f9783474c..68d3df58f 100644
--- a/cpp/fory/serialization/fory.h
+++ b/cpp/fory/serialization/fory.h
@@ -868,12 +868,12 @@ private:
     const RefMode top_level_ref_mode =
         read_ctx_->track_ref() ? RefMode::Tracking : RefMode::NullOnly;
     T result = Serializer<T>::read(*read_ctx_, top_level_ref_mode, true);
+    read_ctx_->ref_reader().resolve_callbacks(read_ctx_->error());
     // Check for errors at deserialization boundary
     if (FORY_PREDICT_FALSE(read_ctx_->has_error())) {
       return Unexpected(read_ctx_->take_error());
     }
 
-    read_ctx_->ref_reader().resolve_callbacks();
     return result;
   }
 
diff --git a/cpp/fory/serialization/map_serializer.h 
b/cpp/fory/serialization/map_serializer.h
index 0b893e829..ecfe03b94 100644
--- a/cpp/fory/serialization/map_serializer.h
+++ b/cpp/fory/serialization/map_serializer.h
@@ -250,6 +250,10 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
   constexpr bool val_is_polymorphic = is_polymorphic_v<V>;
   constexpr bool key_is_shared_ref = is_shared_ref_v<K>;
   constexpr bool val_is_shared_ref = is_shared_ref_v<V>;
+  constexpr bool key_is_smart_ptr =
+      is_std_shared_ptr_v<K> || is_std_unique_ptr_v<K>;
+  constexpr bool val_is_smart_ptr =
+      is_std_shared_ptr_v<V> || is_std_unique_ptr_v<V>;
 
   const bool is_key_declared =
       has_generics && !need_to_write_type_for_field<K>();
@@ -264,6 +268,8 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
   // Track current chunk's types for polymorphic handling
   const TypeInfo *current_key_type_info = nullptr;
   const TypeInfo *current_val_type_info = nullptr;
+  Harness::WriteDataFn current_key_writer = nullptr;
+  Harness::WriteDataFn current_val_writer = nullptr;
 
   for (const auto &[key, value] : map) {
     // Check if key or value is null (for nullable types: optional, shared_ptr,
@@ -304,9 +310,16 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
         }
         ctx.write_uint8(chunk_header);
 
-        // write ref flag first if tracking refs
-        if (write_ref) {
-          write_not_null_ref_flag(ctx, RefMode::NullOnly);
+        if constexpr (key_is_shared_ref) {
+          // A null-value entry is its own chunk, but its non-null key still
+          // participates in the map's root reference graph.
+          Serializer<K>::write(key, ctx,
+                               write_ref ? RefMode::Tracking : RefMode::None,
+                               !(chunk_header & DECL_KEY_TYPE), has_generics);
+          if (FORY_PREDICT_FALSE(ctx.has_error())) {
+            return;
+          }
+          continue;
         }
 
         // Then write type info if not declared
@@ -357,9 +370,16 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
         }
         ctx.write_uint8(chunk_header);
 
-        // write ref flag first if tracking refs
-        if (write_ref) {
-          write_not_null_ref_flag(ctx, RefMode::NullOnly);
+        if constexpr (val_is_shared_ref) {
+          // A null-key entry is its own chunk, but its non-null value still
+          // participates in the map's root reference graph.
+          Serializer<V>::write(value, ctx,
+                               write_ref ? RefMode::Tracking : RefMode::None,
+                               !(chunk_header & DECL_VALUE_TYPE), 
has_generics);
+          if (FORY_PREDICT_FALSE(ctx.has_error())) {
+            return;
+          }
+          continue;
         }
 
         // Then write type info if not declared
@@ -523,13 +543,25 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
       need_write_header = false;
       current_key_type_info = key_type_info;
       current_val_type_info = val_type_info;
+      if constexpr (key_is_polymorphic && key_is_smart_ptr) {
+        current_key_writer = key_type_info->harness.write_data_fn;
+      }
+      if constexpr (val_is_polymorphic && val_is_smart_ptr) {
+        current_val_writer = val_type_info->harness.write_data_fn;
+      }
     }
 
     // write key-value pair
     // For shared_ptr with ref tracking: write ref flag + data
     // For other types: null cases already handled via KEY_NULL/VALUE_NULL,
     // so just write data directly
-    if constexpr (key_is_shared_ref) {
+    if constexpr (key_is_polymorphic && key_is_smart_ptr) {
+      const RefMode ref_mode = key_is_shared_ref && ctx.track_ref()
+                                   ? RefMode::Tracking
+                                   : RefMode::None;
+      Serializer<K>::write_with_data(key, ctx, ref_mode, current_key_writer,
+                                     has_generics);
+    } else if constexpr (key_is_shared_ref) {
       if (ctx.track_ref()) {
         Serializer<K>::write(key, ctx, RefMode::Tracking, false, has_generics);
       } else {
@@ -543,7 +575,13 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
       }
     }
 
-    if constexpr (val_is_shared_ref) {
+    if constexpr (val_is_polymorphic && val_is_smart_ptr) {
+      const RefMode ref_mode = val_is_shared_ref && ctx.track_ref()
+                                   ? RefMode::Tracking
+                                   : RefMode::None;
+      Serializer<V>::write_with_data(value, ctx, ref_mode, current_val_writer,
+                                     has_generics);
+    } else if constexpr (val_is_shared_ref) {
       if (ctx.track_ref()) {
         Serializer<V>::write(value, ctx, RefMode::Tracking, false,
                              has_generics);
@@ -567,6 +605,8 @@ inline void write_map_data_slow(const MapType &map, 
WriteContext &ctx,
       need_write_header = true;
       current_key_type_info = nullptr;
       current_val_type_info = nullptr;
+      current_key_writer = nullptr;
+      current_val_writer = nullptr;
     }
   }
 
@@ -734,6 +774,10 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
   constexpr bool val_is_polymorphic = is_polymorphic_v<V>;
   constexpr bool key_is_shared_ref = is_shared_ref_v<K>;
   constexpr bool val_is_shared_ref = is_shared_ref_v<V>;
+  constexpr bool key_is_smart_ptr =
+      is_std_shared_ptr_v<K> || is_std_unique_ptr_v<K>;
+  constexpr bool val_is_smart_ptr =
+      is_std_shared_ptr_v<V> || is_std_unique_ptr_v<V>;
 
   uint32_t len_counter = 0;
 
@@ -757,9 +801,21 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
       bool track_value_ref = (header & TRACKING_VALUE_REF) != 0;
       bool value_declared = (header & DECL_VALUE_TYPE) != 0;
 
+      if constexpr (val_is_shared_ref) {
+        V value = Serializer<V>::read(
+            ctx, track_value_ref ? RefMode::Tracking : RefMode::None,
+            !value_declared);
+        if (FORY_PREDICT_FALSE(ctx.has_error())) {
+          return MapType{};
+        }
+        result.emplace(K{}, std::move(value));
+        len_counter++;
+        continue;
+      }
+
       // Consume ref flag first if tracking refs
       bool has_value = true;
-      if (track_value_ref || val_is_shared_ref) {
+      if (track_value_ref) {
         has_value = read_null_only_flag(ctx, RefMode::NullOnly);
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
@@ -814,9 +870,21 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
       bool track_key_ref = (header & TRACKING_KEY_REF) != 0;
       bool key_declared = (header & DECL_KEY_TYPE) != 0;
 
+      if constexpr (key_is_shared_ref) {
+        K key = Serializer<K>::read(
+            ctx, track_key_ref ? RefMode::Tracking : RefMode::None,
+            !key_declared);
+        if (FORY_PREDICT_FALSE(ctx.has_error())) {
+          return MapType{};
+        }
+        result.emplace(std::move(key), V{});
+        len_counter++;
+        continue;
+      }
+
       // Consume ref flag first if tracking refs
       bool has_key = true;
-      if (track_key_ref || key_is_shared_ref) {
+      if (track_key_ref) {
         has_key = read_null_only_flag(ctx, RefMode::NullOnly);
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
@@ -877,6 +945,8 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
     // Read type info if not declared
     const TypeInfo *key_type_info = nullptr;
     const TypeInfo *value_type_info = nullptr;
+    Harness::ReadAsFn key_reader = nullptr;
+    Harness::ReadAsFn value_reader = nullptr;
 
     if (!key_declared || key_is_polymorphic) {
       if constexpr (key_is_polymorphic) {
@@ -884,6 +954,13 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
         }
+        if constexpr (key_is_smart_ptr) {
+          key_reader = resolve_polymorphic_reader<nullable_element_t<K>>(
+              ctx, key_type_info);
+          if (FORY_PREDICT_FALSE(ctx.has_error())) {
+            return MapType{};
+          }
+        }
       } else {
         read_type_info<K>(ctx);
       }
@@ -894,6 +971,13 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
         }
+        if constexpr (val_is_smart_ptr) {
+          value_reader = resolve_polymorphic_reader<nullable_element_t<V>>(
+              ctx, value_type_info);
+          if (FORY_PREDICT_FALSE(ctx.has_error())) {
+            return MapType{};
+          }
+        }
       } else {
         read_type_info<V>(ctx);
       }
@@ -919,9 +1003,15 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
       K key;
       if constexpr (key_is_polymorphic) {
         // TRACKING_KEY_REF means full ref tracking for shared_ptr
-        key = Serializer<K>::read_with_type_info(
-            ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
-            *key_type_info);
+        if constexpr (key_is_smart_ptr) {
+          key = Serializer<K>::template read_with_type_info<true>(
+              ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
+              *key_type_info, key_reader);
+        } else {
+          key = Serializer<K>::read_with_type_info(
+              ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
+              *key_type_info);
+        }
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
         }
@@ -943,9 +1033,15 @@ inline MapType read_map_data_slow(ReadContext &ctx, 
uint32_t length) {
       V value;
       if constexpr (val_is_polymorphic) {
         // TRACKING_VALUE_REF means full ref tracking for shared_ptr
-        value = Serializer<V>::read_with_type_info(
-            ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
-            *value_type_info);
+        if constexpr (val_is_smart_ptr) {
+          value = Serializer<V>::template read_with_type_info<true>(
+              ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
+              *value_type_info, value_reader);
+        } else {
+          value = Serializer<V>::read_with_type_info(
+              ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
+              *value_type_info);
+        }
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return MapType{};
         }
diff --git a/cpp/fory/serialization/map_serializer_test.cc 
b/cpp/fory/serialization/map_serializer_test.cc
index dfe74e41c..0d181429c 100644
--- a/cpp/fory/serialization/map_serializer_test.cc
+++ b/cpp/fory/serialization/map_serializer_test.cc
@@ -282,6 +282,48 @@ TEST(MapSerializerTest, MapWithCircularReferences) {
   EXPECT_EQ(deserialized[3].get(), deserialized[4].get());
 }
 
+TEST(MapSerializerTest, NullChunksPreserveSharedRefs) {
+  auto fory =
+      Fory::builder().xlang(true).compatible(false).track_ref(true).build();
+
+  auto first = std::make_shared<int32_t>(11);
+  auto second = std::make_shared<int32_t>(22);
+  std::map<std::shared_ptr<int32_t>, std::shared_ptr<int32_t>> map;
+  map.emplace(first, nullptr);
+  map.emplace(second, first);
+  map.emplace(nullptr, second);
+
+  auto bytes = fory.serialize(map);
+  ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+  auto result = fory.deserialize<
+      std::map<std::shared_ptr<int32_t>, std::shared_ptr<int32_t>>>(
+      bytes->data(), bytes->size());
+  ASSERT_TRUE(result.ok()) << result.error().to_string();
+  ASSERT_EQ(result->size(), 3u);
+
+  std::shared_ptr<int32_t> null_value_key;
+  std::shared_ptr<int32_t> null_key_value;
+  std::shared_ptr<int32_t> pair_key;
+  std::shared_ptr<int32_t> pair_value;
+  for (const auto &[key, value] : *result) {
+    if (!key) {
+      null_key_value = value;
+    } else if (!value) {
+      null_value_key = key;
+    } else {
+      pair_key = key;
+      pair_value = value;
+    }
+  }
+
+  ASSERT_TRUE(null_value_key);
+  ASSERT_TRUE(null_key_value);
+  ASSERT_TRUE(pair_key);
+  ASSERT_TRUE(pair_value);
+  EXPECT_EQ(null_value_key.get(), pair_value.get());
+  EXPECT_EQ(null_key_value.get(), pair_key.get());
+}
+
 // ============================================================================
 // Protocol Compliance Tests
 // ============================================================================
@@ -474,6 +516,31 @@ constexpr uint32_t DERIVED_KEY_B_TYPE_ID = 1001;
 constexpr uint32_t DERIVED_VALUE_X_TYPE_ID = 1002;
 constexpr uint32_t DERIVED_VALUE_Y_TYPE_ID = 1003;
 
+TEST(MapSerializerTest, RejectsUnrelatedPolymorphicValue) {
+  using namespace polymorphic_test;
+
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .compatible(compatible)
+                    .track_ref(true)
+                    .build();
+    ASSERT_TRUE(fory.register_struct<DerivedKeyA>(DERIVED_KEY_A_TYPE_ID).ok());
+
+    std::map<int32_t, std::shared_ptr<BaseKey>> values;
+    values.emplace(1, std::make_shared<DerivedKeyA>(1, "unrelated"));
+    auto bytes = fory.serialize(values);
+    ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+
+    auto rejected =
+        fory.deserialize<std::map<int32_t, std::shared_ptr<BaseValue>>>(
+            bytes->data(), bytes->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), fory::ErrorCode::TypeError);
+  }
+}
+
 // Test map with polymorphic value types (most common case)
 TEST(MapSerializerTest, PolymorphicValueTypes) {
   using namespace polymorphic_test;
diff --git a/cpp/fory/serialization/ref_resolver.h 
b/cpp/fory/serialization/ref_resolver.h
index 1a6322ad0..525fa0d44 100644
--- a/cpp/fory/serialization/ref_resolver.h
+++ b/cpp/fory/serialization/ref_resolver.h
@@ -97,7 +97,7 @@ private:
 
 class RefReader {
 public:
-  using UpdateCallback = std::function<void(const RefReader &)>;
+  using UpdateCallback = std::function<void(const RefReader &, Error &)>;
 
   RefReader() = default;
 
@@ -146,12 +146,15 @@ public:
 
   template <typename T>
   void add_update_callback(uint32_t ref_id, std::shared_ptr<T> *target) {
-    callbacks_.emplace_back([ref_id, target](const RefReader &reader) {
-      auto ref_result = reader.template get_shared_ref<T>(ref_id);
-      if (ref_result.ok()) {
-        *target = ref_result.value();
-      }
-    });
+    callbacks_.emplace_back(
+        [ref_id, target](const RefReader &reader, Error &error) {
+          auto ref_result = reader.template get_shared_ref<T>(ref_id);
+          if (FORY_PREDICT_FALSE(!ref_result.ok())) {
+            error = std::move(ref_result).error();
+            return;
+          }
+          *target = ref_result.value();
+        });
   }
 
   /// Add a callback that will be invoked when references are resolved.
@@ -167,15 +170,24 @@ public:
     callbacks_.emplace_back(std::move(callback));
   }
 
-  void resolve_callbacks() {
+  void resolve_callbacks(Error &error) {
+    if (callbacks_.empty()) {
+      return;
+    }
+    if (FORY_PREDICT_FALSE(!error.ok())) {
+      callbacks_.clear();
+      return;
+    }
     for (const auto &cb : callbacks_) {
-      cb(*this);
+      cb(*this, error);
+      if (FORY_PREDICT_FALSE(!error.ok())) {
+        break;
+      }
     }
     callbacks_.clear();
   }
 
   void reset() {
-    resolve_callbacks();
     refs_.clear();
     callbacks_.clear();
   }
@@ -196,6 +208,10 @@ public:
     return static_cast<uint32_t>(refs_.size() - 1);
   }
 
+  bool is_pending_ref(uint32_t ref_id) const {
+    return ref_id < refs_.size() && !refs_[ref_id].ptr;
+  }
+
 private:
   struct RefSlot {
     std::shared_ptr<void> ptr;
diff --git a/cpp/fory/serialization/serializer.h 
b/cpp/fory/serialization/serializer.h
index 8b6a7b15a..5773cd7d8 100644
--- a/cpp/fory/serialization/serializer.h
+++ b/cpp/fory/serialization/serializer.h
@@ -170,6 +170,31 @@ inline bool type_id_matches(uint32_t actual, uint32_t 
expected) {
   return actual == expected;
 }
 
+/// Resolve a declared polymorphic target before materializing the wire type.
+template <typename T>
+inline Harness::ReadAsFn resolve_polymorphic_reader(ReadContext &ctx,
+                                                    const TypeInfo *type_info) 
{
+  if (FORY_PREDICT_FALSE(type_info->harness.find_read_as_fn == nullptr)) {
+    ctx.set_error(
+        Error::type_error("No C++ type information for polymorphic read"));
+    return nullptr;
+  }
+  const std::type_info &target = typeid(T);
+  Harness::ReadAsFn read_as;
+  if (FORY_PREDICT_TRUE(type_info->cached_read_target == &target)) {
+    read_as = type_info->cached_read_as_fn;
+  } else {
+    read_as = type_info->harness.find_read_as_fn(target);
+    type_info->cached_read_as_fn = read_as;
+    type_info->cached_read_target = &target;
+  }
+  if (FORY_PREDICT_FALSE(read_as == nullptr)) {
+    ctx.set_error(Error::type_error(
+        "Wire type is not compatible with the polymorphic target"));
+  }
+  return read_as;
+}
+
 // ============================================================================
 // Core Serializer API
 // ============================================================================
diff --git a/cpp/fory/serialization/smart_ptr_serializer_test.cc 
b/cpp/fory/serialization/smart_ptr_serializer_test.cc
index 39cc311b5..42ee624e7 100644
--- a/cpp/fory/serialization/smart_ptr_serializer_test.cc
+++ b/cpp/fory/serialization/smart_ptr_serializer_test.cc
@@ -20,6 +20,8 @@
 #include "fory/serialization/fory.h"
 #include "gtest/gtest.h"
 #include <cstdint>
+#include <forward_list>
+#include <map>
 #include <memory>
 #include <optional>
 #include <vector>
@@ -48,6 +50,105 @@ struct UniqueHolder {
   FORY_STRUCT(UniqueHolder, value);
 };
 
+struct NonDefaultStruct {
+  explicit NonDefaultStruct(int32_t value) : value(value) {}
+  NonDefaultStruct() = delete;
+
+  int32_t value;
+  FORY_STRUCT(NonDefaultStruct, value);
+};
+
+struct CustomPolyLeading {
+  virtual ~CustomPolyLeading() = default;
+  int32_t leading_value = 0;
+};
+
+struct CustomPolyBase {
+  virtual ~CustomPolyBase() = default;
+  int32_t base_value = 0;
+  FORY_STRUCT(CustomPolyBase, base_value);
+};
+
+struct CustomPolyDerived : CustomPolyLeading, CustomPolyBase {
+  inline static int reads = 0;
+  int32_t derived_value = 0;
+};
+
+template <> struct Serializer<CustomPolyDerived> {
+  static constexpr TypeId type_id = TypeId::EXT;
+
+  static void write(const CustomPolyDerived &value, WriteContext &ctx,
+                    RefMode ref_mode, bool write_type,
+                    bool has_generics = false) {
+    (void)has_generics;
+    write_not_null_ref_flag(ctx, ref_mode);
+    if (write_type) {
+      auto result =
+          ctx.write_any_type_info(static_cast<uint32_t>(type_id),
+                                  std::type_index(typeid(CustomPolyDerived)));
+      if (!result.ok()) {
+        ctx.set_error(std::move(result).error());
+        return;
+      }
+    }
+    write_data(value, ctx);
+  }
+
+  static void write_data(const CustomPolyDerived &value, WriteContext &ctx) {
+    Serializer<int32_t>::write_data(value.leading_value, ctx);
+    Serializer<int32_t>::write_data(value.base_value, ctx);
+    Serializer<int32_t>::write_data(value.derived_value, ctx);
+  }
+
+  static void write_data_generic(const CustomPolyDerived &value,
+                                 WriteContext &ctx, bool has_generics) {
+    (void)has_generics;
+    write_data(value, ctx);
+  }
+
+  static CustomPolyDerived read(ReadContext &ctx, RefMode ref_mode,
+                                bool read_type) {
+    bool has_value = read_null_only_flag(ctx, ref_mode);
+    if (ctx.has_error() || !has_value) {
+      return {};
+    }
+    if (read_type) {
+      const TypeInfo *type_info = ctx.read_any_type_info(ctx.error());
+      if (ctx.has_error()) {
+        return {};
+      }
+      if (type_info == nullptr) {
+        ctx.set_error(
+            Error::type_error("TypeInfo for CustomPolyDerived not found"));
+        return {};
+      }
+    }
+    return read_data(ctx);
+  }
+
+  static CustomPolyDerived read_data(ReadContext &ctx) {
+    ++CustomPolyDerived::reads;
+    CustomPolyDerived value;
+    value.leading_value = Serializer<int32_t>::read_data(ctx);
+    value.base_value = Serializer<int32_t>::read_data(ctx);
+    value.derived_value = Serializer<int32_t>::read_data(ctx);
+    return value;
+  }
+
+  static CustomPolyDerived read_data_generic(ReadContext &ctx,
+                                             bool has_generics) {
+    (void)has_generics;
+    return read_data(ctx);
+  }
+
+  static CustomPolyDerived read_with_type_info(ReadContext &ctx,
+                                               RefMode ref_mode,
+                                               const TypeInfo &type_info) {
+    (void)type_info;
+    return read(ctx, ref_mode, false);
+  }
+};
+
 namespace {
 
 Fory create_serializer(bool track_ref) {
@@ -184,6 +285,16 @@ TEST(SmartPtrSerializerTest, UniquePtrNullRoundTrip) {
   EXPECT_EQ(deserialized.value, nullptr);
 }
 
+TEST(SmartPtrSerializerTest, RegistersNonDefaultStruct) {
+  auto fory = create_serializer(true);
+  ASSERT_TRUE(
+      fory.register_struct<NonDefaultStruct>("test", "NonDefaultStruct").ok());
+
+  NonDefaultStruct value(42);
+  auto bytes = fory.serialize(value);
+  ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+}
+
 // ============================================================================
 // Polymorphic type tests
 // ============================================================================
@@ -207,6 +318,63 @@ struct Derived2 : Base {
   FORY_STRUCT(Derived2, FORY_BASE(Base), derived2_data);
 };
 
+struct Unrelated {
+  inline static int constructions = 0;
+
+  Unrelated() { ++constructions; }
+  Unrelated(const Unrelated &other) : value(other.value) { ++constructions; }
+  Unrelated(Unrelated &&other) noexcept : value(other.value) {
+    ++constructions;
+  }
+  Unrelated &operator=(const Unrelated &) = default;
+  Unrelated &operator=(Unrelated &&) = default;
+  virtual ~Unrelated() = default;
+
+  int32_t value = 0;
+  FORY_STRUCT(Unrelated, value);
+};
+
+struct LeadingBase {
+  virtual ~LeadingBase() = default;
+  int32_t leading_value = 0;
+  FORY_STRUCT(LeadingBase, leading_value);
+};
+
+struct IntermediateBase : Base {
+  FORY_STRUCT(IntermediateBase, FORY_BASE(Base));
+};
+
+struct OffsetDerived : LeadingBase, IntermediateBase {
+  std::string get_type() const override { return "OffsetDerived"; }
+  int32_t derived_value = 0;
+  FORY_STRUCT(OffsetDerived, FORY_BASE(LeadingBase),
+              FORY_BASE(IntermediateBase), derived_value);
+};
+
+struct VirtualDerived : virtual Base {
+  std::string get_type() const override { return "VirtualDerived"; }
+  int32_t derived_value = 0;
+  FORY_STRUCT(VirtualDerived, FORY_BASE(Base), derived_value);
+};
+
+struct VirtualData {
+  int32_t data_value = 0;
+  FORY_STRUCT(VirtualData, data_value);
+};
+
+struct MixedVirtualDerived : Base, virtual VirtualData {
+  std::string get_type() const override { return "MixedVirtualDerived"; }
+  int32_t derived_value = 0;
+  FORY_STRUCT(MixedVirtualDerived, FORY_BASE(Base), FORY_BASE(VirtualData),
+              derived_value);
+};
+
+struct UndeclaredDerived : LeadingBase, Base {
+  std::string get_type() const override { return "UndeclaredDerived"; }
+  int32_t derived_value = 0;
+  FORY_STRUCT(UndeclaredDerived, derived_value);
+};
+
 struct PolymorphicSharedHolder {
   std::shared_ptr<Base> ptr;
   FORY_STRUCT(PolymorphicSharedHolder, ptr);
@@ -217,6 +385,421 @@ struct PolymorphicUniqueHolder {
   FORY_STRUCT(PolymorphicUniqueHolder, ptr);
 };
 
+void register_polymorphic_types(Fory &fory) {
+  ASSERT_TRUE(fory.register_struct<Base>("test", "Base").ok());
+  ASSERT_TRUE(fory.register_struct<Derived1>("test", "Derived1").ok());
+  ASSERT_TRUE(fory.register_struct<Unrelated>("test", "Unrelated").ok());
+  ASSERT_TRUE(
+      fory.register_struct<OffsetDerived>("test", "OffsetDerived").ok());
+  ASSERT_TRUE(
+      fory.register_struct<VirtualDerived>("test", "VirtualDerived").ok());
+  ASSERT_TRUE(
+      fory.register_struct<MixedVirtualDerived>("test", "MixedVirtualDerived")
+          .ok());
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedSharedType) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+
+    auto unrelated = std::make_shared<Unrelated>();
+    unrelated->value = 42;
+    auto bytes_result = fory.serialize(unrelated);
+    ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+    Unrelated::constructions = 0;
+    auto rejected = fory.deserialize<std::shared_ptr<Base>>(
+        bytes_result->data(), bytes_result->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+    EXPECT_NE(rejected.error().message().find("not compatible"),
+              std::string::npos);
+    EXPECT_EQ(Unrelated::constructions, 0);
+
+    std::shared_ptr<Base> valid = std::make_shared<Derived1>();
+    valid->base_value = 17;
+    auto valid_bytes = fory.serialize(valid);
+    ASSERT_TRUE(valid_bytes.ok()) << valid_bytes.error().to_string();
+    auto decoded = fory.deserialize<std::shared_ptr<Base>>(valid_bytes->data(),
+                                                           
valid_bytes->size());
+    ASSERT_TRUE(decoded.ok()) << decoded.error().to_string();
+    ASSERT_NE(decoded.value(), nullptr);
+    EXPECT_EQ(decoded.value()->get_type(), "Derived1");
+    EXPECT_EQ(decoded.value()->base_value, 17);
+  }
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedUniqueType) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+
+    auto unrelated = std::make_unique<Unrelated>();
+    unrelated->value = 42;
+    auto bytes_result = fory.serialize(unrelated);
+    ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+    Unrelated::constructions = 0;
+    auto rejected = fory.deserialize<std::unique_ptr<Base>>(
+        bytes_result->data(), bytes_result->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+    EXPECT_NE(rejected.error().message().find("not compatible"),
+              std::string::npos);
+    EXPECT_EQ(Unrelated::constructions, 0);
+  }
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedCollections) {
+  for (bool compatible : {false, true}) {
+    for (bool track_ref : {false, true}) {
+      SCOPED_TRACE(::testing::Message() << "compatible=" << compatible
+                                        << ", track_ref=" << track_ref);
+      auto fory = Fory::builder()
+                      .xlang(true)
+                      .track_ref(track_ref)
+                      .compatible(compatible)
+                      .build();
+      register_polymorphic_types(fory);
+
+      std::vector<std::shared_ptr<Unrelated>> values{
+          std::make_shared<Unrelated>()};
+      auto bytes_result = fory.serialize(values);
+      ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+      Unrelated::constructions = 0;
+      auto rejected = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+          bytes_result->data(), bytes_result->size());
+      ASSERT_FALSE(rejected.ok());
+      EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+      EXPECT_EQ(Unrelated::constructions, 0);
+    }
+
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+    std::vector<std::unique_ptr<Unrelated>> values;
+    values.emplace_back(std::make_unique<Unrelated>());
+    auto bytes_result = fory.serialize(values);
+    ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+    Unrelated::constructions = 0;
+    auto rejected = fory.deserialize<std::vector<std::unique_ptr<Base>>>(
+        bytes_result->data(), bytes_result->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+    EXPECT_EQ(Unrelated::constructions, 0);
+  }
+}
+
+TEST(SmartPtrSerializerTest, AdjustsMultipleInheritance) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+
+    auto concrete = std::make_shared<OffsetDerived>();
+    concrete->leading_value = 11;
+    concrete->base_value = 22;
+    concrete->derived_value = 33;
+    std::shared_ptr<Base> shared = concrete;
+    ASSERT_NE(static_cast<const void *>(concrete.get()),
+              static_cast<const void *>(shared.get()));
+
+    auto shared_bytes = fory.serialize(shared);
+    ASSERT_TRUE(shared_bytes.ok()) << shared_bytes.error().to_string();
+    auto shared_result = fory.deserialize<std::shared_ptr<Base>>(
+        shared_bytes->data(), shared_bytes->size());
+    ASSERT_TRUE(shared_result.ok()) << shared_result.error().to_string();
+    auto *shared_derived =
+        dynamic_cast<OffsetDerived *>(shared_result.value().get());
+    ASSERT_NE(shared_derived, nullptr);
+    EXPECT_EQ(shared_derived->leading_value, 11);
+    EXPECT_EQ(shared_derived->base_value, 22);
+    EXPECT_EQ(shared_derived->derived_value, 33);
+
+    auto unique_concrete = std::make_unique<OffsetDerived>();
+    unique_concrete->leading_value = 44;
+    unique_concrete->base_value = 55;
+    unique_concrete->derived_value = 66;
+    std::unique_ptr<Base> unique = std::move(unique_concrete);
+    auto unique_bytes = fory.serialize(unique);
+    ASSERT_TRUE(unique_bytes.ok()) << unique_bytes.error().to_string();
+    auto unique_result = fory.deserialize<std::unique_ptr<Base>>(
+        unique_bytes->data(), unique_bytes->size());
+    ASSERT_TRUE(unique_result.ok()) << unique_result.error().to_string();
+    auto *unique_derived =
+        dynamic_cast<OffsetDerived *>(unique_result.value().get());
+    ASSERT_NE(unique_derived, nullptr);
+    EXPECT_EQ(unique_derived->leading_value, 44);
+    EXPECT_EQ(unique_derived->base_value, 55);
+    EXPECT_EQ(unique_derived->derived_value, 66);
+
+    std::vector<std::shared_ptr<Base>> shared_values;
+    auto shared_value = std::make_shared<OffsetDerived>();
+    shared_value->leading_value = 71;
+    shared_value->base_value = 72;
+    shared_value->derived_value = 73;
+    shared_values.push_back(std::move(shared_value));
+    auto shared_vector_bytes = fory.serialize(shared_values);
+    ASSERT_TRUE(shared_vector_bytes.ok())
+        << shared_vector_bytes.error().to_string();
+    auto shared_vector_result =
+        fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+            shared_vector_bytes->data(), shared_vector_bytes->size());
+    ASSERT_TRUE(shared_vector_result.ok())
+        << shared_vector_result.error().to_string();
+    ASSERT_EQ(shared_vector_result->size(), 1u);
+    auto *shared_vector_derived =
+        dynamic_cast<OffsetDerived *>(shared_vector_result->front().get());
+    ASSERT_NE(shared_vector_derived, nullptr);
+    EXPECT_EQ(shared_vector_derived->leading_value, 71);
+    EXPECT_EQ(shared_vector_derived->base_value, 72);
+    EXPECT_EQ(shared_vector_derived->derived_value, 73);
+
+    std::vector<std::unique_ptr<Base>> unique_values;
+    auto unique_value = std::make_unique<OffsetDerived>();
+    unique_value->leading_value = 81;
+    unique_value->base_value = 82;
+    unique_value->derived_value = 83;
+    unique_values.push_back(std::move(unique_value));
+    auto unique_vector_bytes = fory.serialize(unique_values);
+    ASSERT_TRUE(unique_vector_bytes.ok())
+        << unique_vector_bytes.error().to_string();
+    auto unique_vector_result =
+        fory.deserialize<std::vector<std::unique_ptr<Base>>>(
+            unique_vector_bytes->data(), unique_vector_bytes->size());
+    ASSERT_TRUE(unique_vector_result.ok())
+        << unique_vector_result.error().to_string();
+    ASSERT_EQ(unique_vector_result->size(), 1u);
+    auto *unique_vector_derived =
+        dynamic_cast<OffsetDerived *>(unique_vector_result->front().get());
+    ASSERT_NE(unique_vector_derived, nullptr);
+    EXPECT_EQ(unique_vector_derived->leading_value, 81);
+    EXPECT_EQ(unique_vector_derived->base_value, 82);
+    EXPECT_EQ(unique_vector_derived->derived_value, 83);
+
+    std::map<int32_t, std::shared_ptr<Base>> shared_map;
+    auto map_value = std::make_shared<OffsetDerived>();
+    map_value->leading_value = 91;
+    map_value->base_value = 92;
+    map_value->derived_value = 93;
+    shared_map.emplace(1, std::move(map_value));
+    auto shared_map_bytes = fory.serialize(shared_map);
+    ASSERT_TRUE(shared_map_bytes.ok()) << shared_map_bytes.error().to_string();
+    auto shared_map_result =
+        fory.deserialize<std::map<int32_t, std::shared_ptr<Base>>>(
+            shared_map_bytes->data(), shared_map_bytes->size());
+    ASSERT_TRUE(shared_map_result.ok())
+        << shared_map_result.error().to_string();
+    ASSERT_EQ(shared_map_result->size(), 1u);
+    auto *shared_map_derived =
+        dynamic_cast<OffsetDerived 
*>(shared_map_result->begin()->second.get());
+    ASSERT_NE(shared_map_derived, nullptr);
+    EXPECT_EQ(shared_map_derived->leading_value, 91);
+    EXPECT_EQ(shared_map_derived->base_value, 92);
+    EXPECT_EQ(shared_map_derived->derived_value, 93);
+  }
+}
+
+TEST(SmartPtrSerializerTest, AdjustsVirtualInheritance) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+
+    std::vector<std::shared_ptr<Base>> values;
+    auto value = std::make_shared<VirtualDerived>();
+    value->base_value = 101;
+    value->derived_value = 202;
+    values.push_back(std::move(value));
+
+    auto bytes = fory.serialize(values);
+    ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+    auto result = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+        bytes->data(), bytes->size());
+    ASSERT_TRUE(result.ok()) << result.error().to_string();
+    ASSERT_EQ(result->size(), 1u);
+    auto *derived = dynamic_cast<VirtualDerived *>(result->front().get());
+    ASSERT_NE(derived, nullptr);
+    EXPECT_EQ(derived->base_value, 101);
+    EXPECT_EQ(derived->derived_value, 202);
+
+    std::vector<std::shared_ptr<Base>> mixed_values;
+    auto mixed_value = std::make_shared<MixedVirtualDerived>();
+    mixed_value->base_value = 303;
+    mixed_value->data_value = 404;
+    mixed_value->derived_value = 505;
+    mixed_values.push_back(std::move(mixed_value));
+
+    auto mixed_bytes = fory.serialize(mixed_values);
+    ASSERT_TRUE(mixed_bytes.ok()) << mixed_bytes.error().to_string();
+    auto mixed_result = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+        mixed_bytes->data(), mixed_bytes->size());
+    ASSERT_TRUE(mixed_result.ok()) << mixed_result.error().to_string();
+    ASSERT_EQ(mixed_result->size(), 1u);
+    auto *mixed_derived =
+        dynamic_cast<MixedVirtualDerived *>(mixed_result->front().get());
+    ASSERT_NE(mixed_derived, nullptr);
+    EXPECT_EQ(mixed_derived->base_value, 303);
+    EXPECT_EQ(mixed_derived->data_value, 404);
+    EXPECT_EQ(mixed_derived->derived_value, 505);
+  }
+}
+
+TEST(SmartPtrSerializerTest, UndeclaredBaseWrite) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+    ASSERT_TRUE(
+        fory.register_struct<UndeclaredDerived>("test", "UndeclaredDerived")
+            .ok());
+
+    auto concrete = std::make_shared<UndeclaredDerived>();
+    concrete->derived_value = 123;
+    std::shared_ptr<Base> value = concrete;
+    ASSERT_NE(static_cast<const void *>(concrete.get()),
+              static_cast<const void *>(value.get()));
+
+    auto bytes = fory.serialize(value);
+    ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+    auto exact = fory.deserialize<std::shared_ptr<UndeclaredDerived>>(
+        bytes->data(), bytes->size());
+    ASSERT_TRUE(exact.ok()) << exact.error().to_string();
+    EXPECT_EQ(exact.value()->derived_value, 123);
+
+    auto rejected =
+        fory.deserialize<std::shared_ptr<Base>>(bytes->data(), bytes->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+  }
+}
+
+TEST(SmartPtrSerializerTest, CustomPolymorphicExactRead) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    ASSERT_TRUE(fory.register_extension_type<CustomPolyDerived>(
+                        "test", "CustomPolyDerived")
+                    .ok());
+
+    auto concrete = std::make_shared<CustomPolyDerived>();
+    concrete->leading_value = 11;
+    concrete->base_value = 22;
+    concrete->derived_value = 33;
+    std::shared_ptr<CustomPolyBase> value = concrete;
+    ASSERT_NE(static_cast<const void *>(concrete.get()),
+              static_cast<const void *>(value.get()));
+
+    auto bytes = fory.serialize(value);
+    ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+    CustomPolyDerived::reads = 0;
+    auto result = fory.deserialize<std::shared_ptr<CustomPolyDerived>>(
+        bytes->data(), bytes->size());
+    ASSERT_TRUE(result.ok()) << result.error().to_string();
+    EXPECT_EQ(CustomPolyDerived::reads, 1);
+    EXPECT_EQ(result.value()->leading_value, 11);
+    EXPECT_EQ(result.value()->base_value, 22);
+    EXPECT_EQ(result.value()->derived_value, 33);
+
+    CustomPolyDerived::reads = 0;
+    auto rejected = fory.deserialize<std::shared_ptr<CustomPolyBase>>(
+        bytes->data(), bytes->size());
+    ASSERT_FALSE(rejected.ok());
+    EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+    EXPECT_EQ(CustomPolyDerived::reads, 0);
+  }
+}
+
+TEST(SmartPtrSerializerTest, ForwardListPolymorphism) {
+  for (bool compatible : {false, true}) {
+    SCOPED_TRACE(compatible);
+    auto fory = Fory::builder()
+                    .xlang(true)
+                    .track_ref(true)
+                    .compatible(compatible)
+                    .build();
+    register_polymorphic_types(fory);
+
+    auto shared_value = std::make_shared<OffsetDerived>();
+    shared_value->leading_value = 601;
+    shared_value->base_value = 602;
+    shared_value->derived_value = 603;
+    std::forward_list<std::shared_ptr<Base>> shared_values{shared_value,
+                                                           shared_value};
+
+    auto shared_bytes = fory.serialize(shared_values);
+    ASSERT_TRUE(shared_bytes.ok()) << shared_bytes.error().to_string();
+    auto shared_result =
+        fory.deserialize<std::forward_list<std::shared_ptr<Base>>>(
+            shared_bytes->data(), shared_bytes->size());
+    ASSERT_TRUE(shared_result.ok()) << shared_result.error().to_string();
+    auto shared_it = shared_result->begin();
+    ASSERT_NE(shared_it, shared_result->end());
+    auto *shared_derived = dynamic_cast<OffsetDerived *>(shared_it->get());
+    ASSERT_NE(shared_derived, nullptr);
+    EXPECT_EQ(shared_derived->leading_value, 601);
+    EXPECT_EQ(shared_derived->base_value, 602);
+    EXPECT_EQ(shared_derived->derived_value, 603);
+    auto first_ptr = shared_it->get();
+    ++shared_it;
+    ASSERT_NE(shared_it, shared_result->end());
+    EXPECT_EQ(first_ptr, shared_it->get());
+
+    std::forward_list<std::unique_ptr<Base>> unique_values;
+    auto unique_value = std::make_unique<OffsetDerived>();
+    unique_value->leading_value = 701;
+    unique_value->base_value = 702;
+    unique_value->derived_value = 703;
+    unique_values.push_front(std::move(unique_value));
+
+    auto unique_bytes = fory.serialize(unique_values);
+    ASSERT_TRUE(unique_bytes.ok()) << unique_bytes.error().to_string();
+    auto unique_result =
+        fory.deserialize<std::forward_list<std::unique_ptr<Base>>>(
+            unique_bytes->data(), unique_bytes->size());
+    ASSERT_TRUE(unique_result.ok()) << unique_result.error().to_string();
+    ASSERT_NE(unique_result->begin(), unique_result->end());
+    auto *unique_derived =
+        dynamic_cast<OffsetDerived *>(unique_result->front().get());
+    ASSERT_NE(unique_derived, nullptr);
+    EXPECT_EQ(unique_derived->leading_value, 701);
+    EXPECT_EQ(unique_derived->base_value, 702);
+    EXPECT_EQ(unique_derived->derived_value, 703);
+  }
+}
+
 TEST(SmartPtrSerializerTest, PolymorphicSharedPtrDerived1) {
   auto fory = create_serializer(true);
   fory.register_struct<PolymorphicSharedHolder>(200);
diff --git a/cpp/fory/serialization/smart_ptr_serializers.h 
b/cpp/fory/serialization/smart_ptr_serializers.h
index ea9623015..bb5b91e36 100644
--- a/cpp/fory/serialization/smart_ptr_serializers.h
+++ b/cpp/fory/serialization/smart_ptr_serializers.h
@@ -20,6 +20,7 @@
 #pragma once
 
 #include "fory/serialization/serializer.h"
+#include <cassert>
 #include <memory>
 #include <optional>
 #include <string>
@@ -28,36 +29,54 @@ namespace fory {
 namespace serialization {
 
 // ============================================================================
-// Helper for polymorphic deserialization
+// Helpers for polymorphic smart pointers
 // ============================================================================
 
-/// Reads polymorphic data using the appropriate harness function based on 
mode.
-/// In compatible mode, uses read_compatible_fn if available to handle schema
-/// evolution. Otherwise, uses read_data_fn for direct deserialization.
-/// Returns nullptr and sets ctx.error() on failure.
-inline void *read_polymorphic_harness_data(ReadContext &ctx,
-                                           const TypeInfo *type_info) {
-  if (ctx.is_compatible()) {
-    if (!type_info->harness.read_compatible_fn) {
-      ctx.set_error(Error::type_error(
-          "No harness read_compatible function for polymorphic type "
-          "deserialization in compatible mode"));
-      return nullptr;
-    }
-    return type_info->harness.read_compatible_fn(ctx, type_info);
-  }
-  if (!type_info->harness.read_data_fn) {
-    ctx.set_error(Error::type_error(
-        "No harness read function for polymorphic type deserialization"));
+template <typename T>
+inline void write_polymorphic_harness_data(const T &value, WriteContext &ctx,
+                                           bool has_generics,
+                                           Harness::WriteDataFn writer) {
+  assert(writer != nullptr);
+  // A smart pointer may address an offset base subobject, while the dynamic
+  // TypeInfo owns a concrete writer. Recover the complete object before that
+  // writer casts the erased address back to its concrete type.
+  writer(dynamic_cast<const void *>(std::addressof(value)), ctx, has_generics);
+}
+
+FORY_ALWAYS_INLINE void
+write_polymorphic_harness_data(const void *complete_value, WriteContext &ctx,
+                               const TypeInfo &type_info, bool has_generics) {
+  // Root callers capture this address beside typeid before resolver calls so
+  // optimized builds can share the object's RTTI lookup.
+  type_info.harness.write_data_fn(complete_value, ctx, has_generics);
+}
+
+/// Reads polymorphic data through a target-validated harness function.
+/// The reader must be resolved before it runs because the wire can select any
+/// registered type and harness reads may materialize application objects.
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+                                        const TypeInfo *type_info,
+                                        Harness::ReadAsFn read_as) {
+  assert(read_as != nullptr);
+  return static_cast<T *>(read_as(ctx, type_info));
+}
+
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+                                        const TypeInfo *type_info) {
+  Harness::ReadAsFn read_as = resolve_polymorphic_reader<T>(ctx, type_info);
+  if (FORY_PREDICT_FALSE(ctx.has_error())) {
     return nullptr;
   }
-  return type_info->harness.read_data_fn(ctx);
+  return read_polymorphic_harness_data<T>(ctx, type_info, read_as);
 }
 
 /// Overload for TypeInfo reference.
-inline void *read_polymorphic_harness_data(ReadContext &ctx,
-                                           const TypeInfo &type_info) {
-  return read_polymorphic_harness_data(ctx, &type_info);
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+                                        const TypeInfo &type_info) {
+  return read_polymorphic_harness_data<T>(ctx, &type_info);
 }
 
 // ============================================================================
@@ -263,6 +282,9 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
                 "shared_ptr of nullable types "
                 "(optional/shared_ptr/unique_ptr/weak_ptr) is not supported. "
                 "Use the wrapper type directly instead.");
+  static_assert(!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>,
+                "polymorphic shared_ptr element types require a virtual "
+                "destructor");
 
   static constexpr TypeId type_id =
       SharedPtrTypeIdHelper<T, std::is_polymorphic_v<T>>::value;
@@ -300,6 +322,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
       }
       // For polymorphic types, serialize the concrete type dynamically
       if constexpr (is_polymorphic) {
+        const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
         std::type_index concrete_type_id = std::type_index(typeid(*ptr));
         auto type_info_res =
             ctx.type_resolver().get_type_info(concrete_type_id);
@@ -316,8 +339,8 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
             return;
           }
         }
-        const void *value_ptr = ptr.get();
-        type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+        write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                       has_generics);
       } else {
         // T is guaranteed to be a value type by static_assert.
         Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -341,6 +364,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
 
     // For polymorphic types, serialize the concrete type dynamically
     if constexpr (is_polymorphic) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       // get the concrete type_index from the actual object
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
 
@@ -362,10 +386,9 @@ template <typename T> struct 
Serializer<std::shared_ptr<T>> {
         }
       }
 
-      // Call the harness with the raw pointer (which points to DerivedType)
-      // The harness will static_cast it back to the concrete type
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+      // The harness expects the complete concrete object address.
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                     has_generics);
     } else {
       // T is guaranteed to be a value type by static_assert.
       Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -382,6 +405,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
 
     // For polymorphic types, use harness to serialize the concrete type
     if constexpr (std::is_polymorphic_v<T>) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
       auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
       if (!type_info_res.ok()) {
@@ -389,13 +413,39 @@ template <typename T> struct 
Serializer<std::shared_ptr<T>> {
         return;
       }
       const TypeInfo *type_info = type_info_res.value();
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, false);
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info, false);
     } else {
       Serializer<T>::write_data(*ptr, ctx);
     }
   }
 
+  static inline void write_with_data(const std::shared_ptr<T> &ptr,
+                                     WriteContext &ctx, RefMode ref_mode,
+                                     Harness::WriteDataFn writer,
+                                     bool has_generics = false) {
+    static_assert(std::is_polymorphic_v<T>);
+    if (ref_mode == RefMode::None) {
+      if (FORY_PREDICT_FALSE(!ptr)) {
+        ctx.set_error(Error::invalid("std::shared_ptr requires ref_mode != "
+                                     "RefMode::None to encode null state"));
+        return;
+      }
+    } else {
+      if (!ptr) {
+        ctx.write_int8(NULL_FLAG);
+        return;
+      }
+      if (ctx.track_ref()) {
+        if (ctx.ref_writer().try_write_shared_ref(ctx, ptr)) {
+          return;
+        }
+      } else {
+        ctx.write_int8(NOT_NULL_VALUE_FLAG);
+      }
+    }
+    write_polymorphic_harness_data(*ptr, ctx, has_generics, writer);
+  }
+
   static inline void write_data_generic(const std::shared_ptr<T> &ptr,
                                         WriteContext &ctx, bool has_generics) {
     if (!ptr) {
@@ -406,6 +456,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
 
     // For polymorphic types, use harness to serialize the concrete type
     if constexpr (std::is_polymorphic_v<T>) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
       auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
       if (!type_info_res.ok()) {
@@ -413,8 +464,8 @@ template <typename T> struct Serializer<std::shared_ptr<T>> 
{
         return;
       }
       const TypeInfo *type_info = type_info_res.value();
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                     has_generics);
     } else {
       Serializer<T>::write_data_generic(*ptr, ctx, has_generics);
     }
@@ -530,11 +581,10 @@ template <typename T> struct 
Serializer<std::shared_ptr<T>> {
         }
 
         // Use the harness to deserialize the concrete type
-        void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+        T *obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return nullptr;
         }
-        T *obj_ptr = static_cast<T *>(raw_ptr);
         auto result = std::shared_ptr<T>(obj_ptr);
         if (is_first_occurrence) {
           ctx.ref_reader().store_shared_ref_at(reserved_ref_id, result);
@@ -610,20 +660,30 @@ template <typename T> struct 
Serializer<std::shared_ptr<T>> {
     }
   }
 
+  template <bool HasReader = false>
   static inline std::shared_ptr<T>
   read_with_type_info(ReadContext &ctx, RefMode ref_mode,
-                      const TypeInfo &type_info) {
+                      const TypeInfo &type_info,
+                      Harness::ReadAsFn checked_reader = nullptr) {
     constexpr bool is_polymorphic = std::is_polymorphic_v<T>;
+    if constexpr (HasReader) {
+      assert(checked_reader != nullptr);
+    }
 
     // Handle ref_mode == RefMode::None case (similar to Rust)
     if (ref_mode == RefMode::None) {
       // For polymorphic types, use the harness to deserialize the concrete 
type
       if constexpr (is_polymorphic) {
-        void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+        T *obj_ptr;
+        if constexpr (HasReader) {
+          obj_ptr =
+              read_polymorphic_harness_data<T>(ctx, &type_info, 
checked_reader);
+        } else {
+          obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+        }
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return nullptr;
         }
-        T *obj_ptr = static_cast<T *>(raw_ptr);
         return std::shared_ptr<T>(obj_ptr);
       } else {
         // T is guaranteed to be a value type by static_assert.
@@ -694,11 +754,16 @@ template <typename T> struct 
Serializer<std::shared_ptr<T>> {
       DynDepthGuard dyn_depth_guard(ctx);
 
       // Use the harness to deserialize the concrete type
-      void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+      T *obj_ptr;
+      if constexpr (HasReader) {
+        obj_ptr =
+            read_polymorphic_harness_data<T>(ctx, &type_info, checked_reader);
+      } else {
+        obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+      }
       if (FORY_PREDICT_FALSE(ctx.has_error())) {
         return nullptr;
       }
-      T *obj_ptr = static_cast<T *>(raw_ptr);
       auto result = std::shared_ptr<T>(obj_ptr);
       if (flag == REF_VALUE_FLAG) {
         ctx.ref_reader().store_shared_ref_at(reserved_ref_id, result);
@@ -777,6 +842,9 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
                 "unique_ptr of nullable types "
                 "(optional/shared_ptr/unique_ptr/weak_ptr) is not supported. "
                 "Use the wrapper type directly instead.");
+  static_assert(!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>,
+                "polymorphic unique_ptr element types require a virtual "
+                "destructor");
 
   static constexpr TypeId type_id =
       UniquePtrTypeIdHelper<T, std::is_polymorphic_v<T>>::value;
@@ -795,6 +863,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
       }
       // For polymorphic types, serialize the concrete type dynamically
       if constexpr (is_polymorphic) {
+        const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
         std::type_index concrete_type_id = std::type_index(typeid(*ptr));
         auto type_info_res =
             ctx.type_resolver().get_type_info(concrete_type_id);
@@ -811,8 +880,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
             return;
           }
         }
-        const void *value_ptr = ptr.get();
-        type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+        write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                       has_generics);
       } else {
         // T is guaranteed to be a value type by static_assert.
         Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -830,6 +899,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
 
     // For polymorphic types, serialize the concrete type dynamically
     if constexpr (is_polymorphic) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
       auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
       if (!type_info_res.ok()) {
@@ -845,8 +915,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
           return;
         }
       }
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                     has_generics);
     } else {
       // T is guaranteed to be a value type by static_assert.
       Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -862,6 +932,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
     }
     // For polymorphic types, use harness to serialize the concrete type
     if constexpr (std::is_polymorphic_v<T>) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
       auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
       if (!type_info_res.ok()) {
@@ -869,13 +940,33 @@ template <typename T> struct 
Serializer<std::unique_ptr<T>> {
         return;
       }
       const TypeInfo *type_info = type_info_res.value();
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, false);
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info, false);
     } else {
       Serializer<T>::write_data(*ptr, ctx);
     }
   }
 
+  static inline void write_with_data(const std::unique_ptr<T> &ptr,
+                                     WriteContext &ctx, RefMode ref_mode,
+                                     Harness::WriteDataFn writer,
+                                     bool has_generics = false) {
+    static_assert(std::is_polymorphic_v<T>);
+    if (ref_mode == RefMode::None) {
+      if (FORY_PREDICT_FALSE(!ptr)) {
+        ctx.set_error(Error::invalid("std::unique_ptr requires ref_mode != "
+                                     "RefMode::None to encode null state"));
+        return;
+      }
+    } else {
+      if (!ptr) {
+        ctx.write_int8(NULL_FLAG);
+        return;
+      }
+      ctx.write_int8(NOT_NULL_VALUE_FLAG);
+    }
+    write_polymorphic_harness_data(*ptr, ctx, has_generics, writer);
+  }
+
   static inline void write_data_generic(const std::unique_ptr<T> &ptr,
                                         WriteContext &ctx, bool has_generics) {
     if (!ptr) {
@@ -885,6 +976,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
     }
     // For polymorphic types, use harness to serialize the concrete type
     if constexpr (std::is_polymorphic_v<T>) {
+      const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
       std::type_index concrete_type_id = std::type_index(typeid(*ptr));
       auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
       if (!type_info_res.ok()) {
@@ -892,8 +984,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>> 
{
         return;
       }
       const TypeInfo *type_info = type_info_res.value();
-      const void *value_ptr = ptr.get();
-      type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+      write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+                                     has_generics);
     } else {
       Serializer<T>::write_data_generic(*ptr, ctx, has_generics);
     }
@@ -979,11 +1071,10 @@ template <typename T> struct 
Serializer<std::unique_ptr<T>> {
         }
 
         // Use the harness to deserialize the concrete type
-        void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+        T *obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return nullptr;
         }
-        T *obj_ptr = static_cast<T *>(raw_ptr);
         return std::unique_ptr<T>(obj_ptr);
       } else {
         // Monomorphic path: read_type=false means field is marked monomorphic
@@ -1017,20 +1108,30 @@ template <typename T> struct 
Serializer<std::unique_ptr<T>> {
     }
   }
 
+  template <bool HasReader = false>
   static inline std::unique_ptr<T>
   read_with_type_info(ReadContext &ctx, RefMode ref_mode,
-                      const TypeInfo &type_info) {
+                      const TypeInfo &type_info,
+                      Harness::ReadAsFn checked_reader = nullptr) {
     constexpr bool is_polymorphic = std::is_polymorphic_v<T>;
+    if constexpr (HasReader) {
+      assert(checked_reader != nullptr);
+    }
 
     // Handle ref_mode == RefMode::None case (similar to Rust)
     if (ref_mode == RefMode::None) {
       // For polymorphic types, use the harness to deserialize the concrete 
type
       if constexpr (is_polymorphic) {
-        void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+        T *obj_ptr;
+        if constexpr (HasReader) {
+          obj_ptr =
+              read_polymorphic_harness_data<T>(ctx, &type_info, 
checked_reader);
+        } else {
+          obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+        }
         if (FORY_PREDICT_FALSE(ctx.has_error())) {
           return nullptr;
         }
-        T *obj_ptr = static_cast<T *>(raw_ptr);
         return std::unique_ptr<T>(obj_ptr);
       } else {
         // T is guaranteed to be a value type by static_assert.
@@ -1072,11 +1173,16 @@ template <typename T> struct 
Serializer<std::unique_ptr<T>> {
       DynDepthGuard dyn_depth_guard(ctx);
 
       // Use the harness to deserialize the concrete type
-      void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+      T *obj_ptr;
+      if constexpr (HasReader) {
+        obj_ptr =
+            read_polymorphic_harness_data<T>(ctx, &type_info, checked_reader);
+      } else {
+        obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+      }
       if (FORY_PREDICT_FALSE(ctx.has_error())) {
         return nullptr;
       }
-      T *obj_ptr = static_cast<T *>(raw_ptr);
       return std::unique_ptr<T>(obj_ptr);
     } else {
       // T is guaranteed to be a value type by static_assert.
diff --git a/cpp/fory/serialization/type_info.h 
b/cpp/fory/serialization/type_info.h
index d2ee3d4bc..c2c821d66 100644
--- a/cpp/fory/serialization/type_info.h
+++ b/cpp/fory/serialization/type_info.h
@@ -29,6 +29,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <typeinfo>
 #include <vector>
 
 namespace fory {
@@ -71,6 +72,9 @@ struct Harness {
       Result<std::vector<FieldInfo>, Error> (*)(TypeResolver &);
   using AnyWriteFn = void (*)(const std::any &value, WriteContext &ctx);
   using AnyReadFn = std::any (*)(ReadContext &ctx);
+  using ReadAsFn = void *(*)(ReadContext &ctx,
+                             const struct TypeInfo *type_info);
+  using FindReadAsFn = ReadAsFn (*)(const std::type_info &target);
 
   Harness() = default;
   Harness(WriteFn write, ReadFn read, WriteDataFn write_data,
@@ -85,7 +89,8 @@ struct Harness {
   bool valid() const {
     return write_fn != nullptr && read_fn != nullptr &&
            write_data_fn != nullptr && read_data_fn != nullptr &&
-           destroy_fn != nullptr && sorted_field_infos_fn != nullptr;
+           destroy_fn != nullptr && sorted_field_infos_fn != nullptr &&
+           find_read_as_fn != nullptr;
   }
 
   WriteFn write_fn = nullptr;
@@ -97,6 +102,9 @@ struct Harness {
   ReadCompatibleFn read_compatible_fn = nullptr;
   AnyWriteFn any_write_fn = nullptr;
   AnyReadFn any_read_fn = nullptr;
+  // Polymorphic smart-pointer reads resolve this before materializing the wire
+  // type so only declared C++ base relationships can reach an owning reader.
+  FindReadAsFn find_read_as_fn = nullptr;
 };
 
 // ============================================================================
@@ -132,6 +140,11 @@ struct TypeInfo {
   fory::flat_hash_map<std::string, size_t> name_to_index;
   std::vector<uint8_t> type_def;
   Harness harness;
+  // TypeInfo and its harness are immutable after registration. Cache the last
+  // read target so repeated root operations avoid walking the declared base
+  // graph; ThreadSafeFory uses distinct cloned TypeInfo owners per pooled 
Fory.
+  mutable const std::type_info *cached_read_target = nullptr;
+  mutable Harness::ReadAsFn cached_read_as_fn = nullptr;
   // Pre-encoded meta strings for efficient writing (avoids re-encoding on each
   // write)
   std::unique_ptr<CachedMetaString> encoded_namespace;
diff --git a/cpp/fory/serialization/type_resolver.h 
b/cpp/fory/serialization/type_resolver.h
index d73b62a2f..44d1e2822 100644
--- a/cpp/fory/serialization/type_resolver.h
+++ b/cpp/fory/serialization/type_resolver.h
@@ -1477,6 +1477,27 @@ private:
   static void *harness_read_compatible_adapter_abstract(ReadContext &ctx,
                                                         const TypeInfo *ti);
 
+  template <typename Source, typename Target>
+  static void *harness_struct_read_as(ReadContext &ctx,
+                                      const TypeInfo *type_info);
+
+  template <typename Source, typename Target>
+  static void *harness_exact_read_as(ReadContext &ctx,
+                                     const TypeInfo *type_info);
+
+  template <typename Source, typename Current, bool MatchAddress>
+  static Harness::ReadAsFn find_struct_read_impl(const std::type_info &target);
+
+  template <typename Source, typename Bases, bool MatchAddress,
+            size_t Index = 0>
+  static Harness::ReadAsFn find_base_read_impl(const std::type_info &target);
+
+  template <typename Source, typename Current>
+  static Harness::ReadAsFn find_struct_read(const std::type_info &target);
+
+  template <typename T>
+  static Harness::ReadAsFn find_exact_read(const std::type_info &target);
+
   static std::string make_name_key(const std::string &ns,
                                    const std::string &name);
   static uint64_t make_user_type_key(uint32_t type_id, uint32_t user_type_id);
@@ -1547,6 +1568,98 @@ inline void TypeResolver::check_registration_thread() {
       << "TypeResolver has been finalized, cannot register more types";
 }
 
+template <typename Source, typename Target>
+inline void *TypeResolver::harness_struct_read_as(ReadContext &ctx,
+                                                  const TypeInfo *type_info) {
+  static_assert(std::is_convertible_v<Source *, Target *>,
+                "polymorphic read target must be an accessible base");
+  if constexpr (std::is_abstract_v<Source> ||
+                !std::is_default_constructible_v<Source>) {
+    ctx.set_error(Error::type_error(
+        "Cannot deserialize abstract or non-default-constructible type"));
+    return nullptr;
+  } else {
+    void *value = ctx.is_compatible()
+                      ? harness_read_compatible_adapter<Source>(ctx, type_info)
+                      : harness_read_data_adapter<Source>(ctx);
+    return static_cast<Target *>(static_cast<Source *>(value));
+  }
+}
+
+template <typename Source, typename Target>
+inline void *TypeResolver::harness_exact_read_as(ReadContext &ctx,
+                                                 const TypeInfo *type_info) {
+  static_assert(std::is_convertible_v<Source *, Target *>,
+                "polymorphic read target must be an accessible base");
+  // Custom serializers own their wire compatibility and have no generated
+  // compatible reader. Their exact reader must use the same data entry point
+  // in both modes.
+  if (FORY_PREDICT_FALSE(type_info->harness.read_data_fn == nullptr)) {
+    ctx.set_error(Error::type_error(
+        "No harness read function for polymorphic type deserialization"));
+    return nullptr;
+  }
+  void *value = type_info->harness.read_data_fn(ctx);
+  return static_cast<Target *>(static_cast<Source *>(value));
+}
+
+template <typename Source, typename Bases, bool MatchAddress, size_t Index>
+inline Harness::ReadAsFn
+TypeResolver::find_base_read_impl(const std::type_info &target) {
+  if constexpr (Index == std::tuple_size_v<Bases>) {
+    return nullptr;
+  } else {
+    using BaseToken = std::tuple_element_t<Index, Bases>;
+    using Base = typename BaseToken::Type;
+    Harness::ReadAsFn read_as =
+        find_struct_read_impl<Source, Base, MatchAddress>(target);
+    if (read_as != nullptr) {
+      return read_as;
+    }
+    return find_base_read_impl<Source, Bases, MatchAddress, Index + 1>(target);
+  }
+}
+
+template <typename Source, typename Current, bool MatchAddress>
+inline Harness::ReadAsFn
+TypeResolver::find_struct_read_impl(const std::type_info &target) {
+  const std::type_info &current = typeid(Current);
+  const bool matches = MatchAddress ? &target == &current : target == current;
+  if (matches) {
+    if constexpr (std::is_convertible_v<Source *, Current *>) {
+      return &harness_struct_read_as<Source, Current>;
+    }
+    return nullptr;
+  }
+  using MetaDesc = decltype(meta::fory_field_info(std::declval<Current>()));
+  return find_base_read_impl<Source, typename MetaDesc::DirectBaseTypes,
+                             MatchAddress>(target);
+}
+
+template <typename Source, typename Current>
+inline Harness::ReadAsFn
+TypeResolver::find_struct_read(const std::type_info &target) {
+  // RTTI objects normally share an address. Search every declared base by
+  // address first so the hot path never calls type_info::operator==; repeat
+  // with portable equality only for types whose RTTI crosses DSO boundaries.
+  Harness::ReadAsFn read_as =
+      find_struct_read_impl<Source, Current, true>(target);
+  if (FORY_PREDICT_TRUE(read_as != nullptr)) {
+    return read_as;
+  }
+  return find_struct_read_impl<Source, Current, false>(target);
+}
+
+template <typename T>
+inline Harness::ReadAsFn
+TypeResolver::find_exact_read(const std::type_info &target) {
+  const std::type_info &current = typeid(T);
+  if (&target == &current || target == current) {
+    return &harness_exact_read_as<T, T>;
+  }
+  return nullptr;
+}
+
 namespace detail {
 
 template <typename T>
@@ -2085,6 +2198,7 @@ Harness 
TypeResolver::make_struct_harness_impl(std::true_type) {
                   &TypeResolver::harness_read_compatible_adapter_abstract<T>);
   harness.any_write_fn = &detail::any_write_adapter<T>;
   harness.any_read_fn = &detail::any_read_adapter_abstract<T>;
+  harness.find_read_as_fn = &TypeResolver::find_struct_read<T, T>;
   return harness;
 }
 
@@ -2099,6 +2213,7 @@ Harness 
TypeResolver::make_struct_harness_impl(std::false_type) {
                   &TypeResolver::harness_read_compatible_adapter<T>);
   harness.any_write_fn = &detail::any_write_adapter<T>;
   harness.any_read_fn = &detail::any_read_adapter<T>;
+  harness.find_read_as_fn = &TypeResolver::find_struct_read<T, T>;
   return harness;
 }
 
@@ -2111,6 +2226,7 @@ template <typename T> Harness 
TypeResolver::make_serializer_harness() {
                   &TypeResolver::harness_empty_sorted_fields<T>);
   harness.any_write_fn = &detail::any_write_adapter<T>;
   harness.any_read_fn = &detail::any_read_adapter<T>;
+  harness.find_read_as_fn = &TypeResolver::find_exact_read<T>;
   return harness;
 }
 
diff --git a/cpp/fory/serialization/weak_ptr_serializer.h 
b/cpp/fory/serialization/weak_ptr_serializer.h
index 3283bc5b7..31e3f836d 100644
--- a/cpp/fory/serialization/weak_ptr_serializer.h
+++ b/cpp/fory/serialization/weak_ptr_serializer.h
@@ -350,7 +350,12 @@ template <typename T> struct Serializer<SharedWeak<T>> {
         return SharedWeak<T>::from(ref_result.value());
       }
 
-      // Forward reference - create empty weak and register callback
+      if (FORY_PREDICT_FALSE(!ctx.ref_reader().is_pending_ref(ref_id))) {
+        ctx.set_error(std::move(ref_result).error());
+        return SharedWeak<T>();
+      }
+
+      // Forward reference - create empty weak and register callback.
       SharedWeak<T> result;
       add_weak_update_callback(ctx.ref_reader(), ref_id, result);
       return result;
@@ -415,7 +420,12 @@ template <typename T> struct Serializer<SharedWeak<T>> {
         return SharedWeak<T>::from(ref_result.value());
       }
 
-      // Forward reference
+      if (FORY_PREDICT_FALSE(!ctx.ref_reader().is_pending_ref(ref_id))) {
+        ctx.set_error(std::move(ref_result).error());
+        return SharedWeak<T>();
+      }
+
+      // Forward reference.
       SharedWeak<T> result;
       add_weak_update_callback(ctx.ref_reader(), ref_id, result);
       return result;
@@ -448,11 +458,14 @@ private:
     // Capture a copy of the SharedWeak - it shares internal storage
     SharedWeak<T> weak_copy = weak;
     ref_reader.add_update_callback(
-        ref_id, [weak_copy, ref_id](const RefReader &reader) mutable {
+        ref_id,
+        [weak_copy, ref_id](const RefReader &reader, Error &error) mutable {
           auto ref_result = reader.template get_shared_ref<T>(ref_id);
-          if (ref_result.ok()) {
-            weak_copy.update(std::weak_ptr<T>(ref_result.value()));
+          if (FORY_PREDICT_FALSE(!ref_result.ok())) {
+            error = std::move(ref_result).error();
+            return;
           }
+          weak_copy.update(std::weak_ptr<T>(ref_result.value()));
         });
   }
 };
diff --git a/cpp/fory/serialization/weak_ptr_serializer_test.cc 
b/cpp/fory/serialization/weak_ptr_serializer_test.cc
index 0764fce3a..dceb5689d 100644
--- a/cpp/fory/serialization/weak_ptr_serializer_test.cc
+++ b/cpp/fory/serialization/weak_ptr_serializer_test.cc
@@ -171,6 +171,50 @@ struct NodeWithParent {
   FORY_STRUCT(NodeWithParent, value, parent, children);
 };
 
+TEST(WeakPtrSerializerTest, RejectsResolvedTypeMismatch) {
+  Config config;
+  config.track_ref = true;
+  ReadContext ctx(config, std::make_unique<TypeResolver>());
+  ctx.ref_reader().store_shared_ref_at(0, std::make_shared<int32_t>(42));
+  Buffer buffer;
+  buffer.write_int8(REF_FLAG);
+  buffer.write_var_uint32(0);
+  ctx.attach(buffer);
+
+  auto result =
+      Serializer<SharedWeak<SimpleStruct>>::read(ctx, RefMode::Tracking, 
false);
+
+  EXPECT_TRUE(result.expired());
+  ASSERT_TRUE(ctx.has_error());
+  EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidRef);
+  EXPECT_NE(ctx.error().message().find("Reference type mismatch"),
+            std::string::npos);
+}
+
+TEST(WeakPtrSerializerTest, RejectsForwardTypeMismatch) {
+  Config config;
+  config.track_ref = true;
+  ReadContext ctx(config, std::make_unique<TypeResolver>());
+  uint32_t ref_id = ctx.ref_reader().reserve_ref_id();
+  Buffer buffer;
+  buffer.write_int8(REF_FLAG);
+  buffer.write_var_uint32(ref_id);
+  ctx.attach(buffer);
+
+  auto result =
+      Serializer<SharedWeak<SimpleStruct>>::read(ctx, RefMode::Tracking, 
false);
+  ASSERT_FALSE(ctx.has_error());
+  EXPECT_TRUE(result.expired());
+
+  ctx.ref_reader().store_shared_ref_at(ref_id, std::make_shared<int32_t>(42));
+  ctx.ref_reader().resolve_callbacks(ctx.error());
+
+  ASSERT_TRUE(ctx.has_error());
+  EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidRef);
+  EXPECT_NE(ctx.error().message().find("Reference type mismatch"),
+            std::string::npos);
+}
+
 // ============================================================================
 // Serialization Tests
 // ============================================================================
diff --git a/docs/guide/cpp/custom-serializers.md 
b/docs/guide/cpp/custom-serializers.md
index 60b969ae6..8fe4d4353 100644
--- a/docs/guide/cpp/custom-serializers.md
+++ b/docs/guide/cpp/custom-serializers.md
@@ -191,7 +191,7 @@ struct Serializer<CustomType> {
     write_not_null_ref_flag(ctx, ref_mode);
     if (write_type) {
       auto result = ctx.write_any_type_info(
-          static_cast<uint32_t>(TypeId::UNKNOWN),
+          static_cast<uint32_t>(type_id),
           std::type_index(typeid(CustomType)));
       if (!result.ok()) {
         ctx.set_error(std::move(result).error());
diff --git a/docs/guide/cpp/polymorphism.md b/docs/guide/cpp/polymorphism.md
index 3c9bbb3ff..b28f0eb04 100644
--- a/docs/guide/cpp/polymorphism.md
+++ b/docs/guide/cpp/polymorphism.md
@@ -48,13 +48,13 @@ struct Dog : Animal {
   std::string speak() const override { return "Woof!"; }
   std::string breed;
 };
-FORY_STRUCT(Dog, age, breed);
+FORY_STRUCT(Dog, FORY_BASE(Animal), breed);
 
 struct Cat : Animal {
   std::string speak() const override { return "Meow!"; }
   std::string color;
 };
-FORY_STRUCT(Cat, age, color);
+FORY_STRUCT(Cat, FORY_BASE(Animal), color);
 
 // Struct with polymorphic field
 struct Zoo {
@@ -337,7 +337,7 @@ FORY_STRUCT(GraphNode, id, neighbors);
 struct WeightedNode : GraphNode {
   double weight = 0.0;
 };
-FORY_STRUCT(WeightedNode, id, neighbors, weight);
+FORY_STRUCT(WeightedNode, FORY_BASE(GraphNode), weight);
 
 // Enable ref tracking to handle shared references and cycles
 auto fory = Fory::builder().xlang(true).track_ref(true).build();
@@ -392,14 +392,25 @@ auto fory = Fory::builder()
    };
    ```
 
-4. **Register all concrete types** before serialization/deserialization:
+4. **Declare every serialized base relationship** with `FORY_BASE`:
+
+   ```cpp
+   FORY_STRUCT(DerivedType, FORY_BASE(BaseType), derived_field);
+   ```
+
+   This lets Fory validate polymorphic values and correctly adjust pointers for
+   multiple inheritance during deserialization. A derived value whose base
+   relationship is not declared cannot be deserialized through that base smart
+   pointer type.
+
+5. **Register all concrete types** before serialization/deserialization:
 
    ```cpp
    fory.register_struct<Derived1>(100);
    fory.register_struct<Derived2>(101);
    ```
 
-5. **Use `dynamic_cast`** to downcast after deserialization:
+6. **Use `dynamic_cast`** to downcast after deserialization:
 
    ```cpp
    auto* derived = dynamic_cast<DerivedType*>(base_ptr.get());
@@ -408,13 +419,13 @@ auto fory = Fory::builder()
    }
    ```
 
-6. **Adjust `max_dyn_depth`** based on your data structure depth:
+7. **Adjust `max_dyn_depth`** based on your data structure depth:
 
    ```cpp
    auto fory = Fory::builder().xlang(true).max_dyn_depth(10).build();
    ```
 
-7. **Use `nullable()`** for optional polymorphic fields:
+8. **Use `nullable()`** for optional polymorphic fields:
 
    ```cpp
    FORY_STRUCT(Holder, (optional_ptr, fory::F().nullable()));


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to