lutaml-model 0.8.9 → 0.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 002a96224c1367b179f30fe6c2f984b7ae80fa7a6c222d8866b10e26e8ee8c4c
-  data.tar.gz: 2677ff0aca481ae66bf7be4f47cb132417b8d59ddbbf5d266129e9e6c6017e57
+  metadata.gz: b1dea5a70c106b45dafcf2950dda9a8a1c2d8f2d37a4d32ec9a610e461b97a91
+  data.tar.gz: ca6332ea17ae83c4473a5143d454f155006ad369759dab98c48a1ba825aa6d74
 SHA512:
-  metadata.gz: c28f9a50a50f742dc106fb34af4e620b8f12f036b5256e6e5b36bec7ed3ae0634294e078edeb48cef3983e82b266abdb214baa7dceab9e7bd865ad8858162bb5
-  data.tar.gz: 6ef9ffdf02e9e7497a717d082c77c4fce9de3350f1039c3073135fc5d1107ebd50c0024419c33839ff895c70f97aa5907c67455a19f29d4a56e3ca9815c08c79
+  metadata.gz: 01c6623cc80b904875abe68601be5f4b76f441a0b6d0a599325db9454152072c4548985b29e12656b79cffeb28a965ddbf2d3191c6dc617503d914324cee3d35
+  data.tar.gz: 38c58ea41a62c035f56ba5a6ae758ed45e861417d7b41dba4003418600f36a88b6ab1a6ab753bd3ff54c3c45a2ed25ac13a68c774c9f488e9785d3d5c44894c6

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-05-14 09:40:04 UTC using RuboCop version 1.86.0.
+# on 2026-05-18 04:34:59 UTC using RuboCop version 1.86.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,28 +11,13 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'lutaml-model.gemspec'
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: with_first_argument, with_fixed_indentation
-Layout/ArgumentAlignment:
-  Exclude:
-    - 'lib/lutaml/model/store.rb'
-
-# Offense count: 2982
+# Offense count: 3012
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowInHeredoc.
-Layout/TrailingWhitespace:
-  Exclude:
-    - 'lib/lutaml/model/store.rb'
-
 # Offense count: 21
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: enums
@@ -129,23 +114,23 @@ Lint/UselessConstantScoping:
   Exclude:
     - 'lib/lutaml/xml/mapping_rule.rb'
 
-# Offense count: 342
+# Offense count: 345
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
 
-# Offense count: 39
+# Offense count: 40
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
-  Max: 127
+  Max: 133
 
 # Offense count: 16
 # Configuration parameters: CountBlocks, CountModifierForms.
 Metrics/BlockNesting:
   Max: 6
 
-# Offense count: 302
+# Offense count: 310
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
@@ -161,7 +146,7 @@ Metrics/ParameterLists:
   Max: 24
   MaxOptionalParameters: 5
 
-# Offense count: 253
+# Offense count: 262
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -253,7 +238,7 @@ RSpec/BeforeAfterAll:
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 95
+# Offense count: 96
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -264,7 +249,7 @@ RSpec/DescribeMethod:
     - 'spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb'
     - 'spec/lutaml/xml/serializable_namespace_spec.rb'
 
-# Offense count: 1246
+# Offense count: 1257
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 68
@@ -339,7 +324,7 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/xml/namespace_resolution_strategy_spec.rb'
     - 'spec/lutaml/xml/xml_space_type_spec.rb'
 
-# Offense count: 1482
+# Offense count: 1490
 RSpec/MultipleExpectations:
   Max: 21
 
@@ -393,7 +378,7 @@ RSpec/RepeatedExampleGroupDescription:
 RSpec/SpecFilePathFormat:
   Enabled: false
 
-# Offense count: 32
+# Offense count: 33
 # Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
 RSpec/VerifiedDoubles:
   Exclude:
@@ -401,6 +386,7 @@ RSpec/VerifiedDoubles:
     - 'spec/lutaml/key_value/transformation/rule_compiler_spec.rb'
     - 'spec/lutaml/key_value/transformation/value_serializer_spec.rb'
     - 'spec/lutaml/model/compiled_rule_spec.rb'
+    - 'spec/lutaml/model/optimization_spec.rb'
     - 'spec/lutaml/model/schema/renderer_spec.rb'
     - 'spec/lutaml/model/transformation_builder_spec.rb'
     - 'spec/lutaml/model/transformation_spec.rb'
@@ -457,12 +443,6 @@ Style/MixinUsage:
     - 'bench/bench_unitsml.rb'
     - 'bench/bench_xmi.rb'
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-Style/MultilineIfModifier:
-  Exclude:
-    - 'lib/lutaml/model/store.rb'
-
 # Offense count: 12
 # Configuration parameters: AllowedClasses.
 Style/OneClassPerFile:

data/lib/lutaml/key_value/transform.rb

@@ -33,7 +33,7 @@ module Lutaml
 
           # transformation_for returns nil for cyclic dependencies or :building sentinel
           # Fall back to legacy approach in these cases
-          if transformation.respond_to?(:transform)
+          if transformation.is_a?(Lutaml::KeyValue::Transformation)
             # Use new Transformation to get KeyValueElement
             kv_element = transformation.transform(instance, options)
             # Convert KeyValueElement to hash for backward compatibility with adapters
@@ -68,7 +68,7 @@ module Lutaml
 
       def process_mapping_for_instance(instance, hash, format, rule, options)
         if rule.custom_methods[:to]
-          return instance.send(rule.custom_methods[:to], instance, hash)
+          return instance.public_send(rule.custom_methods[:to], instance, hash)
         end
 
         attribute = attributes[rule.to]
@@ -223,13 +223,13 @@ format)
         value = extract_value_for_delegate(instance, rule)
         return if value.nil? && rule.value_map(:to)[:nil] == :omitted
 
-        attribute = instance.send(rule.delegate).class.attributes(lutaml_register)[rule.to]
+        attribute = instance.public_send(rule.delegate).class.attributes(lutaml_register)[rule.to]
         hash[rule_from_name(rule)] =
           attribute.serialize(value, format, lutaml_register)
       end
 
       def extract_value_for_delegate(instance, rule)
-        instance.send(rule.delegate).send(rule.to)
+        instance.public_send(rule.delegate).public_send(rule.to)
       end
 
       def extract_mappings(options, format)
@@ -268,7 +268,7 @@ format)
       def process_custom_method(rule, instance, value)
         return unless Lutaml::Model::Utils.present?(value)
 
-        model_class.new.send(rule.custom_methods[:from], instance, value)
+        model_class.new.public_send(rule.custom_methods[:from], instance, value)
       end
 
       def cast_value(value, attr, format, rule, instance)

data/lib/lutaml/key_value/transformation/collection_serializer.rb

@@ -175,10 +175,14 @@ options = {})
           items.each do |item|
             next if item.nil?
 
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
-            attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                           item.public_send(value_attribute)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             # Get the attribute definition for the value attribute
@@ -193,7 +197,7 @@ options = {})
               item_mapping = item_class.mappings_for(format, register_id)
               item_mapping&.mappings&.each do |mapping_rule|
                 if mapping_rule.to == value_attribute
-                  child_mappings = mapping_rule.child_mappings if mapping_rule.respond_to?(:child_mappings)
+                  child_mappings = mapping_rule.child_mappings
                   break
                 end
               end
@@ -226,7 +230,9 @@ options)
 
           keyed_hash = {}
           items.each do |item|
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             item_hash = {}
@@ -281,7 +287,9 @@ options)
           items.each do |item|
             next if item.nil?
 
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             item_hash = {}
@@ -340,7 +348,9 @@ options)
           value_attribute = find_value_attribute(child_mappings)
 
           items.each do |item|
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             if value_attribute
@@ -371,7 +381,9 @@ options)
         # Serialize a keyed collection item with value mapping.
         def serialize_keyed_value_item(keyed_hash, item, key_value,
                                        value_attribute, options)
-          attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+          attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                         item.public_send(value_attribute)
+                       end
           return if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
           item_class = item.class
@@ -419,7 +431,9 @@ options)
           child_mappings.each do |attr_name, path_spec|
             next if %i[key value].include?(path_spec)
 
-            attr_value = item.respond_to?(attr_name) ? item.public_send(attr_name) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(attr_name)
+                           item.public_send(attr_name)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             attr_def = nil
@@ -508,7 +522,7 @@ options)
             serialize_collection_value(value, attr_type, options)
           elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Serialize
             serialize_nested_model(value, attr_type, options)
-          elsif attr_type.respond_to?(:new)
+          elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
             serialize_primitive(value, attr_type)
           else
             value
@@ -523,7 +537,7 @@ options)
           # Handle Reference type collections - serialize each as a key
           if attr_type == Lutaml::Model::Type::Reference
             return items.map do |item|
-              item.respond_to?(:"to_#{format}") ? item.send(:"to_#{format}") : item
+              item.is_a?(Lutaml::Model::Type::Value) ? item.public_send(:"to_#{format}") : item
             end
           end
 
@@ -547,7 +561,7 @@ options)
         # Serialize a primitive value.
         def serialize_primitive(value, attr_type)
           wrapped_value = attr_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         end
 
         # Create a transformation for a type class.

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -128,13 +128,13 @@ model_class: nil)
           if rule.attribute_type.is_a?(Class) &&
               rule.attribute_type < Lutaml::Model::Serialize
             validate_serializable_type!(value, rule)
-            return value.send(:"to_#{format}")
+            return value.public_send(:"to_#{format}")
           end
 
           # Wrap value in type and call to_#{format}
-          if rule.attribute_type.respond_to?(:new)
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
             wrapped_value = rule.attribute_type.new(value)
-            wrapped_value.send(:"to_#{format}")
+            wrapped_value.public_send(:"to_#{format}")
           else
             value
           end
@@ -152,7 +152,7 @@ model_class: nil)
           subs = context.substitution_for(rule.attribute_type)
           uses_type_substitution = subs.any? { |s| s.to_type == value.class }
 
-          if rule.attribute_type.respond_to?(:model) && rule.attribute_type.model
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type.include?(Lutaml::Model::Serialize) && rule.attribute_type.model
             # Mapper class: value should be an instance of the mapped model
             unless value.is_a?(rule.attribute_type.model) || uses_type_substitution
               msg = "attribute '#{rule.attribute_name}' value is a '#{value.class}' " \
@@ -227,7 +227,7 @@ model_class: nil)
         # @param rule [CompiledRule] The compiled rule
         # @return [Boolean] true if Reference type
         def reference_type?(rule)
-          return false unless rule.respond_to?(:attribute_name)
+          return false unless rule.is_a?(Lutaml::Model::CompiledRule)
           return false unless model_class
 
           # Get the attribute from the model class to check unresolved_type
@@ -256,8 +256,8 @@ model_class: nil)
           end
 
           # Fallback: just call to_format on the value
-          if value.respond_to?(:"to_#{format}")
-            value.send(:"to_#{format}")
+          if value.is_a?(Lutaml::Model::Type::Value) || value.is_a?(Lutaml::Model::Serialize)
+            value.public_send(:"to_#{format}")
           else
             value
           end

data/lib/lutaml/key_value/transformation.rb

@@ -209,8 +209,8 @@ register = self.register)
         # Handle custom serialization methods (e.g., with: { to: ... })
         if rule.has_custom_methods? && rule.custom_methods[:to]
           # Call custom method which directly modifies the parent element
-          return model_instance.send(rule.custom_methods[:to],
-                                     model_instance, parent)
+          return model_instance.public_send(rule.custom_methods[:to],
+                                            model_instance, parent)
         end
 
         # Handle delegation - extract value from delegated object
@@ -357,11 +357,15 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
               next if item.nil?
 
               # Get the key value from the item
-              key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+              key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                            item.public_send(key_attribute)
+                          end
               next if key_value.nil?
 
               # Get the value from the item
-              attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+              attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                             item.public_send(value_attribute)
+                           end
               next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
               # For the value, we need to transform it appropriately
@@ -419,7 +423,7 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                                                              item_class_mapping, format, register)
 
                   # Find the rule for the value_attribute in the item's class mapping
-                  item_rule = item_class_transformation.send(:compiled_rules).find do |r|
+                  item_rule = item_class_transformation.compiled_rules.find do |r|
                     r.attribute_name == value_attribute
                   end
 
@@ -460,8 +464,9 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
             items.each do |item|
               next if item.nil?
 
-              # Get the key value from the item
-              key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+              key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                            item.public_send(key_attribute)
+                          end
               next if key_value.nil?
 
               # Serialize all attributes except the key
@@ -573,7 +578,9 @@ child_mappings, options)
 
         items.each do |item|
           # Get the key value from the item
-          key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+          key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                        item.public_send(key_attribute)
+                      end
 
           if ENV["DEBUG_KEYED_COLLECTION"]
             puts "  item: #{item.inspect}, key_value=#{key_value.inspect}"
@@ -583,7 +590,9 @@ child_mappings, options)
 
           # If there's a value mapping, serialize just that attribute value
           if value_attribute
-            attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                           item.public_send(value_attribute)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             # Get the attribute definition for proper serialization
@@ -637,7 +646,9 @@ child_mappings, options)
                 next if path_spec == :value
 
                 # Get the attribute value
-                attr_value = item.respond_to?(attr_name) ? item.public_send(attr_name) : nil
+                attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(attr_name)
+                               item.public_send(attr_name)
+                             end
 
                 if ENV["DEBUG_KEYED_COLLECTION"]
                   puts "    #{attr_name}: path_spec=#{path_spec.inspect}, attr_value=#{attr_value.inspect}"
@@ -833,10 +844,9 @@ child_mappings, options)
           child_hash = child_root.to_hash
           child_hash["__root__"]
         # Use the transformation to serialize the nested model
-        elsif attr_type.respond_to?(:new)
-          # Serialize primitive value
+        elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
           wrapped_value = attr_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         else
           value
         end
@@ -940,7 +950,7 @@ child_mappings, options)
           subs = context.substitution_for(rule.attribute_type)
           uses_type_substitution = subs.any? { |s| s.to_type == value.class }
 
-          if rule.attribute_type.respond_to?(:model) && rule.attribute_type.model
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type.include?(Lutaml::Model::Serialize) && rule.attribute_type.model
             # Mapper class: value should be an instance of the mapped model
             # or a valid substituted type
             unless value.is_a?(rule.attribute_type.model) || uses_type_substitution
@@ -1054,14 +1064,14 @@ child_mappings, options)
           end
 
           # Value is a valid Serialize instance - serialize it using its own to_#{format} method
-          return value.send(:"to_#{format}")
+          return value.public_send(:"to_#{format}")
         end
 
         # Wrap value in type and call to_#{format} instance method (like legacy Attribute#serialize_value)
         # This allows custom type subclasses to override to_json, to_yaml, etc.
-        if rule.attribute_type.respond_to?(:new)
+        if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
           wrapped_value = rule.attribute_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         else
           value
         end

data/lib/lutaml/model/adapter_resolver.rb

@@ -225,7 +225,7 @@ module Lutaml
         # @param type [String] normalized type name
         def load_adapter_file(adapter, type)
           loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-          if loader.respond_to?(:load_adapter_file)
+          if loader
             loader.load_adapter_file(adapter, type)
             return
           end
@@ -248,10 +248,8 @@ module Lutaml
         # @param format [Symbol] format name
         def load_moxml_adapter(type_name, format)
           loader = FormatRegistry.adapter_loader_for(format)
-          if loader.respond_to?(:load_moxml_adapter)
-            loader.load_moxml_adapter(type_name,
-                                      format)
-          end
+          loader&.load_moxml_adapter(type_name,
+                                     format)
         end
 
         # Resolve the adapter class from the type name.
@@ -261,7 +259,7 @@ module Lutaml
         # @return [Class] the adapter class
         def class_for(adapter, type)
           loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-          if loader.respond_to?(:class_for)
+          if loader
             return loader.class_for(adapter, type)
           end
 

data/lib/lutaml/model/attribute.rb

@@ -36,20 +36,8 @@ module Lutaml
         :string,
       ].freeze
 
-      # Keys that are safe to propagate from parent to child deserialization.
-      # Parent-internal keys (namespace_uri, resolved_type, converted) are
-      # intentionally excluded — children must derive their own context.
-      CHILD_PROPAGATION_KEYS = %i[
-        lutaml_parent
-        lutaml_root
-        default_namespace
-        import_declaration_plan
-        polymorphic
-        collection
-        render_empty
-        render_nil
-        cdata
-      ].freeze
+      # Delegate propagation to DeserializationContext for single source of truth.
+      CHILD_PROPAGATION_KEYS = Serialize::DeserializationContext::PROPAGATION_KEYS
 
       # Methods where accidental override is likely to cause issues
       # All names are allowed - this list only controls which ones get a warning
@@ -590,9 +578,10 @@ instance_object = nil)
                           type(register)
                         end
         if collection_instance?(value) || value.is_a?(Array)
+          merged_opts = options.merge(resolved_type: resolved_type,
+                                      converted: true)
           return build_collection(value.map do |v|
-            cast(v, format, register,
-                 options.merge(resolved_type: resolved_type, converted: true))
+            cast(v, format, register, merged_opts)
           end)
         end
 
@@ -616,11 +605,11 @@ instance_object = nil)
 
         klass = resolve_polymorphic_class(resolved_type, value, options)
         if can_serialize?(klass, value, format, options)
-          propagated = options.slice(*CHILD_PROPAGATION_KEYS)
+          propagated = Serialize::DeserializationContext.propagate(options)
           klass.apply_mappings(value, format,
                                propagated.merge(register: register))
         elsif needs_conversion?(klass, value)
-          klass.send(:"from_#{format}", value)
+          klass.public_send(:"from_#{format}", value)
         else
           # No need to use register#get_class,
           # can_serialize? method already checks if type is Serializable or not.
@@ -711,9 +700,7 @@ instance_object = nil)
         # Skip validation during deep_dup - options are already validated in original
         # This prevents infinite recursion when process_options! tries to access collection
         self.class.new(name, unresolved_type, duped_options).tap do |dup_attr|
-          # Copy already-processed instance variables directly
-          dup_attr.send(:raw=, @raw)
-          dup_attr.send(:validations=, @validations)
+          dup_attr.copy_internal_state_from(self)
         end
       end
 
@@ -765,6 +752,22 @@ instance_object = nil)
         type_namespace_class(register)&.prefix_default
       end
 
+      # Copy internal state from another Attribute instance.
+      # Used by `dup` to transfer processed state without calling private writers.
+      def copy_internal_state_from(source)
+        @raw = source.raw?
+        @validations = source.validations
+      end
+
+      # Clear type resolution caches for this attribute.
+      # Called by GlobalContext.clear_caches to ensure stale entries
+      # from GC'd TypeContext objects don't persist.
+      def clear_type_cache
+        @type_cache&.clear
+        @cached_type_default = nil
+        @default_type_context = nil
+      end
+
       private
 
       attr_writer :raw, :validations
@@ -852,7 +855,7 @@ instance_object = nil)
                            register
                          end
 
-        as_options = options.slice(*CHILD_PROPAGATION_KEYS).merge(register: value_register)
+        as_options = Serialize::DeserializationContext.propagate(options).merge(register: value_register)
 
         # Respect mapping layer policy: render_empty from MappingRule
         # Allow empty Serializable models when render_empty: true
@@ -874,7 +877,7 @@ instance_object = nil)
 
       def serialize_value(value, format, resolved_type)
         value = wrap_in_type_if_needed(value, resolved_type)
-        value.send(:"to_#{format}")
+        value.public_send(:"to_#{format}")
       end
 
       def wrap_in_type_if_needed(value, resolved_type)

data/lib/lutaml/model/cached_type_resolver.rb

@@ -63,10 +63,11 @@ module Lutaml
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
       def resolve(name, context)
-        # Fast path: Class types are passed through directly (no caching needed)
-        return @delegate.resolve(name, context) if name.is_a?(Class)
-
-        cache_key = build_cache_key(name, context)
+        cache_key = if name.is_a?(Class)
+                      [context.id, name]
+                    else
+                      build_cache_key(name, context)
+                    end
 
         @cache_backend.fetch_or_store(cache_key) do
           @delegate.resolve(name, context)
@@ -79,14 +80,14 @@ module Lutaml
       # @param context [TypeContext] The resolution context
       # @return [Boolean] true if type can be resolved
       def resolvable?(name, context)
-        return true if name.is_a?(Class)
-
-        cache_key = build_cache_key(name, context)
+        cache_key = if name.is_a?(Class)
+                      [context.id, name]
+                    else
+                      build_cache_key(name, context)
+                    end
 
-        # Check cache first (fast path)
         return true if @cache_backend.key?(cache_key)
 
-        # Not in cache - delegate
         @delegate.resolvable?(name, context)
       end
 

data/lib/lutaml/model/cli.rb

@@ -70,7 +70,7 @@ module Lutaml
         format = path.split(".").last.downcase
         format = "yaml" if format == "yml"
 
-        model.send("from_#{format}", content)
+        model.public_send("from_#{format}", content)
       rescue StandardError => e
         raise StandardError, "Error parsing file #{path}: #{e.message}"
       end