lutaml-model 0.8.56 → 0.8.106

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

@@ -95,17 +95,28 @@ module Lutaml
             options.key?(:mappings) || options.key?(:adapter) ||
             options.key?(:_adapter_override) ||
             options.key?(:indent) || options.key?(:xml_declaration) ||
-            options.key?(:declaration) || options.key?(:doctype)
+            options.key?(:declaration) || options.key?(:doctype) ||
+            # prefix requests ride the interpretive writer's use_prefix
+            # option (planner Tier-1) — the plan emission has no
+            # option-aware spelling. The instance-level option prep
+            # rewrites :prefix to :use_prefix before this gate.
+            options.key?(:prefix) || options.key?(:use_prefix)
 
           adapter_name = Lutaml::Model::Config.adapter_for(:xml)
           adapter_name &&= adapter_name.name
           return nil unless adapter_name.to_s.end_with?("LeptrisAdapter")
 
           register = Lutaml::Model::Config.default_register
-          plan = Lutaml::Xml::PlanCompiler.compile(self, register)
-          return nil unless plan && Lutaml::Xml::PlanSerializer.serializable?(plan)
-
-          Lutaml::Xml::PlanSerializer.call(instance, plan)
+          plan = Lutaml::Xml::Leptris::PlanCompiler.compile(self, register)
+          return nil unless plan &&
+            Lutaml::Xml::Leptris::PlanSerializer.serializable?(plan)
+
+          # Namespaced plans ride the plan serializer too: the DOM
+          # emission spells prefixed names and hoists declarations
+          # (the #847 xmlns drop is fixed in PlanSerializer); any
+          # unspellable shape answers nil there and falls back
+          # interpretively.
+          Lutaml::Xml::Leptris::PlanSerializer.call(instance, plan)
         end
 
         # Whole-document native materialization (Phase 5): compile the
@@ -125,16 +136,20 @@ module Lutaml
           return nil unless adapter_name.to_s.end_with?("LeptrisAdapter")
 
           register = Lutaml::Model::Config.default_register
-          plan = Lutaml::Xml::PlanCompiler.compile(self, register)
+          plan = Lutaml::Xml::Leptris::PlanCompiler.compile(self, register)
           return nil unless plan
 
           root = ::Leptris::XML.parse(data.to_s).root
           return nil if root.nil?
           return nil unless root.name == plan[:tree][:name]
 
-          Lutaml::Xml::PlanHydrator.call(self, plan,
+          Lutaml::Xml::Leptris::PlanHydrator.call(self, plan,
                                          plan[:descriptor].walk(root),
-                                         node: root)
+                                         node: root,
+                                         declaration_plan_mode:
+                                           options.fetch(
+                                             :import_declaration_plan, :eager
+                                           ))
         rescue ::Leptris::XML::ParseError => e
           raise Lutaml::Model::InvalidFormatError.new(:xml, e.message)
         end
@@ -149,48 +164,41 @@ module Lutaml
         #
         # @return [Array<Class>] List of error classes
         def format_error_types
-          @format_error_types_base ||= begin
-            errors = [
-              Lutaml::Model::RuntimeCompatibility.safe_constantize("Psych::SyntaxError"),
-              Lutaml::Model::RuntimeCompatibility.safe_constantize("JSON::ParserError"),
-              NoMethodError,
-              TypeError,
-              ArgumentError,
-            ]
-
-            # Collect format-specific error types from FormatRegistry
-            compatibility = Lutaml::Model::RuntimeCompatibility
-            FormatRegistry.all.each_value do |info|
-              next unless info[:error_types]
-
-              info[:error_types].each do |error_class|
-                cls = if error_class.is_a?(String)
-                        compatibility.safe_constantize(error_class)
-                      else
-                        error_class
-                      end
-                errors << cls
-              end
+          # Resolved per call, not memoized: adapter engines load lazily,
+          # and a cache built before an engine loads permanently drops
+          # that engine's parse errors from the rescue list (an
+          # REXML::ParseException leaked un-wrapped when any earlier
+          # parse ran before rexml was required). The constantize pass
+          # is a handful of lookups — negligible against a parse.
+          compatibility = Lutaml::Model::RuntimeCompatibility
+          errors = [
+            compatibility.safe_constantize("Psych::SyntaxError"),
+            compatibility.safe_constantize("JSON::ParserError"),
+            NoMethodError,
+            TypeError,
+            ArgumentError,
+          ]
+
+          FormatRegistry.all.each_value do |info|
+            next unless info[:error_types]
+
+            info[:error_types].each do |error_class|
+              errors << if error_class.is_a?(String)
+                          compatibility.safe_constantize(error_class)
+                        else
+                          error_class
+                        end
             end
-
-            errors.compact.freeze
           end
 
           # Legacy TOML error types are lazy, so check them on each call.
-          compatibility = Lutaml::Model::RuntimeCompatibility
-          toml_errors = compatibility.safe_constantize("TomlRB::ParseError")
-          toml_errors = Array(toml_errors)
+          toml_errors = Array(compatibility.safe_constantize("TomlRB::ParseError"))
           tomllib_err = compatibility.safe_constantize("Tomlib::ParseError")
           toml_errors << tomllib_err if tomllib_err
           teptris_err = compatibility.safe_constantize("Teptris::ParseError")
           toml_errors << teptris_err if teptris_err
 
-          @format_error_types_base + toml_errors
-        end
-
-        # Reset cached error types (for test isolation)
-        def reset_format_error_types_cache!
-          @format_error_types_base = nil
+          (errors + toml_errors).compact
         end
 
         # Create a model instance from a parsed document

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

@@ -172,12 +172,30 @@ module Lutaml
         #
         # @param register [Symbol, nil] The register context
         def ensure_imports!(register = nil)
-          ensure_model_imports!(register)
-          ensure_choice_imports!(register)
-          ensure_restrict_attributes!(register)
-          # Hook for format-specific mapping import resolution.
-          # XML overrides this to call mappings[:xml]&.ensure_mappings_imported!(register)
-          ensure_format_mapping_imports!(register)
+          # Bounded re-entry for the resolution chain. Each leg's
+          # record_import_attempt tail calls attributes(), which calls
+          # back into ensure_imports!; nested passes converge imports
+          # whose targets only become resolvable after an earlier leg
+          # (so they must not be dropped), but with a permanently
+          # pending import the tail re-entered unboundedly and crashed
+          # with SystemStackError (#938). Two levels allow one nested
+          # convergence pass; deeper re-entry is suppressed per
+          # register and the counter unwinds on error.
+          register_id = extract_register_id(register)
+          (@ensure_imports_depth ||= {})[register_id] ||= 0
+          return if @ensure_imports_depth[register_id] >= 2
+
+          @ensure_imports_depth[register_id] += 1
+          begin
+            ensure_model_imports!(register)
+            ensure_choice_imports!(register)
+            ensure_restrict_attributes!(register)
+            # Hook for format-specific mapping import resolution.
+            # XML overrides this to call mappings[:xml]&.ensure_mappings_imported!(register)
+            ensure_format_mapping_imports!(register)
+          ensure
+            @ensure_imports_depth[register_id] -= 1
+          end
         end
 
         # Hook for format-specific mapping import resolution.
@@ -345,8 +363,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?(register_id)
+          instance = allocate
           instance.finalize_deserialization(register_id)
           instance
         end
@@ -392,6 +422,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
@@ -409,6 +455,7 @@ module Lutaml
             unknown = attrs.keys.find { |k| !known.include?(k.to_sym) }
             raise Error, "unknown attribute '#{unknown}' for #{self}"
           end
+          instance.clear_mutated_after_parse!
           instance
         end
 

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,43 @@ 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).
+        # The attribute-set fingerprint at the moment an import
+        # resolution attempt ran — deferred_imports_pending? compares
+        # against it to skip re-resolution on stable sets.
+        def record_import_attempt(register_id)
+          # Raw stores only — the lazy attributes() re-enters
+          # ensure_imports! and, when @models_imported was just set to
+          # false (unresolved imports), cycles through this very
+          # method forever (the uniword register_in SystemStackError).
+          register_attrs = (@register_records ||= {})[register_id]
+          (@import_attempt_fingerprints ||= {})[register_id] =
+            @attributes.size + @choice_attributes.to_a.size +
+            (register_attrs ? register_attrs[:attributes].to_a.size : 0)
+        end
+
+        def deferred_imports_pending?(register_id = nil)
+          register_id ||= Lutaml::Model::Config.default_register
+          has_importables = importable_models.any? { |_m, models| models.any? } ||
+            importable_choices.any? do |_c, imports|
+              imports.any? { |_m, models| models.any? }
+            end || restrict_attributes.any?
+          return false unless has_importables
+
+          # Unresolvable imports stay pending forever; re-running the
+          # ensure chain (and its state-defaults invalidation) on every
+          # allocation thrashed import-heavy models quadratically.
+          # Resolution re-arms only when the attribute set CHANGED
+          # since the last attempt — a late declaration after a failed
+          # resolution re-attempts; a stable set skips.
+          attempted = (@import_attempt_fingerprints ||= {})[register_id]
+          return true if attempted.nil?
+
+          current = attributes(register_id).size + @choice_attributes.to_a.size
+          current != attempted
+        end
+
         def ensure_model_imports!(register_id = nil)
           register_id ||= Lutaml::Model::Config.default_register
           @models_imported = {} if @models_imported.nil? || @models_imported == false
@@ -184,6 +228,7 @@ module Lutaml
           end
 
           @models_imported[register_id] = all_resolved
+          record_import_attempt(register_id)
         end
 
         # Ensure all choice imports are resolved for a specific register
@@ -197,6 +242,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 +262,20 @@ 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
+          record_import_attempt(register_id)
+          # 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
@@ -243,6 +298,11 @@ module Lutaml
         # Uses TracePoint to detect when a class definition is complete,
         # allowing deferred import resolution.
         def setup_trace_point
+          # Opal has no TracePoint. Symbol imports still resolve lazily
+          # on first use (ensure_imports!), so there the class is marked
+          # finalized at once instead of at the end of its body.
+          return @finalized = true if Lutaml::Model.opal?
+
           @trace ||= TracePoint.new(:end) do |_tp|
             if include?(Lutaml::Model::Serialize)
               @finalized = true

data/lib/lutaml/model/serialize.rb

@@ -197,8 +197,11 @@ module Lutaml
       end
 
       def attr_value(attrs, name, attribute)
-        value = Utils.fetch_str_or_sym(attrs, name,
-                                       attribute.default(lutaml_register, self))
+        # The default is computed only on absence: it used to be
+        # evaluated eagerly as the fetch fallback on EVERY value,
+        # paying proc/static default dispatch per present attribute.
+        value = Utils.fetch_str_or_sym(attrs, name, Utils::MISSING)
+        value = attribute.default(lutaml_register, self) if value.equal?(Utils::MISSING)
         attribute.cast_value(value, lutaml_register)
       end
 
@@ -368,15 +371,20 @@ module Lutaml
           value = self.class.apply_value_map(value, vmap, attr)
           # Performance: Only call ensure_utf8 for string values
           value = self.class.ensure_utf8(value) if value.is_a?(::String)
-          public_send(:"#{name}=", value)
+          # Interpolating the writer symbol allocated a String per
+          # attribute per instance; the per-register writer table is
+          # interned once per class.
+          public_send(self.class.instantiate_writers(lutaml_register)[name], value)
           using_default_for(name) if default
         end
       end
 
       def determine_value(attrs, name, attr)
-        if attrs.key?(name) || attrs.key?(name.to_s)
-          return attr_value(attrs, name, attr)
-        end
+        # One hash pass: a sentinel fetch distinguishes absent keys
+        # from present-nil values, replacing two key probes plus the
+        # re-fetch inside attr_value (four hash ops per attribute).
+        value = Utils.fetch_str_or_sym(attrs, name, Utils::MISSING)
+        return attr.cast_value(value, lutaml_register) unless value.equal?(Utils::MISSING)
 
         resolved = attr.default_value(lutaml_register, self)
         return Lutaml::Model::UninitializedClass.instance if Lutaml::Model::Utils.uninitialized?(resolved)

data/lib/lutaml/model/type/time.rb

@@ -13,6 +13,12 @@ module Lutaml
           case value
           when ::Time then value
           when ::DateTime then value.to_time
+          when ::Integer
+            # YAML 1.1 sexagesimal: psych resolves an unquoted hh:mm:ss
+            # scalar to seconds since midnight (25200 for "07:00:00").
+            # Feeding that integer through Time.parse yields a garbage
+            # date — reconstruct the wall-clock time of the current day.
+            ::Date.today.to_time + value
           else ::Time.parse(value.to_s)
           end
         rescue ArgumentError

data/lib/lutaml/model/type/value.rb

@@ -67,12 +67,14 @@ from: nil)
           # @param type_class [Class] the type class to look up
           # @return [Hash, nil] { to: Proc, from: Proc } or nil
           def format_type_serializer_for(format, type_class)
-            # Hot path: memoize per [format, resolved class] — the hierarchy
-            # walk below only runs on a miss. Format serializers register at
-            # load time, so a hit is stable.
-            cache = SERIALIZER_LOOKUP_CACHE
-            key = [format, type_class]
-            return cache[key] if cache.key?(key)
+            # Hot path: memoized per format -> class with NO key
+            # allocation — the previous [format, class] array key
+            # allocated on every lookup (2k arrays per 200 serializes in
+            # the object-mode profile). Identity-keyed nested maps; the
+            # hierarchy walk below only runs on a miss, and format
+            # serializers register at load time, so a hit is stable.
+            per_format = (SERIALIZER_LOOKUP_CACHE[format] ||= {}.compare_by_identity)
+            return per_format[type_class] if per_format.key?(type_class)
 
             klass = type_class
             found = nil
@@ -85,7 +87,7 @@ from: nil)
 
               klass = klass.superclass
             end
-            cache[key] = found
+            per_format[type_class] = found
             found
           end
 

data/lib/lutaml/model/type_resolver.rb

@@ -44,7 +44,9 @@ module Lutaml
       # 5. Raise UnknownTypeError if not found anywhere
       #
       # @param name [Symbol, String, Class] The type name or class to resolve
-      # @param context [TypeContext] The resolution context
+      # @param context [TypeContext, nil] The resolution context (nil means
+      #   no primary registry and no fallbacks — an id registered in the
+      #   Register namespace but not as a type context)
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
       #
@@ -66,11 +68,11 @@ module Lutaml
         type_name = name.to_sym
 
         # 1. Check primary registry
-        type = context.lookup_local(type_name)
+        type = context&.lookup_local(type_name)
         return apply_substitutions(type, context) if type
 
         # 2. Check fallback contexts in order
-        if context.has_fallbacks?
+        if context&.has_fallbacks?
           context.fallback_contexts.each do |fallback_context|
             type = resolve_from_fallback(type_name, fallback_context)
             return apply_substitutions(type, context) if type
@@ -97,8 +99,8 @@ module Lutaml
         # 5. Type not found - raise error
         raise UnknownTypeError.new(
           type_name,
-          context_id: context.id,
-          available_types: available_type_names(context),
+          context_id: context&.id,
+          available_types: context ? available_type_names(context) : [],
         )
       end
 

data/lib/lutaml/model/utils.rb

@@ -3,6 +3,10 @@
 module Lutaml
   module Model
     module Utils
+      # Fetch sentinel distinguishing absent keys from present-nil
+      # values; shared by the deserialization fast paths.
+      MISSING = Object.new.freeze
+
       class << self
         UNINITIALIZED = Lutaml::Model::UninitializedClass.instance
 
@@ -175,19 +179,28 @@ module Lutaml
             if hash.key?(key)
               hash[key]
             else
-              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+              sym = key.to_sym
+              hash.key?(sym) ? hash[sym] : default
             end
           when Symbol
             if hash.key?(key)
               hash[key]
             else
-              (hash.key?(key.to_s) ? hash[key.to_s] : default)
+              # Symbol#name is the frozen string — no allocation per probe.
+              # This branch is the hot path of the serialization walk
+              # (Symbol attribute names against String-keyed hashes), and
+              # the double key.to_s here was a top string allocation site
+              # in large-document metanorma compiles.
+              str = key.name
+              hash.key?(str) ? hash[str] : default
             end
           else
-            if hash.key?(key.to_s)
-              hash[key.to_s]
+            str = key.to_s
+            if hash.key?(str)
+              hash[str]
             else
-              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+              sym = key.to_sym
+              hash.key?(sym) ? hash[sym] : default
             end
           end
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.56"
+    VERSION = "0.8.106"
   end
 end

data/lib/lutaml/model.rb

@@ -294,3 +294,10 @@ require "#{__dir__}/xml/format"
 # Builder must be prepended AFTER XML so its initialize runs first
 # (Builder -> XML InstanceMethods -> Serialize)
 Lutaml::Model::Serialize.prepend(Lutaml::Model::Serialize::Builder)
+
+# Opal does not propagate a module prepended into an already-included
+# module to classes that included it earlier (see lib/lutaml/xml/format.rb).
+# Serializable included Serialize at boot, so Builder goes onto it directly.
+if Lutaml::Model.opal?
+  Lutaml::Model::Serializable.prepend(Lutaml::Model::Serialize::Builder)
+end

data/lib/lutaml/xml/adapter/xml_parser.rb

@@ -22,7 +22,7 @@ module Lutaml
           parsed = parse_with_moxml(xml, parse_encoding)
           root_element = parsed.root
 
-          raise_empty_document_error if root_element.nil?
+          raise_empty_document_error(parsed.parse_errors) if root_element.nil?
 
           root = self::PARSED_ELEMENT_CLASS.new(root_element)
           doc_pis = extract_document_processing_instructions(parsed)
@@ -69,8 +69,11 @@ module Lutaml
           }
         end
 
-        def raise_empty_document_error
+        def raise_empty_document_error(parse_errors = nil)
           message = self::EMPTY_DOCUMENT_ERROR_MESSAGE
+          if parse_errors && !parse_errors.empty?
+            message += " (the XML engine reported: #{parse_errors.join('; ')})"
+          end
 
           case self::EMPTY_DOCUMENT_ERROR_TYPE
           when :parse_exception

data/lib/lutaml/xml/adapter_loader.rb

@@ -19,9 +19,12 @@ module Lutaml
                          File.join(File.dirname(__FILE__), "adapter", type)
                        end
         require adapter_path
-      rescue LoadError
+      rescue LoadError => e
+        # Chain the cause: a known adapter whose underlying engine gem is
+        # missing (e.g. no nokogiri in the Gemfile) must not present as a
+        # bare unknown-type error — the LoadError names the real gap.
         raise Lutaml::Model::UnknownAdapterTypeError.new("xml", type),
-              cause: nil
+              cause: e
       end
 
       # Load the Moxml adapter for XML

data/lib/lutaml/xml/format.rb

@@ -22,11 +22,9 @@ end
 module Lutaml
   module Xml
     autoload :HtmlEntities, "#{__dir__}/html_entities"
-    autoload :PlanCompiler, "#{__dir__}/plan_compiler"
-    autoload :PlanHydrator, "#{__dir__}/plan_hydrator"
-    autoload :PlanOrder, "#{__dir__}/plan_order"
-    autoload :PlanSerializer, "#{__dir__}/plan_serializer"
-    autoload :PlanWalk, "#{__dir__}/plan_walk"
+    # The leptris plan fast path lives under its own namespace; its
+    # autoloads and the leptris version gate live in lutaml/xml/leptris.
+    autoload :Leptris, "#{__dir__}/leptris"
     # Error module for XML-specific errors
     module Error
       autoload :XmlError, "#{__dir__}/error/xml_error"
@@ -202,7 +200,13 @@ Lutaml::Model::FormatRegistry.register(
                    else
                      {
                        available: %i[nokogiri ox oga rexml leptris],
-                       default: :nokogiri,
+                       # #908: the metadata default is the LAST resort —
+                       # explicit configuration and moxml runtime detection
+                       # answer first. When resolution falls this far, prefer
+                       # leptris, consistent with moxml's runtime preference
+                       # (leptris whenever present); bundles without it
+                       # resolve through auto-detection long before here.
+                       default: :leptris,
                      }
                    end,
 )
@@ -239,9 +243,11 @@ Lutaml::Model::Serialize.prepend(
 #
 # Anonymous model classes (Class.new { include Serialize }) extend
 # Serialize::ClassMethods rather than inheriting from Serializable, so the
-# ModelImportExt override (root?) must land on ClassMethods too. The other
-# two (FormatConversion, InstanceMethods) are already prepended unconditionally
-# above, so Opal's no-double-prepend rule means we don't repeat them here.
+# ModelImportExt override (root?) must land on ClassMethods too.
+#
+# On Opal (and TruffleRuby, below) the ClassMethods.prepend(FormatConversion)
+# above does not reach Serializable's singleton chain, which extended
+# ClassMethods before it ran, so it is prepended onto that singleton directly.
 #
 # TruffleRuby (34.0.1) has the same propagation gap, on both the include
 # side and the extend/singleton side — a module prepended into an
@@ -269,13 +275,9 @@ if Lutaml::Model.opal? || RUBY_ENGINE == "truffleruby"
     Lutaml::Xml::Serialization::ModelImportExt,
   )
 
-  # TruffleRuby only: Opal's no-double-prepend rule makes the unconditional
-  # ClassMethods.prepend(FormatConversion) above sufficient there.
-  if RUBY_ENGINE == "truffleruby"
-    Lutaml::Model::Serializable.singleton_class.prepend(
-      Lutaml::Xml::Serialization::FormatConversion,
-    )
-  end
+  Lutaml::Model::Serializable.singleton_class.prepend(
+    Lutaml::Xml::Serialization::FormatConversion,
+  )
 end
 
 # Register XML-specific attribute override warning names