lutaml-model 0.8.36 → 0.8.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13023a5add888c4affa15d1e7c025548e329b0aad8112582550be7cff794524a
-  data.tar.gz: 7393786a16da4f06d7962f7395edab78b5985ab1820c98da8b95f66f669be99d
+  metadata.gz: ec31a25915a5fd6ceeb31c2e61456c90ae223e565eab14051f8ddb40e373fe9e
+  data.tar.gz: a2e6027e8684bfcc63e58650f979d880e43836ea5521f0ee0ba5e30205bd89cf
 SHA512:
-  metadata.gz: 03be6773d23935e26c6593d2c966f5063af4840142f988c6db534517b26b7889adc15c11c5d5280b181b9b19e35a971bbbc889ce673d63a750385e5b392d60b7
-  data.tar.gz: 656f73aab6fe55e9dbe8337a8c6ec76fae5c2cadfade74bdd30500d3ea16105cdf3de1ebce9d837b4ddd3c6851e84ac7b5b7a7f40f2729d79827014e9d0a0b9e
+  metadata.gz: a101732ad5730070d1c7629b9bf0e72e6573d01a716cf165846b8474f5b7dca7e2415d80ed7a1f8d526fea61363ecbba414e9ecb819f8f2b42b9f09636e81d03
+  data.tar.gz: 42e60f78f63d5d8033edba244858479c95dc1147cf9cc2698ab410d259bd8485a2d2df9825482dc3f895d673177212c1e686a143b5afdde2850d78a706241170

data/bench/bench_sts.rb

@@ -9,6 +9,7 @@
 #   BENCH_JSON=/tmp/results.json bundle exec ruby tmp/bench/bench_sts.rb
 
 require_relative "bench_common"
+require_relative "gate_config"
 include BenchCommon
 
 print_header("STS Ruby Benchmark — ISO/NISO STS document parsing")
@@ -39,11 +40,16 @@ sts_files.each do |label, path|
   end
 end
 
+# The informative print reads the configured gate (bench_compare is the
+# enforcing layer). The old hardcoded 2.0s literal predated the
+# gate_config split and mislabeled every CI run (#313, TODO.max-perf/09).
 puts "\n  Gate checks:"
 if results["iso-13849-1MB"]
-  status = results["iso-13849-1MB"][:avg_time] < 2.0 ? "PASS" : "FAIL"
-  printf "  ISO-13849-1MB < 2.0s: %s (%.3fs)\n", status,
-         results["iso-13849-1MB"][:avg_time]
+  gate = GateConfig::GATES.dig(:sts, "iso-13849-1MB") || {}
+  limit = gate[:absolute_max]
+  avg = results["iso-13849-1MB"][:avg_time]
+  status = avg < limit ? "PASS" : "FAIL"
+  printf "  ISO-13849-1MB < %.1fs: %s (%.3fs)\n", limit, status, avg
 end
 
 write_results_json(json_output_path, results) if json_output_path

data/lib/lutaml/model/adapter_resolver.rb

@@ -2,6 +2,10 @@
 
 module Lutaml
   module Model
+    # Marker stored by set_adapter_class: the resolved slot holds a
+    # pre-resolved class (or nil, meaning "unset — keep detecting").
+    FIXED_ADAPTER_TYPE = :__fixed__
+
     # Single authority for adapter resolution: (format, type_name) → adapter class.
     #
     # Consolidates adapter metadata, loading, validation, and auto-detection
@@ -38,11 +42,19 @@ module Lutaml
             return resolved_adapter_class(format, scope_override)
           end
 
-          # 2. Explicitly configured type
+          # 2. Explicitly configured type — a named type is an explicit pin
+          # and must never fall through to auto-detection: detection loads
+          # optional engines (e.g. yeptris) into the process even when the
+          # user pinned a standard adapter, which crashes platforms where
+          # the engine's build is broken. FIXED_ADAPTER_TYPE with no
+          # resolved class means "unset" (set_adapter_class(format, nil))
+          # and keeps the old detect-through behavior.
           configured = configured_type(format)
           if configured
             adapter = resolved[format]
             return adapter if adapter
+
+            return load_and_cache(format, configured) if configured != FIXED_ADAPTER_TYPE
           end
 
           # 3. Lazy auto-detection (cached)
@@ -91,7 +103,7 @@ module Lutaml
         # @return [void]
         def set_adapter_class(format, adapter_class)
           resolved[format] = adapter_class
-          configured_types[format] = :__fixed__
+          configured_types[format] = FIXED_ADAPTER_TYPE
         end
 
         # Load and resolve an adapter class by type name.

data/lib/lutaml/model/attribute.rb

@@ -1029,6 +1029,16 @@ instance_object = nil)
         @default_type_context = nil
       end
 
+      # Public validation contract: mappings check their targets at
+      # finalize (lutaml-model#296), the cast path checks per value.
+      def validate_attr_type!(resolved_type)
+        return true if resolved_type <= Serializable || resolved_type <= Type::Value
+        return true if resolved_type.include?(Serialize)
+
+        raise Lutaml::Model::InvalidAttributeTypeError.new(name,
+                                                           resolved_type.name)
+      end
+
       private
 
       attr_writer :raw, :validations
@@ -1040,14 +1050,6 @@ instance_object = nil)
         match&.last
       end
 
-      def validate_attr_type!(resolved_type)
-        return true if resolved_type <= Serializable || resolved_type <= Type::Value
-        return true if resolved_type.include?(Serialize)
-
-        raise Lutaml::Model::InvalidAttributeTypeError.new(name,
-                                                           resolved_type.name)
-      end
-
       # validated_range_object is provided by CollectionHandler module
 
       def validate_name!(name, reserved_methods:)

data/lib/lutaml/model/choice.rb

@@ -3,11 +3,12 @@
 module Lutaml
   module Model
     class Choice
-      attr_reader :attributes,
-                  :model,
-                  :min,
-                  :max
-      attr_accessor :format
+      attr_reader :attributes, :min, :max
+      attr_accessor :model, :format
+
+      # Rebound at mapping finalize: sequence-nested choices are built
+      # against the mapping object, validation resolves through the
+      # mapper class (lutaml-model#687).
 
       INTERNAL_ATTRIBUTES = %i[@flat_attributes].freeze
 

data/lib/lutaml/model/liquefiable.rb

@@ -25,6 +25,27 @@ module Lutaml
           register_liquid_drop_class
         end
 
+        # lutaml-model#800: models defined before `require "liquid"` keep
+        # their `liquid do ... end` mappings; the drop class materializes
+        # on first use. Consumers that require Liquid first keep the
+        # eager path unchanged.
+        def ensure_liquid_registered!
+          if !Object.const_defined?(:Liquid) && !liquid_loadable?
+            raise Lutaml::Model::LiquidNotEnabledError
+          end
+
+          register_class_if_liquid_defined
+        end
+
+        # Load the Liquid gem on first use; a missing gem surfaces as
+        # LiquidNotEnabledError at the point a drop is actually needed.
+        def liquid_loadable?
+          require "liquid"
+          true
+        rescue LoadError
+          false
+        end
+
         def liquid_class(class_name)
           @custom_liquid_class_name = class_name
         end
@@ -94,6 +115,7 @@ module Lutaml
         end
 
         def to_liquid_class
+          ensure_liquid_registered!
           register_methods unless @methods_generated
 
           base_drop_class
@@ -132,8 +154,6 @@ module Lutaml
         end
 
         def liquid(&block)
-          return unless Object.const_defined?(:Liquid)
-
           mappings[:liquid] ||= ::Lutaml::Model::Liquid::Mapping.new
           mappings[:liquid].instance_eval(&block) if block
           mappings[:liquid]
@@ -155,6 +175,7 @@ module Lutaml
       end
 
       def to_liquid
+        self.class.ensure_liquid_registered!
         self.class.validate_liquid!
 
         self.class.register_methods

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

@@ -45,6 +45,13 @@ module Lutaml
         end
       end
 
+      # Normalized name spellings for matching, computed once. The name
+      # is fixed after construction (attr_reader only), so the memo is
+      # safe. Hot loops used to redo Array(name).map(&:to_s) per element.
+      def name_strings
+        @name_strings ||= Array(name).map(&:to_s).freeze
+      end
+
       def initialize(
         name,
         to:,

data/lib/lutaml/model/sequence.rb

@@ -5,11 +5,12 @@ module Lutaml
     class Sequence
       include DeepDupable
 
-      attr_accessor :model, :attributes
+      attr_accessor :model, :attributes, :compositors
       attr_reader :format
 
       def initialize(model, format: nil)
         @attributes = []
+        @compositors = []
         @model = model
         @format = format
       end
@@ -19,6 +20,7 @@ module Lutaml
       def deep_dup(new_model = nil)
         dup_seq = Sequence.new(new_model || @model, format: @format)
         dup_seq.attributes = Utils.deep_dup(@attributes)
+        dup_seq.compositors = Utils.deep_dup(@compositors)
         dup_seq
       end
 
@@ -32,7 +34,50 @@ module Lutaml
       end
 
       def map_element(name, **options)
-        @attributes << @model.map_element(name, **options)
+        rule = @model.map_element(name, **options)
+        @attributes << rule
+        if (nested = @choice_in_progress)
+          nested.attributes << rule
+        end
+        rule
+      end
+
+      # An xs:choice compositor nested inside an xs:sequence
+      # (lutaml-model#687). Element rules mapped in the block take
+      # their positional place in this sequence AND carry the choice
+      # on their model attributes, so validation applies order and
+      # exclusivity exactly as a model-level choice does. The choice
+      # itself is remembered in #compositors — the compositor shape
+      # stays queryable next to the flat rule order.
+      def choice(min: 1, max: 1, &block)
+        nested = Choice.new(@model, min, max, format: @format)
+        previous = @choice_in_progress
+        @choice_in_progress = nested
+        begin
+          instance_eval(&block)
+        ensure
+          @choice_in_progress = previous
+        end
+        @compositors << nested
+        nested
+      end
+
+      # Bind nested choice compositors to the mapper's model attributes
+      # (options[:choice]), so validation applies order and exclusivity
+      # the same way a model-level choice does. Runs at mapping finalize,
+      # when the mapper class is known — the DSL block runs earlier.
+      def bind_choice_compositors!(mapper_class)
+        @compositors.each do |choice|
+          choice.model = mapper_class
+          # The choice's contents become the model attributes its rules
+          # target — the same shape a model-level choice carries — so
+          # validation machinery works unchanged.
+          bound = choice.attributes.filter_map do |rule|
+            mapper_class.attributes[rule.to]
+          end.uniq
+          choice.attributes.replace(bound)
+          bound.each { |target| target.options[:choice] = choice }
+        end
       end
 
       def import_model_mappings(model, register = nil)

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

@@ -12,6 +12,59 @@ module Lutaml
         #
         # @param attr [Attribute] The attribute to define methods for
         # @param register [Symbol, nil] The register for type resolution
+        # Compile (per class, cached) the method that seeds every attribute
+        # with its "no data arrived" sentinel: collections share the frozen
+        # LAZY_EMPTY_COLLECTION, scalars share the UninitializedClass
+        # singleton. Compiled once instead of walked per instance — the
+        # grammars-compile-don't-interpret rule applied to object state.
+        # Compile (per class, on demand) the method that seeds every
+        # attribute with its "no data arrived" sentinel: collections share
+        # the frozen LAZY_EMPTY_COLLECTION, scalars share the
+        # UninitializedClass singleton. Compiled once instead of walked
+        # per instance — grammars compile, they don't interpret.
+        def compile_state_defaults!(_register = nil)
+          attrs = attributes
+
+          if attrs.empty?
+            define_method(:__init_deserialized_state_defaults) do
+              # no attributes to seed
+            end
+            return
+          end
+
+          lines = attrs.map do |name, attr|
+            if attr.collection?
+              "@#{name} = Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION"
+            else
+              "@#{name} = Lutaml::Model::UninitializedClass.instance"
+            end
+          end.join("\n")
+
+          # class_eval interpolates per-attribute `@name = <sentinel>` lines:
+          #   def __init_deserialized_state_defaults
+          #     @id = Lutaml::Model::UninitializedClass.instance
+          #     @items = Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION
+          #   end
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def __init_deserialized_state_defaults
+            #{lines}
+            end
+          RUBY
+        end
+
+        def invalidate_state_defaults!
+          # Opal's method_defined? takes no inherit flag (see the
+          # setter_defined check in define_regular_attribute_methods).
+          defined_now = if Lutaml::Model.opal?
+                          method_defined?(:__init_deserialized_state_defaults)
+                        else
+                          method_defined?(:__init_deserialized_state_defaults, false)
+                        end
+          return unless defined_now
+
+          remove_method(:__init_deserialized_state_defaults)
+        end
+
         def define_attribute_methods(attr, register = nil)
           name = attr.name
           register_id = extract_register_id(register)
@@ -200,6 +253,7 @@ module Lutaml
           attr = Attribute.new(name, type, options)
           @attributes[name] = attr
           @merged_attributes_cache = nil
+          invalidate_state_defaults!
           define_attribute_methods(attr)
 
           attr

data/lib/lutaml/model/serialize.rb

@@ -108,15 +108,20 @@ module Lutaml
         @using_default = nil
         @lutaml_register = register
 
-        # Initialize all attributes to their "empty" state.
-        # Collections use a shared frozen sentinel (zero allocation per instance).
-        # Non-collections use UninitializedClass.instance (singleton, no allocation).
-        # This ensures consistent initial state for the deserialization pipeline:
-        # attributes that don't match any rule keep their UninitializedClass value,
-        # avoiding the need for the setter to be called as a no-op.
-        self.class.attributes(register).each do |name, attr|
-          instance_variable_set(:"@#{name}",
-                                attr.collection? ? LAZY_EMPTY_COLLECTION : Lutaml::Model::UninitializedClass.instance)
+        # Default register: seed through the per-class compiled method
+        # (plain `@x = sentinel` writes). The previous per-instance
+        # instance_variable_set loop was a measured hot spot — one send
+        # and one symbol allocation per attribute per instance. Register-
+        # specific attribute sets are rare and keep the generic walk.
+        if register.nil? || register == :default
+          klass = self.class
+          klass.compile_state_defaults! unless klass.method_defined?(:__init_deserialized_state_defaults)
+          __init_deserialized_state_defaults
+        else
+          self.class.attributes(register).each do |name, attr|
+            instance_variable_set(:"@#{name}",
+                                  attr.collection? ? LAZY_EMPTY_COLLECTION : Lutaml::Model::UninitializedClass.instance)
+          end
         end
       end
 

data/lib/lutaml/model/store.rb

@@ -6,15 +6,28 @@ require "weakref" unless Lutaml::Model.opal?
 module Lutaml
   module Model
     class Store
-      # Compact dead WeakRef shells once a class bucket grows past this size.
+      # Compact dead index entries once a class bucket grows past this size.
       COMPACTION_THRESHOLD = 1000
 
       # Once the threshold is exceeded, only compact every Nth subsequent
-      # register call. Amortises the O(N) reject! over N inserts so
+      # register call. Amortises the O(N) prune over N inserts so
       # register stays O(1) per call rather than O(N) per call (O(N^2)
       # cumulatively for the class).
       COMPACTION_INTERVAL = 1000
 
+      WeakBucket = if Lutaml::Model.opal?
+                     # Opal has neither WeakRef nor ObjectSpace::WeakMap; documents in
+                     # the browser are small, so strong references are the fallback.
+                     ::Hash
+                   else
+                     # CRuby: WeakMap holds keys weakly with zero Ruby-level
+                     # allocation per insert and no per-object finalizer — the WeakRef
+                     # approach allocated one finalizer-registering object per
+                     # instance (lutaml-model#695) and dominated GC cycles on
+                     # instance-heavy parses.
+                     ::ObjectSpace::WeakMap
+                   end
+
       class << self
         def instance
           @instance ||= new
@@ -42,8 +55,10 @@ module Lutaml
       end
 
       def initialize
-        @store = ::Hash.new { |hash, key| hash[key] = [] }
-        # Nested index: { model_key => { reference_key => { value => WeakRef(object) } } }
+        # WeakMap-based buckets: value presence marks liveness, no
+        # per-instance allocation (lutaml-model#695).
+        @store = ::Hash.new { |hash, key| hash[key] = WeakBucket.new }
+        # Nested index: { model_key => { reference_key => { value => object } } }
         # Grouped by model_key so register only iterates this class's own indices.
         @index = {}
         @inserts_since_compaction = ::Hash.new(0)
@@ -52,11 +67,10 @@ module Lutaml
 
       def register(object)
         model_key = object.class.to_s
-        refs = @store[model_key]
-        refs << WeakRef.new(object)
+        @store[model_key][object] = true
         @inserts_since_compaction[model_key] += 1
 
-        compact_if_needed(refs, model_key)
+        compact_if_needed(model_key)
 
         update_existing_indices(object, model_key)
       end
@@ -78,25 +92,26 @@ module Lutaml
         obj
       end
 
+      def live_objects(model_key)
+        bucket = @store[model_key]
+        return [] unless bucket
+
+        live_objects_for(bucket)
+      end
+
       def clear
-        @store = ::Hash.new { |hash, key| hash[key] = [] }
+        @store = ::Hash.new { |hash, key| hash[key] = WeakBucket.new }
         @index = {}
         @inserts_since_compaction = ::Hash.new(0)
         @compaction_count = 0
       end
 
       def store
-        @store.transform_values do |refs|
-          refs.each_with_object([]) do |ref, alive|
-            alive << ref.__getobj__ if ref.weakref_alive?
-          rescue WeakRef::RefError
-            nil
-          end
-        end
+        @store.transform_values { |refs| live_objects_for(refs) }
       end
 
       def refs_for(model_key)
-        @store[model_key]
+        LiveView.new(self, model_key)
       end
 
       def inserts_since_compaction
@@ -117,15 +132,15 @@ module Lutaml
         @index[model_key] ||= {}
       end
 
-      # Build index for a (model_class, reference_key) pair by scanning existing instances.
+      # Build index for a (model_class, reference_key) pair by scanning
+      # live instances. Index values hold WeakRefs: the index must not
+      # pin objects (only the rare classes with resolved reference keys
+      # pay this; the per-instance bucket stays allocation-free WeakMap).
       def build_index(model_indices, model_key, reference_key)
         entries = model_indices[reference_key] = {}
-        @store[model_key]&.each do |ref|
-          obj = ref.__getobj__
+        each_live(model_key) do |obj|
           value = obj.public_send(reference_key)
           entries[value] = WeakRef.new(obj) if value
-        rescue WeakRef::RefError
-          next
         end
       end
 
@@ -136,11 +151,9 @@ module Lutaml
         model_indices = @index[model_key]
         return unless model_indices
 
-        model_indices.each do |reference_key, entries|
+        model_indices.each_key do |reference_key|
           value = object.public_send(reference_key)
-          entries[value] = WeakRef.new(object) if value
-        rescue WeakRef::RefError
-          next
+          model_indices[reference_key][value] = WeakRef.new(object) if value
         end
       end
 
@@ -150,17 +163,11 @@ module Lutaml
         nil
       end
 
-      def compact_if_needed(refs, model_key)
-        return unless refs.size > COMPACTION_THRESHOLD
+      def compact_if_needed(model_key)
         return unless @inserts_since_compaction[model_key] >= COMPACTION_INTERVAL
 
         @inserts_since_compaction[model_key] = 0
         @compaction_count += 1
-        refs.reject! do |ref|
-          !ref.weakref_alive?
-        rescue WeakRef::RefError
-          true
-        end
         prune_index(model_key)
       end
 
@@ -177,6 +184,37 @@ module Lutaml
           entries.empty?
         end
       end
+
+      def each_live(model_key, &block)
+        @store[model_key]&.each_key(&block)
+      end
+
+      def live_objects_for(bucket)
+        # WeakMap#each_key requires a block on CRuby; WeakMap#each
+        # yields key/value pairs, and Hash buckets enumerate the same
+        # way (value is `true` for WeakMap, the object for the Opal
+        # fallback keyed by object identity).
+        bucket.map { |key, _value| key }
+      end
+
+      # Array-shaped live view over a class's WeakMap bucket, for
+      # specs/debugging (refs_for used to expose the raw array).
+      class LiveView
+        include Enumerable
+
+        def initialize(store, model_key)
+          @store = store
+          @model_key = model_key
+        end
+
+        def each(&block)
+          @store.live_objects(@model_key).each(&block)
+        end
+
+        def size
+          @store.live_objects(@model_key).size
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.36"
+    VERSION = "0.8.37"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -84,6 +84,7 @@ module Lutaml
         @cached_elements = {}
         @cached_attributes = {}
         @cached_mappings = {}
+        @cached_attribute_name_counts = {}
         @finalized = false
       end
 
@@ -98,6 +99,17 @@ module Lutaml
         # Resolve any deferred mapping imports before finalizing
         ensure_mappings_imported!
 
+        # lutaml-model#687: nested sequence choices tag their target
+        # model attributes now that the mapper class is known.
+        @element_sequence.each do |seq|
+          seq.bind_choice_compositors!(mapper_class)
+        end
+
+        # lutaml-model#296: a mapped rule whose attribute type can never
+        # accept the serialization shape fails here, with the attribute
+        # and type named, instead of surfacing mid-parse as a cast oddity.
+        validate_mapped_attribute_types!(mapper_class)
+
         # Validate mixed content requires collection attribute for content mapping
         validate_mixed_content_collection!(mapper_class)
 
@@ -108,6 +120,7 @@ module Lutaml
         @cached_elements.clear
         @cached_attributes.clear
         @cached_mappings.clear
+        @cached_attribute_name_counts.clear
         @finalized = true
       end
 
@@ -1028,6 +1041,26 @@ module Lutaml
         end
       end
 
+      # Fire InvalidAttributeTypeError at definition time for mapped
+      # rules whose target attribute type is neither a Type::Value nor
+      # Serializable (lutaml-model#296). Undeclared types are left to
+      # deferred-import resolution.
+      def validate_mapped_attribute_types!(mapper_class)
+        (elements + attributes).each do |rule|
+          target = mapper_class.attributes[rule.to]
+          next unless target
+
+          begin
+            resolved = target.type(Lutaml::Model::Config.default_register)
+          rescue Lutaml::Model::UnknownTypeError
+            next
+          end
+          next unless resolved.is_a?(Class)
+
+          target.validate_attr_type!(resolved)
+        end
+      end
+
       def elements(register_id = nil)
         reg_key = register_id || :default
         cached = @cached_elements[reg_key]
@@ -1060,6 +1093,26 @@ module Lutaml
         @raw_mapping
       end
 
+      # lutaml-model#790/#791: whether `rule` is the only attribute rule
+      # claiming its exact name spelling. The answer is a property of the
+      # mapping, not the document, so it is counted once per register
+      # (rules sharing a spelling make each other non-sole).
+      def sole_local_attribute_claimant?(rule, register_id = nil)
+        reg_key = register_id || :default
+        counts = @cached_attribute_name_counts[reg_key]
+        unless counts
+          counts = {}
+          attributes(register_id).each do |r|
+            key = r.name_strings
+            counts[key] = (counts[key] || 0) + 1
+          end
+          counts.freeze if @finalized
+          @cached_attribute_name_counts[reg_key] = counts
+        end
+
+        (counts[rule.name_strings] || 1) == 1
+      end
+
       def mappings(register_id = nil)
         reg_key = register_id || :default
         cached = @cached_mappings[reg_key]

data/lib/lutaml/xml/model_transform.rb

@@ -12,6 +12,15 @@ module Lutaml
     # - Used by model's serialization pipeline via Transform.for(:xml)
     #
     class ModelTransform < ::Lutaml::Model::Transform
+      # Namespaced rule name -> [local_name, rule_uri]. Pure string
+      # splitting, deterministic per spelling, shared across parses.
+      # Concurrent::Map under threaded MRI, plain Hash under Opal.
+      NAMESPACED_NAME_PARTS = if Lutaml::Model.opal?
+                                {}
+                              else
+                                Lutaml::Model::RuntimeCompatibility.require_native("concurrent")
+                                Concurrent::Map.new
+                              end
       include NestedCollectionAttribute
 
       # Performance: Frozen empty hash to reduce allocations
@@ -487,16 +496,11 @@ _effective_register)
         mapping = klass.mappings_for(:xml, effective_register)
         return true unless mapping
 
-        expected = Array(rule.name).map(&:to_s)
-        mapping.mappings.none? do |sib|
-          next false unless sib.attribute? && !sib.equal?(rule)
-
-          Array(sib.name).map(&:to_s) == expected
-        end
+        mapping.sole_local_attribute_claimant?(rule, effective_register)
       end
 
       def value_for_xml_attribute(doc, rule, rule_names,
-                                  flexible_local: false)
+                                  flexible_local: false, session: nil)
         # For attributes, rule_names may contain namespaced names, but find_attribute_value
         # expects prefix:name or just name, so we need to convert namespaced names to prefix format.
         #
@@ -524,7 +528,8 @@ _effective_register)
         # (e.g., v:ext without xmlns:v="...").
         if value.nil? && rule_names.any? { |rn| rn.include?(":") }
           value = find_attribute_by_local_name(doc, rule_names,
-                                               flexible_local: flexible_local)
+                                               flexible_local: flexible_local,
+                                               session: session)
         end
 
         value = value&.split(rule.delimiter) if rule.delimiter
@@ -588,49 +593,61 @@ _effective_register)
       # @param rule_names [Array<String>] the rule names to match
       # @return [String, nil] the attribute value or nil
       def find_attribute_by_local_name(doc, rule_names,
-                                       flexible_local: false)
+                                       flexible_local: false, session: nil)
+        root_index = session&.root_local_attribute_index
+
         rule_names.each do |rn|
           next unless rn.include?(":")
 
-          last_colon_index = rn.rindex(":")
-          local_name = rn[(last_colon_index + 1)..]
-          rule_uri = rn[0...last_colon_index]
-
-          matched_attr = doc.root.attributes.each_value.find do |attr|
-            # Local-name fallback serves two lenient cases only:
-            # - an attribute with an undeclared prefix (raw name keeps the
-            #   colon, namespace unresolvable), the historical purpose;
-            # - an attribute whose resolved namespace IS one of the rule's
-            #   namespace URIs (prefix rebinding, lutaml-model#744).
-            # Everything else — including a definitively namespace-less
-            # attribute and an attribute from a foreign namespace — must
-            # not satisfy the fallback, or a plain rule steals a
-            # namespaced sibling attribute (lutaml-model#758). An
-            # XmlAttribute with a resolved namespace has namespaced_name
-            # "URI:local", so this comparison is allocation-free.
-            if flexible_local
-              # Sole claimant: any qualification of the local name binds
-              # (element namespace, foreign extension namespace, none).
-              attr.unprefixed_name == local_name ||
-                ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name
-            elsif attr.namespace.nil?
-              next false if attr.namespace_prefix.nil? &&
-                !attr.name.include?(":")
-
-              attr.unprefixed_name == local_name ||
-                ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name
-            else
-              # Prefixed attributes carry namespaced_name "prefix:local",
-              # which a URI-form rule name can never equal — match by the
-              # attribute's resolved namespace instead.
-              attr.namespace == rule_uri && attr.unprefixed_name == local_name
-            end
+          # Splitting a namespaced rule name is pure string work repeated
+          # per element; memoized per spelling (bounded by the model's
+          # distinct rule names).
+          parts = NAMESPACED_NAME_PARTS[rn]
+          unless parts
+            last_colon_index = rn.rindex(":")
+            parts = [rn[(last_colon_index + 1)..], rn[0...last_colon_index]]
+            NAMESPACED_NAME_PARTS[rn] = parts
           end
+          local_name, rule_uri = parts
+
+          candidates = root_index&.[](local_name)
+          matched_attr = if candidates
+                           candidates.find do |attr|
+                             local_name_match?(attr, local_name, rule_uri,
+                                               flexible_local)
+                           end
+                         else
+                           doc.root.attributes.each_value.find do |attr|
+                             local_name_match?(attr, local_name, rule_uri,
+                                               flexible_local)
+                           end
+                         end
           return matched_attr&.value if matched_attr
         end
         nil
       end
 
+      # Namespace discipline of the lenient local-name fallback
+      # (#744/#758/#790): sole claimants bind any qualification; shared
+      # names must resolve to the rule's namespace.
+      def local_name_match?(attr, local_name, rule_uri, flexible_local)
+        if flexible_local
+          attr.unprefixed_name == local_name ||
+            attr_name_local(attr) == local_name
+        elsif attr.namespace.nil?
+          return false if attr.namespace_prefix.nil? && !attr.name.include?(":")
+
+          attr.unprefixed_name == local_name ||
+            attr_name_local(attr) == local_name
+        else
+          attr.namespace == rule_uri && attr.unprefixed_name == local_name
+        end
+      end
+
+      def attr_name_local(attr)
+        (colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name
+      end
+
       def value_for_rule(session, rule, options, cached_attr = nil,
                          extra_rule_names = nil)
         doc = session.doc

data/lib/lutaml/xml/parse_session.rb

@@ -24,6 +24,25 @@ module Lutaml
         @instance_is_serialize ||= instance.is_a?(::Lutaml::Model::Serialize)
       end
 
+      # Local-name -> [attributes] index over the root element's
+      # attributes, built on first lenient lookup (TODO.max-perf/08).
+      # The fallback used to rescan every attribute per missed rule;
+      # elements are parse-frozen, so the index builds at most once per
+      # session. Each attribute is filed under every local-name spelling
+      # the matcher compares (unprefixed name and colon-split local).
+      def root_local_attribute_index
+        @root_local_attribute_index ||= begin
+          index = ::Hash.new { |h, k| h[k] = [] }
+          doc.root.attributes.each_value do |attr|
+            local_names(attr).each do |key|
+              entries = index[key]
+              entries << attr unless entries.include?(attr)
+            end
+          end
+          index
+        end
+      end
+
       def model_class
         @model_class ||= instance.class
       end
@@ -57,3 +76,9 @@ module Lutaml
     end
   end
 end
+
+def local_names(attr)
+  colon = attr.name.rindex(":")
+  split_local = colon ? attr.name[(colon + 1)..] : attr.name
+  [attr.unprefixed_name, split_local].compact.uniq
+end

data/spec/lutaml/model/adapter_resolver_configured_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::AdapterResolver, ".adapter_for with a configured type" do
+  after do
+    Lutaml::Model::Config.configure do |config|
+      config.xml_adapter_type = :nokogiri
+      config.yaml_adapter_type = :standard
+      config.json_adapter_type = :standard
+    end
+  end
+
+  it "resolves the configured adapter without running auto-detection" do
+    Lutaml::Model::Config.configure do |config|
+      config.json_adapter_type = :standard
+    end
+
+    adapter = described_class.adapter_for(:json)
+
+    expect(described_class.configured_type(:json)).to eq(:standard)
+    expect(adapter.name).to include("Json::Standard")
+  end
+
+  it "does not load the optional yeptris engine when a standard adapter is configured" do
+    skip "yeptris already loaded by an earlier spec" if Object.const_defined?(:Yeptris)
+
+    Lutaml::Model::Config.configure do |config|
+      config.yaml_adapter_type = :standard
+      config.json_adapter_type = :standard
+    end
+
+    described_class.adapter_for(:yaml)
+    described_class.adapter_for(:json)
+
+    expect(Object.const_defined?(:Yeptris)).to be(false)
+  end
+end

data/spec/lutaml/model/liquefiable_lazy_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#800: `liquid do ... end` blocks survive a boot order in
+# which Liquid is required after lutaml-model; the drop class
+# materializes on first use instead of requiring Liquid at definition.
+RSpec.describe "Liquefiable lazy registration" do
+  it "materializes the drop class on first to_liquid" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      liquid do
+        map "full_name", to: :name
+      end
+    end
+
+    # Mapping stored at definition; drop registration is lazy
+    expect(klass.liquid_mappings.mappings).not_to be_empty
+
+    drop = klass.new(name: "Apollo").to_liquid
+    expect(drop).to be_a(Liquid::Drop)
+    expect(drop.full_name).to eq("Apollo")
+  end
+
+  it "keeps ensure_liquid_registered! idempotent" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+    end
+
+    klass.ensure_liquid_registered!
+    first = klass.base_drop_class
+    klass.ensure_liquid_registered!
+    expect(klass.base_drop_class).to equal(first)
+  end
+end

data/spec/lutaml/model/mapping_type_validation_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#296: a mapped rule whose attribute type can never accept
+# the serialization shape fails at mapping definition, naming the
+# attribute and the type, instead of surfacing mid-parse.
+RSpec.describe "Mapping-time attribute type validation" do
+  it "raises InvalidAttributeTypeError at definition for a non-castable type" do
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :ends, Object
+
+        xml do
+          element "doc"
+          map_element "ends", to: :ends
+        end
+      end
+    end.to raise_error(Lutaml::Model::InvalidAttributeTypeError) do |err|
+      expect(err.message).to include("attribute `ends`")
+      expect(err.message).to include("Object")
+    end
+  end
+
+  it "accepts Value, Serializable, and collection types" do
+    item = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      xml do 
+        element "item"
+        map_element "name", to: :name
+      end
+    end
+
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :count, :integer
+        attribute :name, :string
+        attribute :items, item, collection: true
+
+        xml do
+          element "doc"
+          map_element "count", to: :count
+          map_element "items", to: :items
+        end
+      end
+    end.not_to raise_error
+  end
+
+  it "leaves undeclared (deferred) types to import resolution" do
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :later, :missing_type_name
+
+        xml do
+          element "doc"
+          map_element "later", to: :later
+        end
+      end
+    end.not_to raise_error
+  end
+end

data/spec/lutaml/model/sequence_choice_compositor_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#687: an xs:sequence remembers a nested xs:choice
+# compositor. Element rules inside `choice` take their position in the
+# sequence and carry the choice on their model attributes, so validation
+# applies order and exclusivity.
+RSpec.describe "Sequence with nested choice" do
+  let(:model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :title, :string
+      attribute :hardcover, :string
+      attribute :paperback, :string
+      attribute :author, :string, collection: true
+
+      xml do
+        element "book"
+        sequence do
+          map_element "title", to: :title
+          choice do
+            map_element "hardcover", to: :hardcover
+            map_element "papercover", to: :paperback
+            map_element "paperback", to: :paperback
+          end
+          map_element "author", to: :author
+        end
+      end
+    end
+  end
+
+  it "records the choice as a compositor alongside the flat order" do
+    sequence = model.mappings_for(:xml).element_sequence.first
+    expect(sequence.compositors).to contain_exactly(
+      an_instance_of(Lutaml::Model::Choice),
+    )
+    choice = sequence.compositors.first
+    # After finalize the choice carries the model attributes its rules
+    # target — the shape validation machinery expects.
+    expect(choice.attributes.map(&:name)).to eq(%i[hardcover paperback])
+  end
+
+  it "keeps the model attributes tagged with the nested choice" do
+    choice = model.mappings_for(:xml).element_sequence.first.compositors.first
+    expect(model.attributes[:hardcover].options[:choice]).to equal(choice)
+    expect(model.attributes[:paperback].options[:choice]).to equal(choice)
+  end
+
+  it "validates order and exclusivity" do
+    valid = model.from_xml(
+      "<book><title>T</title><paperback>PB</paperback><author>A</author></book>",
+    )
+    expect(valid.validate).to be_empty
+
+    out_of_order = model.from_xml(
+      "<book><author>A</author><title>T</title><hardcover>HB</hardcover></book>",
+    )
+    expect(out_of_order.validate).not_to be_empty
+
+    both_branches = model.from_xml(
+      "<book><title>T</title><hardcover>HB</hardcover>" \
+      "<paperback>PB</paperback><author>A</author></book>",
+    )
+    expect(both_branches.validate).not_to be_empty
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -202,12 +202,10 @@ RSpec.describe Lutaml::Model::Store do
       # After compaction, the refs array should be smaller than before
       # (some dead refs removed). Exact count depends on GC timing,
       # but the live refs must still be present.
-      live = instance.refs_for(model_class.to_s)
-      alive_count = live.count do |ref|
-        ref.weakref_alive?
-      rescue WeakRef::RefError
-        false
-      end
+      # refs_for yields live objects directly under the WeakMap buckets
+      # (dead keys never surface), so the live count is bounded by the
+      # post-GC population regardless of compaction timing.
+      alive_count = instance.refs_for(model_class.to_s).count
       expect(alive_count).to be < (threshold + 1 + interval)
     end
 
@@ -225,14 +223,18 @@ RSpec.describe Lutaml::Model::Store do
       expect(counters[other_class.to_s]).to eq(3)
     end
 
-    it "does not compact when exactly at threshold" do
-      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+    it "compacts only on interval multiples" do
+      interval = Lutaml::Model::Store::COMPACTION_INTERVAL
       instance = described_class.instance
 
-      _objects = Array.new(threshold) { |i| model_class.new(id: "edge-#{i}") }
-
-      # refs.size == threshold, which does not satisfy size > threshold
+      # WeakMap buckets shed dead keys without help, so compaction is
+      # purely index maintenance on a fixed cadence: the counter fires
+      # exactly at each interval boundary, never between.
+      (interval - 1).times { |i| model_class.new(id: "edge-#{i}") }
       expect(instance.compaction_count).to eq(0)
+
+      model_class.new(id: "edge-trigger")
+      expect(instance.compaction_count).to eq(1)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.36
+  version: 0.8.37
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1686,6 +1686,7 @@ files:
 - spec/lutaml/key_value/transformation/value_serializer_spec.rb
 - spec/lutaml/key_value/transformation_spec.rb
 - spec/lutaml/model/absent_value_contracts_spec.rb
+- spec/lutaml/model/adapter_resolver_configured_spec.rb
 - spec/lutaml/model/attribute_apply_value_map_spec.rb
 - spec/lutaml/model/attribute_collection_spec.rb
 - spec/lutaml/model/attribute_default_cache_spec.rb
@@ -1743,6 +1744,7 @@ files:
 - spec/lutaml/model/key_value_data_model/key_value_element_spec.rb
 - spec/lutaml/model/key_value_mapping_spec.rb
 - spec/lutaml/model/lazy_collection_spec.rb
+- spec/lutaml/model/liquefiable_lazy_spec.rb
 - spec/lutaml/model/liquefiable_spec.rb
 - spec/lutaml/model/liquid/indexed_access_spec.rb
 - spec/lutaml/model/liquid_compatibility_spec.rb
@@ -1750,6 +1752,7 @@ files:
 - spec/lutaml/model/map_all_spec.rb
 - spec/lutaml/model/map_content_spec.rb
 - spec/lutaml/model/mapping_rule_perf_guard_spec.rb
+- spec/lutaml/model/mapping_type_validation_spec.rb
 - spec/lutaml/model/mixed_content_spec.rb
 - spec/lutaml/model/model_transformer_spec.rb
 - spec/lutaml/model/multiple_mapping_spec.rb
@@ -1783,6 +1786,7 @@ files:
 - spec/lutaml/model/schema/renderers/union_spec.rb
 - spec/lutaml/model/schema/xsd_schema_spec.rb
 - spec/lutaml/model/schema/yaml_schema_spec.rb
+- spec/lutaml/model/sequence_choice_compositor_spec.rb
 - spec/lutaml/model/sequence_spec.rb
 - spec/lutaml/model/serializable_spec.rb
 - spec/lutaml/model/serializable_validation_spec.rb