lutaml-model 0.8.105 → 0.8.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9d133a4a89e51d9a1ed811bd992faeac4f0a8513e283b46f079707bcc083f7e
-  data.tar.gz: e4df7bb98a1f7518bdd9f2194934e91feea5367bbf536f75aa4353a067b65049
+  metadata.gz: 1bcd55c9589b05b0eb9c4c9e0231a8e92b9063c3c34a5f9c76da5fc99e2c28f9
+  data.tar.gz: eb53b700df96a27985ff448b264fc9c4f022200d0efc8ebb313db635c6618f49
 SHA512:
-  metadata.gz: 7040ad58b0a31222207e14245293f8f20eb674180dcd55936de938151f16fc5260615f5ec3244769e4644af0bd6f02c9262e87717cbdff9d578a6b1365bbbb3a
-  data.tar.gz: f5d38407f6e5ad1b87bad426f68398a6e1249b57c928aa1a94f0585b144517542f0565c38ad2f53b31bc2c80bdaf63a5425968ba883c9d222508940f9b8b1c17
+  metadata.gz: 3e865d6c056755e187437ebf83d2423b9027df62f0f91822ff85f52541b935219869fb76e3cdd5f98c7422aef828ecea618c454259e82f0c86fa9457ca4e43dc
+  data.tar.gz: 65b581acd3765958cbf7d0e2f1607dfc552d60b441ea42d85bbd247a5c04b4487957cd951853c1fc822b3bd79ad701e6c02820476b022af5f73398d7dc8191e4

data/Gemfile

@@ -49,7 +49,7 @@ gem "rexml"
 # exact-URI attribute rows, nested-attribute capture, wildcard rows,
 # walk-side ns retention and leniency, :unqualified rows, and the
 # address-based text attach all ride it.
-gem "leptris", ">= 1.9.336.0"
+gem "leptris", ">= 1.9.351.1"
 gem "teptris"
 gem "yeptris" unless Gem.win_platform?
 # TODO: revert rng branch to main when lutaml/rng#32 is merged

data/lib/lutaml/model/attribute.rb

@@ -389,12 +389,18 @@ module Lutaml
 
       def cast_value(value, register)
         if list_like?(value)
-          build_collection(cast_items(value, register), register: register)
+          items = cast_items(value, register)
         elsif coerce_to_collection?(value)
-          build_collection(cast_items([value], register), register: register)
+          items = cast_items([value], register)
         else
-          cast_element(value, register)
+          return cast_element(value, register)
         end
+        # cast_items already returns a fresh array, so the plain-Array
+        # collection needs no re-wrap — build_collection's
+        # collection_class.new would copy it again.
+        return items if !custom_collection? && collection_class == ::Array
+
+        build_collection(items, register: register)
       end
 
       # Plain Arrays count as list input. On singular attributes

data/lib/lutaml/model/configuration.rb

@@ -37,7 +37,7 @@ module Lutaml
         @conversion_cache = nil
         @configured = false
         @xml_plan_fast_path = true
-        @xml_plan_ordered_path = false
+        @xml_plan_ordered_path = true
         @element_order_tracking = true
       end
 

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

@@ -223,6 +223,7 @@ module Lutaml
           # Clear memoized attribute merge (see .attributes)
           @merged_attributes_cache = nil
           @instantiate_writers = nil
+          @instantiate_attr_pairs = nil
 
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
@@ -402,7 +403,10 @@ module Lutaml
           attrs_by = attributes(register_id)
           writers = instantiate_writers(register_id)
           given = 0
-          attrs_by.each do |name, attr|
+          # Memoized pair array: Hash#each mints a [name, attr] pair
+          # per attribute per instance (~5 allocs/instance on
+          # hydration-heavy corpora); Array#each reuses its elements.
+          instantiate_attr_pairs(register_id).each do |name, attr|
             next if attr.derived?
 
             # Symbol keys hit directly (native-extension callers);
@@ -468,6 +472,14 @@ module Lutaml
             end
         end
 
+        # [name, attr] pairs in attributes order — instantiate's loop
+        # iterates this instead of the attributes Hash so the per-call
+        # pair array disappears (see the instantiate comment).
+        def instantiate_attr_pairs(register_id = nil)
+          (@instantiate_attr_pairs ||= {})[register_id] ||=
+            attributes(register_id).to_a.freeze
+        end
+
         # Define register-specific attribute methods on the class itself.
         #
         # Called once per (class, register) combination. Replaces per-instance

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.105"
+    VERSION = "0.8.107"
   end
 end

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

@@ -15,6 +15,10 @@ module Lutaml
       # (their values echo name and type_tag; native collection values
       # echo neither — leptris-ruby#220).
       module PlanHydrator
+        # Row kinds whose child type/plan resolve once per plan (see
+        # child_row_plans).
+        CHILD_ROW_KINDS = %i[nested ordered_deferred].freeze
+
         class << self
           # plan: the compiled plan entry for model_class
           # value: the walk root PlanValue (element)
@@ -41,7 +45,7 @@ module Lutaml
                         element_buckets(node, plan[:contested_names])
                       end
             attr_kwargs = attributes_kwargs(plan, value, node)
-            child_kwargs, children, delegates =
+            child_kwargs, children, delegates, run_children =
               children_kwargs(model_class, plan, value, buckets, register)
             plan[:collection_defaults].each do |name|
               next if attr_kwargs.key?(name) || child_kwargs.key?(name)
@@ -51,8 +55,8 @@ module Lutaml
             # TODO.max-perf/33: the bulk constructor — allocate +
             # compiled writers, from_hash semantics — measured ~30x on
             # hydration-heavy corpora versus the generic constructor.
-            instance = model_class.instantiate(attr_kwargs.merge(child_kwargs),
-                                               register)
+            attr_kwargs.update(child_kwargs)
+            instance = model_class.instantiate(attr_kwargs, register)
             instance.lutaml_parent = parent if parent
             instance.lutaml_root ||= parent&.lutaml_root || parent
             # Root prefix fidelity (the interpretive transform records
@@ -84,7 +88,8 @@ module Lutaml
               child.lutaml_parent = instance
               child.lutaml_root ||= instance.lutaml_root || instance
             end
-            interpret_deferred(model_class, plan, value, instance, node, buckets)
+            interpret_deferred(model_class, plan, value, instance, node,
+                               buckets, run_children)
             route_delegates(delegates, instance)
             instance
           end
@@ -144,8 +149,12 @@ module Lutaml
             kwargs = {}
             sole_claimants = sole_claimant_names(plan)
             ns_attr_names = plan[:ns_attr_names]
-            plan_attr_rows(plan).each do |rule, attr, name|
-              v = value.attribute(name)
+            rows = plan_attr_rows(plan)
+            # #1670 batch face (leptris 1.9.351.1): one FFI crossing
+            # per node instead of one per (node x attribute name).
+            bound = value.attributes_snapshot
+            rows.each do |rule, attr, name|
+              v = bound[name]
               if v.nil? && node && sole_claimants.include?(name)
                 # #754/#790 parity: a sole-claimant attribute rule binds
                 # any qualification (the interpretive matcher's lenient
@@ -235,7 +244,8 @@ module Lutaml
           def children_kwargs(_model_class, plan, value, buckets = nil,
                               register = nil)
             register ||= Lutaml::Model::Config.default_register
-            grouped, tagged = group_children(value, plan[:row_tags])
+            grouped, tagged, run_children = group_children(value,
+                                                           plan[:row_tags])
             buckets = nil unless buckets && plan[:needs_nodes]
             kwargs = {}
             children = []
@@ -244,10 +254,21 @@ module Lutaml
             # the block-backed Hash is a fresh object per hydrated row.
             spellings = nil
             row_tags = plan[:row_tags]
+            wire_names = row_wire_names(plan)
+            row_memo = child_row_plans(plan, register)
+            # Array#each with a top-of-loop counter: each_with_index
+            # mints an enumerator per hydrated node — 14.7K allocations
+            # per parse on the pnas guardrail — and next must keep its
+            # continue semantics.
+            rows = plan[:rows]
+            idx = -1
             # rubocop:disable Metrics/BlockLength -- one row-kind
             # dispatch table; splitting it would scatter the contract
-            plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate, row_type), idx|
+            rows.each do |row|
+              idx += 1
+              rule, attr, kind, spelling, delegate, _row_type = row
               tag = row_tags&.[](idx)
+              name = wire_names[idx]
               case kind
               when :scalar
                 # Raw passthrough: the model constructor is the single
@@ -265,7 +286,7 @@ module Lutaml
                   first = if tag
                             tagged[tag]&.first
                           else
-                            grouped.dig(rule.name.to_s, 0)
+                            grouped.dig(name, 0)
                           end
                   v = first&.string_value
                   v = mapped_empty_value(rule) if v.nil? && first
@@ -277,7 +298,7 @@ module Lutaml
               when :wildcard_any
                 # interpreted post-instance (interpret_deferred)
               when :content
-                runs = content_runs(value)
+                runs = content_runs(value, run_children)
                 if runs.empty? && !attr.collection?
                   # An empty element's content binds through the rule's
                   # value map for scalar content attributes: "" for the
@@ -293,15 +314,13 @@ module Lutaml
                 # walk against its own node + element_order from the
                 # node's children. Without one (direct PlanHydrator
                 # use), the subtree fragment-parses interpretively.
-                if buckets
-                  child_type = row_type || attr.type(register)
-                  child_plan = PlanCompiler.compile(child_type, register)
-                  selected, = child_bucket(buckets, rule, child_plan,
-                                            contested_name?(plan, rule))
+                if buckets && row_memo[idx]
+                  child_type, child_plan, child_register, contested = row_memo[idx]
+                  selected = child_selection(buckets, name, child_plan, contested)
                   items = (selected || []).map do |n|
                     call(child_type, child_plan,
                          child_plan[:descriptor].walk(n), node: n,
-                                                          register: register)
+                                                          register: child_register)
                   end
                   unless items.empty?
                     children.concat(items)
@@ -314,10 +333,10 @@ module Lutaml
                 # source node casts through the attribute — the full
                 # interpretive machinery on the bridged island,
                 # identical semantics to the interpretive path.
-                contested_uri = if plan[:contested_names]&.include?(rule.name.to_s)
+                contested_uri = if plan[:contested_names]&.include?(name)
                                   child_type_uri(attr, register)
                                 end
-                elements = deferred_elements(value, rule, buckets,
+                elements = deferred_elements(value, name, buckets,
                                              contested_uri)
                 next if elements.empty?
 
@@ -330,7 +349,7 @@ module Lutaml
                          attr.collection? ? results : results.first)
                 end
               when :collection_cb
-                values = grouped[rule.name.to_s].to_a.map do |item|
+                values = grouped[name].to_a.map do |item|
                   item&.string_value
                 end
                 values = mapped_capture_values(values, rule)
@@ -344,7 +363,7 @@ module Lutaml
                 values = if tag
                            tagged[tag].to_a.map(&:string_value)
                          else
-                           native_collection(value, rule.name.to_s)
+                           native_collection(value, name)
                          end
                 values = mapped_capture_values(values, rule) unless values.nil?
                 unless values.nil?
@@ -354,29 +373,33 @@ module Lutaml
                 spellings ||= Hash.new { |h, k| h[k] = [] }
                 spellings[[rule, attr]] << grouped[spelling.to_s].to_a
               when :nested
-                child_type = row_type || attr.type(register)
-                child_plan = PlanCompiler.compile(child_type, register)
-                selected, = child_bucket(buckets, rule, child_plan,
-                                            contested_name?(plan, rule))
-                if selected && plan[:contested_names]&.include?(rule.name.to_s)
+                child_type, child_plan, child_register, contested = row_memo[idx]
+                selected = child_selection(buckets, name, child_plan, contested)
+                if selected && contested
                   # Contested name: the walk's grouped values cross-echo
                   # every same-name element into every row — dispatch
                   # per source node instead (the walk is row-scoped).
                   items = selected.map do |n|
                     call(child_type, child_plan,
                          child_plan[:descriptor].walk(n), node: n,
-                                                          register: register)
+                                                          register: child_register)
                   end
                 else
-                  values = grouped.fetch(rule.name.to_s, [])
+                  values = grouped.fetch(name, [])
                   cursor = if child_plan[:needs_nodes] && buckets
                              selected
                            end
-                  items = values.each_with_index
-                    .map do |v, i|
-                      call(child_type, child_plan, v,
-                           node: cursor && cursor[i], register: register)
-                    end
+                  # Indexed loop: each_with_index.map mints an
+                  # enumerator per node with nested rows.
+                  count = values.size
+                  items = Array.new(count)
+                  pos = 0
+                  while pos < count
+                    items[pos] = call(child_type, child_plan, values[pos],
+                                      node: cursor && cursor[pos],
+                                      register: child_register)
+                    pos += 1
+                  end
                 end
                 next if items.empty?
 
@@ -399,7 +422,7 @@ module Lutaml
                        attr.collection? ? values : values.first)
               end
             end
-            [kwargs, children, delegates]
+            [kwargs, children, delegates, run_children]
           end
 
           # Deferred islands: raw subtrees become wrapper elements via a
@@ -410,11 +433,20 @@ module Lutaml
           # node (no fragment parse — the reparse dominated deferred
           # hydration). Ordered children only land here without a node.
           def interpret_deferred(model_class, plan, value, instance, node = nil,
-                                 buckets = nil)
-            plan[:rows].each do |rule, attr, kind, _spelling, _delegate|
+                                 buckets = nil, run_children = nil)
+            # Array#each + top counter: no per-node enumerator (see
+            # children_kwargs).
+            rows = plan[:rows]
+            idx = -1
+            rows.each do |row|
+              idx += 1
+              rule = row[0]
+              attr = row[1]
+              kind = row[2]
+              wire_name = row_wire_names(plan)[idx]
               case kind
               when :content_deferred
-                runs = content_runs(value)
+                runs = content_runs(value, run_children)
                 if runs.empty?
                   # The interpretive pipeline classifies the raw ""
                   # through the rule's value map: the :empty directive
@@ -437,13 +469,13 @@ module Lutaml
                 # concatenated).
                 instance.public_send(:"#{attr.name}=", runs.join)
               when :raw
-                raws = raw_strings(value, rule)
+                raws = raw_strings(value, wire_name)
                 next if raws.empty?
 
                 instance.public_send(:"#{attr.name}=",
                                      attr.collection? ? raws : raws.first)
               when :custom_method
-                elements = deferred_elements(value, rule, buckets)
+                elements = deferred_elements(value, wire_name, buckets)
                 next if elements.empty?
 
                 args = attr.collection? ? elements : elements.first
@@ -453,7 +485,7 @@ module Lutaml
               when :ordered_deferred
                 next if node # hydrated natively in children_kwargs
 
-                results = deferred_elements(value, rule, buckets).map do |element|
+                results = deferred_elements(value, wire_name, buckets).map do |element|
                   attr.cast(element, :xml, register,
                             lutaml_parent: instance,
                             lutaml_root: instance.lutaml_root || instance)
@@ -496,7 +528,7 @@ module Lutaml
                   attr.collection? ? results : results.first,
                 )
               when :polymorphic
-                results = deferred_elements(value, rule, buckets).map do |element|
+                results = deferred_elements(value, wire_name, buckets).map do |element|
                   attr.cast(element, :xml, register,
                             polymorphic: rule.polymorphic,
                             lutaml_parent: instance,
@@ -515,16 +547,16 @@ module Lutaml
           # construction only, no parse), falling back to a fragment
           # parse of the captured subtree when no node is available.
           # Both lists are document-ordered for the row's name.
-          def deferred_elements(value, rule, buckets, contested_uri = nil)
-            return raw_strings(value, rule).map { |raw| fragment_element(raw) } unless buckets
+          def deferred_elements(value, name, buckets, contested_uri = nil)
+            return raw_strings(value, name).map { |raw| fragment_element(raw) } unless buckets
 
-            nodes = buckets[rule.name.to_s]
+            nodes = buckets[name]
             return [] unless nodes
 
             if contested_uri
               # Contested name: bind only the (URI, local) matches —
               # the type's own mapping namespace is the row identity.
-              nodes = buckets[[contested_uri, rule.name.to_s]] || []
+              nodes = buckets[[contested_uri, name]] || []
             end
             nodes.map { |n| bridge_element(n) }
           end
@@ -580,15 +612,14 @@ module Lutaml
             end
           end
 
-          def content_runs(value)
-            out = []
-            value.count.times do |i|
-              c = value.at(i)
-              next unless c.name.nil? && c.kind == :collection
-
-              out.concat(Array.new(c.count) { |j| c.at(j).string_value })
+          # Content runs ride the children snapshot: the nil-name
+          # entries ARE the :collection run groups (one crossing per
+          # node via group_children, none here). The per-group
+          # at/count crossings are the drain itself.
+          def content_runs(_value, run_children)
+            (run_children || []).flat_map do |group|
+              Array.new(group.count) { |j| group.at(j).string_value }
             end
-            out
           end
 
           # Native collection rows echo their producing row's name
@@ -603,11 +634,11 @@ module Lutaml
             nil
           end
 
-          def raw_strings(value, rule)
+          def raw_strings(value, name)
             out = []
             value.count.times do |idx|
               child = value.at(idx)
-              if child.name == rule.name.to_s && child.kind == :raw
+              if child.name == name && child.kind == :raw
                 out << child.string_value
               end
             end
@@ -656,8 +687,14 @@ module Lutaml
             grouped = {}
             want_tags = !row_tags.nil?
             tagged = want_tags ? {} : nil
+            run_children = nil
             names.each_with_index do |name, i|
-              next if name.nil? # content runs, read separately
+              if name.nil?
+                # Content runs: same snapshot pass — at()/count() per
+                # child cost a crossing and a wrapper each.
+                (run_children ||= []) << children[i]
+                next
+              end
 
               child = children[i]
               (grouped[name] ||= []) << child
@@ -665,7 +702,7 @@ module Lutaml
                 (tagged[tags[i]] ||= []) << child
               end
             end
-            [grouped, tagged]
+            [grouped, tagged, run_children]
           end
 
           # Element children bucketed by local name, document order
@@ -693,27 +730,46 @@ module Lutaml
             buckets
           end
 
-          # (URI, local) child identity — the interpretive matcher's
-          # typed-element dispatch: same-name rows in different
-          # namespaces bind by the child type's exact URI (w14:docId vs
-          # w15:docId under one model). Only CONTESTED names dispatch
-          # exactly — a uniquely-named row binds the whole name bucket
-          # leniently (any qualification), and the uri-keyed view is
-          # built only for plans that carry contested names. Returns
-          # [selected, all] where all is the name bucket (aligned with
-          # the walk's grouped values for position filtering).
-          def child_bucket(buckets, rule, child_plan, contested)
-            name = rule.name.to_s
-            all = buckets ? buckets[name] : nil
-            return [all, all] unless buckets && all && contested
+          # Selected source nodes for a child row: contested names
+          # dispatch by (URI, local); every other row binds the whole
+          # name bucket leniently (any qualification). The pair form
+          # this replaces allocated a fresh array per row per node on
+          # the ordered walk (niso gate).
+          def child_selection(buckets, name, child_plan, contested)
+            all = buckets && buckets[name]
+            return all unless buckets && all && contested
 
             tree_ns = child_plan[:tree][:ns]
             exact_uri = tree_ns.is_a?(Hash) ? tree_ns[:exact] : tree_ns
-            if exact_uri
-              qualified = buckets[[exact_uri, name]]
-              return [qualified || [], all]
+            exact_uri ? (buckets[[exact_uri, name]] || []) : all
+          end
+
+          # Per-(plan, register) child-row tuples, computed once and
+          # reused across every node the walk hands this plan: the
+          # per-node type lookup, compile hit, child register
+          # resolution, and contested flag were each a measurable slice
+          # of the ordered-lane allocation profile (niso gate).
+          def child_row_plans(plan, register)
+            plan[:child_row_memo] ||= {}
+            plan[:child_row_memo][register] ||= plan[:rows].map do |rule, attr, kind, _spelling, _delegate, row_type|
+              next nil unless CHILD_ROW_KINDS.include?(kind)
+
+              child_type = row_type || attr.type(register)
+              child_plan = PlanCompiler.compile(child_type, register)
+              child_register = Lutaml::Model::Register.resolve_for_child(
+                child_type, register
+              )
+              [child_type, child_plan, child_register,
+               contested_name?(plan, rule)]
+            end
+          end
+
+          # Plan-frozen wire names: rule.name.to_s minted a fresh string
+          # per row per node in the hot loop.
+          def row_wire_names(plan)
+            plan[:row_wire_names] ||= plan[:rows].map do |rule, _attr, _kind, _spelling, _delegate, _row_type|
+              rule.name.to_s
             end
-            [all, all]
           end
         end
       end

data/lib/lutaml/xml/leptris.rb

@@ -8,22 +8,33 @@ module Lutaml
     # 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
+      # Single capability floor (leptris 1.9.351.1): 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"
+      # form (#1560, 1.9.323), build_result with the address-based
+      # text attach (#408, 1.9.334/1.9.336), and the plan-value
+      # attributes batch face (PlanValue#attributes_snapshot,
+      # leptris-ruby#447). Bundles resolving an older gem keep the
+      # interpretive path — PlanCompiler.compile answers nil — the
+      # opt-out protocol.
+      MIN_LEPTRIS_VERSION = "1.9.351.1"
 
+      # 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 false unless defined?(Gem)
+        return @plan_path_compatible if defined?(@plan_path_compatible)
 
-        spec = Gem.loaded_specs["leptris"]
-        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
+        @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"

data/spec/lutaml/xml/adapter/empty_document_diagnostics_spec.rb

@@ -10,15 +10,24 @@ require "lutaml/xml/adapter/nokogiri_adapter"
 # must surface in the raised message — otherwise the error names the
 # input's emptiness while the input is neither empty nor the problem
 # (lutaml-model#956).
+#
+# moxml#369 changed the recoverable-malformation contract: the leptris
+# adapter's non-strict parse now RECOVERS (the engine's recover mode,
+# leptris#1660) and returns the best-effort tree instead of failing —
+# a mismatched closer yields a document, not a raise. Only inputs with
+# nothing to recover into (whitespace-only) still reach the guard,
+# carrying the recovery diagnostic.
 RSpec.describe "empty-document errors surface engine parse diagnostics" do
   describe Lutaml::Xml::Adapter::LeptrisAdapter do
-    it "appends the engine diagnostic when the parse failed" do
-      expect do
-        described_class.parse("<root><a>x</b></root>")
-      end.to raise_error(Lutaml::Model::InvalidFormatError) do |error|
-        expect(error.message).to include("the XML engine reported:")
-        expect(error.message).to include("XML parse error at byte 14")
+    it "returns a recovered tree for recoverable malformations (moxml#369)" do
+      version = Gem.loaded_specs.fetch("moxml").version
+      recovered = version >= Gem::Version.new("0.5.131")
+      unless recovered
+        skip "moxml predates the recover-mode wiring (0.5.131)"
       end
+
+      doc = described_class.parse("<root><a>x</b></root>")
+      expect(doc.root.name).to eq("root")
     end
 
     it "reports the engine diagnostic for whitespace-only input" do

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -31,13 +31,14 @@ RSpec.describe "XML plan fast path" do
   let(:root_class) { classes[1] }
 
   around do |example|
-    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    old_fast = Lutaml::Model::Config.instance.xml_plan_fast_path
+    old_ordered = Lutaml::Model::Config.instance.xml_plan_ordered_path
     Lutaml::Model::Config.instance.xml_plan_fast_path = true
     Lutaml::Model::Config.instance.xml_plan_ordered_path = true
     example.run
   ensure
-    Lutaml::Model::Config.instance.xml_plan_fast_path = old
-    Lutaml::Model::Config.instance.xml_plan_ordered_path = false
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old_fast
+    Lutaml::Model::Config.instance.xml_plan_ordered_path = old_ordered
   end
 
   # Real-corpus crash (niso-jats): sec-in-sec nesting is a

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.105
+  version: 0.8.107
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64