lutaml-model 0.8.90 → 0.8.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '008334bfed6208a5b73319ca45ef3203aa8de4807daadc7087278b76143a69a3'
-  data.tar.gz: 7f1381b7380337212ace593d64a11fc2e36c990c44304432ba1e7ea6f41887bf
+  metadata.gz: 19d1cc9a53554486e1dda21b67751062851d1990b9878aac1dcd6ccd2542d28e
+  data.tar.gz: 459cecd7cbdd127bb65a52cd6058d027e5139f2926e46d408bea5a28b13f2e7f
 SHA512:
-  metadata.gz: 626ce7c079e4df067729318927eb539b94397e84fe06ad6586eb9c3de63798eabcb24c86204ad10a26685173403f02a5bab80a75217d81cf4d02966a6dbc66fa
-  data.tar.gz: e27d1de126fa01354facfd4c42136bf6cce400a243ffa8a20f91a421ae8d2743d2df4f588a12d9b18ae96a067dd322b126a6362c91a12c601bc2dbe56e3a6ed5
+  metadata.gz: 92637d4ab1efbd63d746983b4e359f2d49c00469e94bb249a050f36f1b80f15b18ae705245fdd8ab563d854e814fea54ce99993f64dbc17beb9c87555f7b3a95
+  data.tar.gz: 54412f06f6f1bed27f74a85495b414cfc6da3274ab03214220c27edd344aff8cd58f70874fa317fb61b9e8523a04725d69152dfde490b3aa61a2d75540a161ed

data/bench/bench_common.rb

@@ -20,7 +20,7 @@ if ENV["PLAN_COMPILE_STATS"]
   at_exit do
     require "pp"
     puts "\nPlanCompiler opt-out histogram:"
-    pp(Lutaml::Xml::Leptris::PlanCompiler.stats)
+    pp(Lutaml::Xml::Leptris::PlanCompiler.plan_stats)
   end
 end
 require "benchmark"

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.90"
+    VERSION = "0.8.92"
   end
 end

data/lib/lutaml/xml/leptris/plan_compiler.rb

@@ -26,9 +26,9 @@ module Lutaml
       # metadata) completes.
       module PlanCompiler
         # TODO.perf/15: env-gated histogram of why models opt out of the
-        # plan path. Set PLAN_COMPILE_STATS=1 and read PlanCompiler.stats
-        # after a parse. Zero cost when disabled.
-        def self.stats
+        # plan path. Set PLAN_COMPILE_STATS=1 and read
+        # PlanCompiler.plan_stats after a parse. Zero cost when disabled.
+        def self.plan_stats
           @plan_stats ||= Hash.new(0)
         end
 

data/lib/lutaml/xml/mapping.rb

@@ -1197,6 +1197,31 @@ module Lutaml
       # transform applies the collection-attribute filter.
       #
       # @return [Hash{Symbol, String => Array<MappingRule>}]
+      # The when_attribute siblings-vs-plain-names partition of the
+      # element rules. A ParseSession used to rebuild this per parsed
+      # node (sessions are per-element), paying an O(rules) pass on
+      # every node of large documents; it is a pure function of the
+      # rules, so it memoizes here — same lifetime as
+      # plain_element_rules_by_attr.
+      def when_attribute_partition
+        @when_attribute_partition ||= begin
+          siblings = {}
+          plain_names = {}
+          mappings.each do |rule|
+            next if rule.attribute? || rule.content_mapping? ||
+              rule.raw_mapping? || rule.cdata
+
+            pairs = rule.when_attribute
+            if pairs && !pairs.empty?
+              (siblings[rule.name.to_s] ||= []) << rule
+            else
+              plain_names[rule.name.to_s] = true
+            end
+          end
+          [siblings, plain_names]
+        end
+      end
+
       def plain_element_rules_by_attr(register_id = nil)
         reg_key = register_id || :default
         @plain_element_rules_by_attr ||= {}

data/lib/lutaml/xml/model_transform.rb

@@ -344,6 +344,14 @@ module Lutaml
         deserialize_attributes = attributes
         mappings.each do |rule|
           record = records&.[](rule)
+
+          # #903: replay-or-drop unmatched named element rules before
+          # any per-rule machinery (see replay_unmatched_rule).
+          if replay_unmatched_rule(child_names_set, record, rule,
+                                   instance, defaults_used, xml_mapping)
+            next
+          end
+
           rule_to = rule.to
 
           if record
@@ -847,7 +855,9 @@ _effective_register)
         Lutaml::Xml::HtmlEntities.decode(value)
       end
 
-      Record = Struct.new(:attr, :derived, :group_skip, :valid)
+      Record = Struct.new(:attr, :derived, :group_skip, :valid,
+                          :unmatched_mode, :replay_writer,
+                          :unmatched_names)
 
       def compiled_rule_records(model_class, register, grouped_plain_rules)
         return {}.compare_by_identity unless model_class.include?(Lutaml::Model::Serialize)
@@ -866,12 +876,76 @@ _effective_register)
         mapping&.mappings(register)&.each do |rule| # rubocop:disable Style/SafeNavigationChain,Style/SafeNavigation
           attr = attribute_for_rule_static(model_class, rule, register)
           group = grouped_plain_rules[rule.to]
+          # #903: for a plain rule, what an unmatched visit writes is
+          # known statically. The fast-skip branch hands the attribute's
+          # uninitialized sentinel to the pipeline; with no value-map
+          # overrides and no transformers every step is identity except
+          # apply_value_map, which maps the :omitted key: the default
+          # map (:nil) yields nil and the visit writes nil through the
+          # setter; an explicit omitted: :omitted map treats it as
+          # treat_omitted? == false and the omission gate ends the
+          # visit untouched. Both endings replay without the walk:
+          # :write_nil (setter write + flag churn) or :drop (nothing).
+          # Everything else -- defaults, aliases, custom from:,
+          # delegates, when_attribute dispatch, transformers, value
+          # maps beyond those two -- keeps its visit.
+          unmatched_mode = nil
+          replay_writer = nil
+          if attr && !attr.derived? &&
+              !rule.render_default && !rule.multiple_mappings? &&
+              !rule.has_custom_method_for_deserialization? &&
+              !rule.delegate &&
+              !(rule.when_attribute && !rule.when_attribute.empty?)
+            rule_transform = rule.transform
+            attr_transform = attr.transform
+            no_transforms =
+              (rule_transform.nil? ||
+               (rule_transform.respond_to?(:empty?) &&
+                rule_transform.empty?)) &&
+              (attr_transform.nil? ||
+               (attr_transform.respond_to?(:empty?) &&
+                attr_transform.empty?))
+            rule_default = attr.default(register)
+            if no_transforms &&
+                (rule_default.nil? ||
+                 rule_default.is_a?(::Lutaml::Model::UninitializedClass)) &&
+                rule.class.transform_dispatch(rule, attr) == :assign
+              if group && group.size > 1 && attr.collection? &&
+                  !group.first.equal?(rule)
+                # Non-first spelling of a #765 group: the visit is a
+                # guarded next (the first member does the merged match).
+                unmatched_mode = :drop
+              else
+                omitted_val = rule.value_map(:from)[:omitted]
+                if omitted_val == :nil
+                  unmatched_mode = :write_nil
+                elsif omitted_val == :omitted
+                  unmatched_mode = :drop
+                end
+              end
+            end
+          end
+          # A first group member does the merged match for every
+          # spelling, so its name-miss test spans the whole group.
+          unmatched_names = if group && group.size > 1
+                              group.map { |r| r.name.to_s }
+                            else
+                              [rule.name.to_s]
+                            end
+          if unmatched_mode == :write_nil
+            replay_writer =
+              rule.class.parsed_assign_writer(model_class, rule.to)
+            unmatched_mode = nil unless replay_writer
+          end
           records[rule] = Record.new(
             attr,
             attr&.derived? || false,
             !!(group && group.size > 1 && attr&.collection? &&
                !group.first.equal?(rule)),
             !!(attr || rule.custom_methods[:from]),
+            unmatched_mode,
+            replay_writer,
+            unmatched_names,
           )
         end
         entry = Struct.new(:version, :records).new(version, records)
@@ -1551,6 +1625,34 @@ effective_register = lutaml_register)
       # @param child_names_set [Set] Set of child namespaced_name and unprefixed_name
       # @param default_namespace [String, nil] the default namespace
       # @return [Boolean] true if a matching child likely exists
+      # #903: for an unmatched named element rule whose record classed
+      # it, replay what the visit would write without the walk: :drop
+      # (the visit ended at the omission gate or was a guarded next)
+      # writes nothing; :write_nil replays the nil the default value
+      # map produces, plus the flag churn. Returns true when handled.
+      def replay_unmatched_rule(child_names_set, record, rule, instance,
+                                defaults_used, xml_mapping)
+        return false unless child_names_set && record
+
+        mode = record.unmatched_mode
+        return false unless mode
+        return false if rule.attribute? || rule.content_mapping? ||
+          rule.raw_mapping? || !rule.name ||
+          xml_mapping.any_element_rule.equal?(rule)
+
+        matched = record.unmatched_names.any? do |n|
+          child_names_set.include?(n)
+        end
+        return false if matched
+
+        return true if mode == :drop
+
+        defaults_used << rule.to
+        instance.public_send(record.replay_writer, nil)
+        instance.value_set_for(rule.to)
+        true
+      end
+
       def child_matches_rule?(rule, child_names_set, default_namespace)
         rule_names = rule.namespaced_names(default_namespace)
         # Array#intersect? requires an Array argument; child_names_set may

data/lib/lutaml/xml/namespace.rb

@@ -58,7 +58,10 @@ module Lutaml
         # @param value [String, nil] the namespace URI
         # @return [String, nil] the namespace URI
         def uri(value = nil)
-          @uri_value = value if value
+          if value
+            @uri_value = value
+            @to_key = nil
+          end
           @uri_value
         end
 
@@ -130,6 +133,7 @@ module Lutaml
         def prefix_default(value = nil)
           if value
             @prefix_default_value = value.to_s
+            @to_key = nil
           end
           @prefix_default_value
         end
@@ -286,13 +290,19 @@ module Lutaml
         #
         # @api private
         def to_key
-          prefix = prefix_default
-          namespace_uri = uri
-
-          if prefix && !prefix.empty?
-            "#{prefix}:#{namespace_uri}"
-          else
-            ":#{namespace_uri}"
+          # Called per element on the serialize path (90k births per
+          # 200-paragraph to_xml); memoized since uri/prefix_default
+          # are set at class-definition time. The setters above
+          # invalidate on reconfiguration.
+          @to_key ||= begin
+            prefix = prefix_default
+            namespace_uri = uri
+
+            if prefix && !prefix.empty?
+              "#{prefix}:#{namespace_uri}"
+            else
+              ":#{namespace_uri}"
+            end
           end
         end
 

data/lib/lutaml/xml/namespace_needs.rb

@@ -8,20 +8,45 @@ module Lutaml
     # This class maintains MECE responsibility: it only stores and organizes
     # namespace needs data. It does NOT make decisions or build XML.
     class NamespaceNeeds
-      attr_reader :namespaces, :children, :type_namespaces,
-                  :type_namespace_classes, :type_attribute_namespaces,
-                  :type_element_namespaces, :type_refs,
-                  :namespace_scope_configs
-
-      def initialize
-        @namespaces = {} # Hash<String, NamespaceUsage>
-        @children = {} # Hash<Symbol, NamespaceNeeds>
-        @type_namespaces = {} # Hash<Symbol, Class>
-        @type_namespace_classes = Set.new # Set<Class>
-        @type_attribute_namespaces = Set.new # Set<Class>
-        @type_element_namespaces = Set.new # Set<Class>
-        @type_refs = [] # Array<TypeNamespace::Reference>
-        @namespace_scope_configs = [] # Array<NamespaceScopeConfig>
+      # Lazy readers: leaf nodes never touch most containers; the
+      # eager 4-Sets + 3-Hashes + 2-Arrays was the serialize path's
+      # top allocation site (150k births per 200-paragraph to_xml).
+      # Readers get the frozen empty truth; writers build on first
+      # touch through the ensure_* helpers below.
+      EMPTY_HASH = {}.freeze
+      EMPTY_SET = ::Set.new.freeze
+      EMPTY_ARRAY = [].freeze
+
+      def namespaces
+        @namespaces || EMPTY_HASH
+      end
+
+      def children
+        @children || EMPTY_HASH
+      end
+
+      def type_namespaces
+        @type_namespaces || EMPTY_HASH
+      end
+
+      def type_namespace_classes
+        @type_namespace_classes || EMPTY_SET
+      end
+
+      def type_attribute_namespaces
+        @type_attribute_namespaces || EMPTY_SET
+      end
+
+      def type_element_namespaces
+        @type_element_namespaces || EMPTY_SET
+      end
+
+      def type_refs
+        @type_refs || EMPTY_ARRAY
+      end
+
+      def namespace_scope_configs
+        @namespace_scope_configs || EMPTY_ARRAY
       end
 
       # Add namespace usage for a specific namespace
@@ -32,29 +57,29 @@ module Lutaml
           raise ArgumentError, "Expected NamespaceUsage, got #{usage.class}"
         end
 
-        @namespaces[key] = usage
+        (@namespaces ||= {})[key] = usage
       end
 
       # Track a type namespace for a specific attribute
       # @param attr_name [Symbol] Attribute name
       # @param ns_class [Class] XmlNamespace class
       def add_type_namespace(attr_name, ns_class)
-        @type_namespaces[attr_name] = ns_class
-        @type_namespace_classes << ns_class
+        (@type_namespaces ||= {})[attr_name] = ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add type attribute namespace to tracking set
       # @param ns_class [Class] XmlNamespace class
       def add_type_attribute_namespace(ns_class)
-        @type_attribute_namespaces << ns_class
-        @type_namespace_classes << ns_class
+        (@type_attribute_namespaces ||= ::Set.new) << ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add type element namespace to tracking set
       # @param ns_class [Class] XmlNamespace class
       def add_type_element_namespace(ns_class)
-        @type_element_namespaces << ns_class
-        @type_namespace_classes << ns_class
+        (@type_element_namespaces ||= ::Set.new) << ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add a type reference for lazy resolution
@@ -65,13 +90,13 @@ module Lutaml
                 "Expected TypeNamespace::Reference, got #{reference.class}"
         end
 
-        @type_refs << reference
+        (@type_refs ||= []) << reference
       end
 
       # Clear type references after resolution
       # Used by TypeNamespaceResolver to prevent reprocessing
       def clear_type_refs
-        @type_refs.clear
+        @type_refs&.clear
       end
 
       # Add namespace scope configuration
@@ -82,7 +107,7 @@ module Lutaml
                 "Expected NamespaceScopeConfig, got #{config.class}"
         end
 
-        @namespace_scope_configs << config
+        (@namespace_scope_configs ||= []) << config
       end
 
       # Add child needs
@@ -94,7 +119,7 @@ module Lutaml
                 "Expected NamespaceNeeds, got #{child_needs.class}"
         end
 
-        @children[name] = child_needs
+        (@children ||= {})[name] = child_needs
       end
 
       # Merge another NamespaceNeeds into this one
@@ -105,9 +130,9 @@ module Lutaml
           raise ArgumentError, "Expected NamespaceNeeds, got #{other.class}"
         end
 
-        # Merge namespaces
+        # Merge namespaces (build containers on first touch)
         other.namespaces.each do |key, usage|
-          if @namespaces.key?(key)
+          if (@namespaces ||= {}).key?(key)
             @namespaces[key].merge(usage)
           else
             @namespaces[key] = usage
@@ -116,7 +141,7 @@ module Lutaml
 
         # Merge children
         other.children.each do |name, child_needs|
-          if @children.key?(name)
+          if (@children ||= {}).key?(name)
             @children[name].merge(child_needs)
           else
             @children[name] = child_needs
@@ -124,17 +149,20 @@ module Lutaml
         end
 
         # Merge type namespaces
-        @type_namespaces.merge!(other.type_namespaces)
-        @type_namespace_classes.merge(other.type_namespace_classes)
-        @type_attribute_namespaces.merge(other.type_attribute_namespaces)
-        @type_element_namespaces.merge(other.type_element_namespaces)
+        (@type_namespaces ||= {}).merge!(other.type_namespaces)
+        (@type_namespace_classes ||= ::Set.new)
+          .merge(other.type_namespace_classes)
+        (@type_attribute_namespaces ||= ::Set.new)
+          .merge(other.type_attribute_namespaces)
+        (@type_element_namespaces ||= ::Set.new)
+          .merge(other.type_element_namespaces)
 
         # Merge type refs
-        @type_refs.concat(other.type_refs)
+        (@type_refs ||= []).concat(other.type_refs)
 
         # Merge namespace scope configs (avoiding duplicates)
         other.namespace_scope_configs.each do |config|
-          unless @namespace_scope_configs.any? do |c|
+          unless (@namespace_scope_configs ||= []).any? do |c|
             c.namespace_class == config.namespace_class
           end
             @namespace_scope_configs << config
@@ -147,32 +175,32 @@ module Lutaml
       # Check if needs are empty
       # @return [Boolean]
       def empty?
-        @namespaces.empty? &&
-          @children.empty? &&
-          @type_refs.empty? &&
-          @type_namespaces.empty? &&
-          @namespace_scope_configs.empty?
+        namespaces.empty? &&
+          children.empty? &&
+          type_refs.empty? &&
+          type_namespaces.empty? &&
+          namespace_scope_configs.empty?
       end
 
       # Get namespace usage by key
       # @param key [String] Namespace key
       # @return [NamespaceUsage, nil]
       def namespace(key)
-        @namespaces[key]
+        namespaces[key]
       end
 
       # Get child needs by name
       # @param name [Symbol] Child attribute name
       # @return [NamespaceNeeds, nil]
       def child(name)
-        @children[name]
+        children[name]
       end
 
       # Check if a namespace is in scope configuration
       # @param ns_class [Class] XmlNamespace class
       # @return [NamespaceScopeConfig, nil]
       def scope_config_for(ns_class)
-        @namespace_scope_configs.find do |config|
+        namespace_scope_configs.find do |config|
           config.namespace_class == ns_class
         end
       end
@@ -180,28 +208,28 @@ module Lutaml
       # Get all namespace classes (from usage and type namespaces)
       # @return [Set<Class>]
       def all_namespace_classes
-        namespace_classes = Set.new(@namespaces.values.map(&:namespace_class))
-        namespace_classes.merge(@type_namespace_classes)
+        classes = Set.new(namespaces.values.map(&:namespace_class))
+        classes.merge(type_namespace_classes)
       end
 
       # Validate internal consistency
       # @raise [RuntimeError] if inconsistent state detected
       def validate!
         # Type attribute and element namespaces should be mutually exclusive
-        overlap = @type_attribute_namespaces & @type_element_namespaces
+        overlap = type_attribute_namespaces & type_element_namespaces
         unless overlap.empty?
           raise "Type namespaces appear in both attribute and element contexts: #{overlap.to_a}"
         end
 
         # All type namespace classes should be in type_namespace_classes
-        @type_attribute_namespaces.each do |ns_class|
-          unless @type_namespace_classes.include?(ns_class)
+        type_attribute_namespaces.each do |ns_class|
+          unless type_namespace_classes.include?(ns_class)
             raise "Type attribute namespace #{ns_class} not in type_namespace_classes"
           end
         end
 
-        @type_element_namespaces.each do |ns_class|
-          unless @type_namespace_classes.include?(ns_class)
+        type_element_namespaces.each do |ns_class|
+          unless type_namespace_classes.include?(ns_class)
             raise "Type element namespace #{ns_class} not in type_namespace_classes"
           end
         end

data/lib/lutaml/xml/parse_session.rb

@@ -84,25 +84,9 @@ module Lutaml
       # Empty unless the mapping uses when_attribute at all; non-Serialize
       # custom models have no mappings to partition.
       def when_attribute_partition
-        @when_attribute_partition ||=
-          if instance_is_serialize && (mapping = xml_mapping)
-            siblings = {}
-            plain_names = {}
-            mapping.mappings.each do |rule|
-              next if rule.attribute? || rule.content_mapping? ||
-                rule.raw_mapping? || rule.cdata
-
-              pairs = rule.when_attribute
-              if pairs && !pairs.empty?
-                (siblings[rule.name.to_s] ||= []) << rule
-              else
-                plain_names[rule.name.to_s] = true
-              end
-            end
-            [siblings, plain_names]
-          else
-            [{}, {}]
-          end
+        return [{}, {}] unless instance_is_serialize && (mapping = xml_mapping)
+
+        mapping.when_attribute_partition
       end
 
       def when_attribute_siblings_by_name

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -101,20 +101,26 @@ model_class, register_id)
             return
           end
 
-          # Extract parent's namespace info for element_form_default inheritance
-          parent_ns_class = parent.namespace_class
-          # Only pass element_form_default VALUE if it was explicitly set
-          # When not set (defaults to :unqualified), pass nil to avoid incorrect blank namespace treatment
-          parent_element_form_default = if parent_ns_class&.element_form_default_set?
-                                          parent_ns_class.element_form_default
-                                        end
-
-          # Merge parent context into options
-          child_options = options.merge(
-            parent_namespace_class: parent_ns_class,
-            parent_element_form_default: parent_element_form_default,
-            parent_element: parent,
-          )
+          # Fast path: the ordered walk pre-sets the parent context keys
+          # for every value it emits (one hash per walk, not per value).
+          # The three keys are always written together, so a parent
+          # identity match implies the namespace context matches too.
+          if options[:parent_element] == parent
+            child_options = options
+          else
+            parent_ns_class = parent.namespace_class
+            # Only pass element_form_default VALUE if it was explicitly set
+            # When not set (defaults to :unqualified), pass nil to avoid incorrect blank namespace treatment
+            parent_element_form_default = if parent_ns_class&.element_form_default_set?
+                                            parent_ns_class.element_form_default
+                                          end
+
+            child_options = options.dup
+            child_options[:parent_namespace_class] = parent_ns_class
+            child_options[:parent_element_form_default] =
+              parent_element_form_default
+            child_options[:parent_element] = parent
+          end
 
           element = yield(rule, value, child_options)
           parent.add_child(element) if element

data/lib/lutaml/xml/transformation.rb

@@ -265,6 +265,20 @@ module Lutaml
         # Loop-invariant for the whole ordered walk (see
         # apply_standard_rules): one merge per model, not per rule.
         rule_options = options.merge(current_model: model_instance)
+        # `root` is the parent of every element value this walk emits,
+        # so the parent context keys are walk-invariant too: set them
+        # once here and apply_element_rule_single's fast path reuses
+        # this hash for every value instead of merging per value.
+        # rule_options itself keeps the caller's parent context for
+        # the attribute/content/raw rules dispatched via apply_rule.
+        element_value_options = rule_options.dup
+        root_ns_class = root.namespace_class
+        element_value_options[:parent_namespace_class] = root_ns_class
+        element_value_options[:parent_element_form_default] =
+          if root_ns_class&.element_form_default_set?
+            root_ns_class.element_form_default
+          end
+        element_value_options[:parent_element] = root
         apply_rules_in_order(
           root, model_instance, options,
           compiled_rules, model_class, register_id
@@ -281,7 +295,7 @@ module Lutaml
               parent: root,
               rule: rule,
               value: value,
-              options: rule_options,
+              options: element_value_options,
             ) do |r, v, child_opts|
               element = create_element_for_value(r, v, child_opts, model_class,
                                                  register_id, register)

data/lutaml-model.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |spec|
   # input-buffer cap (lutaml-model#871).
   spec.add_dependency "moxml", "~> 0.5.84"
   spec.add_dependency "ostruct"
-  spec.add_dependency "rubyzip", "~> 3.4"
+  spec.add_dependency "rubyzip", "~> 3.7"
   spec.add_dependency "thor"
 
   spec.metadata["rubygems_mfa_required"] = "true"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.90
+  version: 0.8.92
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -120,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement