lutaml-model 0.8.137 → 0.8.139

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c2afc32a6388d8ebb0a54a71a1e985860511be854729f2776a5075f255ff0eb
-  data.tar.gz: 6bc50c18c84ab0dc27466b32d9de5566d52d95eb54669c33dcea41fde3ac98f6
+  metadata.gz: a027b25146b1db5759062241ef72d4e6cfb7122f4dff800d5683535bf4767c5b
+  data.tar.gz: 2b49a35df1f800d47d18b2e79737fe58fccc79385a2f38e5e5c9169acae84063
 SHA512:
-  metadata.gz: f2e701ec4c50e37c12c781d14b2fae5296cb95c0845b77a505d3f160c6c7b9ba7b960dadfe2e6d7b580122b8f122b6f1824d6f576f82f39767725ed508676503
-  data.tar.gz: e31699cf34fb46a2c0b2a0cec58e3fce25681c2a1f91c0eab74b0694a60e0f248cb666d5194bfb6630293095b696486f1c2c8c16f854f8303f3bf9b7932ae083
+  metadata.gz: e66ba7f1fff3188bbe477aa108681b53cfbacaec36f7dfd652a54c6305f083a28fc4992e6586312fc22da9bded0864f5336f848538b755a315f8c4fbdde3d427
+  data.tar.gz: 8f1039a43171dea42d3bf5f3db295ae4bc44e15d087fc531a9910515d307634410d3a6b102adfff2b5ee30764ff0e19dbefdeb9e1c84618332981bc95f4c67ab

data/lib/lutaml/model/attribute.rb

@@ -379,6 +379,13 @@ module Lutaml
       # Performance: Frozen empty hash to reduce allocations
       EMPTY_TRANSFORM_HASH = {}.freeze
 
+      # Default-argument options for the serialize lane. The per-call
+      # `options = {}` literal allocated one Hash per serialize call
+      # (two per mapped XML row); every consumer of the argument only
+      # reads it or derives a new hash (merge), so a shared frozen
+      # empty is safe.
+      EMPTY_OPTIONS = {}.freeze
+
       def transform
         # Options are fixed after definition (value_policy memoizes the
         # same way) — the per-call @options[:transform] Hash#[] was hit
@@ -918,7 +925,7 @@ instance_object = nil)
         true
       end
 
-      def serialize(value, format, register, options = {})
+      def serialize(value, format, register, options = EMPTY_OPTIONS)
         value ||= build_collection if collection? && initialize_empty?
         return value if value.nil? || Utils.uninitialized?(value)
 

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

@@ -376,7 +376,11 @@ module Lutaml
           # through the real constructor for them, exactly as the walk
           # did before the compiled seed existed. The seed stays the
           # fast path for classes using the standard initializer.
-          return new if walk_needs_constructor?
+          return new(lutaml_register: register) if constructs_through_initialize?
+          # did before the compiled seed existed, register included. The
+          # seed stays the fast path for classes using the standard
+          # initializer.
+          return new(lutaml_register: register) if constructs_through_initialize?
 
           instance = allocate
           instance.init_walk_state(register_id)
@@ -388,8 +392,8 @@ module Lutaml
         # optional setup, and the compiled walk seed would skip it.
         # (The standard initializer's owner is Serialize::Builder; a
         # class- or parent-defined initialize makes the owner the class.)
-        def walk_needs_constructor?
-          @walk_needs_constructor ||=
+        def constructs_through_initialize?
+          @constructs_through_initialize ||=
             instance_method(:initialize).owner != Lutaml::Model::Serialize::Builder
         end
 
@@ -407,6 +411,14 @@ module Lutaml
           # stack limit — models without pending deferred imports skip
           # it entirely.
           ensure_imports!(register_id) if finalized? && deferred_imports_pending?(register_id)
+          # Custom-initialize classes (#1032's twin): their initialize is
+          # constructor contract — internal state the compiled seeding
+          # cannot know about — so they construct through the real
+          # constructor, then carry the parse's register context.
+          if constructs_through_initialize?
+            instance = new(lutaml_register: register_id)
+            return instance
+          end
           instance = allocate
           instance.finalize_deserialization(register_id)
           instance

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.137"
+    VERSION = "0.8.139"
   end
 end

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

@@ -31,6 +31,17 @@ module Lutaml
         ROOT_ROW = 0xFFFF_FFFF
         EMITTABLE_KINDS = %i[scalar collection nested].freeze
 
+        # Fiber-local buffer of reusable op Hash slots. The engine's
+        # build_result copies every op into FFI memory before it
+        # returns, so the Ruby hashes are dead weight past the call;
+        # recycling them positionally removes one Hash allocation per
+        # emitted op (four per mapped row on the emission lane) at no
+        # semantic cost. Slots are cleared before every reuse, so
+        # stale keys from a prior kind cannot leak into an op.
+        OP_BUFFER_KEY = :lutaml_model_leptris_native_emission_op_buffer
+        OP_BUFFER_BASE_KEY =
+          :lutaml_model_leptris_native_emission_op_buffer_base
+
         class << self
           def compatible?(plan)
             !plan[:ordered] && tree_emittable?(plan[:tree])
@@ -49,28 +60,59 @@ module Lutaml
             end
           end
 
+          # len is the logical length of the buffer: slots [base, len) hold
+          # the ops of the emission in progress. base is nonzero when a
+          # user hook re-enters to_xml mid-emission — the inner
+          # emission appends after the outer's written slots instead of
+          # overwriting them. The tail is trimmed after the engine
+          # consumed the result so a pathological document cannot grow
+          # the buffer without bound.
           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)
+            buf = (Thread.current[OP_BUFFER_KEY] ||= [])
+            base = (Thread.current[OP_BUFFER_BASE_KEY] ||= 0)
+            len = base
+            begin
+              op_slot(buf, len)
+              buf[len][:kind] = :element
+              buf[len][:row_index] = ROOT_ROW
+              len = emit_element(buf, len + 1, instance, plan, register, 0)
+              op_slot(buf, len)
+              buf[len][:kind] = :end
+              len += 1
+              compact = plan[:descriptor].serialize(
+                plan[:descriptor].build_result(buf[base, len - base]),
+              )
+              ::Leptris::XML.parse(compact).to_xml(indent: 2, no_decl: true)
+            ensure
+              buf.slice!(len..) if buf.size > len
+              Thread.current[OP_BUFFER_BASE_KEY] = base
+            end
           end
 
           private
 
+          # Cleared slot len of the buffer, reusing the Hash object a
+          # previous emission left there when present. Also publishes
+          # this emission's exclusive end as the fiber-local base: the
+          # walk evaluates user code (model getters, default procs,
+          # registered serializers) between slots, and a re-entrant
+          # to_xml from that code must append after every written op,
+          # never overlap this emission's slots.
+          def op_slot(buf, len)
+            Thread.current[OP_BUFFER_BASE_KEY] = len + 1
+            (buf[len] ||= {}).clear
+          end
+
           # 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)
+          def emit_element(buf, len, instance, plan, register, plan_index)
             my_index = plan_index
             layout = flat_layout_for(plan)
 
-            emit_attributes(ops, instance, plan, my_index, register)
+            len = emit_attributes(buf, len, instance, plan, my_index, register)
 
             plan[:rows].each_with_index do |(rule, attr, kind, _spelling, delegate), row_index|
               value = value_of(instance, attr, delegate)
@@ -83,31 +125,41 @@ module Lutaml
                 # as the DOM lane does.
                 if value.is_a?(::Array)
                   value.each do |item|
-                    ops << scalar_op(my_index, row_index, attr, item, register)
+                    len = scalar_op(buf, len, my_index, row_index, attr, item,
+                                  register)
                   end
                 else
-                  ops << scalar_op(my_index, row_index, attr, value, register)
+                  len = scalar_op(buf, len, 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)
+                  len = scalar_op(buf, len, my_index, row_index, attr, item,
+                                register)
                 end
               when :nested
                 _tree, child_rel = layout[row_index]
                 next unless child_rel
 
+                child_plans = child_plans_for(plan, row_index)
                 Array(value).each do |item|
-                  child_plan = nested_plans_for(plan)[[item.class, rule.name.to_s]] ||
-                    (nested_plans_for(plan)[[item.class, rule.name.to_s]] =
+                  child_plan = child_plans[item.class] ||
+                    (child_plans[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 }
+                  op_slot(buf, len)
+                  buf[len][:kind] = :element
+                  buf[len][:plan_index] = my_index
+                  buf[len][:row_index] = row_index
+                  len += 1
+                  len = emit_element(buf, len, item, child_plan,
+                                   register, my_index + child_rel)
+                  op_slot(buf, len)
+                  buf[len][:kind] = :end
+                  len += 1
                 end
               end
             end
+            len
           end
 
           # {nested row_index => [child tree, relative flat index]} —
@@ -133,19 +185,50 @@ module Lutaml
             end
           end
 
-          def emit_attributes(ops, instance, plan, plan_index, register)
+          # The name bookkeeping is static per plan — attr_rows and the
+          # tree's attribute rows never vary per instance — so the
+          # name->tree row_index map is memoized on the plan. Only
+          # instances carrying a recorded attribute order (parsed
+          # documents whose XML attribute sequence must be replayed)
+          # take the per-instance path.
+          def emit_attributes(buf, len, 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] }
+              emit_attributes_recorded(buf, len, instance, plan, plan_index,
+                                       register, recorded)
+              return len
+            end
+
+            tree_attrs = plan[:tree][:attributes] || []
+            row_indices = attr_row_indices_for(plan, tree_attrs)
+            attr_rows = plan[:attr_rows]
+            attr_rows.each do |rule, attr, _sp, delegate|
+              value = value_of(instance, attr, delegate)
+              next if value.nil?
+
+              name = rule.name.to_s
+              row_index = row_indices[name]
+              next unless row_index
+
+              op_slot(buf, len)
+              buf[len][:kind] = :attr
+              buf[len][:plan_index] = plan_index
+              buf[len][:row_index] = row_index
+              buf[len][:name] = name
+              buf[len][:value] = attr.serialize(value, :xml, register).to_s
+              len += 1
             end
+            len
+          end
+
+          def emit_attributes_recorded(buf, len, instance, plan, plan_index,
+                                       register, recorded)
+            attr_rows = plan[:attr_rows]
+            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 }
             tree_attrs = plan[:tree][:attributes] || []
+            row_indices = attr_row_indices_for(plan, tree_attrs)
             names.each do |name|
               entry = by_name[name]
               next unless entry
@@ -154,18 +237,40 @@ module Lutaml
               value = value_of(instance, attr, delegate)
               next if value.nil?
 
-              row_index = tree_attrs.index { |a| a[:name] == name }
+              row_index = row_indices[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 }
+              op_slot(buf, len)
+              buf[len][:kind] = :attr
+              buf[len][:plan_index] = plan_index
+              buf[len][:row_index] = row_index
+              buf[len][:name] = name
+              buf[len][:value] = attr.serialize(value, :xml, register).to_s
+              len += 1
+            end
+            len
+          end
+
+          # name -> tree_attrs index, first occurrence wins (same match
+          # semantics as the Array#index scan it replaced).
+          def attr_row_indices_for(plan, tree_attrs)
+            return plan[:attr_row_indices] if plan[:attr_row_indices]
+
+            indices = {}
+            tree_attrs.each_with_index do |tree_attr, i|
+              name = tree_attr[:name]
+              indices[name] = i unless indices.key?(name)
             end
+            plan[:attr_row_indices] = indices
           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 }
+          def scalar_op(buf, len, plan_index, row_index, attr, value, register)
+            op_slot(buf, len)
+            buf[len][:kind] = :scalar
+            buf[len][:plan_index] = plan_index
+            buf[len][:row_index] = row_index
+            buf[len][:value] = attr.serialize(value, :xml, register).to_s
+            len + 1
           end
 
           def value_of(instance, attr, delegate)
@@ -177,8 +282,11 @@ module Lutaml
             end
           end
 
-          def nested_plans_for(plan)
-            plan[:nested_plans] ||= {}
+          # Compiled child plans per nested row, keyed by row index and
+          # then by member class. Keying through Integers and classes
+          # avoids allocating a [class, name] pair per emitted child.
+          def child_plans_for(plan, row_index)
+            (plan[:nested_plans_by_row] ||= {})[row_index] ||= {}
           end
         end
       end

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

@@ -122,6 +122,8 @@ module Lutaml
             # them (compiling here silently dropped pi_settings).
             return opt_out!(:processing_instruction) unless
               mapping.processing_instruction_mappings.empty?
+            # Wildcard attribute families ride the interpretive path too
+            return opt_out!(:all_attributes) if mapping.all_attributes_rule
 
             rows = []
             attr_rows = [] # [[rule, attr, row_name]] hydration metadata

data/lib/lutaml/xml/mapping.rb

@@ -38,7 +38,7 @@ module Lutaml
         @xml_instance
       end
 
-      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule
+      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule, :all_attributes_rule
 
       def initialize
         super
@@ -49,6 +49,7 @@ module Lutaml
         @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
+        @all_attributes_rule = nil
         @mixed_content = false
         @xml_space = nil
         @format = :xml
@@ -875,6 +876,26 @@ module Lutaml
         )
       end
 
+      # Capture every attribute not claimed by an explicit map_attribute
+      # (and matching an optional pattern) into a Hash attribute, and emit
+      # it back as attributes after the mapped ones on serialization —
+      # the remainder semantics of map_all, for attribute families
+      # (lutaml-model#1031): HTML data-*, ARIA aria-*, on* handlers.
+      #
+      # @param to [Symbol] the Hash attribute name
+      # @param matching [Regexp, nil] optional name filter; nil captures
+      #   every unclaimed attribute
+      #
+      # @example
+      #   xml do
+      #     element "mn"
+      #     map_attribute "name", to: :name
+      #     map_all_attributes to: :other_attributes, matching: /\A(data-|aria-|on)/
+      #   end
+      def map_all_attributes(to:, matching: nil)
+        @all_attributes_rule = AllAttributesMapping.new(to, matching)
+      end
+
       def sequence(&block)
         @element_sequence << ::Lutaml::Model::Sequence.new(self,
                                                            format: :xml).tap do |s|
@@ -1681,5 +1702,21 @@ module Lutaml
         self.class.new(@target.dup, @to)
       end
     end
+
+    # Wildcard attribute-family mapping (#1031): the target Hash collects
+    # every attribute no explicit map_attribute claims and that matches
+    # the optional pattern; serialization emits each pair as an attribute.
+    class AllAttributesMapping
+      attr_reader :to, :matching
+
+      def initialize(to, matching)
+        @to = to
+        @matching = matching
+      end
+
+      def dup
+        self.class.new(@to, @matching)
+      end
+    end
   end
 end

data/lib/lutaml/xml/model_transform.rb

@@ -503,11 +503,50 @@ module Lutaml
         apply_processing_instruction_deserialization(doc, instance, xml_mapping,
                                                      effective_register)
 
+        apply_all_attributes_deserialization(doc, instance, xml_mapping)
+
         run_consolidation(instance, effective_register, instance_is_serialize)
 
         instance
       end
 
+      # #1031: wildcard attribute families. After the explicit attribute
+      # rules have consumed their names, every remaining unprefixed
+      # attribute matching the rule's pattern lands in the target Hash —
+      # names claimed by explicit rules never leak into it.
+      def apply_all_attributes_deserialization(doc, instance, xml_mapping)
+        rule = xml_mapping.all_attributes_rule
+        return if rule.nil?
+
+        element = doc.is_a?(::Lutaml::Xml::XmlElement) ? doc : doc.root
+        return if element.nil?
+
+        claimed = attribute_names_claimed_by_rules(xml_mapping)
+        remainder = {}
+        element.attributes.each_value do |attr|
+          name = attr.unprefixed_name.to_s
+          next if claimed.include?(name)
+          next if rule.matching && !rule.matching.match?(name)
+
+          remainder[name] = attr.value
+        end
+        return if remainder.empty?
+
+        instance.public_send(:"#{rule.to}=", remainder)
+        instance.value_set_for(rule.to) if instance.is_a?(::Lutaml::Model::Serialize)
+      end
+
+      # Attribute names claimed by explicit map_attribute rules, plus the
+      # engine-handled schemaLocation (which renders through
+      # raw_schema_location, not the remainder).
+      def attribute_names_claimed_by_rules(xml_mapping)
+        names = %w[schemaLocation]
+        xml_mapping.mapping_attributes_hash.each_value do |rule_or_array|
+          Array(rule_or_array).each { |rule| names << rule.name.to_s }
+        end
+        names
+      end
+
       def validate_document!(doc, options)
         return unless doc.is_a?(Array)
 

data/lib/lutaml/xml/transformation.rb

@@ -101,6 +101,9 @@ module Lutaml
           apply_standard_rules(root, model_instance, options)
         end
 
+        # The wildcard attribute family emits after the mapped attributes
+        apply_all_attributes_mappings(root, model_instance, mapping)
+
         root
       end
 
@@ -242,6 +245,27 @@ module Lutaml
       end
 
       # Check if element order should be used for serialization
+
+      # #1031: emit the wildcard attribute family after the mapped
+      # attributes. Attributes render in insertion order; the remainder
+      # follows the explicitly mapped names.
+      def apply_all_attributes_mappings(root, model_instance, mapping)
+        rule = mapping.all_attributes_rule
+        return if rule.nil?
+
+        value = model_instance.public_send(rule.to)
+        return if value.nil? || !value.is_a?(::Hash)
+
+        value.each do |name, attr_value|
+          next if attr_value.nil?
+
+          root.add_attribute(
+            ::Lutaml::Xml::DataModel::XmlAttribute.new(name.to_s,
+                                                       attr_value.to_s, nil),
+          )
+        end
+      end
+
       #
       # @param model_instance [Object] The model instance
       # @param mapping [Xml::Mapping] The mapping

data/spec/lutaml/model/map_all_attributes_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #1031: wildcard attribute families — every attribute no explicit
+# map_attribute claims and that matches the pattern lands in a Hash and
+# is emitted back after the mapped attributes on serialization.
+RSpec.describe "map_all_attributes" do
+  let(:model_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :data_attributes, :hash
+
+      xml do
+        element "mn"
+        map_attribute "name", to: :name
+        map_all_attributes to: :data_attributes, matching: /\A(data-|aria-|on)/
+      end
+    end
+  end
+
+  let(:stubbed) do
+    stub_const("MapAllAttributesModel", model_class)
+    MapAllAttributesModel
+  end
+
+  it "captures unclaimed, pattern-matching attributes into the Hash" do
+    xml = '<mn name="x" data-title="T" onclick="f()" aria-label="L" unre="nope"/>'
+    model = stubbed.from_xml(xml)
+
+    expect(model.name).to eq("x")
+    expect(model.data_attributes).to eq(
+      "data-title" => "T", "onclick" => "f()", "aria-label" => "L",
+    )
+  end
+
+  it "never lets mapped names leak into the remainder" do
+    xml = '<mn name="x" data-name="D"/>'
+    model = stubbed.from_xml(xml)
+
+    expect(model.data_attributes).to eq("data-name" => "D")
+  end
+
+  it "emits the remainder after the mapped attributes on serialization" do
+    model = stubbed.from_xml(
+      '<mn name="x" data-title="T" onclick="f()"/>',
+    )
+    out = model.to_xml
+
+    expect(out).to include('name="x"')
+    expect(out).to include('data-title="T"')
+    expect(out).to include('onclick="f()"')
+    expect(out.index("name=")).to be < out.index("data-title=")
+  end
+
+  it "round-trips losslessly" do
+    xml = '<mn name="x" data-title="T" onclick="f()" aria-label="L"/>'
+    model = stubbed.from_xml(xml)
+    round_tripped = stubbed.from_xml(model.to_xml)
+
+    expect(round_tripped.data_attributes).to eq(model.data_attributes)
+    expect(round_tripped.name).to eq(model.name)
+  end
+
+  it "emits nothing when the remainder is empty" do
+    model = stubbed.from_xml('<mn name="x"/>')
+    out = model.to_xml
+
+    expect(out).not_to include("data-")
+  end
+
+  it "captures every unclaimed attribute when no pattern is given" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :other_attributes, :hash
+
+      xml do
+        element "el"
+        map_attribute "name", to: :name
+        map_all_attributes to: :other_attributes
+      end
+    end
+    stub_const("MapAllNoPatternModel", klass)
+
+    model = klass.from_xml('<el name="x" zeta="1"/>')
+
+    expect(model.other_attributes).to eq("zeta" => "1")
+  end
+end

data/spec/lutaml/model/walk_constructor_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A class that defines its own initialize is built through it by the
+# from_* walk, and the walk hands it the register exactly as
+# `new(lutaml_register:)` did before the compiled seed existed: a
+# constructor that tells a blank construction from a caller's by that
+# keyword sees the same call either way.
+RSpec.describe "Walk construction of a custom-initialize class" do
+  let(:model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      json do
+        map "name", to: :name
+      end
+
+      class << self
+        attr_accessor :constructions
+      end
+
+      def initialize(*args, **kwargs)
+        self.class.constructions << [args, kwargs.keys]
+        @internal = :ready
+        super
+      end
+
+      attr_reader :internal
+    end
+  end
+
+  before do
+    stub_const("WalkConstructorModel", model)
+    model.constructions = []
+  end
+
+  it "runs the class's own initialize" do
+    expect(model.from_json('{"name":"a"}').internal).to eq(:ready)
+  end
+
+  it "passes the register, as the walk did through new(lutaml_register:)" do
+    parsed = model.from_json('{"name":"a"}')
+
+    expect(model.constructions).to eq([[[], [:lutaml_register]]])
+    expect(parsed.name).to eq("a")
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -819,4 +819,65 @@ RSpec.describe "XML plan fast path" do
       )
     end
   end
+
+  describe "native emission op buffer" do
+    around do |example|
+      Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+    end
+
+    it "keeps a re-entrant to_xml from a getter from corrupting the outer emission" do
+      inner = Class.new(Lutaml::Model::Serializable) do
+        attribute :v, :string
+
+        xml do
+          element "inner"
+          map_attribute "v", to: :v
+        end
+      end
+      outer = Class.new(Lutaml::Model::Serializable) do
+        attribute :v, :string
+        attribute :items, inner, collection: true
+
+        xml do
+          element "outer"
+          map_attribute "v", to: :v
+          map_element "inner", to: :items
+        end
+
+        define_method(:items) do
+          inner.new(v: "reentrant").to_xml
+          @items
+        end
+      end
+
+      model = outer.new(v: "x", items: [inner.new(v: "1"), inner.new(v: "2")])
+      expected = "<outer v=\"x\">\n  <inner v=\"1\"/>\n  <inner v=\"2\"/>\n</outer>"
+      expect(model.to_xml).to eq(expected)
+      expect(model.to_xml).to eq(expected)
+    end
+
+    it "keeps interleaved emissions of distinct models stable" do
+      alpha = Class.new(Lutaml::Model::Serializable) do
+        attribute :a, :string
+
+        xml do
+          element "alpha"
+          map_attribute "a", to: :a
+        end
+      end
+      beta = Class.new(Lutaml::Model::Serializable) do
+        attribute :b, :integer
+
+        xml do
+          element "beta"
+          map_attribute "b", to: :b
+        end
+      end
+
+      5.times do
+        expect(alpha.new(a: "x").to_xml).to eq("<alpha a=\"x\"/>")
+        expect(beta.new(b: 7).to_xml).to eq("<beta b=\"7\"/>")
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.137
+  version: 0.8.139
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1796,6 +1796,7 @@ files:
 - spec/lutaml/model/liquid/indexed_access_spec.rb
 - spec/lutaml/model/liquid_compatibility_spec.rb
 - spec/lutaml/model/logger_spec.rb
+- spec/lutaml/model/map_all_attributes_spec.rb
 - spec/lutaml/model/map_all_spec.rb
 - spec/lutaml/model/map_content_spec.rb
 - spec/lutaml/model/map_unmapped_spec.rb
@@ -1912,6 +1913,7 @@ files:
 - spec/lutaml/model/value_map_spec.rb
 - spec/lutaml/model/value_policy_spec.rb
 - spec/lutaml/model/value_transformation_comprehensive_spec.rb
+- spec/lutaml/model/walk_constructor_spec.rb
 - spec/lutaml/model/with_child_mapping_spec.rb
 - spec/lutaml/model/writer_assigned_attribute_spec.rb
 - spec/lutaml/model/xml_decoupling_spec.rb