lutaml-model 0.8.17 → 0.8.18

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

@@ -39,8 +39,10 @@ module Lutaml
 
           return self unless block
 
-          # Enable order tracking for mixed_content models
-          @__order_tracking__ = mixed_content?
+          # Enable order tracking for ordered and mixed_content models.
+          # `ordered?` is true for both `ordered` and `mixed_content`
+          # (mixed_content sets @ordered = true in addition to @mixed_content).
+          @__order_tracking__ = ordered?
 
           # Evaluate the block - use instance_eval for no-receiver style
           # The block's first parameter determines the style:
@@ -62,6 +64,17 @@ module Lutaml
           mapping&.mixed_content? || false
         end
 
+        # Check if this model has ordered or mixed_content enabled.
+        # Both set @ordered = true on the XML mapping; mixed_content
+        # additionally sets @mixed_content = true. Order tracking is
+        # needed for either mode so the builder can emit elements in
+        # setter-call order rather than declaration order.
+        # @return [Boolean]
+        def ordered?
+          mapping = self.class.mappings_for(:xml, lutaml_register)
+          mapping&.ordered? || false
+        end
+
         private
 
         # Intercept method calls to track order for mixed_content

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

@@ -71,71 +71,19 @@ module Lutaml
                                propagated.merge(register: instance.lutaml_register))
         end
 
-        # Apply a value map to transform a value
+        # Apply a value map to transform a value.
         #
-        # Handles nil, empty, and omitted values according to the value map.
+        # Delegates to Attribute#apply_value_map. See attribute.rb for the
+        # canonical implementation.
         #
         # @param value [Object] The value to transform
         # @param value_map [Hash] The value map configuration
         # @param attr [Attribute] The attribute definition
         # @return [Object] The transformed value
         def apply_value_map(value, value_map, attr)
-          if value.nil?
-            value_for_option(value_map[:nil], attr)
-          elsif Utils.empty?(value)
-            # Check for new boolean value_map format (from: { empty: true/false })
-            # Only use new format if the value is explicitly boolean (TrueClass or FalseClass)
-            if value_map[:from] && (value_map[:from][:empty].is_a?(TrueClass) || value_map[:from][:empty].is_a?(FalseClass))
-              return value_map[:from][:empty]
-            end
-            # Check for direct boolean format (rule.value_map(:from) returns { empty: true })
-            # Only return directly if it's a boolean value (TrueClass/FalseClass), not a symbol
-            if value_map[:empty].is_a?(TrueClass) || value_map[:empty].is_a?(FalseClass)
-              return value_map[:empty]
-            end
-
-            # Fall back to legacy value_map format
-            value_for_option(value_map[:empty], attr, value)
-          elsif Utils.uninitialized?(value)
-            # Check for new boolean value_map format (from: { omitted: true/false })
-            # Only use new format if the value is explicitly boolean (TrueClass or FalseClass)
-            if value_map[:from] && (value_map[:from][:omitted].is_a?(TrueClass) || value_map[:from][:omitted].is_a?(FalseClass))
-              return value_map[:from][:omitted]
-            end
-            # Check for direct boolean format (rule.value_map(:from) returns { omitted: false })
-            # Only return directly if it's a boolean value (TrueClass/FalseClass), not a symbol
-            if value_map[:omitted].is_a?(TrueClass) || value_map[:omitted].is_a?(FalseClass)
-              return value_map[:omitted]
-            end
+          return value unless attr
 
-            # Fall back to legacy value_map format
-            value_for_option(value_map[:omitted], attr)
-          else
-            value
-          end
-        end
-
-        # Get the value for a specific option in a value map
-        #
-        # @param option [Symbol] The option (:nil, :empty, etc.)
-        # @param attr [Attribute] The attribute definition
-        # @param empty_value [Object] The empty value to use (optional)
-        # @return [Object, nil, UninitializedClass] The appropriate value
-        def value_for_option(option, attr, empty_value = nil)
-          return nil if option == :nil
-          return empty_value || empty_object(attr) if option == :empty
-
-          Lutaml::Model::UninitializedClass.instance
-        end
-
-        # Get an empty object for an attribute
-        #
-        # @param attr [Attribute] The attribute definition
-        # @return [String, Array] Empty string or collection
-        def empty_object(attr)
-          return attr.build_collection if attr.collection?
-
-          ""
+          attr.apply_value_map(value, value_map)
         end
 
         # Ensure a value is UTF-8 encoded
@@ -145,6 +93,10 @@ module Lutaml
         def ensure_utf8(value)
           case value
           when String
+            # Opal strings are JS strings with no per-string encoding;
+            # String#encode there doesn't accept MRI's keyword options.
+            return value if Lutaml::Model.opal?
+
             value.encode("UTF-8", invalid: :replace, undef: :replace,
                                   replace: "")
           when Array

data/lib/lutaml/model/serialize.rb

@@ -202,9 +202,7 @@ module Lutaml
       def validate_attribute!(attr_name)
         attr = self.class.attributes[attr_name]
         value = instance_variable_get(:"@#{attr_name}")
-        resolver = Services::DefaultValueResolver.new(attr, lutaml_register,
-                                                      self)
-        attr.validate_value!(value, lutaml_register, resolver)
+        attr.validate_value!(value, lutaml_register, instance_object: self)
       end
 
       def key_exist?(hash, key)
@@ -301,12 +299,11 @@ module Lutaml
           return attr_value(attrs, name, attr)
         end
 
-        if attr.default_set?(lutaml_register, self)
-          using_default_for(name)
-          attr.default(lutaml_register, self)
-        else
-          Lutaml::Model::UninitializedClass.instance
-        end
+        resolved = attr.default_value(lutaml_register, self)
+        return Lutaml::Model::UninitializedClass.instance if Lutaml::Model::Utils.uninitialized?(resolved)
+
+        using_default_for(name)
+        attr.cast_value(resolved, lutaml_register)
       end
 
       def resolve_reference_key(ref)

data/lib/lutaml/model/services/rule_value_extractor.rb

@@ -50,9 +50,8 @@ instance_object)
         return fetch_value(name) if Utils.string_or_symbol_key?(doc, name)
 
         if attr
-          resolver = Services::DefaultValueResolver.new(attr, register,
-                                                        instance_object)
-          return resolver.default_value if resolver.default_set?
+          resolved = attr.default_value(register, instance_object)
+          return resolved unless Utils.uninitialized?(resolved)
         end
 
         uninitialized_value

data/lib/lutaml/model/services.rb

@@ -4,8 +4,6 @@ module Lutaml
   module Model
     module Services
       autoload :Base, "#{__dir__}/services/base"
-      autoload :DefaultValueResolver,
-               "#{__dir__}/services/default_value_resolver"
       autoload :Type, "#{__dir__}/services/type"
     end
   end

data/lib/lutaml/model/store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "weakref"
+# Opal has no `weakref` stdlib; runtime_compatibility.rb provides a stub.
+require "weakref" unless Lutaml::Model.opal?
 
 module Lutaml
   module Model

data/lib/lutaml/model/toml.rb

@@ -16,7 +16,7 @@ module Lutaml
       Transform = ::Lutaml::Toml::Adapter::Transform
 
       def self.detect_toml_adapter
-        return nil if Lutaml::Model::RuntimeCompatibility.opal?
+        return nil if Lutaml::Model.opal?
 
         # Skip tomlib on Windows entirely due to segfault issues
         if Lutaml::Model::RuntimeCompatibility.windows?

data/lib/lutaml/model/transform.rb

@@ -85,48 +85,26 @@ module Lutaml
       protected
 
       def apply_value_map(value, value_map, attr)
-        if value.nil?
-          value_for_option(value_map[:nil], attr)
-        elsif Utils.empty?(value)
-          # Check for boolean value_map format (value_map[:empty] is true/false)
-          # Only apply for Boolean type attributes
-          if value_map[:empty].is_a?(TrueClass) || value_map[:empty].is_a?(FalseClass)
-            # Check if attribute is a Boolean type
-            attr_type = attr&.type || attr&.unresolved_type
-            if attr_type == Lutaml::Model::Type::Boolean
-              return value_map[:empty]
-            end
-          end
-          value_for_option(value_map[:empty], attr, value)
-        elsif Utils.uninitialized?(value)
-          # Check for boolean value_map format (value_map[:omitted] is true/false)
-          # Only apply for Boolean type attributes
-          if value_map[:omitted].is_a?(TrueClass) || value_map[:omitted].is_a?(FalseClass)
-            # Check if attribute is a Boolean type
-            attr_type = attr&.type || attr&.unresolved_type
-            if attr_type == Lutaml::Model::Type::Boolean
-              return value_map[:omitted]
-            end
-          end
-          value_for_option(value_map[:omitted], attr)
-        else
-          value
+        return attr.apply_value_map(value, value_map) if attr
+
+        # Attribute-less dispatch for custom-method-only rules. Mirrors
+        # Attribute#apply_value_map for the options that need no attribute
+        # info: :nil -> nil and :omitted -> uninitialized. A typed :empty needs
+        # an Attribute (a crash case pre-consolidation), so the value passes
+        # through unchanged.
+        key = if value.nil? then :nil
+              elsif Utils.empty?(value) then :empty
+              elsif Utils.uninitialized?(value) then :omitted
+              end
+        return value unless key
+
+        case value_map[key]
+        when :nil then nil
+        when :empty then value
+        else Lutaml::Model::UninitializedClass.instance
         end
       end
 
-      def value_for_option(option, attr, empty_value = nil)
-        return nil if option == :nil
-        return empty_value || empty_object(attr) if option == :empty
-
-        Lutaml::Model::UninitializedClass.instance
-      end
-
-      def empty_object(attr)
-        return [] if attr.collection?
-
-        ""
-      end
-
       def mappings_for(format, register = nil)
         context.mappings_for(format, register)
       end

data/lib/lutaml/model/transformation_registry.rb

@@ -90,7 +90,7 @@ module Lutaml
 
       def initialize
         @transformations = {} # Cache for transformation instances (mutex-protected for cycle detection)
-        @mappings = if RuntimeCompatibility.opal?
+        @mappings = if Lutaml::Model.opal?
                       {}
                     else
                       Concurrent::Map.new

data/lib/lutaml/model/type.rb

@@ -16,6 +16,7 @@ module Lutaml
       autoload :Boolean, "#{__dir__}/type/boolean"
       autoload :Decimal, "#{__dir__}/type/decimal"
       autoload :Reference, "#{__dir__}/type/reference"
+      autoload :Union, "#{__dir__}/union"
       autoload :Hash, "#{__dir__}/type/hash"
       autoload :Symbol, "#{__dir__}/type/symbol"
       autoload :Duration, "#{__dir__}/type/duration"

data/lib/lutaml/model/union.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      # Functional xsd:union: an attribute value conforms to one of several
+      # declared member types. A single shared class recognized by identity
+      # (mirrors Type::Reference); the per-attribute member list lives in the
+      # attribute's @options[:union_member_types]. Stateless: serialization is
+      # driven by value.class, never by per-instance tracking.
+      #
+      # This class owns ALL union knowledge: the conformance engine, the
+      # definition-time validation, and the per-format mapped-field source.
+      # Every serializer touchpoint is a thin identity check that delegates here.
+      class Union < Value
+        # Options that cannot be combined with a union member list.
+        INCOMPATIBLE_OPTIONS = %i[polymorphic raw with child_mappings].freeze
+
+        # Native Ruby class a parsed/plain-Ruby value already has when it
+        # conforms to a scalar member without needing a lexical-space parse.
+        NATIVE_CLASSES = {
+          Lutaml::Model::Type::Integer => ::Integer,
+          Lutaml::Model::Type::Float => ::Float,
+          Lutaml::Model::Type::Boolean => [::TrueClass, ::FalseClass],
+          Lutaml::Model::Type::String => ::String,
+        }.freeze
+
+        # Native classes for value types whose dependency loads lazily
+        # (require "bigdecimal" / "date"). Looked up by constant name so the
+        # union never force-loads an optional dependency; if such a value
+        # exists at runtime, its constant is necessarily already defined.
+        # Decimal's native class (BigDecimal) loads lazily (require
+        # "bigdecimal"); looked up by constant name so the union never
+        # force-loads it. (Decimal is the only supported value type with a
+        # lazily-loaded native class.)
+        LAZY_NATIVE_CLASS_NAMES = {
+          Lutaml::Model::Type::Decimal => :BigDecimal,
+        }.freeze
+
+        INTEGER_LEXICAL = /\A\s*[+-]?\d+\s*\z/
+        # Matches Type::Boolean.cast (XSD true/false/1/0 plus the library's
+        # t/f/yes/no/y/n forms), so a union :boolean accepts the same inputs as
+        # a plain :boolean attribute.
+        BOOLEAN_LEXICAL = /\A(true|false|t|f|yes|no|y|n|1|0)\z/i
+
+        FLOAT_LEXICAL = lambda do |string|
+          Float(string).finite?
+        rescue ArgumentError, TypeError
+          false
+        end
+
+        # Whether a String input belongs to a scalar member's lexical space.
+        # Keyed by member class (identity), parallel to NATIVE_CLASSES.
+        LEXICAL_PREDICATES = {
+          Lutaml::Model::Type::Integer => ->(s) { s.match?(INTEGER_LEXICAL) },
+          Lutaml::Model::Type::Float => FLOAT_LEXICAL,
+          Lutaml::Model::Type::Decimal => FLOAT_LEXICAL,
+          Lutaml::Model::Type::Boolean => ->(s) { s.match?(BOOLEAN_LEXICAL) },
+          Lutaml::Model::Type::String => ->(_s) { true },
+        }.freeze
+
+        # Sound scalar union members are exactly the value types with a lexical
+        # predicate above: each maps to a distinct, stable Ruby runtime class
+        # (Integer, Float, BigDecimal, TrueClass/FalseClass, String), so the
+        # stateless value.class-driven serialization can always recover the
+        # member. Other value types are excluded because they cannot round-trip
+        # soundly in a union — e.g. Type::Date.cast can yield a DateTime, and
+        # Time / TimeWithoutDate share a Ruby Time class. Models are always OK.
+        SUPPORTED_VALUE_TYPES = LEXICAL_PREDICATES.keys.freeze
+
+        # Lossless numeric widening: a source value type may conform to a
+        # broader member. Narrowing (Float -> integer) and unrelated types are
+        # absent and therefore rejected. Exact-class matches are handled
+        # earlier by the instance_of? check in conform_scalar.
+        WIDENS_INTO = {
+          Integer => [Float, Decimal],
+          Float => [Decimal],
+        }.freeze
+
+        class << self
+          # Resolve the first member (in declared order) whose lexical/structural
+          # space the value belongs to, and the value cast to that member.
+          #
+          # @param value [Object] raw value (scalar, Hash sub-tree, or XmlElement)
+          # @param members [Array<Class>] resolved members, declared order
+          # @param format [Symbol, nil] serialization format being deserialized
+          # @param register [Symbol, nil] register for nested-model resolution
+          # @return [Array(Class, Object), nil] [member, casted] or nil (no match)
+          def conforming_member(value, members, format:, register:)
+            return nil if value.nil? || Utils.uninitialized?(value)
+
+            members.each do |member|
+              casted = if model_member?(member)
+                         conform_model(member, value, format, register)
+                       else
+                         conform_scalar(member, value)
+                       end
+              return [member, casted] unless casted == :no_match
+            end
+            nil
+          end
+
+          # Whether a compiled mapping rule's attribute is a union — the single
+          # identity check every serializer touchpoint shares.
+          def rule?(rule)
+            rule.attribute_type == self
+          end
+
+          # An XML child is routed to member resolution (vs the plain-text
+          # scalar path) when it has child elements or attributes. Resolution
+          # tries model members by key coverage, then falls back to the scalar
+          # members on the element's text — so a text-only element with an
+          # unrelated attribute (e.g. xml:lang) still resolves to a scalar.
+          def xml_structured?(element)
+            return false unless element.respond_to?(:children)
+
+            element.children.any?(&:element?) || element.attributes.any?
+          end
+
+          # Serialize a scalar union value through the value type matching its
+          # own class, so output is canonical/portable (a BigDecimal emits
+          # "1.5", not a raw Ruby object). value.class drives the type —
+          # stateless, identical to how a plain scalar attribute serializes.
+          # Falls back to the value as-is when it maps to no known value type.
+          def serialize_scalar(value, format)
+            type = scalar_type_for(value)
+            return value unless type
+
+            type.new(value).public_send(:"to_#{format}")
+          end
+
+          def validate_members!(members)
+            unless members.is_a?(::Array) && !members.empty?
+              raise ArgumentError, "union type must be a non-empty array of types"
+            end
+
+            resolved = members.map { |member| resolve_member!(member) }
+            validate_catch_all_position!(resolved)
+            resolved
+          end
+
+          def validate_combo!(options)
+            present = INCOMPATIBLE_OPTIONS.select { |key| options[key] }
+            return if present.empty?
+
+            raise ArgumentError,
+                  "union type cannot be combined with: #{present.join(', ')}"
+          end
+
+          private
+
+          def model_member?(member)
+            member.is_a?(::Class) && member.include?(Serialize)
+          end
+
+          # Structural (key-coverage) selection: every input key maps to one of
+          # the member's mapped fields, with no input key left unmapped. Once
+          # selected, field values cast leniently via the member's normal path.
+          # An existing member instance conforms as-is, keeping conformance
+          # idempotent — values can re-enter casting (e.g. a value transformer
+          # builds the member before the cast runs).
+          def conform_model(member, value, format, register)
+            return value if value.is_a?(member)
+
+            keys = input_keys(value, format)
+            return :no_match if keys.nil? || keys.empty?
+
+            field_names = member_field_names(member, format, register)
+            return :no_match unless keys.all? { |key| field_names.include?(key) }
+
+            # Plain-Ruby assignment (format nil) builds straight from the
+            # attribute hash, mirroring how non-union model attributes accept
+            # `Model.new(child: { ... })`; a format builds via the mappings.
+            return member.new(value) if format.nil?
+
+            member.apply_mappings(value, format, register: register)
+          end
+
+          # A scalar conforms if the value already is the member's native Ruby
+          # class (covers parsed and plain-Ruby values), or if a String input
+          # belongs to the member's space. Lenient built-ins (Integer/Float/
+          # Decimal/Boolean/String) are gated by an explicit lexical predicate
+          # so their forgiving casts can't false-match; every other value type
+          # owns its space via its own (strict) cast — nil/raise means no match.
+          def conform_scalar(member, value)
+            # Scalar payload: an XML element contributes its text (so a scalar
+            # member matches when no model member covers it); Hash and primitive
+            # inputs pass through unchanged.
+            value = value.text if xml_element?(value)
+
+            # Exact native class (instance_of?): the value is precisely the
+            # member's native Ruby class (covers parsed and plain-Ruby values).
+            native = Array(NATIVE_CLASSES[member] || lazy_native_class(member))
+            return value if native.any? { |klass| value.instance_of?(klass) }
+
+            predicate = LEXICAL_PREDICATES[member]
+            return :no_match unless predicate
+
+            # String input: accept only within the member's lexical space.
+            if value.is_a?(::String)
+              return predicate.call(value) ? member.cast(value) : :no_match
+            end
+
+            # Native non-string value (e.g. a parsed Integer for a :float
+            # member): accept only as a lossless widening into a broader member,
+            # so a lenient built-in can't narrow or distort it — :float accepts
+            # 42, but :integer won't swallow 3.7 or 3.0. lossless_cast then
+            # guards precision (e.g. 2**60+1 is not exactly representable as
+            # Float).
+            source = scalar_type_for(value)
+            return :no_match unless WIDENS_INTO[source]&.include?(member)
+
+            lossless_cast(member, value)
+          end
+
+          # A native non-string value conforms to a lenient built-in only if the
+          # member's cast preserves it (value-equal round-trip), so cross-numeric
+          # widening is accepted but narrowing/distortion is not.
+          def lossless_cast(member, value)
+            casted = member.cast(value)
+            casted == value ? casted : :no_match
+          rescue StandardError
+            :no_match
+          end
+
+          def lazy_native_class(member)
+            const_name = LAZY_NATIVE_CLASS_NAMES[member]
+            return nil unless const_name && Object.const_defined?(const_name)
+
+            Object.const_get(const_name)
+          end
+
+          # The value type whose native Ruby class the value is an instance of
+          # (reverse of NATIVE_CLASSES plus the lazily-loaded native classes).
+          def scalar_type_for(value)
+            NATIVE_CLASSES.each do |type, klasses|
+              return type if Array(klasses).any? { |k| value.instance_of?(k) }
+            end
+            LAZY_NATIVE_CLASS_NAMES.each_key do |type|
+              klass = lazy_native_class(type)
+              return type if klass && value.instance_of?(klass)
+            end
+            nil
+          end
+
+          # Input keys by format: Hash keys for key-value; child element local
+          # names + attribute names for XML; nil otherwise.
+          def input_keys(value, format)
+            return value.keys.map(&:to_s) if value.is_a?(::Hash)
+
+            if format == :xml && xml_element?(value)
+              names = value.children.select(&:element?).map(&:unprefixed_name) +
+                value.attributes.values.map(&:unprefixed_name)
+              return names.map(&:to_s)
+            end
+
+            nil
+          end
+
+          def xml_element?(value)
+            value.respond_to?(:children) && value.respond_to?(:attributes)
+          end
+
+          # The set of mapped field names for a member in the given format.
+          # One source, parameterized by format. A nil format is plain-Ruby
+          # assignment, which has no mapping context — match on attribute names.
+          def member_field_names(member, format, register)
+            return member.attributes.keys.map(&:to_s) if format.nil?
+
+            mapping = member.mappings_for(format, register)
+            rules = if format == :xml
+                      mapping.elements(register) + mapping.attributes(register)
+                    else
+                      mapping.mappings(register)
+                    end
+            rules.flat_map do |rule|
+              (rule.multiple_mappings? ? rule.name : [rule.name]).map(&:to_s)
+            end
+          end
+
+          def resolve_member!(member)
+            if member.is_a?(::Hash)
+              raise ArgumentError,
+                    "union members must be types or symbols; option hashes " \
+                    "(e.g. { ref: ... }) are not supported as union members"
+            end
+
+            klass =
+              begin
+                Lutaml::Model::Attribute.cast_type!(member)
+              rescue ArgumentError
+                nil
+              end
+            unless klass
+              raise ArgumentError, "invalid union member: #{member.inspect}"
+            end
+            return klass if klass.is_a?(::Class) && klass.include?(Serialize)
+            return klass if SUPPORTED_VALUE_TYPES.include?(klass)
+
+            raise ArgumentError,
+                  "unsupported union member type: #{member.inspect}. Supported " \
+                  "scalar members are :string, :integer, :float, :decimal, " \
+                  ":boolean, or a Serializable model"
+          end
+
+          # The catch-all must be the last member overall (not merely the last
+          # value type): XML scalar matching reads element.text, so a :string
+          # placed before a model member would swallow structured elements too.
+          def validate_catch_all_position!(resolved)
+            return unless resolved.include?(Lutaml::Model::Type::String)
+            return if resolved.last == Lutaml::Model::Type::String
+
+            raise ArgumentError,
+                  "a universal catch-all type must be the last union member"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/utils.rb

@@ -102,6 +102,12 @@ module Lutaml
           snake_case(base_class_name(klass))
         end
 
+        # Return the final segment of a `prefix:local` style qualified name,
+        # e.g. `"xs:string" -> "string"`. Returns nil for nil input.
+        def last_of_split(field)
+          field&.split(":")&.last
+        end
+
         def initialized?(value)
           !value.equal?(UNINITIALIZED)
         end

data/lib/lutaml/model/validation.rb

@@ -14,10 +14,7 @@ module Lutaml
               sub_errors = value.validate
               errors.concat(sub_errors) if sub_errors.is_a?(Array)
             else
-              resolver = Lutaml::Model::Services::DefaultValueResolver.new(
-                attr, register, self
-              )
-              attr.validate_value!(value, register, resolver)
+              attr.validate_value!(value, register, instance_object: self)
             end
           rescue Lutaml::Model::CollectionCountOutOfRangeError => e
             errors << e unless attr.choice

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.17"
+    VERSION = "0.8.18"
   end
 end

data/lib/lutaml/model.rb

@@ -142,6 +142,8 @@ module Lutaml
     autoload :UnknownTypeError, "#{__dir__}/model/error/unknown_type_error"
     autoload :RequiredAttributeMissingError,
              "#{__dir__}/model/error/required_attribute_missing_error"
+    autoload :UnionSchemaUnsupportedError,
+             "#{__dir__}/model/error/union_schema_unsupported_error"
     autoload :MultipleMappingsError,
              "#{__dir__}/model/error/multiple_mappings_error"
     autoload :CollectionTrueMissingError,
@@ -235,6 +237,22 @@ module Lutaml
     def self.reset_configuration!
       @configuration = nil
     end
+
+    # Convenience accessors for runtime/platform detection.
+    # Delegates to RuntimeCompatibility so call sites can write
+    # `Lutaml::Model.opal?` (or `Model.opal?` inside the namespace)
+    # instead of the long `Lutaml::Model::RuntimeCompatibility.opal?`.
+    def self.opal?
+      RuntimeCompatibility.opal?
+    end
+
+    def self.native?
+      RuntimeCompatibility.native?
+    end
+
+    def self.windows?
+      RuntimeCompatibility.windows?
+    end
   end
 end