lutaml-model 0.8.73 → 0.8.74

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b25c7b3e06beee19bd00eeec495484f446a206aed30db2b247a6b493ddb417ae
-  data.tar.gz: 9a4870046688f1dd8076fcbd8bfd10e2a3cbb24a15608413be2b006d0209b7dc
+  metadata.gz: 45577608605b19115a3826164cf851363218b65e71efa0b48a0d25e3a0df913f
+  data.tar.gz: '0181c1f69c5d731ad13dd65fa31a37c929714f3a0a7fd12d9dd59f7e0d093b1a'
 SHA512:
-  metadata.gz: 214c201878c903a3205368c89547f4ad22fb8b2e925b19420dda4e90db28dca9d26d66aa89d50b232ded8dc5258e92f95ff9088cebe9f93a0acf04df626a99a4
-  data.tar.gz: '06390a0d5f7df047f947931c9d1d4f96b970e2a0a890f1e356c10a8e3fbc10bcdc5bbf4d4c01ca5221757f0eac0b9ffae91aabf264368211e5ce18b490a45e65'
+  metadata.gz: ea5765db2e067d6d9b5670eaaa3c4f1269bdea9486ed07179ffa048e4435c0a504542dbf9dbdc0f270f776d084511d7d91998425b024fd8516f3599b7d238616
+  data.tar.gz: 88db0489938297bd0d74e24d169fbf6aecc0245998401159e0795122e24580e050e9dff58672c481f8b7fa14c64314305b23c3d7780962023282fa66a1d549c3

data/lib/lutaml/key_value/transform.rb

@@ -56,13 +56,9 @@ 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)
-            # Use new Transformation to get KeyValueElement
-            kv_element = transformation.transform(instance, options)
-            # Convert KeyValueElement to hash for backward compatibility with adapters
-            # The to_hash method returns {"__root__" => {actual_hash}}
-            kv_hash = kv_element.to_hash
-            # For root element, return just the content hash
-            return kv_hash["__root__"] || kv_hash
+            # transform emits the output hash directly (TODO.perf 19) —
+            # the __root__ Element tree and its to_hash flatten are gone.
+            return transformation.transform(instance, options)
           end
         end
 

data/lib/lutaml/key_value/transformation/collection_serializer.rb

@@ -140,15 +140,11 @@ options = {})
           nil_mapping = to_map[:nil]
 
           if nil_mapping == :empty || converted_from_nil_to_empty
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, []
-            )
-            parent.add_child(element)
+            puts "  HNC-EMPTY #{rule.serialized_name}" if ENV["T19"]
+            parent[rule.serialized_name] = []
           elsif nil_mapping == :nil || converted_from_empty_to_nil
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, nil
-            )
-            parent.add_child(element)
+            puts "  HNC-NIL #{rule.serialized_name}" if ENV["T19"]
+            parent[rule.serialized_name] = nil
           end
           # else: Skip nil collection (default behavior)
         end
@@ -158,8 +154,6 @@ options = {})
           key_attribute = root_mappings.key(:key)
           value_attribute = root_mappings.key(:value)
 
-          parent.value ||= {} if parent.value.nil?
-
           if key_attribute && value_attribute
             handle_root_mappings_key_value(parent, items, key_attribute,
                                            value_attribute, rule, options)
@@ -213,7 +207,7 @@ options = {})
                                else
                                  attr_value
                                end
-            parent.value[key_value.to_s] = serialized_value if serialized_value
+            parent[key_value.to_s] = serialized_value if serialized_value
           end
         end
 
@@ -336,7 +330,7 @@ options)
               end
             end
 
-            parent.value[key_value.to_s] = item_hash unless item_hash.empty?
+            parent[key_value.to_s] = item_hash unless item_hash.empty?
           end
         end
 
@@ -362,10 +356,7 @@ options)
             end
           end
 
-          element = Lutaml::KeyValue::DataModel::Element.new(
-            rule.serialized_name, keyed_hash
-          )
-          parent.add_child(element)
+          parent[rule.serialized_name] = keyed_hash
         end
 
         # Find value attribute from child_mappings.
@@ -490,18 +481,11 @@ options)
 
         # Create an array collection element (default).
         def create_array_collection_element(parent, rule, items, options)
-          coll_element = Lutaml::KeyValue::DataModel::Element.new(rule.serialized_name)
-
-          if items.empty?
-            coll_element.value = []
-          else
-            items.each do |item|
-              child_value = create_value_for_item(rule, item, options)
-              coll_element.add_child(child_value) unless child_value.nil?
-            end
+          built = items.each_with_object([]) do |item, memo|
+            child_value = create_value_for_item(rule, item, options)
+            memo << child_value unless child_value.nil?
           end
-
-          parent.add_child(coll_element)
+          parent[rule.serialized_name] = built
         end
 
         # Create a value element for a collection item.
@@ -554,8 +538,7 @@ options)
         def serialize_nested_model(value, attr_type, options)
           child_transformation = create_transformation(attr_type)
           child_root = child_transformation.transform(value, options)
-          child_hash = child_root.to_hash
-          child_hash["__root__"]
+          child_root.empty? ? nil : child_root
         end
 
         # Serialize a primitive value.

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -303,12 +303,10 @@ model_class: nil)
         # @param options [Hash] Serialization options
         # @return [Hash, nil] The serialized hash or nil if empty
         def transform_nested_model(value, child_transformation, options)
+          # transform emits the content hash directly (TODO.perf 19);
+          # nil for empty keeps render_nil: false working.
           child_root = child_transformation.transform(value, options)
-          child_hash = child_root.to_hash
-          result = child_hash["__root__"]
-
-          # Return nil for empty hashes (allows render_nil: false to work)
-          result.nil? || result.empty? ? nil : result
+          child_root.empty? ? nil : child_root
         end
 
         # Check if the rule defines a Reference type.

data/lib/lutaml/key_value/transformation.rb

@@ -209,7 +209,10 @@ 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
-        root = Lutaml::KeyValue::DataModel::Element.new("__root__")
+        # 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.
+        root = {}
 
         # Apply each compiled rule (with filtering support). A
         # when_attribute partition applies once for its whole key.
@@ -230,11 +233,7 @@ register = self.register)
 
         if ENV["DEBUG_KEYED_COLLECTION"]
           puts "=== TRANSFORM COMPLETE ==="
-          puts "root.children.count: #{root.children.count}"
-          root.children.each do |child|
-            puts "  child key=#{child.key.inspect}, value=#{child.value.inspect}, to_hash=#{child.to_hash.inspect}"
-          end
-          puts "root.to_hash: #{root.to_hash.inspect}"
+          puts "root: #{root.inspect}"
         end
 
         root
@@ -289,15 +288,9 @@ register = self.register)
         end
         return unless present
 
-        element = Lutaml::KeyValue::DataModel::Element.new(
-          group.first.serialized_name,
-        )
-        if items.empty?
-          element.value = []
-        else
-          items.each { |item| element.add_child(item) }
-        end
-        parent.add_child(element)
+        # Items are stamped hashes or primitives: the tree's
+        # children_to_array semantics, expressed directly.
+        parent[group.first.serialized_name] = items
       end
 
       def stamp_discriminator(item, rule)
@@ -332,16 +325,20 @@ register = self.register)
         # Handle custom serialization methods (e.g., with: { to: ... })
         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("__custom__")
           # 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
-            return model_instance.public_send(to_method, model_instance,
-                                              parent, options[:context])
+            model_instance.public_send(to_method, model_instance,
+                                       doc, options[:context])
+          else
+            model_instance.public_send(to_method, model_instance, doc)
           end
-
-          # Call custom method which directly modifies the parent element
-          return model_instance.public_send(to_method, model_instance,
-                                            parent)
+          parent.update(doc.to_hash.fetch("__custom__", {}))
+          return
         end
 
         # Handle delegation - extract value from delegated object
@@ -450,17 +447,9 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
           to_map = (rule.option(:value_map) || {})[:to] || {}
           nil_mapping = to_map[:nil]
           if nil_mapping == :empty || converted_from_nil_to_empty
-            # Render as empty collection
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, []
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = []
           elsif nil_mapping == :nil || converted_from_empty_to_nil
-            # Render nil collection as nil value
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, nil
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = nil
           else
             # Skip nil collection
           end
@@ -519,10 +508,10 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                   # Transform the value to a KeyValueElement
                   value_root = value_transformation.transform(attr_value,
                                                               options)
-                  value_hash = value_root.to_hash
 
-                  # Extract the value from the __root__ wrapper
-                  parent.value[key_value.to_s] = value_hash["__root__"]
+                  # transform emits the output hash directly now
+                  # (TODO.perf 19) — no __root__ wrapper to unwrap.
+                  parent[key_value.to_s] = value_root
                   next
                 end
               end
@@ -540,7 +529,7 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                 # Get the child transformation for the collection item type
                 if item_type.is_a?(Class) && item_type < Lutaml::Model::Serialize
                   # Create a temporary parent KeyValueElement to hold the collection
-                  temp_parent = Lutaml::KeyValue::DataModel::Element.new("__temp__")
+                  temp_parent = {}
 
                   # Convert to array
                   coll_items = Array(attr_value)
@@ -577,18 +566,15 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                                                     coll_items, options)
                   end
 
-                  # Extract the value from temp_parent
-                  temp_hash = temp_parent.to_hash
-                  inner_value = temp_hash["__temp__"]
-                  coll_value = inner_value&.[](value_attribute.to_s) if inner_value
+                  coll_value = temp_parent[value_attribute.to_s]
 
-                  parent.value[key_value.to_s] = coll_value
+                  parent[key_value.to_s] = coll_value
                   next
                 end
               end
 
               # Fallback: just use the value directly
-              parent.value[key_value.to_s] = attr_value
+              parent[key_value.to_s] = attr_value
             end
           # Case 2: Only key attribute specified - serialize all other attributes
           elsif key_attribute
@@ -662,7 +648,7 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                 end
               end
 
-              parent.value[key_value.to_s] = item_hash unless item_hash.empty?
+              parent[key_value.to_s] = item_hash unless item_hash.empty?
             end
           end
 
@@ -872,17 +858,7 @@ child_mappings, options)
           puts "  keyed_hash: #{keyed_hash.inspect}"
         end
 
-        # Create element with hash value
-        element = Lutaml::KeyValue::DataModel::Element.new(
-          rule.serialized_name, keyed_hash
-        )
-
-        if ENV["DEBUG_KEYED_COLLECTION"]
-          puts "  element created: key=#{element.key.inspect}, value=#{element.value.inspect}, children.count=#{element.children.count}"
-          puts "  element.to_hash: #{element.to_hash.inspect}"
-        end
-
-        parent.add_child(element)
+        parent[rule.serialized_name] = keyed_hash
       end
 
       # Create an array collection element (default)
@@ -892,23 +868,13 @@ child_mappings, options)
       # @param items [Array] The collection items
       # @param options [Hash] Options
       def create_array_collection_element(parent, rule, items, options)
-        # Create an element for the collection
-        coll_element = Lutaml::KeyValue::DataModel::Element.new(rule.serialized_name)
-
-        if items.empty?
-          # For empty collections, set value to empty array explicitly
-          coll_element.value = []
-        else
-          # Add each item as a child
-          items.each do |item|
-            child_value = create_value_for_item(rule, item, options)
-            # Use explicit nil check - `if child_value` would fail for boolean false!
-            coll_element.add_child(child_value) unless child_value.nil?
-          end
+        # children_to_array semantics directly: always an array,
+        # nil children skipped (explicit nil check — booleans matter).
+        built = items.each_with_object([]) do |item, memo|
+          child_value = create_value_for_item(rule, item, options)
+          memo << child_value unless child_value.nil?
         end
-
-        # Always add collection element
-        parent.add_child(coll_element)
+        parent[rule.serialized_name] = built
       end
 
       # Get the key attribute for a keyed collection from child_mappings
@@ -956,9 +922,7 @@ child_mappings, options)
               # Since we don't have direct access to the parent mapping here,
               # serialize as array for now (default behavior)
               items.map do |item|
-                child_root = child_transformation.transform(item, options)
-                child_hash = child_root.to_hash
-                child_hash["__root__"]
+                child_transformation.transform(item, options)
               end
             end
           else
@@ -970,10 +934,7 @@ child_mappings, options)
           mapping = attr_type.mappings_for(format, register_id)
           child_transformation = self.class.new(attr_type, mapping, format,
                                                 register)
-          child_root = child_transformation.transform(value,
-                                                      options)
-          child_hash = child_root.to_hash
-          child_hash["__root__"]
+          child_transformation.transform(value, options)
         # Use the transformation to serialize the nested model
         elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
           wrapped_value = attr_type.new(value)
@@ -1001,16 +962,10 @@ child_mappings, options)
           when :omitted
             return
           when :nil
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, nil
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = nil
             return
           when :empty
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, ""
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = ""
             return
           end
 
@@ -1019,16 +974,10 @@ child_mappings, options)
         elsif Lutaml::Model::Utils.uninitialized?(value)
           omitted_mapping = to_map[:omitted]
           if omitted_mapping == :nil
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, nil
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = nil
             return
           elsif omitted_mapping == :empty
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, ""
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = ""
             return
           end
           # uninitialized with no/omitted mapping → skip (default behavior)
@@ -1036,10 +985,7 @@ child_mappings, options)
         elsif Lutaml::Model::Utils.empty?(value)
           empty_mapping = to_map[:empty]
           if empty_mapping == :nil
-            element = Lutaml::KeyValue::DataModel::Element.new(
-              rule.serialized_name, nil
-            )
-            parent.add_child(element)
+            parent[rule.serialized_name] = nil
             return
           elsif empty_mapping == :omitted
             return
@@ -1050,12 +996,7 @@ child_mappings, options)
         # Normal value serialization
         child_value = create_value_for_item(rule, value, options)
 
-        unless child_value.nil?
-          element = Lutaml::KeyValue::DataModel::Element.new(
-            rule.serialized_name, child_value
-          )
-          parent.add_child(element)
-        end
+        parent[rule.serialized_name] = child_value unless child_value.nil?
       end
 
       # Create value for an item (handles nested models and primitives)
@@ -1125,13 +1066,10 @@ child_mappings, options)
 
           if child_transformation
             child_root = child_transformation.transform(value, options)
-            # Return the hash representation of the child
-            # Remove the __root__ wrapper and return just the content
-            child_hash = child_root.to_hash
-            result = child_hash["__root__"]
-            # If the nested model serialized to empty hash, return nil
-            # This allows render_nil: false to work correctly for nested models
-            result.nil? || result.empty? ? nil : result
+            # transform emits the content hash directly (TODO.perf 19);
+            # an empty serialization still returns nil so render_nil:
+            # false keeps working for nested models.
+            child_root.empty? ? nil : child_root
           else
             # Fallback: serialize as primitive
             serialize_value(value, rule)
@@ -1167,15 +1105,12 @@ child_mappings, options)
         # For each key-value pair in the parsed content, add as a child element
         if parsed_content.is_a?(::Hash)
           parsed_content.each do |key, val|
-            element = Lutaml::KeyValue::DataModel::Element.new(key.to_s, val)
-            parent.add_child(element)
+            parent[key.to_s] = val
           end
         elsif parsed_content.is_a?(::Array)
-          # If the parsed content is an array, we can't merge it directly
-          # This shouldn't happen with valid map_all usage, but handle it gracefully
-          element = Lutaml::KeyValue::DataModel::Element.new("__root__",
-                                                             parsed_content)
-          parent.add_child(element)
+          # Graceful handling of unusual map_all content (parity with
+          # the tree's __root__ wrapper)
+          parent["__root__"] = parsed_content
         end
       end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.73"
+    VERSION = "0.8.74"
   end
 end

data/spec/lutaml/key_value/transformation/value_serializer_spec.rb

@@ -5,11 +5,15 @@ require "spec_helper"
 RSpec.describe Lutaml::KeyValue::Transformation::ValueSerializer do
   let(:format) { :json }
   let(:register_id) { :default }
+  # No doubles (house rule): a real transformation factory. Under
+  # hash-direct emission (TODO.perf 19) transform returns the content
+  # hash itself.
   let(:transformation_factory) do
-    ->(_type_class) do
-      double("Transformation",
-             transform: double("Element",
-                               to_hash: { "__root__" => { "name" => "test" } }))
+    ->(type_class) do
+      Lutaml::KeyValue::Transformation.new(
+        type_class, type_class.mappings_for(format, register_id),
+        format, register_id
+      )
     end
   end
 
@@ -106,7 +110,7 @@ RSpec.describe Lutaml::KeyValue::Transformation::ValueSerializer do
       end
 
       it "validates type mismatch" do
-        wrong_value = double("wrong_type")
+        wrong_value = Object.new
         expect do
           serializer.serialize_item(wrong_value, rule)
         end.to raise_error(Lutaml::Model::IncorrectModelError, /but should be/)

data/spec/lutaml/key_value/transformation_spec.rb

@@ -60,9 +60,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
 
         result = transformation.transform(model)
 
-        expect(result).to be_a(Lutaml::KeyValue::DataModel::Element)
-        expect(result.key).to eq("__root__")
-        expect(result.children.length).to eq(3)
+        expect(result).to be_a(Hash)
       end
 
       it "creates proper key-value structure" do
@@ -71,7 +69,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # Remove __root__ wrapper
         expect(hash["__root__"]).to eq({
@@ -87,7 +85,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # nil values should be rendered by default
         expect(hash["__root__"]["age"]).to be_nil
@@ -103,7 +101,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVPerson, mapping, :json, nil)
 
         result = transformation.transform(person)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         expect(hash["__root__"]).to eq({
                                          "name" => "John",
@@ -121,7 +119,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVPerson, mapping, :json, nil)
 
         result = transformation.transform(person)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # nil nested model should be in output (based on default render_nil)
         expect(hash["__root__"]["address"]).to be_nil
@@ -137,7 +135,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         expect(hash["__root__"]).to eq({
                                          "name" => "Dev Team",
@@ -152,7 +150,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # Empty collections are not rendered by default (render_empty defaults to false)
         expect(hash["__root__"]["members"]).to be_nil
@@ -164,7 +162,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # nil collection should be nil by default
         expect(hash["__root__"]["members"]).to be_nil
@@ -190,7 +188,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
                                              nil)
 
         result = transformation.transform(model)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         expect(hash["__root__"]["name"]).to eq("JOHN")
       end
@@ -213,7 +211,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVRenderModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # optional should be omitted
         expect(hash["__root__"].keys).not_to include("optional")
@@ -225,7 +223,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVRenderModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = result.to_hash
+        hash = { "__root__" => result }
 
         # defaulted should be omitted
         expect(hash["__root__"].keys).not_to include("defaulted")
@@ -234,22 +232,22 @@ RSpec.describe Lutaml::KeyValue::Transformation do
   end
 
   describe "architecture compliance" do
-    it "produces OOP data structures, not raw hashes" do
+    it "emits the presentation hash directly (TODO.perf 19)" do
       model = KVSimpleModel.new(name: "John", age: 30, active: true)
       mapping = KVSimpleModel.mappings_for(:json)
       transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
 
       result = transformation.transform(model)
 
-      # Result should be KeyValueElement, not Hash
-      expect(result).to be_a(Lutaml::KeyValue::DataModel::Element)
-      expect(result).not_to be_a(Hash)
-
-      # Children should also be KeyValueElements
-      expect(result.children).to all(be_a(Lutaml::KeyValue::DataModel::Element))
+      # Hash-direct emission: the __root__ Element tree (write-only in
+      # production, immediately flattened by every consumer) is gone;
+      # transform produces the output hash itself.
+      expect(result).to be_a(Hash)
+      expect(result).to eq("name" => "John", "age" => 30, "active" => true)
     end
 
     it "separates content (KeyValueElement) from presentation (Hash)" do
+      skip "superseded by hash-direct emission (TODO.perf 19)"
       model = KVSimpleModel.new(name: "John", age: 30, active: true)
       mapping = KVSimpleModel.mappings_for(:json)
       transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
@@ -259,7 +257,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
       expect(result).to be_a(Lutaml::KeyValue::DataModel::Element)
 
       # Presentation happens via to_hash, not during transformation
-      hash = result.to_hash
+      hash = { "__root__" => result }
       expect(hash).to be_a(Hash)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.73
+  version: 0.8.74
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-27 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64