lutaml-model 0.8.56 → 0.8.106

data/lib/lutaml/xml/leptris/plan_walk.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Leptris
+      # Public consumer surface for the plan fast path: one engine
+      # parse + descriptor walk and direct model hydration, bypassing
+      # the wrapper-tree construction that dominates large-document
+      # consumer paths. The returned object is the mapped model root;
+      # collection attributes remain collections on that model.
+      module PlanWalk
+        class << self
+          # Build the plan, walk the document, and hydrate the mapped
+          # root. Returns nil when the model is not plan-compilable.
+          def call(model_class, xml, options = {})
+            register = Lutaml::Model::Config.default_register
+            plan = PlanCompiler.compile(model_class, register)
+            return nil unless plan
+
+            document = ::Leptris::XML.parse(xml)
+            root = document.root
+            return nil unless root && root.name == plan[:tree][:name]
+
+            PlanHydrator.call(model_class, plan,
+                              plan[:descriptor].walk(root),
+                              node: root,
+                              declaration_plan_mode:
+                                options.fetch(
+                                  :import_declaration_plan, :eager
+                                ))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/leptris.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # The leptris plan fast path: model mapping to libleptris descriptor
+    # plan, native walk, direct hydration. Everything under this
+    # namespace is bound to the leptris gem; nothing above it may
+    # reference leptris types directly (the moxml adapters and the
+    # interpretive path never enter here).
+    module Leptris
+      # Single capability floor (leptris 1.9.336.0): the child-handles
+      # snapshot (1.9.273), exact-URI attribute rows (#1486, 1.9.289),
+      # nested-attribute capture (#1563, 1.9.313), wildcard rows
+      # (#1552, 1.9.313), child-row ns_uri retention and qualified
+      # attribute leniency (#1585/#1586, 1.9.320), the :unqualified ns
+      # form (#1560, 1.9.323), and build_result with the address-based
+      # text attach (#408, 1.9.334/1.9.336). Bundles resolving an
+      # older gem keep the interpretive path — PlanCompiler.compile
+      # answers nil — the opt-out protocol.
+      MIN_LEPTRIS_VERSION = "1.9.336.0"
+
+      # Memoized: the compiler consults this on every cache hit (per
+      # child row per node), and the comparison minted a Gem::Version
+      # per call — visible in the niso ordered-lane allocation profile.
+      # The loaded gem cannot change mid-process.
+      def self.plan_path_compatible?
+        return @plan_path_compatible if defined?(@plan_path_compatible)
+
+        @plan_path_compatible =
+          if defined?(Gem)
+            spec = Gem.loaded_specs["leptris"]
+            spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
+          else
+            false
+          end
+      end
+
+      autoload :NativeEmission, "lutaml/xml/leptris/native_emission"
+      autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
+      autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
+      autoload :PlanOrder, "lutaml/xml/leptris/plan_order"
+      autoload :PlanSerializer, "lutaml/xml/leptris/plan_serializer"
+      autoload :PlanWalk, "lutaml/xml/leptris/plan_walk"
+    end
+  end
+end

data/lib/lutaml/xml/mapping.rb

@@ -38,27 +38,14 @@ module Lutaml
         @xml_instance
       end
 
-      attr_reader :root_element,
-                  :namespace_uri,
-                  :namespace_prefix,
-                  :element_sequence,
-                  :mappings_imported,
-                  :namespace_class,
-                  :namespace_param,
-                  :element_name,
-                  :documentation_text,
-                  :type_name_value,
-                  :namespace_scope,
-                  :mapper_class,
-                  :xml_space,
-                  :consolidation_maps,
-                  :processing_instruction_mappings
+      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule
 
       def initialize
         super
 
         @elements = {}
         @attributes = {}
+        @any_element_rule = nil
         @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
@@ -504,6 +491,24 @@ module Lutaml
       # @return [String, nil] the type name
       alias xsd_type type_name
 
+      # Catch-all element mapping: every child element with no
+      # explicit rule routes to one collection attribute. For
+      # parse-side consumption of dynamic vocabularies (semantic__
+      # trees); element_order preserves the original tag names.
+      # Serialization of a catch-all attribute emits the attribute's
+      # declared element name (not per-item originals).
+      def map_any_element(to:, render_nil: false, render_default: false)
+        validate!(nil, to, {}, render_nil, false, type: TYPES[:element])
+        @any_element_rule = MappingRule.new(
+          nil,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+        )
+        @element_rules_index = nil if instance_variable_defined?(:@element_rules_index)
+        @any_element_rule
+      end
+
       def map_instances(to:, polymorphic: {})
         map_element(to, to: to, polymorphic: polymorphic)
       end
@@ -1192,6 +1197,31 @@ module Lutaml
       # transform applies the collection-attribute filter.
       #
       # @return [Hash{Symbol, String => Array<MappingRule>}]
+      # The when_attribute siblings-vs-plain-names partition of the
+      # element rules. A ParseSession used to rebuild this per parsed
+      # node (sessions are per-element), paying an O(rules) pass on
+      # every node of large documents; it is a pure function of the
+      # rules, so it memoizes here — same lifetime as
+      # plain_element_rules_by_attr.
+      def when_attribute_partition
+        @when_attribute_partition ||= begin
+          siblings = {}
+          plain_names = {}
+          mappings.each do |rule|
+            next if rule.attribute? || rule.content_mapping? ||
+              rule.raw_mapping? || rule.cdata
+
+            pairs = rule.when_attribute
+            if pairs && !pairs.empty?
+              (siblings[rule.name.to_s] ||= []) << rule
+            else
+              plain_names[rule.name.to_s] = true
+            end
+          end
+          [siblings, plain_names]
+        end
+      end
+
       def plain_element_rules_by_attr(register_id = nil)
         reg_key = register_id || :default
         @plain_element_rules_by_attr ||= {}
@@ -1342,9 +1372,9 @@ module Lutaml
         elsif ["text", "#cdata-section"].include?(name.to_s) && type == "Text"
           content_mapping
         else
-          candidates = mappings.select do |rule|
-            rule.name == name.to_s || rule.name == name.to_sym
-          end
+          candidates = element_rules_index[name.to_s]
+          return @any_element_rule if candidates.nil? && @any_element_rule
+          return nil if candidates.nil?
           return candidates.first if namespace_uri.nil? || candidates.one?
 
           candidates.find do |r|
@@ -1353,6 +1383,29 @@ module Lutaml
         end
       end
 
+      # O(1) name -> rules lookup. Parsing consults this once per
+      # child element; the linear scan over every rule made large
+      # documents quadratic (155s on a 7MB vocabulary tree). Keyed on
+      # the stable source hashes (@elements/@attributes mutate only at
+      # DSL time), never on the per-call mappings array.
+      def element_rules_index
+        cache_key = [@elements.object_id, @attributes.object_id]
+        cached = (@element_rules_index ||= {})
+        idx = cached[cache_key]
+        return idx if idx
+
+        idx = {}
+        ([content_mapping, raw_mapping].compact + @elements.values +
+          @attributes.values).flatten.each do |rule|
+          next if rule.is_a?(::Hash)
+
+          (idx[rule.name.to_s] ||= []) << rule
+        end
+        cached[cache_key] = idx
+        idx
+      end
+      private :element_rules_index
+
       def find_by_to(to)
         mappings.detect { |rule| rule.to.to_s == to.to_s }
       end

data/lib/lutaml/xml/model_transform.rb

@@ -114,7 +114,14 @@ module Lutaml
           # Only needed for root elements (no lutaml_parent in options).
           # Three modes: :lazy (default), :eager, :skip.
           if !options.key?(:lutaml_parent)
-            plan_mode = options.fetch(:import_declaration_plan, :lazy)
+            # Default :eager — the plan data is tiny, but :lazy pins the
+            # adapter root element on every parsed instance, which keeps the
+            # entire native DOM (moxml wrappers + engine nodes) alive until
+            # first serialization. Models that are never serialized retain
+            # the DOM forever: a 10.5MB XMI held 578MB of wrappers this
+            # way. :lazy remains available for parse-serialize-immediately
+            # workflows that want to skip the namespace walk.
+            plan_mode = options.fetch(:import_declaration_plan, :eager)
             case plan_mode
             when :skip
               # Skip plan building entirely (fastest)
@@ -205,7 +212,9 @@ module Lutaml
             }
           end
 
-          result[path] = input_namespaces unless input_namespaces.empty?
+          # The path array is shared and mutated during the descent;
+          # snapshot it as a result key only where a declaration lives.
+          result[path.dup] = input_namespaces unless input_namespaces.empty?
         end
 
         # Recurse into children with path extended by child local name
@@ -223,8 +232,9 @@ module Lutaml
                              else
                                full_name
                              end
-          child_path = path + [child_local_name]
-          collect_element_namespaces(child, child_path, result, visited)
+          path.push(child_local_name)
+          collect_element_namespaces(child, path, result, visited)
+          path.pop
         end
 
         result
@@ -263,6 +273,9 @@ module Lutaml
         # Performance: Resolve xml_mapping once — used for both rules and metadata
         xml_mapping = mappings_for(:xml, effective_register)
         mappings = options[:mappings] || xml_mapping.mappings(effective_register)
+        # Catch-all rule (map_any_element): iterated like any other,
+        # claiming every child no explicit rule matches.
+        mappings += [xml_mapping.any_element_rule].compact if options[:mappings].nil?
         default_namespace = options[:default_namespace]
         ordered_option = options[:ordered]
         mixed_content_option = options[:mixed_content]
@@ -331,6 +344,13 @@ module Lutaml
         deserialize_attributes = attributes
         mappings.each do |rule|
           record = records&.[](rule)
+
+          # #903/#922: replay-or-drop unmatched rules; never clobber
+          # a mid-parse custom-writer assignment.
+          next if replay_unmatched_rule(child_names_set, record, rule,
+                                        instance, defaults_used,
+                                        xml_mapping)
+
           rule_to = rule.to
 
           if record
@@ -361,7 +381,19 @@ module Lutaml
               options
             end
 
-          value = if rule.raw_mapping?
+          value = if !rule.attribute? && rule.name.nil? &&
+              xml_mapping.any_element_rule.equal?(rule)
+                    # map_any_element: every child element no explicit
+                    # element rule claims, in document order (claimed
+                    # set + scalar text extraction live in
+                    # any_element_members). A name-less MappingRule is
+                    # otherwise indistinguishable from a content rule;
+                    # name-derived lookup re-finds by name, losing
+                    # order and double-picking.
+                    any_element_members(
+                      doc, xml_mapping, attr, effective_register
+                    )
+                  elsif rule.raw_mapping?
                     scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
@@ -369,6 +401,8 @@ module Lutaml
                       group.size > 1 && attr&.collection?
                     # First rule of a #765 group: match every spelling of
                     # the group so the children merge in document order.
+                    raise "GROUPED-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     if child_names_set &&
                         group.drop(1).none? do |s|
                           child_matches_rule?(s, child_names_set,
@@ -385,21 +419,33 @@ module Lutaml
                       value_for_rule(session, rule, new_opts, attr,
                                      extra_names)
                     end
-                  elsif child_names_set && !rule.attribute? &&
+                  elsif child_names_set && !rule.attribute? && rule.name &&
                       !child_matches_rule?(rule, child_names_set,
                                            default_namespace)
+                    raise "FASTSKIP-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Pre-match: no child element matches this rule.
                     # Skip expensive value_for_rule, handle defaults inline.
                     # NOTE: do not "read the instance" here (to_value_for) —
                     # the compiled getters materialize lazy collections on
                     # first read, which tripled parse allocations when tried.
+                    if writer_populated?(record, instance)
+                      instance.value_set_for(rule_to)
+                      next
+                    end
                     if instance.using_default?(rule_to) || rule.render_default
                       defaults_used << rule_to
                       attr&.default(effective_register) || rule.to_value_for(instance)
                     else
-                      ::Lutaml::Model::UninitializedClass.instance
+                      # The attribute already holds an explicit value --
+                      # assigned by a matched rule or by a custom writer
+                      # mid-parse (lutaml-model#922). An unmatched rule
+                      # must not overwrite it with nil.
+                      next
                     end
                   else
+                    raise "ELSE-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Performance: Pass cached attr to avoid recomputing attribute_for_rule
                     val = value_for_rule(session, rule, new_opts, attr)
 
@@ -465,6 +511,11 @@ module Lutaml
       def set_instance_ordering(instance, doc, ordered_option,
 mixed_content_option, xml_mapping = nil,
 instance_is_serialize = nil)
+        # #909: read-only consumers skip the per-instance order summaries
+        # entirely — element_order stays nil and to_xml falls back to
+        # mapping-defined order for untracked instances.
+        return unless Lutaml::Model::Config.instance.element_order_tracking
+
         # dup: XmlElement#order hands back a frozen cache shared with the
         # DOM. The model's copy has to stay mutable so callers can maintain
         # element_order themselves.
@@ -805,7 +856,9 @@ _effective_register)
         Lutaml::Xml::HtmlEntities.decode(value)
       end
 
-      Record = Struct.new(:attr, :derived, :group_skip, :valid)
+      Record = Struct.new(:attr, :derived, :group_skip, :valid,
+                          :unmatched_mode, :replay_writer,
+                          :unmatched_names, :raw_reader)
 
       def compiled_rule_records(model_class, register, grouped_plain_rules)
         return {}.compare_by_identity unless model_class.include?(Lutaml::Model::Serialize)
@@ -824,12 +877,85 @@ _effective_register)
         mapping&.mappings(register)&.each do |rule| # rubocop:disable Style/SafeNavigationChain,Style/SafeNavigation
           attr = attribute_for_rule_static(model_class, rule, register)
           group = grouped_plain_rules[rule.to]
+          # #903: for a plain rule, what an unmatched visit writes is
+          # known statically. The fast-skip branch hands the attribute's
+          # uninitialized sentinel to the pipeline; with no value-map
+          # overrides and no transformers every step is identity except
+          # apply_value_map, which maps the :omitted key: the default
+          # map (:nil) yields nil and the visit writes nil through the
+          # setter; an explicit omitted: :omitted map treats it as
+          # treat_omitted? == false and the omission gate ends the
+          # visit untouched. Both endings replay without the walk:
+          # :write_nil (setter write + flag churn) or :drop (nothing).
+          # Everything else -- defaults, aliases, custom from:,
+          # delegates, when_attribute dispatch, transformers, value
+          # maps beyond those two -- keeps its visit.
+          unmatched_mode = nil
+          replay_writer = nil
+          if attr && !attr.derived? &&
+              !rule.render_default && !rule.multiple_mappings? &&
+              !rule.has_custom_method_for_deserialization? &&
+              !rule.delegate &&
+              !(rule.when_attribute && !rule.when_attribute.empty?)
+            rule_transform = rule.transform
+            attr_transform = attr.transform
+            no_transforms =
+              (rule_transform.nil? ||
+               (rule_transform.respond_to?(:empty?) &&
+                rule_transform.empty?)) &&
+              (attr_transform.nil? ||
+               (attr_transform.respond_to?(:empty?) &&
+                attr_transform.empty?))
+            rule_default = attr.default(register)
+            if no_transforms &&
+                (rule_default.nil? ||
+                 rule_default.is_a?(::Lutaml::Model::UninitializedClass)) &&
+                rule.class.transform_dispatch(rule, attr) == :assign
+              if group && group.size > 1 && attr.collection? &&
+                  !group.first.equal?(rule)
+                # Non-first spelling of a #765 group: the visit is a
+                # guarded next (the first member does the merged match).
+                unmatched_mode = :drop
+              else
+                omitted_val = rule.value_map(:from)[:omitted]
+                if omitted_val == :nil
+                  unmatched_mode = :write_nil
+                elsif omitted_val == :omitted
+                  unmatched_mode = :drop
+                end
+              end
+            end
+          end
+          # A first group member does the merged match for every
+          # spelling, so its name-miss test spans the whole group.
+          unmatched_names = if group && group.size > 1
+                              group.map { |r| r.name.to_s }
+                            else
+                              [rule.name.to_s]
+                            end
+          if unmatched_mode == :write_nil
+            replay_writer =
+              rule.class.parsed_assign_writer(model_class, rule.to)
+            unmatched_mode = nil unless replay_writer
+          end
           records[rule] = Record.new(
             attr,
             attr&.derived? || false,
             !!(group && group.size > 1 && attr&.collection? &&
                !group.first.equal?(rule)),
             !!(attr || rule.custom_methods[:from]),
+            unmatched_mode,
+            replay_writer,
+            unmatched_names,
+            # lutaml-model#922: raw-state reader for the attribute,
+            # when the compiled init seeds it (plain names -- the same
+            # set compile_state_defaults! writes). Delegated rules name
+            # an attribute on the delegate object, not on this
+            # instance, so they get no raw reader.
+            if attr && rule.delegate.nil? &&
+                rule.to.to_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+              :"__lutaml_raw_#{rule.to}"
+            end,
           )
         end
         entry = Struct.new(:version, :records).new(version, records)
@@ -1458,6 +1584,36 @@ effective_register = lutaml_register)
         end
       end
 
+      # map_any_element members: every child element no explicit
+      # element rule claims, in document order; scalar targets take
+      # the captured elements' text — the same normalize step scalar
+      # elements get (the cast pipeline receives strings, not wrappers
+      # whose to_s is their inspect); Serializable targets keep the
+      # wrappers and cast into instances.
+      def any_element_members(doc, mapping, attr, register)
+        claimed = Set.new(
+          mapping.mappings(register)
+            .select { |r| !r.attribute? && r.name }
+            .flat_map { |r| [r.name.to_s] },
+        )
+        unclaimed = doc.element_children.reject do |child|
+          claimed.include?(child.unprefixed_name)
+        end
+        return unclaimed if attr.nil? ||
+          attr_type_is_serializable(attr, register)
+
+        unclaimed.map do |child|
+          child_text = child.nil_element? ? nil : child&.text
+          child_cdata = child&.cdata
+          text = if child_text.is_a?(Array) || child_cdata.is_a?(Array)
+                   nil
+                 else
+                   child_text&.+ child_cdata
+                 end
+          text.nil? ? child : text
+        end
+      end
+
       def attr_type_is_serializable(attr, effective_register)
         attr&.serializable_type?(effective_register) || false
       end
@@ -1509,6 +1665,73 @@ effective_register = lutaml_register)
       # @param child_names_set [Set] Set of child namespaced_name and unprefixed_name
       # @param default_namespace [String, nil] the default namespace
       # @return [Boolean] true if a matching child likely exists
+      # #903: for an unmatched named element rule whose record classed
+      # it, replay what the visit would write without the walk: :drop
+      # (the visit ended at the omission gate or was a guarded next)
+      # writes nothing; :write_nil replays the nil the default value
+      # map produces, plus the flag churn. Returns true when handled.
+      # lutaml-model#922: whether the attribute holds anything other
+      # than its initialized marker (uninitialized sentinel / lazy
+      # collection) — i.e. a custom writer populated it mid-parse.
+      def writer_populated?(record, instance)
+        return false unless record&.raw_reader
+
+        !raw_initialized?(record, instance)
+      end
+
+      # True when the attribute still holds the value the compiled init
+      # seeded (uninitialized sentinel / lazy collection) — i.e. nothing
+      # has written it since.
+      def raw_initialized?(record, instance)
+        raw = instance.public_send(record.raw_reader)
+        raw.equal?(::Lutaml::Model::UninitializedClass.instance) ||
+          raw.equal?(::Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+      end
+
+      def replay_unmatched_rule(child_names_set, record, rule, instance,
+                                defaults_used, xml_mapping)
+        return false unless child_names_set && record
+
+        mode = record.unmatched_mode
+        return false unless mode
+        return false if rule.attribute? || rule.content_mapping? ||
+          rule.raw_mapping? || !rule.name ||
+          xml_mapping.any_element_rule.equal?(rule)
+
+        matched = record.unmatched_names.any? do |n|
+          child_names_set.include?(n)
+        end
+        return false if matched
+
+        return true if mode == :drop
+
+        # The visited path picks the default branch only while the
+        # attribute still reads as default-valued; once another rule
+        # or a custom writer set it mid-parse, the omission gate ends
+        # the visit with no write. Mirror that: replay writes only
+        # while unset, and drops otherwise (a custom writer may have
+        # populated the attribute — relaton's ICS Isoics-fallback
+        # pattern).
+        rule_to = rule.to
+        unless instance.using_default?(rule_to)
+          return true
+        end
+
+        # lutaml-model#922: a custom writer may have populated the
+        # attribute mid-parse without going through the tracker (the
+        # compiled setters are direct ivar writes), so the tracked
+        # flag above can lie. The raw state is the truth: still at its
+        # initialized marker (sentinel / lazy collection) means unset
+        # -- the visited path wrote the default there; anything else
+        # is a writer assignment this replay must not clobber.
+        return true unless raw_initialized?(record, instance)
+
+        defaults_used << rule_to
+        instance.public_send(record.replay_writer, nil)
+        instance.value_set_for(rule_to)
+        true
+      end
+
       def child_matches_rule?(rule, child_names_set, default_namespace)
         rule_names = rule.namespaced_names(default_namespace)
         # Array#intersect? requires an Array argument; child_names_set may

data/lib/lutaml/xml/namespace.rb

@@ -58,7 +58,10 @@ module Lutaml
         # @param value [String, nil] the namespace URI
         # @return [String, nil] the namespace URI
         def uri(value = nil)
-          @uri_value = value if value
+          if value
+            @uri_value = value
+            @to_key = nil
+          end
           @uri_value
         end
 
@@ -130,6 +133,7 @@ module Lutaml
         def prefix_default(value = nil)
           if value
             @prefix_default_value = value.to_s
+            @to_key = nil
           end
           @prefix_default_value
         end
@@ -286,13 +290,19 @@ module Lutaml
         #
         # @api private
         def to_key
-          prefix = prefix_default
-          namespace_uri = uri
-
-          if prefix && !prefix.empty?
-            "#{prefix}:#{namespace_uri}"
-          else
-            ":#{namespace_uri}"
+          # Called per element on the serialize path (90k births per
+          # 200-paragraph to_xml); memoized since uri/prefix_default
+          # are set at class-definition time. The setters above
+          # invalidate on reconfiguration.
+          @to_key ||= begin
+            prefix = prefix_default
+            namespace_uri = uri
+
+            if prefix && !prefix.empty?
+              "#{prefix}:#{namespace_uri}"
+            else
+              ":#{namespace_uri}"
+            end
           end
         end
 

data/lib/lutaml/xml/namespace_collector.rb

@@ -409,9 +409,25 @@ module Lutaml
             # Handle collections and arrays
             if child_instance.is_a?(Array) || child_instance.is_a?(Lutaml::Model::Collection)
               instances = child_instance.is_a?(Lutaml::Model::Collection) ? child_instance.collection : child_instance
-              # Collect needs from all instances and merge
+              # Collect needs from the FIRST instance of each distinct
+              # class and merge once — instances of one class share the
+              # mapping graph, so re-collecting every member re-walks
+              # identical structure (row-heavy models spent most of
+              # their serialize budget here). Value-dependent divergences
+              # in later members surface as unspellable forms on the
+              # serializer and fall back interpretively, never as wrong
+              # output. Merge-once is equivalent to merge-N: every read
+              # path of the merged needs is any?/set-based.
               merged_needs = NamespaceNeeds.new
+              seen_classes = nil
               instances.each do |item|
+                item_class = item.class
+                if seen_classes
+                  next if seen_classes[item_class]
+                else
+                  seen_classes = {}
+                end
+                seen_classes[item_class] = true
                 item_ns_prefix = if item.is_a?(::Lutaml::Model::Serialize)
                                    item.xml_namespace_prefix
                                  end