lutaml-model 0.8.94 → 0.8.96

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

@@ -99,6 +99,14 @@ module Lutaml
             attr_rows = [] # [[rule, attr]] hydration metadata
             plan_attrs = [] # [{name:, kind:}] rows for the engine plan
             compiled = [] # [rule, attr, kind, spelling, delegate_target]
+            ns_attr_names = [] # exact-URI attribute rows (ambiguity guard)
+            # Local-name claim tallies for attribute rows: a name claimed
+            # by both an exact-URI row and a plain (any-namespace) row
+            # cannot be dispatched by the walk — the ns form :none
+            # matches any qualification, so the plain row captures the
+            # qualified spelling too (#758). The interpretive matcher
+            # owns shared names.
+            attr_local_claims = Hash.new { |h, k| h[k] = { ns: 0, plain: 0 } }
             cdata = false
             mixed_content = false
             needs_nodes = false
@@ -154,15 +162,10 @@ module Lutaml
               return opt_out!(:fragment_with_ns) if fragment_needed && model_ns
 
               if rule.attribute?
-                return opt_out!(:non_scalar) unless scalar_type?(attr, register)
-                # Attribute plan rows are local-name keyed; a type-level
-                # namespace makes the attribute (URI, local)-identified
-                # (lutaml-model#744) — the interpretive matcher owns it
-                # until plan rows carry namespace identity.
-                return opt_out!(:attr_type_ns) if attr.type_namespace_class(register)
-
-                attr_rows << [rule, attr]
-                plan_attrs << { name: rule.name.to_s }
+                opt = compile_attribute_row(rule, attr, register,
+                                            attr_rows, plan_attrs,
+                                            ns_attr_names, attr_local_claims)
+                return opt_out!(opt) if opt
               elsif rule.content_mapping?
                 return opt_out!(:multi_content) if content_rows(rows) >= 1
 
@@ -247,12 +250,23 @@ module Lutaml
             # namespaced models serialize through the interpretive
             # writer (lutaml-model#847: standalone to_xml under leptris
             # dropped the element xmlns entirely).
-            namespaced = !model_ns.nil? || rows.any? { |r| r[:ns] }
+            # Exact-URI attribute rows include their namespaced spelling
+            # here: the plan serializer writes attributes by local name
+            # (no prefixed wire spelling, no declaration emission —
+            # leptris#1551), so these models serialize interpretively.
+            namespaced = !model_ns.nil? || rows.any? { |r| r[:ns] } ||
+              plan_attrs.any? { |a| a[:ns] }
 
             flags = []
             flags << :cdata if cdata
             flags << :mixed_content if mixed_content
-            flags << :ns_lenient if model_ns
+            # Unconditional: a namespace-less model's children match by
+            # local name even when the document declares a default or
+            # prefixed namespace (#932) — the interpretive matcher's
+            # unprefixed-any-URI behavior; elements (unlike attributes)
+            # inherit the default xmlns, so the strict no-URI default
+            # dropped every child of a namespaced document.
+            flags << :ns_lenient
             tree = { name: mapping.root_element.to_s,
                      attributes: plan_attrs, children: rows }
             tree[:ns] = model_ns if model_ns
@@ -267,23 +281,95 @@ module Lutaml
               return nil
             end
 
+            return opt_out!(:attr_ns_claim_conflict) if attr_local_claims
+              .any? { |_, c| c[:ns].positive? && c[:plain].positive? }
+
+            # Exact-URI attribute rows rely on the sole-claimant lenient
+            # recovery for out-of-namespace spellings (the interpretive
+            # exact-first-then-any-qualification precedence), and that
+            # recovery reads the source node — models carrying such rows
+            # must receive one through the buckets chain.
+            needs_nodes = true unless ns_attr_names.empty?
+
+            # A model combining exact-URI attribute rows with nested
+            # child rows needs the walk's nested attribute capture
+            # (leptris#1563, fixed 1.9.313.0): older engines drop the
+            # children's attribute capture under such plans, so they
+            # stay interpretive. Leaf models are unaffected.
+            return opt_out!(:attr_type_ns_nested) if plan_attrs.any? { |a| a[:ns] } &&
+              rows.any? && !Leptris.nested_attr_capture_compatible?
+
+            # The catch-all row: kind :wildcard with an explicit :any ns
+            # form (pad0) — the two-pass walk routes every child no
+            # named row claimed here, tagged for hydrator routing.
+            # Document order recovery and bridging happen in the
+            # hydrator against the source node.
+            if (any_rule = mapping.any_element_rule)
+              any_attr = model_class.attributes(register)[any_rule.to]
+              return opt_out!(:attr_nil) if any_attr.nil?
+
+              needs_nodes = true
+              wildcard_tag = tag += 1
+              compiled << [any_rule, any_attr, :wildcard_any, nil, nil]
+              rows << { name: "__lutaml_any__", kind: :wildcard, ns: :any,
+                        type_tag: wildcard_tag }
+            end
+
             { descriptor: descriptor, tree: tree, rows: compiled,
               attr_rows: attr_rows, mapping: mapping,
               row_tags: row_tags, namespaced: namespaced,
               ordered: mapping.ordered? || mapping.mixed_content?,
               needs_nodes: needs_nodes,
-              collection_defaults: collection_defaults }
+              collection_defaults: collection_defaults,
+              ns_attr_names: ns_attr_names.empty? ? nil : ns_attr_names,
+              wildcard_tag: (wildcard_tag if defined?(wildcard_tag)) }
+          end
+
+          # Attribute rows: identity is (URI, local) (lutaml-model#744).
+          # A type-level namespace compiles into an exact-URI AttrPlan ns
+          # row (libleptris 1.9.289): the walk captures the (URI, local)
+          # match and the sole-claimant lenient recovery in PlanHydrator
+          # keeps the interpretive exact-first-then-any-qualification
+          # precedence for out-of-namespace spellings. Returns the
+          # opt-out clause when the row must stay interpretive, nil
+          # otherwise. Types declaring alias URI families stay
+          # interpretive (a plan row holds a single exact URI and
+          # non-sole-claimant alias families have no plan-side
+          # resolution order); :blank / :inherit arrive as Symbols —
+          # no URI to express in a row.
+          def compile_attribute_row(rule, attr, register, attr_rows,
+                                    plan_attrs, ns_attr_names,
+                                    attr_local_claims)
+            return :non_scalar unless scalar_type?(attr, register)
+
+            attr_rows << [rule, attr]
+            type_ns = attr.type_namespace_class(register)
+            claim = attr_local_claims[rule.name.to_s]
+            if type_ns.nil?
+              claim[:plain] += 1
+              plan_attrs << { name: rule.name.to_s }
+              return nil
+            end
+            return :attr_type_ns_symbol if type_ns.is_a?(Symbol)
+            return :attr_type_ns_aliases unless Leptris.attr_ns_rows_compatible? &&
+              type_ns.all_uris.size == 1
+
+            claim[:ns] += 1
+            plan_attrs << { name: rule.name.to_s,
+                            ns: { exact: type_ns.uri.to_s,
+                                  prefix: type_ns.prefix_default&.to_s } }
+            ns_attr_names << rule.name.to_s
+            nil
           end
 
           def compilable_mapping?(mapping)
             # Mapping's uniform interface: root_mappings defaults to
             # false on the base (KeyValue overrides with its own).
-            # A map_any_element catch-all is not plan-shaped yet — the
-            # compiled plan has no row for it, so plan-path models
-            # would silently drop every catch-all child (0.8.86's
-            # smoke catch). The interpretive path owns them until the
-            # plan learns the catch-all row.
-            return false if mapping.any_element_rule
+            # The map_any_element catch-all rides the engine's wildcard
+            # row (leptris#1552, named rows take precedence); engines
+            # without the kind keep the interpretive refusal.
+            return false if mapping.any_element_rule &&
+              !Leptris.wildcard_rows_compatible?
 
             mapping.root_element && !mapping.root_mappings?
           end
@@ -344,9 +430,9 @@ module Lutaml
           # prefix. Blank-namespace rules (xmlns="") match :none.
           def child_ns(rule, _model_ns)
             uri = rule.namespace
-            return { exact: uri.to_s } if uri && !uri.to_s.empty?
+            return :none if uri.nil? || uri.to_s.empty?
 
-            :none
+            { exact: uri.to_s, prefix: rule.prefix&.to_s }
           end
 
           def content_rows(rows)
@@ -360,7 +446,10 @@ module Lutaml
             # Mapping's uniform interface: namespace_class defaults
             # to nil on the base (Xml overrides).
             ns_class = mapping.namespace_class
-            ns_class&.uri ? { exact: ns_class.uri.to_s } : nil
+            return nil unless ns_class&.uri
+
+            { exact: ns_class.uri.to_s,
+              prefix: ns_class.prefix_default&.to_s }
           end
 
           def scalar_type?(attr, register)

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

@@ -72,6 +72,7 @@ module Lutaml
           def attributes_kwargs(plan, value, node = nil)
             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)
               if v.nil? && node && sole_claimants.include?(name)
@@ -83,6 +84,14 @@ module Lutaml
               end
               next if v.nil?
 
+              # (URI, local) rows mirror the interpretive matcher's
+              # ambiguity refusal: a second spelling of the same local
+              # name binds nothing (lutaml-model#744).
+              if ns_attr_names&.include?(name) &&
+                  ambiguous_local_spellings?(node, name)
+                next
+              end
+
               v = v.split(rule.delimiter) if rule.delimiter
               if rule.as_list && rule.as_list[:import]
                 v = rule.as_list[:import].call(v)
@@ -92,6 +101,53 @@ module Lutaml
             kwargs
           end
 
+          # True when the node carries more than one spelling of the
+          # local name (any qualification). Only consulted for exact-URI
+          # attribute rows.
+          def ambiguous_local_spellings?(node, local_name)
+            return false unless node.respond_to?(:attributes)
+
+            seen = false
+            node.attributes.each_value do |attr|
+              name = attr.name.to_s
+              name = name.split(":").last if name.include?(":")
+              next unless name == local_name
+
+              return true if seen
+
+              seen = true
+            end
+            false
+          end
+
+          # A captured-but-empty child marshals as a nil string value.
+          # The interpretive pipeline classifies the raw "" through the
+          # rule's value map (:empty key) — the :empty directive (the
+          # plain-rule default) keeps it as "", :nil binds nil, and any
+          # other directive means uninitialized, i.e. no binding.
+          def mapped_empty_value(rule)
+            case rule.value_map(:from)[:empty]
+            when :nil then nil
+            when :empty then ""
+            else :skip
+            end
+          end
+
+          def mapped_capture_values(values, rule)
+            return values unless values.include?(nil)
+
+            mapped = mapped_empty_value(rule)
+            out = []
+            values.each do |item|
+              if item.nil?
+                out << mapped unless mapped == :skip
+              else
+                out << item
+              end
+            end
+            out
+          end
+
           # Wire-name strings are plan-frozen; materializing them per
           # hydration allocated two or three strings per attribute row
           # per instance.
@@ -128,6 +184,10 @@ module Lutaml
                   # Interpretive parity: several captures into a
                   # non-collection attribute arrive as the full array.
                   v = vals.map(&:string_value)
+                  if v.include?(nil)
+                    v = v.map { |item| item.nil? ? mapped_empty_value(rule) : item }
+                    v.reject! { |item| item == :skip }
+                  end
                 else
                   first = if tag
                             tagged[tag]&.first
@@ -135,16 +195,26 @@ module Lutaml
                             grouped.dig(rule.name.to_s, 0)
                           end
                   v = first&.string_value
+                  v = mapped_empty_value(rule) if v.nil? && first
                 end
-                unless v.nil?
+                unless v.nil? || v == :skip
                   v = rule.transform_value(attr, v, :from, :xml) if rule.transform.is_a?(Class)
                   assign(kwargs, delegates, delegate, rule, attr, v)
                 end
-              when :raw, :custom_method, :polymorphic, :content_deferred
+              when :wildcard_any
                 # interpreted post-instance (interpret_deferred)
               when :content
-                assign(kwargs, delegates, delegate, rule, attr,
-                       content_runs(value))
+                runs = content_runs(value)
+                if runs.empty? && !attr.collection?
+                  # An empty element's content binds through the rule's
+                  # value map for scalar content attributes: "" for the
+                  # plain :empty directive, nil for :nil, skipped for
+                  # anything else (uninitialized).
+                  bound = mapped_empty_value(rule)
+                  assign(kwargs, delegates, delegate, rule, attr, bound) unless bound == :skip
+                else
+                  assign(kwargs, delegates, delegate, rule, attr, runs)
+                end
               when :ordered_deferred
                 # With a source node the child hydrates natively: one
                 # walk against its own node + element_order from the
@@ -165,7 +235,10 @@ module Lutaml
                   end
                 end
               when :collection_cb
-                values = grouped[rule.name.to_s].to_a.map(&:string_value)
+                values = grouped[rule.name.to_s].to_a.map do |item|
+                  item&.string_value
+                end
+                values = mapped_capture_values(values, rule)
                 if rule.transform.is_a?(Class)
                   values = values.map { |v| rule.transform_value(attr, v, :from, :xml) }
                 end
@@ -178,6 +251,7 @@ module Lutaml
                          else
                            native_collection(value, rule.name.to_s)
                          end
+                values = mapped_capture_values(values, rule) unless values.nil?
                 unless values.nil?
                   assign(kwargs, delegates, delegate, rule, attr, values)
                 end
@@ -232,12 +306,19 @@ module Lutaml
               when :content_deferred
                 runs = content_runs(value)
                 if runs.empty?
-                  # The interpretive pipeline marks every applied rule's
-                  # attribute set (model_transform apply). Skipping the
-                  # mark leaves using_default? true, so the serializer's
-                  # render gate suppresses a mapped reader that derives
-                  # content from other attributes (#856).
+                  # The interpretive pipeline classifies the raw ""
+                  # through the rule's value map: the :empty directive
+                  # (the plain-rule default) binds "" — the attribute is
+                  # still marked set, which is what the #856 mark is
+                  # about; :nil binds nil; other directives leave the
+                  # binding unset.
                   instance.value_set_for(attr.name)
+                  case rule.value_map(:from)[:empty]
+                  when :nil
+                    instance.public_send(:"#{attr.name}=", nil)
+                  when :empty
+                    instance.public_send(:"#{attr.name}=", "")
+                  end
                   next
                 end
 
@@ -271,6 +352,39 @@ module Lutaml
 
                 instance.public_send(:"#{attr.name}=",
                                      attr.collection? ? results : results.first)
+              when :wildcard_any
+                # map_any_element: every child element no named row
+                # claims, in document order, bridged as wrappers — the
+                # interpretive pass's contract. The wildcard row's
+                # type_tag marks its captures in the walk.
+                next unless node
+
+                claimed = plan[:rows].filter_map do |wr, _wa, _wk, spelling, _wd|
+                  next if wr.equal?(rule) || wr.name.nil?
+
+                  spelling ? spelling.to_s : wr.name.to_s
+                end.uniq
+                elements = []
+                node.children.each do |child|
+                  next unless child.is_a?(::Leptris::XML::Element)
+                  next if claimed.include?(child.name)
+
+                  elements << bridge_element(child)
+                end
+                next if elements.empty?
+
+                # The interpretive pass casts each collected element
+                # through the attribute: String keeps the wrapper,
+                # Serializable types build model instances.
+                results = elements.map do |element|
+                  attr.cast(element, :xml, register,
+                            lutaml_parent: instance,
+                            lutaml_root: instance.lutaml_root || instance)
+                end
+                instance.public_send(
+                  :"#{attr.name}=",
+                  attr.collection? ? results : results.first,
+                )
               when :polymorphic
                 results = deferred_elements(value, rule, buckets).map do |element|
                   attr.cast(element, :xml, register,

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

@@ -38,16 +38,84 @@ module Lutaml
             return nil if plan[:ordered] && instance.element_order.nil?
 
             doc = ::Leptris::XML::Document.create
-            root = doc.create_element(plan[:tree][:name])
+            ns_ctx = Namespaces.new(plan)
+            return nil if ns_ctx.unspellable?
+
+            root = doc.create_element(
+              ns_ctx.spell(plan[:tree][:name], plan[:tree][:ns]),
+            )
             doc.root = root
+            ns_ctx.declare_on(root)
             if plan[:ordered]
               build_ordered(root, instance, plan, doc, register)
             else
-              build(root, instance, plan, doc, register)
+              build(root, instance, plan, doc, register, ns_ctx)
             end
             doc.to_xml(indent: 2, no_decl: true)
           end
 
+          # Namespace spelling for namespaced plans (#847): every ns
+          # form resolves to a wire spelling (prefix:local, or local
+          # under a default xmlns), and every distinct (prefix, uri)
+          # pair is declared exactly once on the output root in
+          # first-encounter order — the #1558 contract on the DOM
+          # path. A nested plan's own tree ns overrides the inherited
+          # one; rows without an ns form inherit.
+          class Namespaces
+            attr_reader :unspellable
+
+            def initialize(plan)
+              @forms = {}
+              @declared = {}
+              @unspellable = false
+              collect(plan[:tree])
+            end
+
+            def unspellable?
+              @unspellable
+            end
+
+            def collect(tree)
+              register(tree[:ns])
+              (tree[:attributes] || []).each { |attr| register(attr[:ns]) }
+              (tree[:children] || []).each do |row|
+                register(row[:ns]) if row[:ns].is_a?(Hash)
+                collect(row[:plan]) if row[:kind] == :nested && row[:plan]
+              end
+            end
+
+            def register(ns_form)
+              return if ns_form.nil? || ns_form == :none || ns_form == :any
+
+              form = { prefix: ns_form[:prefix], uri: ns_form[:exact] }
+              @forms[ns_form[:exact]] ||= form
+              @unspellable = true if ns_form[:exact] && !ns_form.key?(:prefix)
+            end
+
+            # The wire spelling for a local name under this form.
+            def spell(local, ns_form = nil)
+              form = ns_form.is_a?(Hash) ? ns_form : @forms[ns_form]
+              prefix = form && form[:prefix]
+              prefix ? "#{prefix}:#{local}" : local
+            end
+
+            def form_for(ns_form)
+              return nil if ns_form.nil? || ns_form == :none
+
+              ns_form.is_a?(Hash) ? ns_form : @forms[ns_form]
+            end
+
+            def declare_on(root)
+              @forms.each_value do |form|
+                key = form[:uri]
+                next if key.nil? || @declared[key]
+
+                @declared[key] = true
+                root.add_namespace_definition(form[:prefix], form[:uri])
+              end
+            end
+          end
+
           # Whether the compiled plan is serialize-shaped. Ordered/mixed
           # models serialize through build_ordered from element_order;
           # plain models through plan rows.
@@ -63,9 +131,10 @@ module Lutaml
             Lutaml::Model::Config.default_register
           end
 
-          def build(element, instance, plan, doc, reg = nil)
+          def build(element, instance, plan, doc, reg = nil, ns_ctx = nil,
+                    inherited_ns = nil)
             reg ||= register
-            write_attributes(element, instance, plan, reg)
+            write_attributes(element, instance, plan, reg, ns_ctx)
             plan[:rows].each do |rule, attr, kind, spelling, delegate|
               value = value_of(instance, attr, delegate)
               next unless rule.render?(value, instance)
@@ -76,33 +145,46 @@ module Lutaml
                 # several occurrences serializes one element per item,
                 # as the interpretive writer does. A plain scalar skips
                 # the Array() wrap — the common case.
+                row_ns = plan[:tree][:children]&.find do |r|
+                  r[:name] == rule.name.to_s
+                end&.[](:ns) || inherited_ns
                 if value.is_a?(::Array)
                   value.each do |item|
-                    add_leaf(element, row_name(rule, spelling),
+                    add_leaf(element,
+                             ns_ctx ? ns_ctx.spell(row_name(rule, spelling), row_ns) : row_name(rule, spelling),
                              attr.serialize(item, :xml, reg), doc,
                              attrs: rule.when_attribute)
                   end
                 else
-                  add_leaf(element, row_name(rule, spelling),
+                  add_leaf(element,
+                           ns_ctx ? ns_ctx.spell(row_name(rule, spelling), row_ns) : row_name(rule, spelling),
                            attr.serialize(value, :xml, reg), doc,
                            attrs: rule.when_attribute)
                 end
               when :collection_native, :collection_cb
+                row_ns = plan[:tree][:children]&.find do |r|
+                  r[:name] == rule.name.to_s
+                end&.[](:ns) || inherited_ns
                 Array(value).each do |item|
-                  add_leaf(element, rule.name.to_s,
+                  add_leaf(element,
+                           ns_ctx ? ns_ctx.spell(rule.name.to_s, row_ns) : rule.name.to_s,
                            attr.serialize(item, :xml, reg), doc,
                            attrs: rule.when_attribute)
                 end
               when :nested, :ordered_deferred
                 Array(value).each do |item|
                   child_plan = PlanCompiler.compile(item.class, reg)
-                  child = element.create_child(child_plan[:tree][:name])
+                  child_ns = child_plan[:tree][:ns] || inherited_ns
+                  child = element.create_child(
+                    ns_ctx ? ns_ctx.spell(child_plan[:tree][:name], child_ns) : child_plan[:tree][:name],
+                  )
+                  ns_ctx&.collect(child_plan[:tree])
                   if child_plan[:ordered]
-                    return nil unless build_ordered(child, item, child_plan,
-                                                    doc, reg)
+                    next unless build_ordered(child, item, child_plan,
+                                              doc, reg, ns_ctx, child_ns)
 
                   else
-                    build(child, item, child_plan, doc, reg)
+                    build(child, item, child_plan, doc, reg, ns_ctx, child_ns)
                   end
                 end
               when :raw
@@ -121,9 +203,11 @@ module Lutaml
           # the model are reflected; element_order text is the fallback.
           # PIs drop (interpretive parity). Returns nil when a nested
           # ordered child lacks element_order (caller falls back).
-          def build_ordered(element, instance, plan, doc, reg = nil)
+          def build_ordered(element, instance, plan, doc, reg = nil,
+                            ns_ctx = nil, _inherited_ns = nil)
             reg ||= register
-            write_attributes(element, instance, plan, reg)
+            ns_ctx&.collect(plan[:tree])
+            write_attributes(element, instance, plan, reg, ns_ctx)
             rows_by_name = {}
             plan[:rows].each do |rule, attr, kind, spelling, delegate|
               next unless rule.name
@@ -213,8 +297,16 @@ module Lutaml
 
           # Attributes in document order when the instance recorded it
           # (parsed models), else plan row order.
-          def write_attributes(element, instance, plan, _reg = nil)
+          def write_attributes(element, instance, plan, reg = nil,
+                               ns_ctx = nil)
             recorded = instance.attribute_order
+            attr_prefixes = {}
+            if ns_ctx
+              (plan[:tree][:attributes] || []).each do |a|
+                form = a[:ns].is_a?(Hash) ? a[:ns] : nil
+                attr_prefixes[a[:name]] = form && form[:prefix]
+              end
+            end
             if recorded && !recorded.empty?
               by_name = {}
               plan[:attr_rows].each do |rule, attr, _sp, delegate|
@@ -223,24 +315,28 @@ module Lutaml
               names = recorded |
                 plan[:attr_rows].map { |rule, _a, _s, _d| rule.name.to_s }
               names.each do |name|
-                write_attribute(element, instance, name, by_name[name])
+                write_attribute(element, instance, name, by_name[name],
+                                reg, attr_prefixes[name])
               end
             else
               plan[:attr_rows].each do |rule, attr, _sp, delegate|
                 write_attribute(element, instance, rule.name.to_s,
-                                [rule, attr, delegate])
+                                [rule, attr, delegate], reg,
+                                attr_prefixes[rule.name.to_s])
               end
             end
           end
 
-          def write_attribute(element, instance, name, entry, reg = nil)
+          def write_attribute(element, instance, name, entry, reg = nil,
+                              prefix = nil)
             return unless entry
 
             _rule, attr, delegate = entry
             value = value_of(instance, attr, delegate)
             return if value.nil?
 
-            element.set_attribute(name,
+            spelled = prefix ? "#{prefix}:#{name}" : name
+            element.set_attribute(spelled,
                                   attr.serialize(value, :xml, reg || register).to_s)
           end
 

data/lib/lutaml/xml/leptris.rb

@@ -16,6 +16,23 @@ module Lutaml
       # existing opt-out protocol.
       MIN_LEPTRIS_VERSION = "1.9.273.0"
 
+      # AttrPlan rows carrying an ns form (exact-URI attribute matching,
+      # leptris#1486) shipped in libleptris 1.9.289.0. Older gems keep
+      # type-namespaced attributes on the interpretive path.
+      MIN_LEPTRIS_ATTR_NS_VERSION = "1.9.289.0"
+
+      # Nested child plans capture their declared attribute rows
+      # correctly again as of 1.9.313.0 (leptris#1563: the walk dropped
+      # children's attribute capture when the parent plan carried an
+      # exact-URI attribute row). Older gems keep those models
+      # interpretive.
+      MIN_LEPTRIS_NESTED_ATTR_VERSION = "1.9.313.0"
+
+      # Wildcard child rows (leptris#1552: named-rows-take-precedence
+      # two-pass walk, ns-form aware, type_tag echo) — the plan path's
+      # map_any_element catch-all. Ships with the 1.9.313 binding.
+      MIN_LEPTRIS_WILDCARD_VERSION = "1.9.313.0"
+
       def self.plan_path_compatible?
         return false unless defined?(Gem)
 
@@ -23,6 +40,27 @@ module Lutaml
         spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
       end
 
+      def self.attr_ns_rows_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_ATTR_NS_VERSION)
+      end
+
+      def self.nested_attr_capture_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_NESTED_ATTR_VERSION)
+      end
+
+      def self.wildcard_rows_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_WILDCARD_VERSION)
+      end
+
       autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
       autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
       autoload :PlanOrder, "lutaml/xml/leptris/plan_order"