lutaml-model 0.8.101 → 0.8.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70de43228d2b233faab386c9016139160f2b75e9f76c27386de22104df2820f5
-  data.tar.gz: 78b4591ba8eec19bbc7fde9a1fd2d298c58094b1198352f2323067406d39b5aa
+  metadata.gz: d307b0cf0381619d2f8a8d239a0f0ccdd3bc869b9ece087af504adfc19c1ef1c
+  data.tar.gz: d2b28b3820c8331b45f078325d21492091cbbb15b1240d1750924599ee8ed3ce
 SHA512:
-  metadata.gz: f1d54790ba8f6d44834134ef283b3d146002e3ca4f2e25f0fb99e84bd442878d6470d50f6da81f36a8e4165e93c07e2e3a6de2cffeb981f45b40d849a6be1037
-  data.tar.gz: 4d358cd375296cdb737fa12300076a4154f38aa22ce940cbcb7483453691152d4cbfd25fef88131fe1150105868eb9a1d56fa193028f3bd51eff7eb853d43c09
+  metadata.gz: 6d631f610cf9e057a8c23f3e27945d0ac7ca15a9f9633f5e49143a693148f496a1dfb3a99857efea37653f50241a96f6069d6d03839774368c82479c965942fb
+  data.tar.gz: a4bc2ee7e75df18ebda941551972fb85a960503005dbeae0be453f792db53616785209068d38d43eb68e6e84ad85e2e1ac31fcf07acd41780a15adf4b571ed5b

data/Gemfile

@@ -44,11 +44,12 @@ gem "rexml"
 # Native engines stay development-only: every adapter detects and
 # degrades gracefully at runtime (safe requires + prefer-if-available).
 # yeptris ships no Windows prebuilt platform gem.
-# leptris floor: the plan hydrator's one-crossing snapshot
-# (leptris_plan_value_children_snapshot) landed in 1.9.273.0; older
-# gems fall back to accessor enumeration at runtime, but CI and dev
-# resolve the snapshot-capable line.
-gem "leptris", ">= 1.9.273.0"
+# leptris floor: the single capability line for the plan fast path
+# (see Lutaml::Xml::Leptris::MIN_LEPTRIS_VERSION) — child snapshots,
+# 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 "teptris"
 gem "yeptris" unless Gem.win_platform?
 # TODO: revert rng branch to main when lutaml/rng#32 is merged

data/lib/compat/opal/lutaml_model_boot.rb

@@ -382,6 +382,7 @@ require "lutaml/xml/error/namespace_mismatch_error"
 require "lutaml/xml/error/schema_validation_error"
 require "lutaml/xml/error/xml_configuration_error"
 require "lutaml/xml/error/xml_error"
+require "lutaml/xml/leptris/native_emission"
 require "lutaml/xml/leptris/plan_compiler"
 require "lutaml/xml/leptris/plan_hydrator"
 require "lutaml/xml/leptris/plan_order"

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

@@ -138,7 +138,6 @@ module Lutaml
           register = Lutaml::Model::Config.default_register
           plan = Lutaml::Xml::Leptris::PlanCompiler.compile(self, register)
           return nil unless plan
-          return nil unless Lutaml::Xml::Leptris::PlanCompiler.engine_walk_safe?(plan)
 
           root = ::Leptris::XML.parse(data.to_s).root
           return nil if root.nil?

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.101"
+    VERSION = "0.8.102"
   end
 end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Leptris
+      # The native emission lane of the plan fast path: instead of
+      # minting the output DOM node-by-node through the Ruby
+      # create_child chain, build a plan RESULT from ops
+      # (leptris_plan_result_build), render it through the engine's
+      # plan serializer, reparse the compact output, and write it with
+      # the engine's indented document writer. Both renderings are
+      # pure C; measured 2.4x faster than the DOM-mint loop on the
+      # 500-row audit at a modest allocation increase.
+      #
+      # Byte-parity with the DOM lane holds because both lanes end at
+      # the same document writer over structurally identical
+      # documents: the compact emission escapes exactly as the DOM
+      # text nodes do, and reparsing yields one text node per leaf,
+      # matching the minted tree. The reparse is an engine-internal
+      # cost, not a Ruby one.
+      #
+      # Emission is enabled for the provably static subset: trees with
+      # no namespace form anywhere (every spelling is the unwritten
+      # local name, nothing to declare, no instance-dependent
+      # prefix/default flips) and the non-ordered build() shapes
+      # (attributes, scalars, collections, nested models). Wildcard,
+      # raw, callback, and content rows and ordered models keep the
+      # DOM lane — their emission shapes are not expressible as ops
+      # (or not verified to be) and the DOM lane is byte-exact.
+      module NativeEmission
+        ROOT_ROW = 0xFFFF_FFFF
+        EMITTABLE_KINDS = %i[scalar collection nested].freeze
+
+        class << self
+          def compatible?(plan)
+            !plan[:ordered] && tree_emittable?(plan[:tree])
+          end
+
+          # Pre-order depth-first, children in row order — the same
+          # walk Descriptor.flatten_plan performs, so the plan_index
+          # counters here match the engine's flattened plans array.
+          def tree_emittable?(tree)
+            return false if tree[:ns]
+            return false if (tree[:attributes] || []).any? { |a| a[:ns].is_a?(Hash) }
+
+            (tree[:children] || []).all? do |row|
+              EMITTABLE_KINDS.include?(row[:kind]) &&
+                (row[:kind] != :nested || !row[:plan] || tree_emittable?(row[:plan]))
+            end
+          end
+
+          def emit(instance, plan, register)
+            ops = [{ kind: :element, row_index: ROOT_ROW }]
+            emit_element(ops, instance, plan, register, 0)
+            ops << { kind: :end }
+            compact = plan[:descriptor].serialize(
+              plan[:descriptor].build_result(ops),
+            )
+            ::Leptris::XML.parse(compact).to_xml(indent: 2, no_decl: true)
+          end
+
+          private
+
+          # plan_index: this plan's flattened index. The engine's
+          # flatten_plan pushes each nested row's child plan exactly
+          # once — collection members share that slot — so child flat
+          # indices come from a static per-plan layout (relative to
+          # this plan's index), never from a runtime counter.
+          def emit_element(ops, instance, plan, register, plan_index)
+            my_index = plan_index
+            layout = flat_layout_for(plan)
+
+            emit_attributes(ops, instance, plan, my_index, register)
+
+            plan[:rows].each_with_index do |(rule, attr, kind, _spelling, delegate), row_index|
+              value = value_of(instance, attr, delegate)
+              next unless rule.render?(value, instance)
+
+              case kind
+              when :scalar
+                # Multi-capture parity: an attribute that collected
+                # several occurrences serializes one element per item,
+                # as the DOM lane does.
+                if value.is_a?(::Array)
+                  value.each do |item|
+                    ops << scalar_op(my_index, row_index, attr, item, register)
+                  end
+                else
+                  ops << scalar_op(my_index, row_index, attr, value, register)
+                end
+              when :collection_native, :collection_cb
+                Array(value).each do |item|
+                  ops << scalar_op(my_index, row_index, attr, item, register)
+                end
+              when :nested
+                _tree, child_rel = layout[row_index]
+                next unless child_rel
+
+                Array(value).each do |item|
+                  child_plan = nested_plans_for(plan)[item.class] ||
+                    (nested_plans_for(plan)[item.class] =
+                       PlanCompiler.compile(item.class, register))
+                  ops << { kind: :element, plan_index: my_index,
+                           row_index: row_index }
+                  emit_element(ops, item, child_plan,
+                               register, my_index + child_rel)
+                  ops << { kind: :end }
+                end
+              end
+            end
+          end
+
+          # {nested row_index => [child tree, relative flat index]} —
+          # children of this plan occupy slots my_index+1 .. in row
+          # order, each nested row's subtree sized once.
+          def flat_layout_for(plan)
+            plan[:flat_layout] ||= begin
+              layout = {}
+              rel = 1
+              (plan[:tree][:children] || []).each_with_index do |row, i|
+                next unless row[:kind] == :nested && row[:plan]
+
+                layout[i] = [row[:plan], rel]
+                rel += subtree_size(row[:plan])
+              end
+              layout
+            end
+          end
+
+          def subtree_size(tree)
+            1 + (tree[:children] || []).sum do |row|
+              row[:kind] == :nested && row[:plan] ? subtree_size(row[:plan]) : 0
+            end
+          end
+
+          def emit_attributes(ops, instance, plan, plan_index, register)
+            recorded = instance.attribute_order
+            attr_rows = plan[:attr_rows]
+            if recorded && !recorded.empty?
+              by_name = {}
+              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+              names = recorded | attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
+            else
+              names = attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
+              by_name = {}
+              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+            end
+            tree_attrs = plan[:tree][:attributes] || []
+            names.each do |name|
+              entry = by_name[name]
+              next unless entry
+
+              _rule, attr, delegate = entry
+              value = value_of(instance, attr, delegate)
+              next if value.nil?
+
+              row_index = tree_attrs.index { |a| a[:name] == name }
+              next unless row_index
+
+              ops << { kind: :attr, plan_index: plan_index,
+                       row_index: row_index, name: name,
+                       value: attr.serialize(value, :xml, register).to_s }
+            end
+          end
+
+          def scalar_op(plan_index, row_index, attr, value, register)
+            { kind: :scalar, plan_index: plan_index, row_index: row_index,
+              value: attr.serialize(value, :xml, register).to_s }
+          end
+
+          def value_of(instance, attr, delegate)
+            if delegate
+              target = instance.public_send(delegate)
+              target&.public_send(attr.name)
+            else
+              instance.public_send(attr.name)
+            end
+          end
+
+          def nested_plans_for(plan)
+            plan[:nested_plans] ||= {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -56,9 +56,9 @@ module Lutaml
 
         class << self
           def compile(model_class, register)
-            # Version gate, not a capability probe: the plan path needs
-            # leptris >= 1.9.273.0 (the child-handles snapshot). Older
-            # gems take the interpretive path via the nil opt-out.
+            # Version gate: below MIN_LEPTRIS_VERSION (the single
+            # capability floor) gems take the interpretive path via
+            # the nil opt-out.
             return nil unless Leptris.plan_path_compatible?
 
             # A child model's declared lutaml_default_register takes
@@ -96,49 +96,8 @@ 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)
@@ -335,13 +294,13 @@ module Lutaml
             flags << :ns_lenient
 
             # Namespace-less model child rows bind the strict unwritten
-            # spelling (bare, or inherited default xmlns) on engines
-            # with the leptris#1560 :unqualified form — the interpretive
-            # matcher's exact no-namespace semantic, refusing prefixed
-            # spellings where the ns_lenient superset bound them.
-            # Rows with an explicit form (rule ns, type ns, :none, :any)
-            # are untouched; name-matched element row kinds only.
-            if model_ns.nil? && Leptris.ns_unqualified_rows_compatible?
+            # spelling (bare, or inherited default xmlns) — the
+            # interpretive matcher's exact no-namespace semantic,
+            # refusing prefixed spellings where the ns_lenient
+            # superset bound them. Rows with an explicit form (rule ns,
+            # type ns, :none, :any) are untouched; name-matched element
+            # row kinds only.
+            if model_ns.nil?
               rows.each do |r|
                 next if r[:ns]
 
@@ -373,14 +332,6 @@ module Lutaml
             # 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.
@@ -451,8 +402,7 @@ module Lutaml
               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
+            return :attr_type_ns_aliases unless type_ns.all_uris.size == 1
 
             claim[:ns] += 1
             plan_attrs << { name: rule.name.to_s,
@@ -465,12 +415,6 @@ module Lutaml
           def compilable_mapping?(mapping)
             # Mapping's uniform interface: root_mappings defaults to
             # false on the base (KeyValue overrides with its own).
-            # 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
 
@@ -548,8 +492,7 @@ module Lutaml
             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
+            return :bail_aliases unless type_ns.all_uris.size == 1
 
             form = { exact: type_ns.uri.to_s,
                      prefix: type_ns.prefix_default&.to_s }

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

@@ -37,6 +37,15 @@ module Lutaml
             )
             return nil if plan[:ordered] && instance.element_order.nil?
 
+            # The native lane first: purely namespace-less trees emit
+            # through the engine's result builder and writers, all-C
+            # after the ops list — 2.4x the DOM-mint loop on the
+            # audit corpus. Everything else keeps the DOM lane below
+            # (namespaced spellings are instance-dependent; ordered,
+            # wildcard, raw, and callback shapes are not
+            # ops-expressible).
+            return NativeEmission.emit(instance, plan, register) if NativeEmission.compatible?(plan)
+
             doc = ::Leptris::XML::Document.create
             ns_ctx = Namespaces.new(instance, plan, register)
             return nil if ns_ctx.unspellable?
@@ -430,27 +439,21 @@ module Lutaml
             child
           end
 
-          # Text attach: the address face (leptris#408 adoption,
-          # leptris 1.9.334) passes raw node addresses — the pointer
-          # face mints an FFI::Pointer wrapper per fresh node, the
-          # last per-row Ruby-side allocation on the DOM build. Same
-          # semantics and status contract; probe-gated because a
-          # numerically newer lockstep can publish without the face.
+          # Text attach: the address face (leptris#408 adoption)
+          # passes raw node addresses — the pointer face mints an
+          # FFI::Pointer wrapper per fresh node, the last per-row
+          # Ruby-side allocation on the DOM build.
           def append_text(parent, text, doc)
             node = doc.create_text_node(text)
-            if Leptris.text_attach_addr_compatible?
-              status = ::Leptris::XML::FFI.leptris_element_add_child_addr(
-                parent.c_address, node.c_address
-              )
-              unless status.zero?
-                raise ::Leptris::XML::Error,
-                  "text attach failed (status=#{status})"
-              end
-
-              node
-            else
-              parent.add_child(node)
+            status = ::Leptris::XML::FFI.leptris_element_add_child_addr(
+              parent.c_address, node.c_address
+            )
+            unless status.zero?
+              raise ::Leptris::XML::Error,
+                "text attach failed (status=#{status})"
             end
+
+            node
           end
 
           def value_of(instance, attr, delegate)

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

@@ -16,7 +16,6 @@ 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

@@ -8,47 +8,16 @@ module Lutaml
     # reference leptris types directly (the moxml adapters and the
     # interpretive path never enter here).
     module Leptris
-      # The plan path requires the one-crossing child snapshot
-      # (leptris_plan_value_children_snapshot with child handles,
-      # PlanValue#children_snapshot), which shipped in leptris
-      # 1.9.273.0. Bundles resolving an older gem keep the
-      # interpretive path — PlanCompiler.compile answers nil — the
-      # 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"
-
-      # 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"
-
-      # The :unqualified child-row ns form (leptris#1560: matches only
-      # the UNWRITTEN spelling — bare or inherited-default-ns — and
-      # refuses prefixed spellings, the interpretive matcher's exact
-      # no-namespace semantic) ships in binding 1.9.323.0. Older
-      # engines keep namespace-less model rows on the ns_lenient
-      # superset (local-name matching under any qualification).
-      MIN_LEPTRIS_NS_UNQUALIFIED_VERSION = "1.9.323.0"
+      # 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"
 
       def self.plan_path_compatible?
         return false unless defined?(Gem)
@@ -57,59 +26,7 @@ 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
-
-      # 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
-
-      def self.ns_unqualified_rows_compatible?
-        return false unless defined?(Gem)
-
-        spec = Gem.loaded_specs["leptris"]
-        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_NS_UNQUALIFIED_VERSION)
-      end
-
-      # The address-based text attach (leptris#408, binding 1.9.334):
-      # leptris_element_add_child_addr skips the per-node FFI pointer
-      # mint. Capability-probed, not version-gated — the FFI face is
-      # attached or it is not, and a lockstep can publish without it.
-      @text_attach_addr = nil
-      def self.text_attach_addr_compatible?
-        return @text_attach_addr unless @text_attach_addr.nil?
-
-        @text_attach_addr =
-          !!(defined?(::Leptris::XML::FFI) &&
-            ::Leptris::XML::FFI.respond_to?(:leptris_element_add_child_addr))
-      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"

data/spec/lutaml/xml/plan_type_ns_attribute_spec.rb

@@ -128,15 +128,4 @@ RSpec.describe "XML plan fast path: type-namespaced attribute rows" do
              model, Lutaml::Model::Config.default_register
            )).to be_nil
   end
-
-  # Engines older than the AttrPlan ns form (libleptris 1.9.289) keep
-  # the opt-out — the existing version-gate protocol.
-  it "opts out when the engine predates attribute ns rows" do
-    allow(Lutaml::Xml::Leptris).to receive(:attr_ns_rows_compatible?)
-      .and_return(false)
-
-    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
-             klass, Lutaml::Model::Config.default_register
-           )).to be_nil
-  end
 end

data/spec/lutaml/xml/plan_wildcard_any_spec.rb

@@ -93,13 +93,4 @@ RSpec.describe "XML plan fast path: map_any_element catch-all" do
       member_shapes(interpretive.others).map { |n| n.sub("Nokogiri", "Leptris") },
     )
   end
-
-  it "compiles under engines without wildcard rows to nil" do
-    allow(Lutaml::Xml::Leptris).to receive(:wildcard_rows_compatible?)
-      .and_return(false)
-
-    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
-             host_class, Lutaml::Model::Config.default_register
-           )).to be_nil
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.101
+  version: 0.8.102
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-10 00:00:00.000000000 Z
+date: 2026-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -787,6 +787,7 @@ files:
 - lib/lutaml/xml/html_entities.rb
 - lib/lutaml/xml/leptris.rb
 - lib/lutaml/xml/leptris/element.rb
+- lib/lutaml/xml/leptris/native_emission.rb
 - lib/lutaml/xml/leptris/plan_compiler.rb
 - lib/lutaml/xml/leptris/plan_hydrator.rb
 - lib/lutaml/xml/leptris/plan_order.rb