lutaml-model 0.8.93 → 0.8.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86c5bac7343ebcdc8da3bcd0823d921b71b8a2e36b51db39407377623aa5e6a4
-  data.tar.gz: 70f1211df047a2a18fd9d7aeb95e16bbf42c56ccefcf67d6cce8a2fce0f48278
+  metadata.gz: c5933a3971f4f39e30541f504636641cd059e7a97751ba67a710203dbfdcc45a
+  data.tar.gz: c23b70227e80d99427b9d4125a09e33d9751112bc72a5e6abaca73d6a3897c60
 SHA512:
-  metadata.gz: 43490a24e28b65c3c01e96511d99bdef692c933280d7a5e854d413d9d6d0234e524d7d7512e7fa94af61e5049ecfe509fd8146ea1120a5be445d7dcb608ee4eb
-  data.tar.gz: 89265e10746d04714e1ad7d854c3e39cdd0578f5ed7230542da53eda00258850e75c402fc1c8d3c34590eea1960c9bc63f25079c6bad43854e85a7f9a9eefe71
+  metadata.gz: 473b9970246c24172d6040a9c5062fad06d0fea413a5e04956ac98c0990324f2543668436c9259ad2a30b8647555d1e00102f6346afd3018814d68c2841ca8e5
+  data.tar.gz: f48b568bdc715a7649a262ca5757474f56ecc52d775121be99f18f067570d48d5401ff29cd7141ff768e9ea0a3e0aef5996d32129b8907c386cfd3c72e9f5370

data/.github/workflows/downstream-performance.yml

@@ -116,9 +116,16 @@ jobs:
             File.write("Gemfile", out.join)
           ' /tmp/main-checkout
           bundle install --jobs=4
-          bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb || \
-            { echo "::warning::baseline gate failed — re-running once under less contention (#834)"; \
-              sleep 30; bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb; }
+          # lutaml-model#834: min-of-N across attempts — contention
+          # inflates single-shot timings, so run three attempts and let
+          # the merge keep the least-interfered measurement per fixture.
+          for i in 1 2 3; do
+            bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb || \
+              echo "::warning::baseline attempt $i errored (#834) — continuing with remaining attempts"
+            cp "$BENCH_JSON" "$BENCH_JSON.attempt$i" 2>/dev/null || true
+          done
+          ruby ${{ github.workspace }}/bench/bench_merge_attempts.rb \
+            "$BENCH_JSON" "$BENCH_JSON.attempt1" "$BENCH_JSON.attempt2" "$BENCH_JSON.attempt3"
 
       - name: Run current benchmark (PR branch)
         env:
@@ -146,9 +153,13 @@ jobs:
             File.write("Gemfile", out.join)
           ' ${{ github.workspace }}
           bundle install --jobs=4
-          bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb || \
-            { echo "::warning::gate failed — re-running once under less contention (#834)"; \
-              sleep 30; bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb; }
+          for i in 1 2 3; do
+            bundle exec ruby ${{ github.workspace }}/bench/bench_${{ matrix.downstream }}.rb || \
+              echo "::warning::current attempt $i errored (#834) — continuing with remaining attempts"
+            cp "$BENCH_JSON" "$BENCH_JSON.attempt$i" 2>/dev/null || true
+          done
+          ruby ${{ github.workspace }}/bench/bench_merge_attempts.rb \
+            "$BENCH_JSON" "$BENCH_JSON.attempt1" "$BENCH_JSON.attempt2" "$BENCH_JSON.attempt3"
 
       - name: Compare baseline vs current
         run: |

data/bench/bench_merge_attempts.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# lutaml-model#834: merge N benchmark-attempt JSONs into one result set,
+# taking the per-fixture minimum of every metric. Contention inflates
+# timings; the minimum across attempts is the least-interfered
+# measurement, so gates evaluated on merged output misfire only when
+# EVERY attempt was slow.
+#
+# Usage: ruby bench_merge_attempts.rb <merged.json> <attempt1.json> [attempt2.json ...]
+#
+# Attempt files may be missing (crashed attempt): missing files are
+# skipped; if none exist, nothing is written and the caller's compare
+# step fails on the missing merged file.
+if ARGV.length < 3
+  warn "Usage: #{$PROGRAM_NAME} <merged.json> <attempt1.json> [attempt2.json ...]"
+  exit 1
+end
+
+merged_path = ARGV[0]
+attempt_paths = ARGV[1..]
+
+require "json"
+
+best = {}
+attempt_paths.each do |path|
+  next unless File.exist?(path)
+
+  results = JSON.parse(File.read(path))
+  results.each do |label, metrics|
+    cur = best[label]
+    if cur
+      cur["avg_time"] = [cur["avg_time"], metrics["avg_time"]].min
+      cur["min_time"] = [cur["min_time"], metrics["min_time"]].min
+      cur["max_time"] = [cur["max_time"], metrics["max_time"]].min
+      cur["allocations"] = [cur["allocations"], metrics["allocations"]].min
+      cur["ips"] = [cur["ips"], metrics["ips"]].max
+    else
+      best[label] = metrics.dup
+    end
+  end
+end
+
+if best.nil? || best.empty?
+  warn "No attempt JSONs found among: #{attempt_paths.join(', ')}"
+  exit 1
+end
+
+File.write(merged_path, JSON.pretty_generate(best))
+puts "Merged #{attempt_paths.size} attempt file(s) into #{merged_path} (#{best.size} fixtures)"

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

@@ -62,6 +62,24 @@ module Lutaml
             #{lines}
             end
           RUBY
+
+          # Raw readers compiled alongside the seeding so every
+          # attribute the register can see — including late-merged
+          # imports that bypass define_attribute_methods — carries
+          # one (#933). Idempotent with the declaration-time
+          # definition.
+          raw_lines = attrs.filter_map do |name, _attr|
+            next unless name.to_s.match?(PLAIN_NAME)
+
+            <<~RUBY
+              def __lutaml_raw_#{name}
+                @#{name}
+              end
+            RUBY
+          end.join
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            #{raw_lines}
+          RUBY
         end
 
         # Historical getter shape for punctuation-named attributes and
@@ -104,12 +122,41 @@ module Lutaml
                           end
             remove_method(compiled) if defined_now
           end
+          # The names cache must go with the methods: the memoized
+          # lookup answers stale names for removed methods otherwise.
+          @state_defaults_names.clear
         end
 
         def define_attribute_methods(attr, register = nil)
           name = attr.name
           register_id = extract_register_id(register)
 
+          # lutaml-model#922: raw-state reader for the deserializer's
+          # unmatched-rule handling. A custom writer that assigns a
+          # *different* attribute mid-parse (relaton's ICS Isoics
+          # fallback; any derived-value pattern) is invisible to the
+          # value_set tracker -- public setters don't mark it -- so the
+          # tracked "still default" state lies. The deserializer needs
+          # the raw stored state to know whether an attribute was
+          # writer-populated: still holding the initialized marker
+          # (sentinel / lazy collection) means unset; anything else was
+          # written since init and must never be overwritten by an
+          # unmatched rule's default assignment. Declared here (not in
+          # the state-defaults compilation) so late declarations get it
+          # too -- XMI's extension loader declares attributes after
+          # first parse.
+          if name.to_s.match?(PLAIN_NAME)
+            # class_eval on self: a bare `model` receiver resolves
+            # through the host class's own namespace (omml's Base
+            # answers a Store model) and defined the reader on the
+            # wrong object (#933).
+            class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+              def __lutaml_raw_#{name}
+                @#{name}
+              end
+            RUBY
+          end
+
           if attr.enum?
             add_enum_methods_to_model(
               model,
@@ -354,6 +401,11 @@ module Lutaml
           attr = Attribute.new(name, type, options)
           @attributes[name] = attr
           @merged_attributes_cache = nil
+          # Attributes can be declared after the model has been
+          # instantiated (forward references, post-hoc declarations);
+          # the interned writer table from the first instantiation must
+          # not outlive the attribute set it was built from.
+          @instantiate_writers = nil
           invalidate_state_defaults!
           define_attribute_methods(attr)
 

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

@@ -345,8 +345,20 @@ module Lutaml
         # @param register [Symbol, nil] The register context
         # @return [Object] The allocated instance
         def allocate_for_deserialization(register = nil)
-          instance = allocate
           register_id = extract_register_id(register)
+          # Deferred imports (symbol-form import_model_attributes) must
+          # resolve before state defaults compile: the compiled seeding
+          # and the raw readers cover the post-import attribute set, and
+          # the transform's records already carry the mapping's rules
+          # for imported names — CTR's <m:br> parsed before resolution
+          # had no reader (#933). The constructor path ensures the same
+          # way (initialize_attributes). Guarded: deep object graphs
+          # (XSD schema trees) allocate recursively, and the ensure
+          # chain's frames per level pushed that recursion past the
+          # stack limit — models without pending deferred imports skip
+          # it entirely.
+          ensure_imports!(register_id) if finalized? && deferred_imports_pending?
+          instance = allocate
           instance.finalize_deserialization(register_id)
           instance
         end
@@ -392,6 +404,22 @@ module Lutaml
               # set (nil when no default), never left as the
               # uninitialized sentinel — readers and formatters touch
               # absent attributes freely.
+              #
+              # lutaml-model#922: unless a custom writer already
+              # populated it. An earlier kwarg's writer may have
+              # assigned this attribute as a side effect (relaton's ICS
+              # populates <text> from the Isoics dataset inside code=);
+              # the raw state is the truth — still at its initialized
+              # marker (sentinel / lazy collection) means unset, and
+              # only then is the default seeded. The writer's own
+              # value_set_for (inside the compiled writer) already
+              # marked it set, so it renders.
+              raw = instance.public_send(:"__lutaml_raw_#{name}")
+              unset = raw.nil? ||
+                raw.equal?(Lutaml::Model::UninitializedClass.instance) ||
+                raw.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+              next unless unset
+
               default = attr.default_value(register_id, instance)
               value = if Lutaml::Model::Utils.uninitialized?(default)
                         nil

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

@@ -60,6 +60,10 @@ module Lutaml
           model.attributes.each_value { |attr| define_attribute_methods(attr) }
           @attributes.merge!(Utils.deep_dup(model.attributes))
           @choice_attributes.concat(deep_duplicate_choice_attributes(model))
+          # Imported attributes grow the state-defaults surface (the
+          # raw readers live there) — a first use may already have
+          # compiled it for the pre-import attribute set (#933).
+          invalidate_state_defaults!
           # Ensure @models_imported is a hash; migrate from legacy nil/false state
           @models_imported ||= {}
           @models_imported[reg] = true
@@ -122,6 +126,9 @@ module Lutaml
             deep_duplicate_choice_attributes(model, register_id),
           )
           @merged_attributes_cache = nil
+          # See import_model_attributes: late-registered attributes
+          # must recompile the register's state defaults (#933).
+          invalidate_state_defaults!
         end
         private :register_only_import_model_attributes
 
@@ -153,6 +160,15 @@ module Lutaml
         # Ensure all model imports are resolved for a specific register
         #
         # @param register_id [Symbol, nil] The register context
+        # Whether deferred (symbol-form) imports are still pending —
+        # gates the allocation-time ensure chain (#933).
+        def deferred_imports_pending?
+          importable_models.any? { |_method, models| models.any? } ||
+            importable_choices.any? do |_choice, imports|
+              imports.any? { |_method, models| models.any? }
+            end || restrict_attributes.any?
+        end
+
         def ensure_model_imports!(register_id = nil)
           register_id ||= Lutaml::Model::Config.default_register
           @models_imported = {} if @models_imported.nil? || @models_imported == false
@@ -197,6 +213,7 @@ module Lutaml
           @choices_imported[register_id] = true
           all_resolved = true
 
+          resolved_any = false
           importable_choices.each do |choice, choice_imports|
             choice_imports.each do |method, models|
               models.uniq.each do |model|
@@ -216,11 +233,19 @@ module Lutaml
                 end
 
                 choice.public_send(method, model_class, register_id)
+                resolved_any = true
               end
             end
           end
 
           @choices_imported[register_id] = true if all_resolved
+          # Choice imports can add attributes without passing through
+          # define_attribute_methods — recompile state defaults so the
+          # seeding and raw readers cover them (#933). Only when an
+          # import actually resolved: ensure_choice_imports! runs on
+          # every ensure_imports! (allocation-time), and a recompile
+          # per allocation would churn.
+          invalidate_state_defaults! if resolved_any
         end
 
         # Ensure all restrict attributes are applied

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.93"
+    VERSION = "0.8.95"
   end
 end

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,12 +281,69 @@ 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 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).
+            return opt_out!(:attr_type_ns_nested) if plan_attrs.any? { |a| a[:ns] } &&
+              rows.any?
+
             { 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 }
+          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 } }
+            ns_attr_names << rule.name.to_s
+            nil
           end
 
           def compilable_mapping?(mapping)

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
                 # 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
 

data/lib/lutaml/xml/leptris.rb

@@ -16,6 +16,11 @@ 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"
+
       def self.plan_path_compatible?
         return false unless defined?(Gem)
 
@@ -23,6 +28,13 @@ 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
+
       autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
       autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
       autoload :PlanOrder, "lutaml/xml/leptris/plan_order"

data/lib/lutaml/xml/model_transform.rb

@@ -345,12 +345,11 @@ module Lutaml
         mappings.each do |rule|
           record = records&.[](rule)
 
-          # #903: replay-or-drop unmatched named element rules before
-          # any per-rule machinery (see replay_unmatched_rule).
-          if replay_unmatched_rule(child_names_set, record, rule,
-                                   instance, defaults_used, xml_mapping)
-            next
-          end
+          # #903/#922: replay-or-drop unmatched rules; never clobber
+          # a mid-parse custom-writer assignment.
+          next if replay_unmatched_rule(child_names_set, record, rule,
+                                        instance, defaults_used,
+                                        xml_mapping)
 
           rule_to = rule.to
 
@@ -436,11 +435,19 @@ module Lutaml
                     # NOTE: do not "read the instance" here (to_value_for) —
                     # the compiled getters materialize lazy collections on
                     # first read, which tripled parse allocations when tried.
+                    if writer_populated?(record, instance)
+                      instance.value_set_for(rule_to)
+                      next
+                    end
                     if instance.using_default?(rule_to) || rule.render_default
                       defaults_used << rule_to
                       attr&.default(effective_register) || rule.to_value_for(instance)
                     else
-                      ::Lutaml::Model::UninitializedClass.instance
+                      # The attribute already holds an explicit value --
+                      # assigned by a matched rule or by a custom writer
+                      # mid-parse (lutaml-model#922). An unmatched rule
+                      # must not overwrite it with nil.
+                      next
                     end
                   else
                     raise "ELSE-BODY" if ENV["CATCHDBG"] && rule.name.nil?
@@ -857,7 +864,7 @@ _effective_register)
 
       Record = Struct.new(:attr, :derived, :group_skip, :valid,
                           :unmatched_mode, :replay_writer,
-                          :unmatched_names)
+                          :unmatched_names, :raw_reader)
 
       def compiled_rule_records(model_class, register, grouped_plain_rules)
         return {}.compare_by_identity unless model_class.include?(Lutaml::Model::Serialize)
@@ -946,6 +953,15 @@ _effective_register)
             unmatched_mode,
             replay_writer,
             unmatched_names,
+            # lutaml-model#922: raw-state reader for the attribute,
+            # when the compiled init seeds it (plain names -- the same
+            # set compile_state_defaults! writes). Delegated rules name
+            # an attribute on the delegate object, not on this
+            # instance, so they get no raw reader.
+            if attr && rule.delegate.nil? &&
+                rule.to.to_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+              :"__lutaml_raw_#{rule.to}"
+            end,
           )
         end
         entry = Struct.new(:version, :records).new(version, records)
@@ -1630,6 +1646,24 @@ effective_register = lutaml_register)
       # (the visit ended at the omission gate or was a guarded next)
       # writes nothing; :write_nil replays the nil the default value
       # map produces, plus the flag churn. Returns true when handled.
+      # lutaml-model#922: whether the attribute holds anything other
+      # than its initialized marker (uninitialized sentinel / lazy
+      # collection) — i.e. a custom writer populated it mid-parse.
+      def writer_populated?(record, instance)
+        return false unless record&.raw_reader
+
+        !raw_initialized?(record, instance)
+      end
+
+      # True when the attribute still holds the value the compiled init
+      # seeded (uninitialized sentinel / lazy collection) — i.e. nothing
+      # has written it since.
+      def raw_initialized?(record, instance)
+        raw = instance.public_send(record.raw_reader)
+        raw.equal?(::Lutaml::Model::UninitializedClass.instance) ||
+          raw.equal?(::Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+      end
+
       def replay_unmatched_rule(child_names_set, record, rule, instance,
                                 defaults_used, xml_mapping)
         return false unless child_names_set && record
@@ -1659,6 +1693,15 @@ effective_register = lutaml_register)
           return true
         end
 
+        # lutaml-model#922: a custom writer may have populated the
+        # attribute mid-parse without going through the tracker (the
+        # compiled setters are direct ivar writes), so the tracked
+        # flag above can lie. The raw state is the truth: still at its
+        # initialized marker (sentinel / lazy collection) means unset
+        # -- the visited path wrote the default there; anything else
+        # is a writer assignment this replay must not clobber.
+        return true unless raw_initialized?(record, instance)
+
         defaults_used << rule_to
         instance.public_send(record.replay_writer, nil)
         instance.value_set_for(rule_to)

data/spec/lutaml/model/late_attribute_declaration_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Attributes can be declared after the model has been instantiated
+# (forward references, post-hoc declarations). The interned writer
+# table built during the first instantiation must not outlive the
+# attribute set it was built from.
+RSpec.describe "attributes declared after first instantiation" do
+  it "initializes attributes added after an earlier instantiation" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+    end
+
+    klass.new(name: "first")
+
+    klass.attribute :size, :string
+    instance = klass.new(name: "second", size: "L")
+
+    expect(instance.name).to eq("second")
+    expect(instance.size).to eq("L")
+  end
+
+  it "keeps earlier instances unaffected" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+    end
+
+    first = klass.new(name: "first")
+    klass.attribute :size, :string
+
+    expect(first.name).to eq("first")
+    expect(first.respond_to?(:size)).to be(true)
+  end
+end

data/spec/lutaml/model/writer_assigned_attribute_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module WriterAssigned
+  class Plain < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+
+  class Defaulted < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string, default: -> { "" }
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+end
+
+# lutaml-model#922: a custom writer that assigns a *different* attribute
+# mid-parse (relaton's Relaton::Bib::ICS populates <text> from the Isoics
+# dataset inside code=) must survive the deserializer's unmatched-rule
+# handling: the default seeding in Initialization#instantiate and the
+# unmatched-rule replay must never overwrite a value a writer assigned.
+RSpec.describe "attributes assigned inside another attribute's writer" do
+  %i[Plain Defaulted].each do |klass_name|
+    describe "with #{klass_name.to_s.downcase} text attribute" do
+      let(:klass) { WriterAssigned.const_get(klass_name) }
+
+      it "keeps the derived value through from_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.text).to eq("derived-67.060")
+      end
+
+      it "renders the derived value on to_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.to_xml).to include("<text>derived-67.060</text>")
+      end
+    end
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -64,10 +64,12 @@ RSpec.describe "XML plan fast path" do
     expect(parsed).to be_a(node)
   end
 
-  # lutaml-model#744: attribute plan rows are local-name keyed — a
-  # type-namespaced attribute (xmi:type vs type) must take the
-  # interpretive matcher, or the namespaced value is silently lost.
-  it "opts models with type-namespaced attributes out to the interpretive path" do
+  # lutaml-model#744/#758: a local name claimed by BOTH a
+  # type-namespaced attribute row and a plain row stays interpretive —
+  # the walk's ns form :none matches any qualification, so the plain
+  # row would capture the qualified spelling too. The interpretive
+  # matcher dispatches the spellings correctly.
+  it "opts shared-local-name attribute claims out to the interpretive path" do
     xmi_ns = Class.new(Lutaml::Xml::Namespace) do
       uri "http://www.omg.org/spec/XMI/20131001"
       prefix_default "xmi"

data/spec/lutaml/xml/plan_ns_less_document_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: namespace-less models on namespaced documents" do
+  # lutaml-model#932: elements (unlike attributes) inherit the default
+  # xmlns, so the walk's strict no-URI default dropped every child of a
+  # namespaced document for models that declare no namespace. The
+  # ns_lenient flag restores the interpretive matcher's behavior:
+  # children match by local name under any document qualification.
+
+  let(:child_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :fileref, :string
+
+      xml do
+        element "imagedata"
+        map_attribute "fileref", to: :fileref
+      end
+    end
+    stub_const("NsLessDoc::Imagedata", klass)
+    klass
+  end
+
+  def define_parent
+    child_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :imagedata, NsLessDoc::Imagedata
+      attribute :content, :string, collection: true
+
+      xml do
+        element "imageobject"
+        map_element "imagedata", to: :imagedata
+        map_content to: :content
+      end
+    end
+    
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  it "binds nested children under a default namespace" do
+    parent = define_parent
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          '<imagedata fileref="x.png"/></imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children under a prefixed namespace" do
+    parent = define_parent
+    doc = '<db:imageobject xmlns:db="http://docbook.org/ns/docbook">' \
+          '<db:imagedata fileref="x.png"/></db:imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "keeps binding on namespace-less documents" do
+    parent = define_parent
+    doc = %(<imageobject><imagedata fileref="x.png"/></imageobject>)
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children of mixed-content models under a default namespace" do
+    parent = define_parent
+    parent.xml do
+      element "imageobject"
+      mixed_content
+      map_content to: :content
+      map_element "imagedata", to: :imagedata
+    end
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          'text<imagedata fileref="x.png"/>tail</imageobject>' 
+
+    parsed = parent.from_xml(doc)
+    expect(parsed.imagedata.fileref).to eq("x.png")
+    expect(parsed.content).to include("text")
+  end
+end

data/spec/lutaml/xml/plan_type_ns_attribute_spec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: type-namespaced attribute rows" do
+  # Attribute identity is (URI, local) (lutaml-model#744). A map_attribute
+  # whose TYPE carries a namespace class used to opt the whole model out
+  # of the plan path; it now compiles into an exact-URI AttrPlan ns row
+  # (libleptris 1.9.289) with the sole-claimant lenient recovery keeping
+  # the interpretive exact-first-then-any-qualification precedence.
+
+  let(:wml_ns) do
+    Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/type-ns/wml"
+      prefix_default "w"
+    end
+  end
+
+  let(:val_type) do
+    stub_const("PlanTypeNsAttr::WmlNs", wml_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace PlanTypeNsAttr::WmlNs
+      end
+    end
+    stub_const("PlanTypeNsAttr::ValType", type)
+    type
+  end
+
+  let(:klass) do
+    val_type
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, PlanTypeNsAttr::ValType
+
+      xml do
+        element "keepNext"
+        namespace PlanTypeNsAttr::WmlNs
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanTypeNsAttr::KeepNext", model)
+    model
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  it "compiles a model whose attribute type carries a namespace" do
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      klass, Lutaml::Model::Config.default_register
+    )
+
+    expect(plan).not_to be_nil
+    ns_row = plan[:tree][:attributes].find { |a| a[:name] == "val" }
+    expect(ns_row[:ns]).to eq(exact: "http://example.com/type-ns/wml")
+  end
+
+  it "binds the attribute from the type's namespace" do
+    doc = %(<w:keepNext xmlns:w="http://example.com/type-ns/wml" w:val="yes"/>)
+
+    expect(klass.from_xml(doc).val).to eq("yes")
+  end
+
+  # The interpretive matcher refuses an ambiguous local name outright:
+  # a foreign spelling alongside the canonical one binds nothing. The
+  # exact-URI row mirrors that refusal (lutaml-model#744).
+  it "refuses to bind when a foreign spelling accompanies the canonical one" do
+    doc = '<w:keepNext xmlns:w="http://example.com/type-ns/wml" ' \
+          'xmlns:f="http://example.com/foreign" val="foreign" w:val="canonical"/>'
+
+    expect(klass.from_xml(doc).val).to be_nil
+  end
+
+  # Interpretive parity: the plan path resolves exactly as the
+  # interpretive matcher (nokogiri) does on every spelling shape.
+  it "matches the interpretive path's resolution on all spelling shapes" do
+    canonical = %(<w:keepNext xmlns:w="http://example.com/type-ns/wml" w:val="yes"/>)
+    ambiguous = '<w:keepNext xmlns:w="http://example.com/type-ns/wml" ' \
+                'xmlns:f="http://example.com/foreign" val="foreign" w:val="canonical"/>'
+    foreign_only = '<w:keepNext xmlns:f="http://example.com/foreign" ' \
+                   'xmlns:w="http://example.com/type-ns/wml" val="foreign"/>'
+
+    [canonical, ambiguous, foreign_only].each do |doc|
+      interpretive = Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+        klass.from_xml(doc).val
+      end
+
+      expect(klass.from_xml(doc).val).to eq(interpretive)
+    end
+  end
+
+  # A type declaring alias URI families stays interpretive: the plan row
+  # holds one exact URI and non-sole-claimant alias families have no
+  # plan-side resolution order.
+  it "keeps alias-declaring types on the interpretive path" do
+    aliased_ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/type-ns/canonical"
+      uri_aliases "http://example.com/type-ns/alias"
+    end
+    stub_const("PlanTypeNsAttr::AliasedNs", aliased_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace PlanTypeNsAttr::AliasedNs
+      end
+    end
+    stub_const("PlanTypeNsAttr::AliasedValType", type)
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, PlanTypeNsAttr::AliasedValType
+
+      xml do
+        element "keepNext"
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanTypeNsAttr::AliasedKeepNext", model)
+
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
+             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/person_spec.rb

@@ -115,12 +115,13 @@ RSpec.describe Person do
     expect(model.to_yaml).to eq(attributes_yaml.to_yaml)
   end
 
-  # yeptris misparses time-only scalars ("07:00:00" anchors to a fixed
-  # date at midnight) — pending the engine fix, this example cannot
-  # pass under the in-suite-detected engine.
-  # rubocop:disable RSpec/PendingWithoutReason -- yeptris misparses time-only
-  # scalars (fixed-date midnight anchor); engine fix pending upstream.
-  xit "deserializes from YAML" do
+  # yeptris 0.6.29.x regressed the time-only scalar anchor: "07:00:00"
+  # comes back as a fixed 2025-07-19 00:00 instead of today-07:00
+  # (psych answers exactly; verified on the psych path). Re-pended
+  # until the yeptris typed-materialize ships the fix — evidence on
+  # moxml#336. 873a67bd un-pended these on the premise that the
+  # 0.6.28.x behavior held; it did not survive the 0.6.29 cut.
+  xit "deserializes from YAML" do # rubocop:disable RSpec/PendingWithoutReason -- yeptris time-only misparse; engine fix pending.
     yaml = attributes_yaml.to_yaml
     person = described_class.from_yaml(yaml)
     expect(person.first_name).to eq("John")
@@ -133,7 +134,7 @@ RSpec.describe Person do
   end
 
   # Same yeptris time-only scalar misparse as above.
-  xit "deserializes from YAML array" do
+  xit "deserializes from YAML array" do # rubocop:disable RSpec/PendingWithoutReason -- yeptris time-only misparse; engine fix pending.
     yaml = [attributes_yaml.dup, attributes_yaml.dup].to_yaml
 
     persons = described_class.from_yaml(yaml)
@@ -154,5 +155,4 @@ RSpec.describe Person do
     expect(persons[1].wakeup_time).to eq(Time.parse("07:00:00"))
     expect(persons[1].active).to be true
   end
-  # rubocop:enable RSpec/PendingWithoutReason
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.93
+  version: 0.8.95
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-04 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -184,6 +184,7 @@ files:
 - bench/bench_alloc_audit.rb
 - bench/bench_common.rb
 - bench/bench_compare.rb
+- bench/bench_merge_attempts.rb
 - bench/bench_mml.rb
 - bench/bench_niso.rb
 - bench/bench_sts.rb
@@ -1759,6 +1760,7 @@ files:
 - spec/lutaml/model/jsonl_spec.rb
 - spec/lutaml/model/key_value_data_model/key_value_element_spec.rb
 - spec/lutaml/model/key_value_mapping_spec.rb
+- spec/lutaml/model/late_attribute_declaration_spec.rb
 - spec/lutaml/model/lazy_collection_spec.rb
 - spec/lutaml/model/liquefiable_lazy_spec.rb
 - spec/lutaml/model/liquefiable_spec.rb
@@ -1872,6 +1874,7 @@ files:
 - spec/lutaml/model/value_policy_spec.rb
 - spec/lutaml/model/value_transformation_comprehensive_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
 - spec/lutaml/model/xsd_form_default_patterns_spec.rb
 - spec/lutaml/model/xsd_patterns_spec.rb
@@ -1983,7 +1986,9 @@ files:
 - spec/lutaml/xml/pipeline_integration_spec.rb
 - spec/lutaml/xml/plain_model_accessors_spec.rb
 - spec/lutaml/xml/plan_fast_path_spec.rb
+- spec/lutaml/xml/plan_ns_less_document_spec.rb
 - spec/lutaml/xml/plan_partition_spec.rb
+- spec/lutaml/xml/plan_type_ns_attribute_spec.rb
 - spec/lutaml/xml/plan_walk_spec.rb
 - spec/lutaml/xml/prefix_control_spec.rb
 - spec/lutaml/xml/register_spec.rb