lutaml-model 0.8.52 → 0.8.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92e0193fa58094112522b5a7717aed2f568d77096eb0ae3bc1a246be28c05bf0
-  data.tar.gz: 20dcd124c22c695cc0a8fca65d04422ac84f468515ef153d909e5a6dcf5eac67
+  metadata.gz: ffb19b7e87ec763167dc806fb0fd0b37a1ca292e7627333ba1238f06c3e5f17e
+  data.tar.gz: 340c6f96fb82f0d972ca654f548db51bdef12155bc94ae95e3eaf6eacf96af29
 SHA512:
-  metadata.gz: 0cc3e71dceb6ae87db00453efbd905de28dc10d528cd38426b29c2c0da1a67d64d41a59095e45a9da1daa97888a4d001c8211b0ad64a3a011ef46949e71206a6
-  data.tar.gz: c444800a986c0e34bc1502fd671f53d7ff4776377d89b62225b857c923f4b97058042094145caf0d0a54db37576bedd546a733e114a444118ff2e13241092d83
+  metadata.gz: d79e2b5b7fce4f6ba3115cdb190365b8a1fc1212922f00cabf2e9855fa85c2350808c0844f78c55015de4e8c8cf480cbdf5390e8afaa0a401f01ad6e2a1d93a3
+  data.tar.gz: c6a29c349be599ddfcbcb53087c17178de7de17aa1afa46fb5e2fc6eb2b3c4b0c0189b68a26aa77d0e2d561966c4001c0bd04abacf2d6e987d8846185b6add29

data/.github/workflows/release.yml

@@ -13,9 +13,11 @@ on:
   repository_dispatch:
     types: [ do-release ]
 
+# Least-privilege ceiling for the called rubygems-release.yml: its release job
+# needs contents:write (git tag push) and id-token:write (OIDC Trusted Publishing).
+# packages:write is not required for RubyGems Trusted Publishing.
 permissions:
   contents: write
-  packages: write
   id-token: write
 
 jobs:
@@ -24,5 +26,10 @@ jobs:
     with:
       next_version: ${{ github.event.inputs.next_version }}
     secrets:
-      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
+      # OMIT rubygems-api-key: metanorma/ci switches to OIDC Trusted Publishing
+      # when the secret is empty (USE_OIDC = rubygems-api-key == ''). Trusted
+      # Publishing is already configured for lutaml gems on rubygems.org —
+      # do not re-introduce LUTAML_CI_RUBYGEMS_API_KEY here.
+      # pat_token is optional (private-gem checkout + GH Packages). Keep if
+      # the org still uses private deps; drop once pure public.
       pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/docs/_guides/advanced-mapping.adoc

@@ -613,6 +613,14 @@ as `collection: true` when the element repeats. A rule without
 `when_attribute` that shares the name only claims occurrences no
 discriminator rule claimed, so every occurrence is captured exactly once.
 
+On the key-value formats the same coexistence applies to
+`when_attribute` rules sharing one key, regardless of declaration order.
+A rule *without* `when_attribute` is an unconditional claim on the bare
+slot: declaring one replaces prior bare rules on that key — including a
+parent class's rule the subclass remaps to a different attribute — while
+`when_attribute` partitions on the key survive. A partition rule replaces
+only a prior partition with the same target; otherwise it accumulates.
+
 By default an occurrence no rule claims — an uncovered discriminator
 value, or a missing discriminator attribute — is silently dropped.
 Declare `unmatched: :raise` on a discriminator rule to fail the parse

data/lib/lutaml/key_value/mapping.rb

@@ -148,17 +148,40 @@ module Lutaml
           serialize: serialize,
         )
         # lutaml-model#88: rules may share a wire key (when_attribute
-        # partitions) — store per-key arrays, like the XML mapping. A
-        # rule redefining the same target (`to:`) replaces its
-        # predecessor, so subclass and redeclaration overrides keep the
-        # pre-array replace semantics.
+        # partitions) — store per-key arrays, like the XML mapping.
+        # Replacement policy, MECE by rule kind:
+        #   * a bare rule (no when_attribute) replaces prior BARE rules
+        #     on the same wire key — subclass remaps of a key to a
+        #     different attribute (e.g. base `ref → Ref`, subclass
+        #     `ref → text`) must not leave both rules active — while
+        #     when_attribute partitions on the key survive regardless
+        #     of declaration order;
+        #   * a when_attribute rule replaces only a prior partition
+        #     with the same target (`to:`), otherwise it accumulates.
         existing = @mappings[mapping_name]
         if existing.nil?
           @mappings[mapping_name] = [rule]
-        elsif (index = existing.index { |r| r.to == rule.to })
-          existing[index] = rule
+        elsif rule.when_attribute.empty?
+          # Bare claim: prior bare rules on the key are superseded;
+          # partitions survive regardless of declaration order.
+          @mappings[mapping_name] =
+            existing.reject { |r| r.when_attribute.empty? } + [rule]
         else
-          existing << rule
+          index = kv_partition_replace_index(existing, rule)
+          if index
+            existing[index] = rule
+          else
+            existing << rule
+          end
+        end
+      end
+
+      # Index of the prior partition a when_attribute rule replaces
+      # (same target), or nil. Extracted: a block in an elsif condition
+      # mis-binds (the known do/end trap).
+      def kv_partition_replace_index(existing, rule)
+        existing.index do |r|
+          r.to == rule.to && !r.when_attribute.empty?
         end
       end
 

data/lib/lutaml/model/attribute.rb

@@ -161,6 +161,18 @@ module Lutaml
         )
       end
 
+      # Resolution that never materializes deferred model classes:
+      # raises UnknownTypeError for a not-yet-loaded class name.
+      # Mapping-time validation uses this so finalizing one mapping
+      # cannot fire an autoload that re-enters another model file
+      # mid-definition.
+      def loaded_type(context_or_register = nil)
+        return if unresolved_type.nil?
+
+        context = normalize_context(context_or_register)
+        resolver.resolve(unresolved_type, context, materialize: false)
+      end
+
       def type(context_or_register = nil)
         return if unresolved_type.nil?
 

data/lib/lutaml/model/cached_type_resolver.rb

@@ -62,7 +62,9 @@ module Lutaml
       # @param context [TypeContext] The resolution context
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
-      def resolve(name, context)
+      def resolve(name, context, materialize: true)
+        return @delegate.resolve(name, context, materialize: false) unless materialize
+
         cache_key = if name.is_a?(Class)
                       [context.id, name]
                     else

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

@@ -204,6 +204,7 @@ module Lutaml
 
           # Clear memoized attribute merge (see .attributes)
           @merged_attributes_cache = nil
+          @instantiate_writers = nil
 
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
@@ -368,22 +369,23 @@ module Lutaml
         def instantiate(attrs = {}, register = nil)
           instance = allocate_for_deserialization(register)
           register_id = instance.lutaml_register
-          given = {}
-          attrs.each do |key, value|
-            name = key.to_sym
-            next if name == :lutaml_register
-
-            unless attributes(register_id).key?(name)
-              raise Error, "unknown attribute '#{name}' for #{self}"
-            end
-
-            given[name] = value
-          end
-          attributes(register_id).each do |name, attr|
+          attrs_by = attributes(register_id)
+          writers = instantiate_writers(register_id)
+          given = 0
+          attrs_by.each do |name, attr|
             next if attr.derived?
 
-            if given.key?(name)
-              instance.public_send(:"#{name}=", given[name])
+            # Symbol keys hit directly (native-extension callers);
+            # string keys fall back with one allocated name.
+            key = if attrs.key?(name)
+                    given += 1
+                    name
+                  elsif (str_name = name.to_s) && attrs.key?(str_name)
+                    given += 1
+                    str_name
+                  end
+            if key
+              instance.public_send(writers[name], attrs[key])
             else
               # Absent keys seed their default explicitly, mirroring
               # initialize_attributes: every mapped attribute ends up
@@ -396,13 +398,29 @@ module Lutaml
                       else
                         attr.cast_value(default, register_id)
                       end
-              instance.public_send(:"#{name}=", value)
+              instance.public_send(writers[name], value)
               instance.using_default_for(name)
             end
           end
+          reserved = (attrs.key?(:lutaml_register) ? 1 : 0) +
+            (attrs.key?("lutaml_register") ? 1 : 0)
+          if given + reserved < attrs.size
+            known = attrs_by.keys
+            unknown = attrs.keys.find { |k| !known.include?(k.to_sym) }
+            raise Error, "unknown attribute '#{unknown}' for #{self}"
+          end
           instance
         end
 
+        # Writer method symbols for instantiate, memoized per register
+        # alongside the attribute merge (cleared with it).
+        def instantiate_writers(register_id = nil)
+          (@instantiate_writers ||= {})[register_id] ||= attributes(register_id)
+            .each_with_object({}) do |(name, _attr), memo|
+              memo[name] = :"#{name}="
+            end
+        end
+
         # Define register-specific attribute methods on the class itself.
         #
         # Called once per (class, register) combination. Replaces per-instance

data/lib/lutaml/model/type_resolver.rb

@@ -51,7 +51,11 @@ module Lutaml
       # @example
       #   TypeResolver.resolve(:string, context)  #=> Lutaml::Model::Type::String
       #   TypeResolver.resolve(MyClass, context)  #=> MyClass (pass-through)
-      def self.resolve(name, context)
+      # materialize: false resolves only what the registries know
+      # without const_get — definition-time validation must not fire
+      # autoloads (a pending autoload re-enters the model file being
+      # defined and re-evaluates its mapping on the populated state).
+      def self.resolve(name, context, materialize: true)
         # Apply substitutions even if already a class
         # This is important for type substitution (e.g., Glaze -> RegisterGlaze)
         if name.is_a?(Class)
@@ -79,8 +83,9 @@ module Lutaml
         return apply_substitutions(type, context) if type
 
         # 4. Try Type.const_get for CamelCase type names (e.g., "Decimal" -> Type::Decimal)
-        # This maintains backward compatibility with old Register behavior
-        if name.is_a?(String)
+        # This maintains backward compatibility with old Register behavior.
+        # Skipped for non-materializing resolution: const_get fires autoloads.
+        if materialize && name.is_a?(String)
           begin
             type = Lutaml::Model::Type.const_get(name)
             return apply_substitutions(type, context) if type

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.52"
+    VERSION = "0.8.54"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -1112,7 +1112,7 @@ module Lutaml
           next unless target
 
           begin
-            resolved = target.type(Lutaml::Model::Config.default_register)
+            resolved = target.loaded_type(Lutaml::Model::Config.default_register)
           rescue Lutaml::Model::UnknownTypeError
             next
           end

data/lib/lutaml/xml/model_transform.rb

@@ -731,18 +731,29 @@ _effective_register)
         # each_value scan below is dead whenever the index exists.
         return nil if root_index && !candidates
 
-        matched_attr = if candidates
-                         candidates.find do |attr|
-                           local_name_match?(attr, local_name, rule_uri,
-                                             flexible_local)
-                         end
-                       else
-                         doc.root.attributes.each_value.find do |attr|
-                           local_name_match?(attr, local_name, rule_uri,
-                                             flexible_local)
-                         end
-                       end
-        matched_attr&.value
+        matched = if candidates
+                    candidates.select do |attr|
+                      local_name_match?(attr, local_name, rule_uri,
+                                        flexible_local)
+                    end
+                  else
+                    doc.root.attributes.each_value.select do |attr|
+                      local_name_match?(attr, local_name, rule_uri,
+                                        flexible_local)
+                    end
+                  end
+        # Attribute identity is (namespace URI, local name) — #841. The
+        # lenient probe is a recovery mechanism for the single
+        # undeclared-prefix case; several distinct matches are an
+        # ambiguity the document order must not arbitrate.
+        if matched.size > 1
+          identities = matched.map(&:namespaced_name).join(", ")
+          warn "[Lutaml::Model] ambiguous attribute for rule " \
+               "#{rule_name.inspect}: #{identities} all match by local " \
+               "name on <#{doc.root.unprefixed_name}>; no value bound"
+          return nil
+        end
+        matched.first&.value
       end
 
       # Namespace discipline of the lenient local-name fallback

data/lib/lutaml/xml/plan_compiler.rb

@@ -110,6 +110,11 @@ module Lutaml
 
             if rule.attribute?
               return nil 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 nil if attr.type_namespace_class(register)
 
               attr_rows << [rule, attr]
               plan_attrs << { name: rule.name.to_s }

data/lib/lutaml/xml/xml_element.rb

@@ -385,11 +385,24 @@ module Lutaml
         ensure_attribute_index
 
         if attribute_name.is_a?(Array)
+          # Alias list: at most one spelling variant may be present.
+          # Several simultaneous matches are an authoring ambiguity —
+          # attribute identity is (namespace URI, local name) — #841 —
+          # and array order must not arbitrate.
+          found = nil
           attribute_name.each do |name|
             val = @attribute_index[name]
-            return val unless val.nil?
+            next if val.nil?
+
+            if found
+              warn "[Lutaml::Model] ambiguous attribute aliases " \
+                   "#{found[0].inspect} and #{name.inspect} both present " \
+                   "on <#{unprefixed_name}>; no value bound"
+              return nil
+            end
+            found = [name, val]
           end
-          nil
+          found&.last
         else
           @attribute_index[attribute_name]
         end

data/spec/fixtures/autoload_probe/never_loaded_model.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DeferHost
+  class NeverLoadedModel < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "never"
+      map_element "value", to: :value
+    end
+  end
+end

data/spec/lutaml/key_value/subclass_remap_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A subclass that remaps a parent wire key onto a different attribute
+# must replace the parent's rule, not accumulate beside it. Pre-#88
+# (hash-keyed by wire name) this was automatic; the #88 array form
+# only replaced on matching `to:`, leaving both rules active and
+# breaking consumers like glossarist's V2::Citation (base maps
+# `ref → Ref`, V2 remaps `ref → text`).
+RSpec.describe "Key-value subclass wire-key remap" do
+  it "replaces the parent rule when the subclass remaps the same key to a different attribute" do
+    base = Class.new(Lutaml::Model::Serializable) do
+      attribute :ref, :string
+      attribute :label, :string
+
+      key_value do
+        map :ref, to: :ref
+      end
+    end
+
+    child = Class.new(base) do
+      key_value do
+        map :ref, to: :label
+      end
+    end
+
+    ref_spellings = [:ref, "ref"].freeze
+    rules = child.mappings_for(:yaml).mappings.select do |r|
+      ref_spellings.include?(r.name)
+    end
+    # Only the child's rule must remain
+    expect(rules.map(&:to)).to eq([:label])
+  end
+
+  it "still accumulates when_attribute partitions of the same wire key" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :a, :string
+      attribute :b, :string
+
+      key_value do
+        map :body, to: :a, when_attribute: { "type" => "a" }
+        map :body, to: :b, when_attribute: { "type" => "b" }
+      end
+    end
+
+    body_spellings = [:body, "body"].freeze
+    expected_targets = %i[a b].freeze
+    rules = klass.mappings_for(:yaml).mappings.select do |r|
+      body_spellings.include?(r.name)
+    end
+    expect(rules.map(&:to)).to match_array(expected_targets)
+  end
+end

data/spec/lutaml/model/deferred_type_no_materialize_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Definition-time attribute-type validation (lutaml-model#296) must
+# resolve types WITHOUT materializing deferred model classes. Eager
+# resolution const_get-fires pending autoloads, which re-enters the
+# model file being defined, re-opens its classes, and re-evaluates an
+# xml mapping block against the already-populated mapping — rejected
+# for map_all_content ("map_all is not allowed ... with map_all").
+RSpec.describe "Definition-time type validation" do
+  # The probe REQUIRES const mechanics (Object.const_set + autoload):
+  # stub_const would define a plain constant and defeat the test.
+  it "leaves a pending autoload unfired while validating a mapping" do
+    probe = Module.new
+    Object.const_set(:DeferHostProbe, probe)
+    probe.autoload(:NeverLoadedModel,
+                   File.expand_path("../../fixtures/autoload_probe/never_loaded_model", __dir__))
+
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :ref, "DeferHostProbe::NeverLoadedModel"
+
+        xml do
+          element "doc"
+          map_element "ref", to: :ref
+        end
+      end
+    end.not_to raise_error
+
+    registered = probe.autoload?(:NeverLoadedModel)
+    expect(registered).to be_truthy,
+      "mapping validation materialized the deferred type — it must " \
+      "stay pending for deferred-import resolution"
+  ensure
+    # rubocop:disable-next RSpec/RemoveConst -- unloading the autoload probe
+    Object.send(:remove_const, :DeferHostProbe) if Object.const_defined?(:DeferHostProbe)
+  end
+end

data/spec/lutaml/xml/attribute_ambiguity_surface_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Attribute identity is (namespace URI, local name) — lutaml-model#841.
+# Where matching previously resolved silently by order (document order
+# in the lenient recovery, array order in alias lists), several
+# distinct matches are an ambiguity: no value binds and the collision
+# is surfaced on stderr.
+module AttributeAmbiguitySurfaceSpec
+  # Lenient recovery: sole-claimant rule spelled URI:local while the
+  # document's prefixes stay undeclared (#754 recovery case).
+  class LenientProbe < Lutaml::Model::Serializable
+    attribute :ext, :string
+
+    xml do
+      element "probe"
+      map_attribute "urn:example:v:ext", to: :ext
+    end
+  end
+
+  # Alias list: spelling variants of one name — at most one may occur.
+  class AliasProbe < Lutaml::Model::Serializable
+    attribute :status, :string
+
+    xml do
+      element "probe"
+      map_attribute %w[status product-status], to: :status
+    end
+  end
+end
+
+RSpec.describe "Ambiguous attribute matches surface instead of resolving by order" do
+  describe "lenient local-name recovery" do
+    it "recovers the single undeclared-prefix attribute" do
+      probe = AttributeAmbiguitySurfaceSpec::LenientProbe.from_xml(
+        %(<probe v:ext="1"/>),
+      )
+      expect(probe.ext).to eq("1")
+    end
+
+    it "binds no value when several same-local attributes match" do
+      expect do
+        probe = AttributeAmbiguitySurfaceSpec::LenientProbe.from_xml(
+          %(<probe v:ext="1" w:ext="2"/>),
+        )
+        expect(probe.ext).to be_nil
+      end.to output(/ambiguous attribute/i).to_stderr
+    end
+
+    it "prefers the exact qualified match when the prefix IS declared" do
+      probe = AttributeAmbiguitySurfaceSpec::LenientProbe.from_xml(
+        %(<probe xmlns:v="urn:example:v" v:ext="1" w:ext="2"/>),
+      )
+      expect(probe.ext).to eq("1")
+    end
+  end
+
+  describe "alias lists" do
+    it "reads the single present alias" do
+      probe = AttributeAmbiguitySurfaceSpec::AliasProbe.from_xml(
+        %(<probe product-status="draft"/>),
+      )
+      expect(probe.status).to eq("draft")
+
+      probe = AttributeAmbiguitySurfaceSpec::AliasProbe.from_xml(
+        %(<probe status="open"/>),
+      )
+      expect(probe.status).to eq("open")
+    end
+
+    it "binds no value when two aliases are simultaneously present" do
+      expect do
+        probe = AttributeAmbiguitySurfaceSpec::AliasProbe.from_xml(
+          %(<probe status="open" product-status="draft"/>),
+        )
+        expect(probe.status).to be_nil
+      end.to output(/ambiguous attribute aliases/i).to_stderr
+    end
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -64,6 +64,39 @@ 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
+    xmi_ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://www.omg.org/spec/XMI/20131001"
+      prefix_default "xmi"
+    end
+    xmi_type = Class.new(Lutaml::Model::Type::String) do
+      xml { namespace xmi_ns }
+    end
+    parameter = Class.new(Lutaml::Model::Serializable) do
+      attribute :xmi_type, xmi_type
+      attribute :classifier_type, :string
+
+      xml do
+        element "ownedParameter"
+        map_attribute "type", to: :xmi_type
+        map_attribute "type", to: :classifier_type
+      end
+    end
+    stub_const("PlanFastPath::NamespacedParam", parameter)
+
+    parsed = parameter.from_xml(
+      '<ownedParameter xmlns:xmi="http://www.omg.org/spec/XMI/20131001" ' \
+      'xmi:type="uml:Parameter" type="EAnone_void"/>',
+    )
+
+    expect(parsed.xmi_type).to eq("uml:Parameter")
+    expect(parsed.classifier_type).to eq("EAnone_void")
+    expect(Lutaml::Xml::PlanCompiler.compile(parameter, :default)).to be_nil
+  end
+
   it "is on by default and can be disabled" do
     expect(Lutaml::Model::Configuration.new.xml_plan_fast_path).to be(true)
 

data/spec/lutaml/xml/xml_element_guard_spec.rb

@@ -40,11 +40,19 @@ RSpec.describe "XmlElement performance guard specs" do
         expect(element.find_attribute_value("missing")).to be_nil
       end
 
-      it "finds first match from array of names" do
-        result = element.find_attribute_value(["missing1", "class", "id"])
+      it "finds the single present name from array of names" do
+        result = element.find_attribute_value(["missing1", "class", "missing2"])
         expect(result).to eq("foo")
       end
 
+      it "binds no value when two names in the array are both present" do
+        # Attribute identity is (namespace URI, local name) — #841;
+        # array order must not arbitrate an ambiguity.
+        expect do
+          expect(element.find_attribute_value(["class", "id"])).to be_nil
+        end.to output(/ambiguous attribute aliases/i).to_stderr
+      end
+
       it "returns nil when no name in array matches" do
         expect(element.find_attribute_value(["missing1", "missing2"])).to be_nil
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.52
+  version: 0.8.54
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-21 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -977,6 +977,7 @@ files:
 - spec/benchmarks/xml_parsing_benchmark_spec.rb
 - spec/ceramic_spec.rb
 - spec/fixtures/address.rb
+- spec/fixtures/autoload_probe/never_loaded_model.rb
 - spec/fixtures/ceramic.rb
 - spec/fixtures/geolexica_v2_concept.rb
 - spec/fixtures/geolexica_v2_sample.yaml
@@ -1685,6 +1686,7 @@ files:
 - spec/lutaml/jsonld/adapter_spec.rb
 - spec/lutaml/key_value/adapter/toml/teptris_adapter_spec.rb
 - spec/lutaml/key_value/group_instantiate_spec.rb
+- spec/lutaml/key_value/subclass_remap_spec.rb
 - spec/lutaml/key_value/transformation/collection_serializer_spec.rb
 - spec/lutaml/key_value/transformation/rule_compiler_spec.rb
 - spec/lutaml/key_value/transformation/value_serializer_spec.rb
@@ -1729,6 +1731,7 @@ files:
 - spec/lutaml/model/custom_vobject_adapter_spec.rb
 - spec/lutaml/model/default_register_spec.rb
 - spec/lutaml/model/defaults_spec.rb
+- spec/lutaml/model/deferred_type_no_materialize_spec.rb
 - spec/lutaml/model/delegation_spec.rb
 - spec/lutaml/model/derived_attribute_serialization_spec.rb
 - spec/lutaml/model/dynamic_attribute_spec.rb
@@ -1899,6 +1902,7 @@ files:
 - spec/lutaml/xml/adapter/ox_adapter_spec.rb
 - spec/lutaml/xml/adapter/rexml_adapter_spec.rb
 - spec/lutaml/xml/adapter/xml_namespace_spec.rb
+- spec/lutaml/xml/attribute_ambiguity_surface_spec.rb
 - spec/lutaml/xml/attribute_element_namespace_disjoint_spec.rb
 - spec/lutaml/xml/attribute_namespace_disjointness_spec.rb
 - spec/lutaml/xml/builder/builder_spec.rb