lutaml-model 0.8.95 → 0.8.97

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

@@ -86,8 +86,49 @@ module Lutaml
             end
           end
 
+          # Two engine walk defects gate walk-side consumers here; both
+          # bail models to the interpretive matcher, whose exact-first-
+          # then-any-qualification precedence binds what the walk drops.
+          # The serialize side (PlanSerializer) reads the Ruby tree and
+          # stays on the fast path. leptris 1.9.320.0 (#1587) fixes
+          # both defects — the scan is skipped there and every model
+          # rides the walk again.
+          #
+          # leptris#1585: exact-URI CHILD-row ns_uri strings are not
+          # retained engine-side — once the build anchors are GC'd (a
+          # warm walk plus one GC suffices), those rows stop matching
+          # and hydration silently answers nil.
+          #
+          # leptris#1586: plain attribute rows do not leniently match
+          # namespace-qualified wire attributes (uniword fontTable:
+          # every w:name/w:val against a plain attr row hydrates nil).
+          # A plan level carrying plain attr rows under a namespaced
+          # chain therefore cannot be trusted on the walk; attribute
+          # rows with an exact URI (or :any) and plans without any
+          # namespace form are unaffected.
+          def engine_walk_safe?(plan)
+            return true if Leptris.walk_ns_safety_compatible?
+
+            tree_safe?(plan[:tree], false)
+          end
+
           private
 
+          def tree_safe?(tree, ancestor_ns)
+            namespaced = ancestor_ns || tree[:ns].is_a?(Hash)
+            attrs = tree[:attributes] || []
+            return false if namespaced &&
+              attrs.any? { |a| !a[:ns].is_a?(Hash) && a[:ns] != :any }
+
+            (tree[:children] || []).all? do |row|
+              return false if row[:ns].is_a?(Hash)
+
+              next true unless row[:kind] == :nested && row[:plan]
+
+              tree_safe?(row[:plan], namespaced)
+            end
+          end
+
           def build(model_class, register)
             return nil unless model_class.is_a?(Class) &&
               model_class.include?(::Lutaml::Model::Serialize)
@@ -162,7 +203,7 @@ module Lutaml
               return opt_out!(:fragment_with_ns) if fragment_needed && model_ns
 
               if rule.attribute?
-                opt = compile_attribute_row(rule, attr, register,
+                opt = compile_attribute_row(rule, attr, register, mapping,
                                             attr_rows, plan_attrs,
                                             ns_attr_names, attr_local_claims)
                 return opt_out!(opt) if opt
@@ -225,7 +266,22 @@ module Lutaml
                   return opt_out!(:non_scalar) unless scalar_type?(attr, register)
 
                   row = { name: rule.name.to_s }
-                  row[:ns] = child_ns(rule, model_ns) if rule.namespace_set?
+                  if rule.namespace_set?
+                    row[:ns] = child_ns(rule, model_ns)
+                  else
+                    # The interpretive writer qualifies an element row
+                    # by its attribute's type namespace when the rule
+                    # declares none (resolve step 4). Rows without the
+                    # type form inherit the tree namespace and land
+                    # under the wrong default xmlns (uniword
+                    # CoreProperties: <dc:title> spelled <title>).
+                    type_ns_form = element_type_ns_form(rule, attr,
+                                                        register, model_ns)
+                    return opt_out!(:elem_type_ns_symbol) if type_ns_form == :bail_symbol
+                    return opt_out!(:elem_type_ns_aliases) if type_ns_form == :bail_aliases
+
+                    row[:ns] = type_ns_form if type_ns_form
+                  end
                   # lutaml-model#88: same-name rows partitioned by the
                   # rule's discriminator ride the engine's exclusive
                   # predicate match (leptris 1.9.221+, #1272).
@@ -292,14 +348,28 @@ module Lutaml
             needs_nodes = true unless ns_attr_names.empty?
 
             # A model combining exact-URI attribute rows with nested
-            # child rows stays interpretive: the engine's walk drops
-            # nested-children attribute capture under such plans
-            # (FontTable's w:name under an mc:Ignorable ns row —
-            # observed 1.9.311.3; filed upstream). Leaf models keep the
-            # lift — that is the measured win (uniword's deep property
-            # models are leaves).
+            # 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?
+              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,
@@ -307,7 +377,8 @@ module Lutaml
               ordered: mapping.ordered? || mapping.mixed_content?,
               needs_nodes: needs_nodes,
               collection_defaults: collection_defaults,
-              ns_attr_names: ns_attr_names.empty? ? nil : ns_attr_names }
+              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).
@@ -322,8 +393,8 @@ module Lutaml
           # 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,
+          def compile_attribute_row(rule, attr, register, mapping,
+                                    attr_rows, plan_attrs, ns_attr_names,
                                     attr_local_claims)
             return :non_scalar unless scalar_type?(attr, register)
 
@@ -331,6 +402,24 @@ module Lutaml
             type_ns = attr.type_namespace_class(register)
             claim = attr_local_claims[rule.name.to_s]
             if type_ns.nil?
+              # attribute_form_default :qualified on the model's
+              # namespace qualifies locally-declared attributes under
+              # the parent URI — the interpretive
+              # resolve_attribute_namespace contract (WML: updateFields
+              # w:val under xmlns="..."). The W3C default is
+              # :unqualified, so == :qualified means explicitly set.
+              # Rules with an explicit :blank stay unprefixed.
+              ns_class = mapping.namespace_class
+              if rule.namespace_param != :blank && ns_class &&
+                  ns_class.attribute_form_default == :qualified
+                claim[:ns] += 1
+                plan_attrs << { name: rule.name.to_s,
+                                ns: { exact: ns_class.uri.to_s,
+                                      prefix: ns_class.prefix_default&.to_s } }
+                ns_attr_names << rule.name.to_s
+                return nil
+              end
+
               claim[:plain] += 1
               plan_attrs << { name: rule.name.to_s }
               return nil
@@ -341,7 +430,8 @@ module Lutaml
 
             claim[:ns] += 1
             plan_attrs << { name: rule.name.to_s,
-                            ns: { exact: type_ns.uri.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
@@ -349,12 +439,11 @@ module Lutaml
           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
@@ -415,9 +504,32 @@ 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?
+
+            { exact: uri.to_s, prefix: rule.prefix&.to_s }
+          end
+
+          # Type-namespace ns form for a scalar element row, mirroring
+          # the interpretive resolve_element_namespace step 4: the
+          # attribute's type namespace qualifies the row when the rule
+          # declares none. Rows inheriting the tree namespace (type ns
+          # nil, :inherit, or equal to the model's own URI) get no form.
+          # :blank and alias families have no row-expressible form —
+          # the model stays interpretive.
+          def element_type_ns_form(rule, attr, register, model_ns)
+            return nil if rule.namespace_set?
 
-            :none
+            type_ns = attr.type_namespace_class(register)
+            return nil if type_ns.nil? || type_ns == :inherit
+            return :bail_symbol if type_ns.is_a?(Symbol)
+            return :bail_aliases unless Leptris.attr_ns_rows_compatible? &&
+              type_ns.all_uris.size == 1
+
+            form = { exact: type_ns.uri.to_s,
+                     prefix: type_ns.prefix_default&.to_s }
+            return nil if form[:exact] == model_ns&.[](:exact)
+
+            form
           end
 
           def content_rows(rows)
@@ -431,7 +543,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

@@ -201,7 +201,7 @@ module Lutaml
                   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
                 runs = content_runs(value)
@@ -352,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,135 @@ 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(instance, plan, register)
+            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.
+          # Namespace spelling sourced from the interpretive writer's
+          # own machinery: NamespaceCollector + DeclarationPlanner
+          # decide prefix-vs-default per namespace exactly as the
+          # interpretive path does — no heuristic divergence (the
+          # uniword FontScheme/Image regressions). Option-bearing
+          # calls (prefix: true) never reach here; the serializer's
+          # plain spelling is the interpretive writer's plain
+          # spelling.
+          class Namespaces
+            attr_reader :unspellable
+
+            def initialize(instance, plan, register)
+              @forms = {}
+              @hoisted = {}
+              @declared = {}
+              @unspellable = false
+              mapping = plan[:mapping]
+              # The interpretive writer plans from the BUILT element
+              # tree: absent attributes (nil values) and absent
+              # children contribute no namespace needs, so an element
+              # whose own namespace would otherwise be prefix-hoisted
+              # (W3C: prefixed attributes need a prefix declaration)
+              # falls back to default-ns format. Collecting from the
+              # instance reproduces that — collecting from nil (type
+              # analysis) hoists every declared need and diverges
+              # (`<w:b xmlns:w>` vs the interpretive `<b xmlns>` when
+              # val=true omits the only prefixed attribute).
+              ns_prefix = if instance.is_a?(::Lutaml::Model::Serialize)
+                            instance.xml_namespace_prefix
+                          end
+              collect_options = { mapper_class: instance.class }
+              if ns_prefix && !ns_prefix.empty?
+                collect_options[:__xml_namespace_prefix] = ns_prefix
+              end
+              needs = Lutaml::Xml::NamespaceCollector.new(register).collect(
+                instance, mapping, **collect_options
+              )
+              planner = Lutaml::Xml::DeclarationPlanner.new(register)
+              declared_plan = planner.plan(
+                instance.class, mapping, needs, options: {}
+              )
+              declared_plan.root_node&.hoisted_declarations&.each do |prefix, uri|
+                @hoisted[uri] = prefix
+                @forms[uri] = { prefix: prefix, uri: uri }
+              end
+              collect(plan[:tree])
+            end
+
+            def unspellable?
+              @unspellable
+            end
+
+            def collect(tree)
+              check(tree[:ns])
+              (tree[:attributes] || []).each { |a| check(a[:ns]) }
+              (tree[:children] || []).each do |row|
+                check(row[:ns]) if row[:ns].is_a?(Hash)
+                collect(row[:plan]) if row[:kind] == :nested && row[:plan]
+              end
+            end
+
+            # An exact form the planner did not declare cannot be
+            # spelled — the serializer falls back interpretively.
+            def check(ns_form)
+              return if ns_form.nil? || ns_form == :none || ns_form == :any
+
+              uri = ns_form[:exact]
+              @unspellable = true if uri && !@forms.key?(uri)
+            end
+
+            # The planner's hoisted prefix for a URI (nil when hoisted
+            # as the default namespace).
+            def prefix_for(uri)
+              @hoisted[uri]
+            end
+
+            # The wire spelling for a local name under this form: the
+            # planner's hoisted prefix for the URI, or unprefixed when
+            # hoisted as the default namespace.
+            def spell(local, ns_form = nil)
+              uri = if ns_form.is_a?(Hash)
+                      ns_form[:exact]
+                    else
+                      @forms.key?(ns_form) ? @forms[ns_form][:uri] : nil
+                    end
+              prefix = uri ? @hoisted[uri] : nil
+              prefix ? "#{prefix}:#{local}" : local
+            end
+
+            def form_for(ns_form)
+              return nil if ns_form.nil? || ns_form == :none
+
+              ns_form.is_a?(Hash) ? { prefix: @hoisted[ns_form[:exact]], uri: ns_form[:exact] } : @forms[ns_form]
+            end
+
+            def declare_on(root, _attr_form_prefix = nil)
+              @hoisted.each do |uri, prefix|
+                key = uri
+                next if key.nil? || @declared[key]
+
+                @declared[key] = true
+                root.add_namespace_definition(prefix, 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 +182,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 +196,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 +254,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 +348,25 @@ 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
+                # Namespaced attributes always spell prefixed (W3C:
+                # attributes cannot use the default namespace) — the
+                # interpretive writer emits the type namespace's own
+                # prefix even when the element hoists the same URI as
+                # the default namespace (updateFields w:val under
+                # xmlns="...").
+                attr_prefixes[a[:name]] =
+                  if form
+                    form[:prefix] || ns_ctx.prefix_for(form[:exact])
+                  end
+              end
+            end
             if recorded && !recorded.empty?
               by_name = {}
               plan[:attr_rows].each do |rule, attr, _sp, delegate|
@@ -223,24 +375,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/plan_walk.rb

@@ -16,6 +16,7 @@ module Lutaml
             register = Lutaml::Model::Config.default_register
             plan = PlanCompiler.compile(model_class, register)
             return nil unless plan
+            return nil unless PlanCompiler.engine_walk_safe?(plan)
 
             document = ::Leptris::XML.parse(xml)
             root = document.root

data/lib/lutaml/xml/leptris.rb

@@ -21,6 +21,27 @@ module Lutaml
       # 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"
+
+      # Walk-side namespace safety (leptris#1587, closing #1585 and
+      # #1586): child-row exact-URI ns_uri is retained engine-side
+      # (deep-copied at build, freed with the plan) and plain attribute
+      # rows leniently match namespace-qualified wire attributes
+      # (exact-first-then-any, top level and nested). Both shipped in
+      # 1.9.320.0; older engines keep the affected models interpretive
+      # through PlanCompiler.engine_walk_safe?.
+      MIN_LEPTRIS_WALK_NS_SAFETY_VERSION = "1.9.320.0"
+
       def self.plan_path_compatible?
         return false unless defined?(Gem)
 
@@ -35,6 +56,32 @@ module Lutaml
         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
+
+      # Memoized: consulted per parse on the walk gate hot path, and
+      # the loaded leptris spec cannot change within a process.
+      @walk_ns_safety = nil
+      def self.walk_ns_safety_compatible?
+        return @walk_ns_safety unless @walk_ns_safety.nil?
+        return (@walk_ns_safety = false) unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        @walk_ns_safety =
+          !!(spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_WALK_NS_SAFETY_VERSION))
+      end
+
       autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
       autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
       autoload :PlanOrder, "lutaml/xml/leptris/plan_order"