lutaml-model 0.8.129 → 0.8.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6903f41ec929cb64ce2450b6979f832e0a832f8afbbe82a134af3db157d2fdd8
-  data.tar.gz: 3d2f61efc2e609ade7d440994d318c1b190255c243f33ec96538de2a4cda5774
+  metadata.gz: 411fee08073d8c3578b1071024486fa23ed6f1c3b93e918f7c47e175b9a95f90
+  data.tar.gz: 80e702fd74cda828374ffc7b5367311a2b49ce5ba2d5580e8038e13b6b9269ca
 SHA512:
-  metadata.gz: 7f82b33a1e8ac555aa6c756007da45a99dc3e506fd58c1f780446c112397314b3a76b0978566dc3c3279651e76701f0537b87dd1c700accaeb77f789497e20dc
-  data.tar.gz: 1100e41da62097636496a5fe31d1ac6a77f55ac491a8a3313eb96dfa4ceda55c52ba92166eda902f07bceae1ace17fd2224c2190c9b9792c5ca76ff4ce29293f
+  metadata.gz: d48928bc46206f2067989a4637ace150fcf71db4df6c18e1df93de5c621c088db0490bf85d860ec6861ad08d208218553a5d2ae7806ea4b5e88067b0032d51ed
+  data.tar.gz: 8d0127e8139146f8d1df26a488904d7e48202e4c5b75a49f67a895f87d372507f9217253590496c44513677653bd8516f009d59f7889a41832c2e12333987585

data/docs/key_value_data_model.adoc

@@ -697,21 +697,21 @@ end
 
 === Detection Logic
 
-All adapters follow this pattern:
+The transformation emits the output hash directly (hash-direct
+emission), and every adapter serializes the hash it is given:
 
 [source,ruby]
 ----
-def to_json(root, options = {})
-  if root.is_a?(Lutaml::KeyValue::DataModel::Element)
-    build_from_key_value_element(root)
-  elsif root.is_a?(Hash)
-    build_from_hash(root)  # Legacy path
-  else
-    raise TypeError, "Expected KeyValueElement or Hash, got #{root.class}"
-  end
+def to_json(hash, options = {})
+  JSON.generate(hash)
 end
 ----
 
+`Lutaml::KeyValue::DataModel::Element` remains the content model for
+rule compilation and for custom `to:` handlers (whose scratch document
+element merges its payload into the output hash), but the Element tree
+is no longer passed across the adapter boundary.
+
 === Building from KeyValueElement
 
 ==== JSON Example

data/lib/lutaml/json/adapter/multi_json_adapter.rb

@@ -22,13 +22,7 @@ module Lutaml
         def to_json(*args)
           require "multi_json"
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           # LutaML's own threading keys must not reach the backend; the
           # rest (e.g. :pretty) are meaningful to multi_json. The json

data/lib/lutaml/json/adapter/oj_adapter.rb

@@ -27,13 +27,7 @@ module Lutaml
         def to_json(*args)
           require "oj"
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           Oj.dump(attributes_to_serialize, *args)
         # rubocop:enable Style/ArgumentsForwarding

data/lib/lutaml/json/adapter/standard_adapter.rb

@@ -22,13 +22,7 @@ module Lutaml
 
         def to_json(*args)
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           unless GeneratorOptions.lutaml_options?(args.first)
             return JSON.generate(attributes_to_serialize, args.first)

data/lib/lutaml/key_value/adapter/json/multi_json_adapter.rb

@@ -26,13 +26,7 @@ module Lutaml
           def to_json(*args)
             require "multi_json"
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             # LutaML's own options must not reach the backend: the json
             # gem 3.x and Oj both raise on unknown generator options

data/lib/lutaml/key_value/adapter/json/oj_adapter.rb

@@ -31,13 +31,7 @@ module Lutaml
           def to_json(*args)
             require "oj"
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             Oj.dump(attributes_to_serialize, *args)
           # rubocop:enable Style/ArgumentsForwarding

data/lib/lutaml/key_value/adapter/json/standard_adapter.rb

@@ -25,13 +25,7 @@ module Lutaml
 
           def to_json(*args)
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             unless Lutaml::Json::GeneratorOptions.lutaml_options?(args.first)
               return JSON.generate(attributes_to_serialize, args.first)

data/lib/lutaml/key_value/adapter/toml/teptris_adapter.rb

@@ -25,13 +25,7 @@ module Lutaml
           def to_toml(*)
             require "teptris"
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             Teptris::TOML.dump(attributes_to_serialize)
           end

data/lib/lutaml/key_value/adapter/toml/toml_rb_adapter.rb

@@ -20,13 +20,7 @@ module Lutaml
           def to_toml(*)
             require "toml-rb"
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             TomlRB.dump(attributes_to_serialize)
           rescue LoadError

data/lib/lutaml/key_value/adapter/toml/tomlib_adapter.rb

@@ -25,13 +25,7 @@ module Lutaml
           def to_toml(*)
             require "tomlib"
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             Tomlib.dump(attributes_to_serialize)
             # Tomlib::Generator.new(to_h).toml_str

data/lib/lutaml/key_value/adapter/yaml/standard_adapter.rb

@@ -24,13 +24,7 @@ module Lutaml
 
           def to_yaml(options = {})
             # Handle KeyValueElement input (new symmetric architecture)
-            attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                        # Unwrap __root__ wrapper to get actual content
-                                        @attributes.to_hash["__root__"]
-                                      else
-                                        # Legacy Hash input (backward compatibility)
-                                        @attributes
-                                      end
+            attributes_to_serialize = @attributes
 
             YAML.dump(attributes_to_serialize, options)
           end

data/lib/lutaml/key_value/data_model/element.rb

@@ -85,6 +85,21 @@ module Lutaml
           has_value? && !has_children?
         end
 
+        # The content this element carries, independent of its own key:
+        # the child-merged structure when children exist, otherwise the
+        # direct value (nil when neither). This is the half of to_hash
+        # that survives the {key => ...} envelope, so callers that
+        # assemble documents themselves never round-trip through a key.
+        #
+        # @return [Object, nil]
+        def payload
+          if has_children?
+            children_to_value
+          elsif has_value?
+            @value
+          end
+        end
+
         # Convert to Hash representation
         #
         # This is the primary method for adapter rendering.
@@ -93,19 +108,10 @@ module Lutaml
         # 2. If has children that are all Elements: {key => merged_hash}
         # 3. If has children that are mixed/primitives: {key => array}
         # 4. If has both value and children: children take precedence
-        # 5. Special case: __root__ with no children returns empty hash (for omitted attributes)
         #
         # @return [Hash]
         def to_hash
-          if has_children?
-            { @key => children_to_value }
-          elsif has_value?
-            { @key => @value }
-          else
-            # Special case: __root__ element should return empty hash when all attributes omitted
-            # This allows hash["__root__"].keys to work without raising NoMethodError
-            { @key => (@key == "__root__" ? {} : nil) }
-          end
+          { @key => payload }
         end
 
         # String representation for debugging
@@ -123,43 +129,36 @@ module Lutaml
 
         # Hash-like access for backward compatibility
         #
-        # Allows Element to be used like a hash in tests and existing code.
-        # Converts to hash first, then accesses the key.
+        # A child element's payload answers by the child's key; a leaf
+        # answers by its own key ({"name" => "John"}["name"]). This is
+        # what lets custom `to:` handlers build nested structures in
+        # place: `doc["locality"] = {}; doc["locality"]["type"] = v` —
+        # the read returns the child's value hash and the write mutates
+        # it in place.
         #
         # @param key [String, Symbol] Key to access
         # @return [Object] Value for the key
         def [](key)
-          hash = to_hash
-          # If this is the root element, access the inner hash
-          if @key == "__root__" && hash.key?("__root__")
-            inner = hash["__root__"]
-            inner.is_a?(Hash) ? inner[key.to_s] : nil
-          else
-            hash[key.to_s]
-          end
+          key = key.to_s
+          child = @children.find { |c| c.is_a?(Element) && c.key == key }
+          child ? child.payload : to_hash[key]
         end
 
         # Hash-like assignment for backward compatibility
         #
         # Allows Element to be used like a hash in tests and existing code.
-        # Creates a new child Element for the key-value pair.
+        # Replaces any existing child element of the same key, then adds
+        # a new child Element for the key-value pair.
         #
         # @param key [String, Symbol] Key to set
         # @param value [Object] Value to set
         # @return [Object] The assigned value
         def []=(key, value)
-          # For root element, add child with the key-value pair
-          if @key == "__root__"
-            # Remove existing child with same key if any
-            @children.reject! do |child|
-              child.is_a?(Element) && child.key == key.to_s
-            end
-            # Add new child
-          else
-            # For non-root elements, convert to hash and merge
-            # This shouldn't normally happen in the transformation flow
+          key = key.to_s
+          @children.reject! do |child|
+            child.is_a?(Element) && child.key == key
           end
-          @children << Element.new(key.to_s, value)
+          @children << Element.new(key, value)
           value
         end
 

data/lib/lutaml/key_value/mapping_rule.rb

@@ -57,9 +57,8 @@ module Lutaml
       end
 
       def hash_mappings
-        return @root_mappings if @root_mappings
-
-        @child_mappings
+        @hash_mappings = @root_mappings || @child_mappings if @hash_mappings.nil?
+        @hash_mappings
       end
 
       def deep_dup
@@ -81,7 +80,8 @@ module Lutaml
       end
 
       def root_mapping?
-        name == "root_mapping"
+        @root_mapping = name == "root_mapping" if @root_mapping.nil?
+        @root_mapping
       end
 
       # The writer symbol for this rule's target, interned once per

data/lib/lutaml/key_value/transform.rb

@@ -28,7 +28,9 @@ module Lutaml
         end
 
         if model_class.include?(Lutaml::Model::Serialize)
-          instance = model_class.new(lutaml_register: child_register)
+          # #1003: constructor-equivalent state via the compiled walk
+          # seed — no per-attribute determine_value walk per instance.
+          instance = model_class.allocate_for_walk(child_register)
         else
           instance = model_class.new
           register_accessor_methods_for(instance, child_register)
@@ -104,8 +106,7 @@ module Lutaml
           # transformation_for returns nil for cyclic dependencies or :building sentinel
           # Fall back to legacy approach in these cases
           if transformation.is_a?(Lutaml::KeyValue::Transformation)
-            # transform emits the output hash directly (TODO.perf 19) —
-            # the __root__ Element tree and its to_hash flatten are gone.
+            # transform emits the output hash directly (TODO.perf 19)
             return transformation.transform(instance, options)
           end
         end
@@ -430,7 +431,7 @@ child_hash, format, { mappings: type.child_rules })
             children << child
           end
         end
-        instance = model_class.new(lutaml_register: register)
+        instance = model_class.allocate_for_walk(register)
         setters.each { |name, value| instance.public_send(name, value) }
         absent&.each do |rule|
           process_mapping_rule(doc, instance, format, rule, options, nil)
@@ -477,7 +478,7 @@ options)
           to_method = rule.custom_methods[:to]
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `to_*`.
-          if instance.method(to_method).parameters.size >= 3
+          if Lutaml::Model::MappingRule.custom_method_arity(instance.class, to_method).to_i >= 3
             return instance.public_send(to_method, instance, hash,
                                         options[:context])
           end

data/lib/lutaml/key_value/transformation.rb

@@ -221,9 +221,8 @@ register = self.register)
       def transform(model_instance, options = {})
         # For key-value formats, we typically don't have a named root
         # Instead, we create an anonymous root that holds all attributes
-        # Hash-direct emission (TODO.perf 19): the __root__ Element
-        # tree was write-only in production — every consumer flattened
-        # it straight back to a hash. The output hash is built directly.
+        # Hash-direct emission (TODO.perf 19): the output hash is built
+        # directly; the intermediate Element tree and its flatten are gone.
         root = {}
 
         # Apply each compiled rule (with filtering support). A
@@ -343,9 +342,10 @@ register = self.register)
         if rule.has_custom_methods? && rule.custom_methods[:to]
           to_method = rule.custom_methods[:to]
           # Custom methods receive an Element "doc" and populate it
-          # (public contract, TODO.perf 19 keeps it): a scratch element
-          # is merged into the output hash afterwards.
-          doc = Lutaml::KeyValue::DataModel::Element.new("__root__")
+          # (public contract, TODO.perf 19 keeps it): only the doc's
+          # payload — the merged children or the direct value hash —
+          # is merged into the output.
+          doc = Lutaml::KeyValue::DataModel::Element.new(rule.serialized_name)
           # Custom methods may write children, or doc.value[key]=, or
           # nothing at all (pubid 2.0 regression: an empty scratch
           # flattened to {key => nil} and crashed the merge). Seed the
@@ -353,7 +353,7 @@ register = self.register)
           doc.value = {}
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `to_*`.
-          if model_instance.method(to_method).parameters.size >= 3
+          if Lutaml::Model::MappingRule.custom_method_arity(model_instance.class, to_method).to_i >= 3
             model_instance.public_send(to_method, model_instance,
                                        doc, options[:context])
           else
@@ -363,11 +363,11 @@ register = self.register)
           # its return value is ignored. (A mutation-style handler whose
           # last statement is an assignment returns the assigned inner
           # value; honoring it merged child content at the wrong level —
-          # lutaml-model#892.) Empty docs serialize as nothing, matching
-          # the pre-0.8.74 behavior.
-          merged = doc.to_hash
-          parent.update(merged["__root__"]) if merged.is_a?(::Hash) &&
-            merged["__root__"].is_a?(::Hash)
+          # lutaml-model#892.) A doc whose payload is not a hash — nil
+          # (untouched), a scalar, or an array of primitives — serializes
+          # as nothing, matching the pre-0.8.74 behavior.
+          merged = doc.payload
+          parent.update(merged) if merged.is_a?(::Hash)
           return
         end
 
@@ -539,8 +539,7 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                   value_root = value_transformation.transform(attr_value,
                                                               options)
 
-                  # transform emits the output hash directly now
-                  # (TODO.perf 19) — no __root__ wrapper to unwrap.
+                  # transform emits the output hash directly (TODO.perf 19)
                   parent[key_value.to_s] = value_root
                   next
                 end
@@ -1147,10 +1146,14 @@ child_mappings, options)
           parsed_content.each do |key, val|
             parent[key.to_s] = val
           end
-        elsif parsed_content.is_a?(::Array)
-          # Graceful handling of unusual map_all content (parity with
-          # the tree's __root__ wrapper)
-          parent["__root__"] = parsed_content
+        elsif !parsed_content.nil?
+          # A raw mapping's content must be a key-value document — it is
+          # merged into the parent by key. Any other shape (an Array, a
+          # scalar) has no representation here; serializing it under a
+          # synthetic key would leak that key into the document.
+          raise ArgumentError,
+                "raw mapping content must parse to a Hash, got " \
+                "#{parsed_content.class}"
         end
       end
 

data/lib/lutaml/model/attribute.rb

@@ -394,6 +394,18 @@ module Lutaml
         @options[:initialize_empty]
       end
 
+      # True when the default is the empty-collection lambda installed by
+      # set_default_for_collection: the one default whose constructor
+      # state (a plain empty Array) the LAZY_EMPTY_COLLECTION sentinel
+      # materializes to on first read, so walk-state seeding can use the
+      # sentinel instead of running the lambda per instance (#1010).
+      # Restricted to plain-Array collections because the lazy reader
+      # materializes []; custom Collection classes would lose their type.
+      def lazy_collection_default?
+        @implicit_collection_default == true && collection? &&
+          collection_class == ::Array && !enum?
+      end
+
       def validations
         @options[:validations]
       end
@@ -624,6 +636,13 @@ instance_object = nil)
           value.frozen?
       end
 
+      # Static classification of this attribute's default form (:none,
+      # :static, :proc, :delegate) — the constructor's determine_value
+      # and the compiled walk-seed share it.
+      def default_kind
+        @default_kind ||= _default_kind
+      end
+
       def default_value(register, instance_object = nil)
         # The kind is fixed at definition; the common case (no default
         # at all) paid three option checks per absent attribute per
@@ -1368,7 +1387,10 @@ instance_object = nil)
       def set_default_for_collection
         validate_collection_range
         attr = self
-        @options[:default] ||= -> { attr.build_collection } if initialize_empty?
+        if initialize_empty? && !@options[:default]
+          @options[:default] = -> { attr.build_collection }
+          @implicit_collection_default = true
+        end
       end
 
       def validate_options!(options)

data/lib/lutaml/model/collection.rb

@@ -384,11 +384,7 @@ module Lutaml
         private
 
         def unwrap_unwrapped_data(data)
-          # Convert KeyValueElement to Hash if needed
-          hash = data.is_a?(Hash) ? data : data.to_hash
-          # Handle "__root__" wrapper for key-value formats (created by transformation)
-          hash = hash["__root__"] if hash.key?("__root__")
-          result = Utils.fetch_str_or_sym(hash, instance_name)
+          result = Utils.fetch_str_or_sym(data, instance_name)
 
           # Extract values from nested hashes with empty string keys
           # (created by transformation for simple models with single attribute)

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -300,12 +300,31 @@ module Lutaml
         end
       end
 
+      # Arity of a custom (from:/to:) method, memoized per class+method:
+      # the reflection (method()/parameters) allocated per call and ran
+      # per value in the serialize/deserialize hot loops (42% of a
+      # custom-heavy to_json profile).
+      def self.custom_method_arity(klass, method_name)
+        per_klass = (@custom_method_arities ||= {}.compare_by_identity)
+        cache = (per_klass[klass] ||= {}.compare_by_identity)
+        cached = cache[method_name]
+        return cached if cached
+
+        begin
+          arity = klass.instance_method(method_name).parameters.size
+        rescue NameError
+          arity = nil
+        end
+        cache[method_name] = arity
+        arity
+      end
+
       def serialize(model, parent = nil, doc = nil, context = nil)
         if custom_methods[:to]
           to_method = custom_methods[:to]
           # lutaml-model#550: custom methods may declare a fourth
           # context parameter to receive the options passed to `to_*`.
-          if model.method(to_method).parameters.size >= 4
+          if self.class.custom_method_arity(model.class, to_method).to_i >= 4
             model.public_send(to_method, model, parent, doc, context)
           else
             model.public_send(to_method, model, parent, doc)
@@ -555,7 +574,7 @@ context = nil, pre_cast: false)
           target = mapper_class.new
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `from_*`.
-          if target.method(custom).parameters.size >= 3
+          if self.class.custom_method_arity(target.class, custom).to_i >= 3
             target.public_send(custom, model, value, context)
           else
             target.public_send(custom, model, value)

data/lib/lutaml/model/schema/xml_compiler/spec_builder/complex_types.rb

@@ -21,12 +21,17 @@ module Lutaml
               @parent = parent
             end
 
-            # <xs:complexType> -> Definitions::Model.
-            def build(complex_type)
+            # <xs:complexType> -> Definitions::Model. Anonymous types
+            # carry the owning element's name as `root_name` so the
+            # generated class serializes the element, not the internal
+            # CT_ alias.
+            def build(complex_type, root_name: nil)
               model = Definitions::Model.new(
                 class_name: Utils.camel_case(complex_type.name),
-                xml_root: Definitions::XmlRoot.new(kind: :element,
-                                                   name: complex_type.name),
+                xml_root: Definitions::XmlRoot.new(
+                  kind: :element,
+                  name: root_name || complex_type.name,
+                ),
                 mixed: !!complex_type.mixed,
                 namespace_class_name: @parent.namespace_class_name,
               )

data/lib/lutaml/model/schema/xml_compiler/spec_builder/members.rb

@@ -110,8 +110,11 @@ module Lutaml
               end
 
               local = Utils.last_of_split(raw_type)
-              Definitions::TypeRef.new(kind: :symbol,
-                                       value: Utils.snake_case(local))
+              primitive = SupportedDataTypes.primitive_symbol(local)
+              Definitions::TypeRef.new(
+                kind: :symbol,
+                value: primitive || Utils.snake_case(local),
+              )
             end
 
             private
@@ -169,8 +172,10 @@ module Lutaml
                                                       element.simple_type)
               end
               if element.complex_type
-                return register_anonymous_complex_type("CT_#{element.name}",
-                                                       element.complex_type)
+                return register_anonymous_complex_type(
+                  "CT_#{element.name}", element.complex_type,
+                  root_name: element.name
+                )
               end
 
               "string"
@@ -184,8 +189,10 @@ module Lutaml
               end
 
               if item.respond_to?(:complex_type) && item.complex_type
-                register_anonymous_complex_type("CT_#{item.name}",
-                                                item.complex_type)
+                register_anonymous_complex_type(
+                  "CT_#{item.name}", item.complex_type,
+                  root_name: item.name
+                )
               end
             end
 
@@ -196,10 +203,10 @@ module Lutaml
               anon_name
             end
 
-            def register_anonymous_complex_type(anon_name, anon_node)
+            def register_anonymous_complex_type(anon_name, anon_node, root_name: nil)
               anon_node.name = anon_name
               @parent.complex_types[anon_name] =
-                @parent.build_complex_type(anon_node)
+                @parent.build_complex_type(anon_node, root_name: root_name)
               anon_name
             end
 

data/lib/lutaml/model/schema/xml_compiler/spec_builder.rb

@@ -156,8 +156,8 @@ module Lutaml
             @simple_types_builder.build(simple_type)
           end
 
-          def build_complex_type(complex_type)
-            @complex_types_builder.build(complex_type)
+          def build_complex_type(complex_type, root_name: nil)
+            @complex_types_builder.build(complex_type, root_name: root_name)
           end
 
           private