fix: remove noncausal registry policies

Author: chaokunyang

.agents/languages/java.md

@@ -101,9 +101,6 @@ Load this file when changing anything under `java/` or when Java drives a cross-
 - `ThreadSafeFory.execute` exposes one borrowed child only for the callback. Do not retain that
   child or register through it; use the facade registration methods so every current and future
   child receives the same setup.
-- A serializer instance registered on a thread-safe facade must implement `Shareable`. Resolver-
-  local serializers use the class, resolver-factory, or module path so every child runtime owns its
-  instance; never replay one resolver-bound serializer across children.
 - Serializer completion used by lazy, JIT, and generated serializers is an internal resolver-owned
   operation. It remains valid after registration freezes and must not be treated as explicit
   registration.

.agents/languages/python.md

@@ -25,18 +25,12 @@ Load this file when changing `python/`, Cython serialization, or Python xlang be
   collisions before publishing resolver maps. Lazy TypeDef completion preserves a configured
   serializer, does not retain partial state, and restores the prior serializer and TypeDef after
   failed completion without adding a lifecycle state.
-- `ThreadSafeFory` accepts serializer classes or factories and constructs a serializer for each
-  child resolver. It must reject resolver-bound serializer instances instead of replaying one
-  instance across pooled children.
 - Registry freeze prohibits explicit type and serializer registration after the first root; it
   does not prohibit native runtime type resolution. Non-strict native writes may discover runtime
   classes or callables, and reads may resolve those authorized by the deserialization policy. Both
   paths may materialize resolver-owned type information or serializer cache entries without
   creating or changing an explicit type, serializer, ID, name, or policy registration. Do not
   describe these operations as late registration.
-- Function serialization writes captured globals as a data-only exact `dict`. Keep the reader's
-  exact-type check before sizing or merging the namespace; a dict subclass or other mapping must not
-  introduce runtime behavior into function reconstruction.
 - Use explicit Cython fields and methods for fixed hot-path shapes. Avoid `__getattr__`, generic `object` fields, public bridge internals, or `Fory` backreferences where ownership can stay explicit.
 - Keep Python and Cython context/ref-tracking branch conditions and stack mutations semantically aligned unless a documented intentional difference exists.
 - Root deserialization graph memory budget state belongs to pure-Python and Cython `ReadContext`.

cpp/fory/serialization/collection_serializer.h

@@ -562,9 +562,6 @@ inline bool read_declared_same_type_collection(Container &result,
       auto elem = Serializer<T>::read(ctx, RefMode::None, false);
       collection_insert(result, std::move(elem));
     }
-    if (FORY_PREDICT_FALSE(ctx.has_error())) {
-      return false;
-    }
     return true;
   }
 
@@ -586,15 +583,9 @@ inline bool read_declared_same_type_collection(Container &result,
       checkpoint_byte = ctx.buffer().logical_reader_index();
     }
   }
-  if (FORY_PREDICT_FALSE(ctx.has_error())) {
-    return false;
-  }
-  if (checkpoint_item != length &&
-      FORY_PREDICT_FALSE(!detail::settle_unbacked_container_items(
-          ctx, length - checkpoint_item, checkpoint_byte))) {
-    return false;
-  }
-  return true;
+  return checkpoint_item == length ||
+         detail::settle_unbacked_container_items(ctx, length - checkpoint_item,
+                                                 checkpoint_byte);
 }
 
 template <typename T, typename Alloc>
@@ -625,15 +616,10 @@ read_declared_same_type_collection(std::forward_list<T, Alloc> &result,
       }
     }
   }
-  if (FORY_PREDICT_FALSE(ctx.has_error())) {
-    return false;
-  }
   if constexpr (!read_data_always_advances_v<T>) {
-    if (checkpoint_item != length &&
-        FORY_PREDICT_FALSE(!detail::settle_unbacked_container_items(
-            ctx, length - checkpoint_item, checkpoint_byte))) {
-      return false;
-    }
+    return checkpoint_item == length ||
+           detail::settle_unbacked_container_items(
+               ctx, length - checkpoint_item, checkpoint_byte);
   }
   return true;
 }
@@ -679,15 +665,10 @@ read_same_type_info_collection_body(Container &result, ReadContext &ctx,
       }
     }
   }
-  if (FORY_PREDICT_FALSE(ctx.has_error())) {
-    return false;
-  }
   if constexpr (MeasureProgress) {
-    if (checkpoint_item != length &&
-        FORY_PREDICT_FALSE(!detail::settle_unbacked_container_items(
-            ctx, length - checkpoint_item, checkpoint_byte))) {
-      return false;
-    }
+    return checkpoint_item == length ||
+           detail::settle_unbacked_container_items(
+               ctx, length - checkpoint_item, checkpoint_byte);
   }
   return true;
 }
@@ -720,15 +701,10 @@ inline bool read_same_type_info_collection_body(
       }
     }
   }
-  if (FORY_PREDICT_FALSE(ctx.has_error())) {
-    return false;
-  }
   if constexpr (MeasureProgress) {
-    if (checkpoint_item != length &&
-        FORY_PREDICT_FALSE(!detail::settle_unbacked_container_items(
-            ctx, length - checkpoint_item, checkpoint_byte))) {
-      return false;
-    }
+    return checkpoint_item == length ||
+           detail::settle_unbacked_container_items(
+               ctx, length - checkpoint_item, checkpoint_byte);
   }
   return true;
 }

cpp/fory/serialization/serialization_test.cc

@@ -29,7 +29,6 @@
 #include <chrono>
 #include <cstdint>
 #include <cstring>
-#include <forward_list>
 #include <limits>
 #include <map>
 #include <memory>
@@ -984,49 +983,6 @@ TEST(SerializationTest, SkipNoneListConsumesBudget) {
   ASSERT_TRUE(ctx.has_error());
 }
 
-TEST(SerializationTest, LastElementErrorSafepoints) {
-  Config config;
-
-  std::vector<uint8_t> declared_bytes{2};
-  Buffer declared_buffer(declared_bytes);
-  ReadContext declared_ctx(config, std::make_unique<TypeResolver>());
-  declared_ctx.attach(declared_buffer);
-  std::vector<int32_t> declared_values;
-  EXPECT_FALSE(read_declared_same_type_collection<int32_t>(declared_values,
-                                                           declared_ctx, 2));
-  EXPECT_TRUE(declared_ctx.has_error());
-
-  std::vector<uint8_t> forward_bytes{2};
-  Buffer forward_buffer(forward_bytes);
-  ReadContext forward_ctx(config, std::make_unique<TypeResolver>());
-  forward_ctx.attach(forward_buffer);
-  std::forward_list<int32_t> forward_values;
-  EXPECT_FALSE(read_declared_same_type_collection<int32_t>(forward_values,
-                                                           forward_ctx, 2));
-  EXPECT_TRUE(forward_ctx.has_error());
-
-  std::vector<uint8_t> type_info_bytes{2};
-  Buffer type_info_buffer(type_info_bytes);
-  ReadContext type_info_ctx(config, std::make_unique<TypeResolver>());
-  type_info_ctx.attach(type_info_buffer);
-  TypeInfo type_info;
-  type_info.harness.read_data_always_advances = true;
-  std::vector<int32_t> type_info_values;
-  EXPECT_FALSE(read_same_type_info_collection<int32_t>(
-      type_info_values, type_info_ctx, 2, type_info));
-  EXPECT_TRUE(type_info_ctx.has_error());
-
-  std::vector<uint8_t> measured_bytes{2};
-  Buffer measured_buffer(measured_bytes);
-  ReadContext measured_ctx(config, std::make_unique<TypeResolver>());
-  measured_ctx.attach(measured_buffer);
-  type_info.harness.read_data_always_advances = false;
-  std::vector<int32_t> measured_values;
-  EXPECT_FALSE(read_same_type_info_collection<int32_t>(
-      measured_values, measured_ctx, 2, type_info));
-  EXPECT_TRUE(measured_ctx.has_error());
-}
-
 // ============================================================================
 // Character Type Tests (C++ native only)
 // ============================================================================

cpp/fory/serialization/struct_serializer.h

@@ -4615,9 +4615,6 @@ struct Serializer<T, std::enable_if_t<is_fory_serializable_v<T>>> {
     }
     const TypeInfo *type_info = type_info_res.value();
     ctx.write_struct_type_info(type_info);
-    if (FORY_PREDICT_FALSE(ctx.has_error())) {
-      return;
-    }
   }
 
   /// Read and validate type info.

csharp/src/Fory/Fory.cs

@@ -177,8 +177,8 @@ public byte[] Serialize<T>(in T value)
         _registryFrozen = true;
         ByteWriter writer = _writeContext.Writer;
         writer.Reset();
-        // A previous failed root may leave references behind. Reset before serializer lookup,
-        // because generated or application serializer factories can fail during that lookup.
+        // Serializer lookup is part of the root and may fail before codec entry, so establish the
+        // root's clean context before invoking generated or application serializer factories.
         _writeContext.ResetFor(writer);
         Serializer<T> serializer = _typeResolver.GetSerializer<T>();
         WriteHead(writer);

csharp/tests/Fory.Tests/ExternalTypeSerializationTests.cs

@@ -401,6 +401,8 @@ public void CustomSerializerReplacesGenerated()
         ExternalFields value = new() { Count = 19, Name = "custom" };
         ForyRuntime generated = ForyRuntime.Builder().Build();
         generated.Register<ExternalFields>(6106);
+        Assert.Throws<InvalidDataException>(
+            () => generated.Register<ExternalFields, ExternalFieldsCustomSerializer>(6107));
         byte[] generatedBytes = generated.Serialize(value);
 
         ForyRuntime custom = ForyRuntime.Builder().Build();
@@ -411,8 +413,6 @@ public void CustomSerializerReplacesGenerated()
         Assert.NotEqual(generatedBytes, customBytes);
         Assert.Equal(value.Count, decoded.Count);
         Assert.Equal(value.Name, decoded.Name);
-        Assert.Throws<InvalidOperationException>(
-            () => generated.Register<ExternalFields, ExternalFieldsCustomSerializer>(6107));
     }
 
     [Fact]

csharp/tests/Fory.Tests/RuntimeEdgeCaseTests.cs

@@ -137,7 +137,6 @@ public override LookupFailureValue ReadData(ReadContext context)
     }
 }
 
-[ForyStruct]
 public sealed class FailingWritePayload
 {
     public int Value { get; set; }
@@ -834,15 +833,6 @@ public void ThreadSafeDottedNameRoundTrip()
         Assert.Equal("custom", decoded.Marker);
     }
 
-    [Fact]
-    public void RegistryFreezesAfterSuccessfulRoot()
-    {
-        ForyRuntime fory = ForyRuntime.Builder().Build();
-        Assert.Equal(1, fory.Deserialize<int>(fory.Serialize(1)));
-
-        Assert.Throws<InvalidOperationException>(() => fory.Register<FrozenPayload>(710));
-    }
-
     [Fact]
     public void FrozenRegistryRejectsBeforeMutation()
     {
@@ -1041,11 +1031,11 @@ public void TrailingFailureKeepsTypeMetaCache(bool useSpan)
 
         if (useSpan)
         {
-            Assert.ThrowsAny<Exception>(() => DeserializeIntSpan(fory, invalidPayload));
+            Assert.Throws<InvalidDataException>(() => DeserializeIntSpan(fory, invalidPayload));
         }
         else
         {
-            Assert.ThrowsAny<Exception>(() => fory.Deserialize<int>(invalidPayload));
+            Assert.Throws<InvalidDataException>(() => fory.Deserialize<int>(invalidPayload));
         }
 
         Assert.True(context.TryGetTypeMetaByHash(firstHash, out _));

docs/object-serialization/java/custom-serializers.md

@@ -212,11 +212,6 @@ fory.registerSerializer(
     CustomMap.class, resolver -> new CustomMapSerializer<>(resolver, CustomMap.class));
 ```
 
-For `ThreadSafeFory`, pass a serializer class or resolver factory when the serializer is
-runtime-local. The facade constructs one instance for each underlying runtime. An instance may be
-registered directly only when it implements `Shareable`. Construct a runtime-local union serializer
-inside a `ForyModule`, which is installed separately into every underlying runtime.
-
 ## Shareability
 
 Implement the `Shareable` marker interface when the serializer can be safely reused across

docs/object-serialization/python/configuration.md

@@ -57,8 +57,8 @@ class ThreadSafeFory:
     def __init__(self, fory_factory=None, **kwargs)
 ```
 
-Pass either a no-argument `fory_factory` that returns a configured `Fory` instance, or pass normal
-`Fory` construction options through `**kwargs`.
+When supplied, `fory_factory` creates each pooled `Fory` instance. Otherwise, `**kwargs` are passed
+to the normal `Fory` constructor.
 
 ## Parameters
 
@@ -84,7 +84,6 @@ Pass either a no-argument `fory_factory` that returns a configured `Fory` instan
 
 ```python
 fory = pyfory.Fory(xlang=True)
-thread_safe_fory = pyfory.ThreadSafeFory(xlang=True)
 
 # Serialization (serialize/deserialize are identical to dumps/loads)
 data: bytes = fory.serialize(obj)
@@ -94,14 +93,11 @@ obj = fory.deserialize(data)
 data: bytes = fory.dumps(obj)
 obj = fory.loads(data)
 
-# Direct Fory registration by id; serializer instances belong to that Fory.
+# Type registration by id
 fory.register(MyClass, type_id=123)
 fory.register(MyClass, type_id=123, serializer=custom_serializer)
 
-# ThreadSafeFory constructs one serializer per pooled child from a class or factory.
-thread_safe_fory.register(MyClass, type_id=123, serializer=CustomSerializer)
-
-# Direct Fory registration by name
+# Type registration by name
 fory.register(MyClass, name="my.package.MyClass")
 fory.register(MyClass, name="my.package.MyClass", serializer=custom_serializer)
 ```