lutaml-model 0.8.41 → 0.8.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fc47a2bee1b20995c17426890ae3fdc3f9db24317a8cb0c83ea3e81f13372be
-  data.tar.gz: 72b52030485d681b901b077b75195a40d7779c0ec12df982e8bc7f49b3ef9dad
+  metadata.gz: fe2357c36c2a199a3788090dffd420874612482e21e7ac678bd5f1e6fdd575ce
+  data.tar.gz: a3d601af07558b2915dce9f4df383c00b905505c8fbcd192a89ad88b3e66ea49
 SHA512:
-  metadata.gz: dc281b89a9c032cff1f2a38de58b465dccc5385421d9daed7a8244adec62a282a79163b392224a2ead89d93281bbf1d6f5772f879f088a930332ae8821c7784e
-  data.tar.gz: 1d0c2b049cc9c45e7dfe0dd0a6ec6326c98011ab09c6a9f32eff39b36a67cfce1dd97f20341d301258acfc9c9eb282d43718d3a7ab0e0401ae29e6d1a936d724
+  metadata.gz: c82bb3761127b4beb8f2d267a60d107d69eb509cd2fd094763eed5ab5d0814497252db4cd1311709072ab829b156aac46f839852bcc4f20f37e627aa7b5daea7
+  data.tar.gz: 32aa679d229c03ccccf0ee8f1359f9559309b92f5493a0207fd5a495e0f8ef1a0cc3255a0e4e30c2e7c5319e8910a8863286116d6a0e4bfe72af1a0b8be2c71f

data/docs/_guides/advanced-mapping.adoc

@@ -562,3 +562,35 @@ end
 ====
 
 
+
+=== Attribute-value dispatch on a shared element name
+
+When several distinct attributes share one wire element, selected by a
+sibling attribute's value, declare the discriminator with `when_attribute:`
+
+[source,ruby]
+----
+class Requirement < Lutaml::Model::Serializable
+  attribute :guidance, Component, collection: true
+  attribute :purpose, Component, collection: true
+
+  xml do
+    element "requirement"
+    map_element "component", to: :guidance,
+                             when_attribute: { "type" => "guidance" }
+    map_element "component", to: :purpose,
+                             when_attribute: { "type" => "purpose" }
+  end
+end
+----
+
+Each rule hydrates only from the `<component>` occurrences whose `type`
+attribute carries the expected value, in document order; uncovered values
+are ignored by all discriminator rules. On serialization the discriminator
+pair is re-emitted on the element (unless the value's own mapping already
+writes that attribute).
+
+Co-occurrence semantics: several `when_attribute` rules may share the
+element name; each target attribute fills independently, so declare each
+as `collection: true` when the element repeats. Rules without
+`when_attribute` keep claiming every occurrence of their name as before.

data/lib/lutaml/key_value/mapping.rb

@@ -78,7 +78,8 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true
       )
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with, render_nil, render_empty)
@@ -100,6 +101,7 @@ module Lutaml
           polymorphic_map: polymorphic_map,
           transform: transform,
           value_map: value_map,
+          serialize: serialize,
         )
       end
 

data/lib/lutaml/key_value/mapping_rule.rb

@@ -22,7 +22,8 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true
       )
         super(
           name,
@@ -41,6 +42,7 @@ module Lutaml
           polymorphic_map: polymorphic_map,
           transform: transform,
           value_map: value_map,
+          serialize: serialize,
         )
 
         @child_mappings = child_mappings
@@ -65,6 +67,7 @@ module Lutaml
           child_mappings: Lutaml::Model::Utils.deep_dup(child_mappings),
           root_mappings: Lutaml::Model::Utils.deep_dup(root_mappings),
           value_map: Lutaml::Model::Utils.deep_dup(@value_map),
+          serialize: serialize?,
         )
       end
 

data/lib/lutaml/key_value/transform.rb

@@ -127,6 +127,8 @@ module Lutaml
       end
 
       def valid_mapping?(rule, options)
+        return false if rule.respond_to?(:serialize?) && !rule.serialize?
+
         only = options[:only]
         except = options[:except]
         name = rule.to

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

@@ -230,6 +230,7 @@ transformation_factory:)
             custom_methods: custom_methods,
             delegate: delegate,
             root_mappings: mapping_rule.root_mappings,
+            serialize: mapping_rule.serialize?,
           )
         end
 
@@ -239,6 +240,8 @@ transformation_factory:)
         # @param options [Hash] Transformation options (may contain :only, :except)
         # @return [Boolean] true if the rule should be applied
         def valid_mapping?(rule, options)
+          return false if rule.option(:serialize) == false
+
           only = options[:only]
           except = options[:except]
           name = rule.attribute_name

data/lib/lutaml/model/attribute.rb

@@ -172,30 +172,56 @@ module Lutaml
           end
         end
 
-        # Non-default register path: resolve directly without normalize_context
-        # when context_or_register is already a TypeContext or Symbol (common cases)
-        context = case context_or_register
-                  when Lutaml::Model::TypeContext
-                    context_or_register
-                  when Symbol
-                    GlobalContext.context(context_or_register) || GlobalContext.default_context
-                  when Lutaml::Model::Register
-                    GlobalContext.context(context_or_register.id) || GlobalContext.default_context
-                  else
-                    GlobalContext.default_context
-                  end
-
-        # Performance: Cache per TypeContext identity.
-        # When type substitution replaces a TypeContext, the object_id changes,
-        # so old cache entries are never hit again (safe invalidation).
-        cache_key = context.object_id
-        @type_cache ||= {}
-        cached = @type_cache[cache_key]
-        return cached if cached
-
-        resolved = resolver.resolve(unresolved_type, context)
-        @type_cache[cache_key] = resolved
-        resolved
+        # Register/Symbol path: the resolution is a static fact of
+        # (attribute, register id), but the old code walked
+        # GlobalContext.context — a singleton hop, a delegation, a to_sym
+        # normalization and a registry lookup — on every call (2.4 M calls,
+        # 3.9 M GlobalContext#context hits per ISO-13849 parse). Cache keyed
+        # on the register id itself; a context replaced under the same id
+        # bumps GlobalContext.context_generation and flushes the cache.
+        register_id = case context_or_register
+                      when Symbol
+                        context_or_register
+                      when Lutaml::Model::Register
+                        context_or_register.id
+                      end
+
+        if register_id
+          cache = (@type_cache_by_register ||= {})
+          generation = GlobalContext.context_generation
+          if @type_cache_generation != generation
+            cache.clear
+            @type_cache_generation = generation
+          end
+          cached = cache[register_id]
+          return cached if cached
+
+          context = GlobalContext.context(register_id)
+          # An unregistered id falls back to the (thread-local) default
+          # context — do not pin that answer in the shared cache.
+          return resolver.resolve(unresolved_type, context || GlobalContext.default_context) unless context
+
+          resolved = resolver.resolve(unresolved_type, context)
+          cache[register_id] = resolved
+          resolved
+        elsif context_or_register.is_a?(Lutaml::Model::TypeContext)
+          # Performance: Cache per TypeContext identity.
+          # When type substitution replaces a TypeContext, the object_id changes,
+          # so old cache entries are never hit again (safe invalidation).
+          cache_key = context_or_register.object_id
+          @type_cache ||= {}
+          cached = @type_cache[cache_key]
+          return cached if cached
+
+          resolved = resolver.resolve(unresolved_type, context_or_register)
+          @type_cache[cache_key] = resolved
+          resolved
+        else
+          @cached_type_default ||= begin
+            context = normalize_context(context_or_register)
+            resolver.resolve(unresolved_type, context)
+          end
+        end
       end
 
       # @api public
@@ -305,7 +331,10 @@ module Lutaml
       EMPTY_TRANSFORM_HASH = {}.freeze
 
       def transform
-        @options[:transform] || EMPTY_TRANSFORM_HASH
+        # Options are fixed after definition (value_policy memoizes the
+        # same way) — the per-call @options[:transform] Hash#[] was hit
+        # 2.9 M times on the ISO-13849 parse profile.
+        @transform ||= @options[:transform] || EMPTY_TRANSFORM_HASH
       end
 
       def method_name
@@ -438,7 +467,7 @@ module Lutaml
       def cast_element(value, register)
         # Resolve first: an undeclared type has to raise UnknownTypeError
         # even for a nil value (the 0.8.33 behavior).
-        type(register)
+        resolved_type = type(register)
 
         return value if Utils.uninitialized?(value)
 
@@ -448,7 +477,7 @@ module Lutaml
         # manufacture a typed INSTANCE from nothing: that is the
         # phantom #793 removed, suppressed by the post-check below.
         if value.nil?
-          result = cast_element_present(value, register)
+          result = cast_element_present(value, register, resolved_type)
           return result if result.nil?
           return nil if result.is_a?(Lutaml::Model::Type::Value) ||
             result.is_a?(Lutaml::Model::Serialize)
@@ -456,11 +485,11 @@ module Lutaml
           return result
         end
 
-        cast_element_present(value, register)
+        cast_element_present(value, register, resolved_type)
       end
 
-      def cast_element_present(value, register)
-        resolved_type = type(register)
+      def cast_element_present(value, register, resolved_type = nil)
+        resolved_type ||= type(register)
 
         return cast_union(value, nil, register) if union?
         return resolved_type.new(value) if value.is_a?(::Hash) && !hash_type?
@@ -474,8 +503,10 @@ module Lutaml
         # The castability verdict is a class-hierarchy fact, immutable
         # per resolved type — check once, not per value (TODO.max-perf/15).
         checked = (@castable_types ||= {}.compare_by_identity)
-        validate_attr_type!(resolved_type) unless checked[resolved_type]
-        checked[resolved_type] = true
+        unless checked[resolved_type]
+          validate_attr_type!(resolved_type)
+          checked[resolved_type] = true
+        end
 
         resolved_type.cast(value)
       end
@@ -518,6 +549,7 @@ instance_object = nil)
       def immutable_value?(value)
         value.nil? || value.is_a?(Numeric) || value.is_a?(String) ||
           value.is_a?(Symbol) || value == true || value == false ||
+          value.equal?(::Lutaml::Model::UninitializedClass.instance) ||
           value.frozen?
       end
 
@@ -925,6 +957,11 @@ instance_object = nil)
             Lutaml::Model::Type::Union.validate_members!(@options[:union_member_types])
           Lutaml::Model::Type::Union.validate_combo!(@options)
         end
+        # `restrict` merges new options into the SAME attribute object
+        # post-construction — the option-derived memos must reset here or
+        # collection?/transform keep answering from the pre-restrict state.
+        remove_instance_variable(:@collection_option) if defined?(@collection_option)
+        remove_instance_variable(:@transform) if defined?(@transform)
         @raw = !!@options[:raw]
         if @raw
           warn "[DEPRECATED] attribute :#{name}, :string, raw: true is deprecated. " \
@@ -1031,6 +1068,8 @@ instance_object = nil)
         @type_cache&.clear
         @cached_type_default = nil
         @default_type_context = nil
+        @type_cache_by_register&.clear
+        @type_cache_generation = nil
       end
 
       # Public validation contract: mappings check their targets at

data/lib/lutaml/model/collection_handler.rb

@@ -14,7 +14,9 @@ module Lutaml
       #
       # @return [Object, nil] The collection option value
       def collection
-        @options[:collection]
+        @collection_option = @options[:collection] unless defined?(@collection_option)
+
+        @collection_option
       end
 
       # Check if this attribute is a collection
@@ -59,7 +61,17 @@ module Lutaml
       # @param register [Symbol, nil] Register for custom-collection type resolution
       # @return [Object] A new collection instance
       def build_collection(*args, register: nil)
-        items = args.flatten
+        # args.flatten allocated a fresh Array even for the dominant
+        # calls: no args, or one already-flat Array from cast_items
+        # (71,949 flatten allocations per ISO-13849 parse).
+        items = if args.empty?
+                  []
+                elsif args.length == 1 && (first = args[0]).is_a?(::Array) &&
+                    first.none?(::Array)
+                  first
+                else
+                  args.flatten
+                end
         unless register && initialize_accepts_register?
           return collection_class.new(items)
         end

data/lib/lutaml/model/global_context.rb

@@ -64,6 +64,18 @@ module Lutaml
         @default_context_id = :default
         @namespace_register_map = {} # namespace_uri => register_id
         @mutex = Mutex.new
+        @context_generation = 0
+      end
+
+      # Bumped whenever a named context is registered, replaced,
+      # unregistered, or the registry is reset. Callers that cache a
+      # resolution keyed on a context ID compare this generation to
+      # invalidate — a replaced context under the same ID must not keep
+      # answering from a stale cache.
+      #
+      # @return [Integer]
+      def context_generation
+        @context_generation
       end
 
       # Get the current default context.
@@ -123,6 +135,10 @@ module Lutaml
       # @return [void]
       def register_context(context)
         @registry.register(context)
+        # A replacement under an existing id must not keep answering from
+        # the resolver's [context.id, name]-keyed cache.
+        @resolver.clear_cache(context.id)
+        @context_generation += 1
       end
 
       # Create and register a new context.
@@ -133,12 +149,14 @@ module Lutaml
       # @param substitutions [Array<TypeSubstitution, Hash>] Type substitutions
       # @return [TypeContext] The created context
       def create_context(id:, registry: nil, fallback_to: [], substitutions: [])
-        @registry.create(
+        context = @registry.create(
           id: id,
           registry: registry,
           fallback_to: fallback_to,
           substitutions: substitutions,
         )
+        @context_generation += 1
+        context
       end
 
       # Unregister a context and clear its caches.
@@ -148,6 +166,7 @@ module Lutaml
       def unregister_context(id)
         @resolver.clear_cache(id)
         @registry.unregister(id)
+        @context_generation += 1
       end
 
       # Execute a block with a specific context as default.
@@ -185,6 +204,7 @@ module Lutaml
           end
           @namespace_register_map.clear
           @default_context_id = :default
+          @context_generation += 1
         end
       end
 
@@ -363,6 +383,10 @@ context_id = nil)
             instance.context(id)
           end
 
+          def context_generation
+            instance.context_generation
+          end
+
           def clear_xml_namespace_registry!
             instance.clear_xml_namespace_registry!
           end

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -70,7 +70,9 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true,
+        when_attribute: {}
       )
         @name = name
         @to = to
@@ -92,6 +94,11 @@ module Lutaml
         @polymorphic = polymorphic
         @polymorphic_map = polymorphic_map
         @transform = transform
+        @serialize_mapping = serialize
+        # Attribute-value discriminator (lutaml-model#88): select this
+        # rule's wire occurrences by a sibling attribute value, e.g.
+        # `when_attribute: { "type" => "guidance" }`.
+        @when_attribute = (when_attribute || {}).freeze
 
         # Cache whether this rule needs the full deserialize chain.
         # Over 95% of rules are "simple" (no custom method, no delegate).
@@ -122,6 +129,15 @@ module Lutaml
         @value_map[:from].freeze
         @value_map[:to].freeze
         @value_map.freeze
+
+        # The :from treatment flags are read on every rule application of
+        # every parse; they are static once @value_map is final. The three
+        # Hash#[] chains per value used to cost 1.4 M value_map calls per
+        # ISO-13849 parse.
+        from_map = @value_map[:from]
+        @treat_nil_flag = from_map[:nil] != :omitted
+        @treat_empty_flag = from_map[:empty] != :omitted
+        @treat_omitted_flag = from_map[:omitted] != :omitted
       end
 
       def default_value_map(options = {})
@@ -165,6 +181,11 @@ module Lutaml
 
       alias from name
       alias render_default? render_default
+
+      # Whether this rule participates in serialization output. False
+      # marks a hydrate-only mapping: consumed by from_* but never
+      # rendered by to_*. (The value callback #serialize is separate.)
+      def serialize? = @serialize_mapping
       alias attribute? attribute
 
       def render?(value, instance = nil, options = {})
@@ -243,14 +264,20 @@ module Lutaml
       end
 
       def treat_nil?(options = {})
+        return @treat_nil_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:nil] != :omitted
       end
 
       def treat_empty?(options = {})
+        return @treat_empty_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:empty] != :omitted
       end
 
       def treat_omitted?(options = {})
+        return @treat_omitted_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:omitted] != :omitted
       end
 
@@ -313,6 +340,16 @@ context = nil)
       # each time (240k allocations on the ISO-13849 serialize profile).
       # Rules may be frozen, so no per-instance memo: one to_s instead
       # of two is the frozen-safe diet.
+      # Discriminator pairs this rule selects (and re-emits) on, empty
+      # for an ordinary rule.
+      def when_attribute
+        @when_attribute ||= {}.freeze
+      end
+
+      def when_attribute?
+        !when_attribute.empty?
+      end
+
       def custom_method_only?
         name = attribute_name.to_s
         (name.start_with?("__") && name.end_with?("__")) ||
@@ -402,6 +439,47 @@ context = nil)
       # Frozen empty array for the common case of no transformers
       EMPTY_TRANSFORMERS = [].freeze
 
+      # Verdict for handle_transform_method's dispatch, computed once per
+      # (rule, attribute) — both are static after definition, but rules may
+      # be frozen, so the memo lives at class level keyed on identity.
+      # :assign — no transformer runs on deserialize (fast path);
+      # :import — hash/proc transformers go through ImportTransformer.
+      TRANSFORM_DISPATCH = {}.compare_by_identity
+
+      def self.transform_dispatch(rule, attr)
+        per_attr = TRANSFORM_DISPATCH[rule]
+        if per_attr.nil?
+          per_attr = {}.compare_by_identity
+          TRANSFORM_DISPATCH[rule] = per_attr
+        end
+        verdict = per_attr[attr]
+        return verdict if verdict
+
+        rule_transform = rule.transform
+        # NB: `::Hash` — inside Lutaml::Model the bare constant `Hash` is
+        # the hash-format adapter class, so a plain is_a?(Hash) is always
+        # false here (the original dispatch shared that shadow and never
+        # took the hash-transform branch).
+        rule_has = rule_transform.is_a?(Class) ||
+          (rule_transform.is_a?(::Hash) && !rule_transform.empty?)
+        attr_transform = attr&.transform
+        attr_has = attr_transform &&
+          (attr_transform.is_a?(Class) ||
+           (attr_transform.is_a?(::Hash) && !attr_transform.empty?))
+
+        verdict = if !rule_has && !attr_has
+                    :assign
+                  elsif rule.get_transformers(attr).any? do |t|
+                    t.is_a?(Class) && t < Lutaml::Model::ValueTransformer
+                  end
+                    :assign
+                  else
+                    :import
+                  end
+        per_attr[attr] = verdict
+        verdict
+      end
+
       def get_transformers(attribute)
         # Fast path: most rules have no transforms at all
         rule_transform = transform
@@ -480,28 +558,16 @@ context = nil)
 
       def handle_transform_method(model, value, attributes, context = nil)
         attr = attributes[to]
-        # Fast path: no transforms at all (covers 95%+ of rules)
-        # transform defaults to {} which is truthy but semantically empty
-        rule_has_transform = transform.is_a?(Class) || (transform.is_a?(Hash) && !transform.empty?)
-        attr_has_transform = attr&.transform && (attr.transform.is_a?(Class) || (attr.transform.is_a?(Hash) && !attr.transform.empty?))
-        if !rule_has_transform && !attr_has_transform
-          assign_value(model, value)
-          return true
-        end
-
-        # If we have class-based transformers, they were already applied in transform_value
-        # Only call ImportTransformer for hash/proc-based transformers
-        transformers = get_transformers(attr)
-        has_class_transformer = transformers.any? { |t| t.is_a?(Class) && t < Lutaml::Model::ValueTransformer }
-
-        if has_class_transformer
-          # Class transformers already applied, just assign the value
-          assign_value(model, value)
-        else
-          # Hash/proc transformers need ImportTransformer
+        # The transform verdict (none / class-based already applied /
+        # hash-proc via ImportTransformer) is static per (rule, attr) —
+        # it was recomputed with is_a? chains on every rule application
+        # (16.8 M Kernel#is_a? per ISO-13849 parse across the walk).
+        if self.class.transform_dispatch(self, attr) == :import
           transformed = ImportTransformer.call(value, self, attr,
                                                context: context)
           assign_value(model, transformed)
+        else
+          assign_value(model, value)
         end
         true
       end

data/lib/lutaml/model/register.rb

@@ -87,12 +87,18 @@ module Lutaml
           (RESOLVE_CACHE[child_class] ||= {})[parent_register] =
             _resolve_for_child_uncached(child_class, parent_register)
         else
+          # Read-first: Concurrent::Map#compute_if_absent takes the mutex
+          # on EVERY call, hits included — 1.35 M synchronized blocks per
+          # ISO-13849 parse for answers that never change. The plain #[]
+          # read is lock-free; nil is a valid cached answer, hence key?.
           # Nested maps: class → register → result. Every hop keys on a
           # stable object (Class / Symbol), so the hot lookup allocates
           # nothing — the flat [object_id, register] array key cost one
           # Array per call, six per parsed element.
           per_class = RESOLVE_CACHE[child_class] # rubocop:todo Style/IdenticalConditionalBranches
-          per_class ||= RESOLVE_CACHE.compute_if_absent(child_class) do
+          return per_class[parent_register] if per_class&.key?(parent_register)
+
+          per_class = RESOLVE_CACHE.compute_if_absent(child_class) do
             Concurrent::Map.new
           end
           per_class.compute_if_absent(parent_register) do

data/lib/lutaml/model/serialize/initialization.rb

@@ -122,12 +122,26 @@ module Lutaml
         # @param register [Symbol, nil] The register context
         # @return [Hash] The attributes hash
         def attributes(register = nil)
-          ensure_imports!(register) if finalized?
+          # Cache hit first: a filled entry can only exist after imports
+          # were ensured for that register (the fill path below runs
+          # ensure_imports! first), and mutations that invalidate the
+          # merge clear @merged_attributes_cache. The lookup was walked
+          # per rule application (751k per ISO-13849 parse).
           if @register_records&.any?
             register_id = extract_register_id(register)
-            (@merged_attributes_cache ||= {})[register_id] ||=
-              @attributes.merge(@register_records[register_id][:attributes])
+            cached = (@merged_attributes_cache ||= {})[register_id]
+            return cached if cached
+
+            ensure_imports!(register) if finalized?
+            # ensure_imports! may re-entrantly run clear_cache (restrict /
+            # import resolution), which nils @merged_attributes_cache —
+            # compute the merge first and re-materialize the memo store
+            # at write time (#815: standalone to_xml on register-bound
+            # models crashed with nil[] here).
+            merged = @attributes.merge(@register_records[register_id][:attributes])
+            (@merged_attributes_cache ||= {})[register_id] = merged
           else
+            ensure_imports!(register) if finalized?
             @attributes
           end
         end

data/lib/lutaml/model/serialize.rb

@@ -241,12 +241,21 @@ module Lutaml
       end
 
       def respond_to_missing?(method_name, include_private = false)
-        (method_name.to_s.end_with?("=") && attribute_exist?(method_name)) ||
-          super
+        # Setter probes from non-compiled dispatch land here ~24k times per
+        # ISO-13849 parse; strip the suffix once instead of re-walking
+        # attribute_exist?'s to_s/chomp/to_sym chain.
+        name = method_name.to_s
+        if name.end_with?("=") &&
+            self.class.attributes(lutaml_register)
+                .key?(name.delete_suffix("=").to_sym)
+          return true
+        end
+
+        super
       end
 
       def attribute_exist?(name)
-        name = name.to_s.chomp("=").to_sym if name.end_with?("=")
+        name = name.to_s.delete_suffix("=").to_sym if name.end_with?("=")
 
         self.class.attributes(lutaml_register).key?(name)
       end

data/lib/lutaml/model/type/string.rb

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       class String < Value
         # Performance-optimized cast with short-circuit for already-correct types
-        def self.cast(value, options = {})
+        def self.cast(value, options = EMPTY_OPTIONS)
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.41"
+    VERSION = "0.8.43"
   end
 end