kettle-jem 7.1.8 → 7.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c5f5fc9bc53f2126159023d8c5648b14d48bf686a3db540d79468848fb3d30
-  data.tar.gz: f44a05f17df8cb139e53b1bae7be96c439eada3e4f958387175e161ba08bf93b
+  metadata.gz: cc954a9b2e13ecec8a5dbf0858c76b7a7157f92fabd6f07092024690ab163048
+  data.tar.gz: '0628e48c05357df4f752ef7e252cb3992d380ab578faaeee44801d7e818ed39f'
 SHA512:
-  metadata.gz: fdafbae49efd6f2858c718ee4b7df6a14502c561e8d98b9bf11c96d5b1795b4710f2eb0aeddb3951392d9ec164afb533aa7db4d56ea6ea7cb44da21bc9398efa
-  data.tar.gz: 186e8070d0d5aed6c18d6db8937e3d267ac38bef6703f2e5445b6bdfffc6cf2da9a097f63b580084c7eabce82fe7631eaa6da18c45ddfe09da1fe2133bb7a55f
+  metadata.gz: 1c549dd026691dbfc28854df99784f1b3c8904237d19f23eaab450de64983c5f9116102811e385f997a661c443e4efe01b6832613dbef6da5c1d9b30eeaad451
+  data.tar.gz: 54991a0795b8d7da63318264a5dcefec11cbe78e0ba151a9a53ab56ff8c39b4b6375070b80007d0c446b59c4bc7ad2ee8756c63c25a209f3cf0edfd79b6e900e

data/CHANGELOG.md

@@ -30,6 +30,59 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [7.1.10] - 2026-08-29
+
+- TAG: [v7.1.10][7.1.10t]
+- COVERAGE: 93.56% -- 10937/11690 lines in 16 files
+- BRANCH COVERAGE: 76.95% -- 4658/6053 branches in 16 files
+- 17.92% documented
+
+### Changed
+
+- Record template-run changelog updates before the bootstrap commit so generated changes and their maintenance summary are committed together.
+
+- [kc] kettle-jem-deps-floor: Update kettle-jem template dependency floors:
+  - kettle-changelog (>= 1.0.3 -> >= 1.0.5)
+  - kettle-dev (>= 3.0.13 -> >= 3.0.16)
+  - kettle-drift (>= 1.0.12 -> >= 1.0.13)
+  - kettle-family (>= 1.2.62 -> >= 1.2.63)
+  - kettle-jem (>= 7.1.7 -> >= 7.1.8)
+  - kettle-soup-cover (>= 3.0.9 -> >= 3.0.10)
+  - kettle-test (>= 2.0.20 -> >= 2.0.21)
+  - nomono (>= 1.1.4 -> >= 1.1.5)
+
+- [kc] kettle-jem-workflow-pins: Update pinned GitHub Actions in kettle-jem templates:
+  - apache/skywalking-eyes/dependency v0.8.0 (61275cc80d0798a405cb070f7d3a8aaf7cf2c2c1) -> v0.9.0 (a196742f472feaffafea537ce5a2a4c3c53a8de4)
+  - github/codeql-action/analyze v4.37.8 (db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28) -> v4.37.9 (cdf488f595d80d6e07e03d4674febd5ab45fa938)
+  - github/codeql-action/autobuild v4.37.8 (db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28) -> v4.37.9 (cdf488f595d80d6e07e03d4674febd5ab45fa938)
+  - github/codeql-action/init v4.37.8 (db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28) -> v4.37.9 (cdf488f595d80d6e07e03d4674febd5ab45fa938)
+
+- [kc] kettle-jem/template: updated 1194 project files:
+  - code and tests (60)
+  - configuration (36)
+  - dependencies (441)
+  - documentation (27)
+  - other (369)
+  - workflows (261)
+
+- [kc] kettle-jem-deps-floor: Update kettle-jem template dependency floors:
+  - kettle-dev (>= 3.0.16 -> >= 3.0.17)
+  - kettle-family (>= 1.2.63 -> >= 1.2.64)
+
+- [kc] kettle-jem/prepare: updated 13 project files:
+  - dependencies (13)
+
+- [kc] kettle-jem/template: updated 3 project files:
+  - code and tests (1)
+  - dependencies (1)
+  - other (1)
+
+### Fixed
+
+- Keep external superclass expressions out of generated standalone version files.
+
+- Skip template changelog recording for partial destination projects that do not contain a changelog.
+
 ## [7.1.8] - 2026-08-26
 
 - TAG: [v7.1.8][7.1.8t]
@@ -1621,7 +1674,9 @@ Please file a bug if you notice a violation of semantic versioning.
 - Released kettle-jem as part of the initial StructuredMerge Ruby 7.0.0 gem set.
 - Included packaged templates and parser-backed merge support for Ruby gem templating.
 
-[Unreleased]: https://github.com/structuredmerge/structuredmerge-ruby/compare/v7.1.8...HEAD
+[Unreleased]: https://github.com/structuredmerge/structuredmerge-ruby/compare/v7.1.10...HEAD
+[7.1.10]: https://github.com/structuredmerge/structuredmerge-ruby/compare/v7.1.8...v7.1.10
+[7.1.10t]: https://github.com/structuredmerge/structuredmerge-ruby/releases/tag/v7.1.10
 [7.1.8]: https://github.com/structuredmerge/structuredmerge-ruby/compare/v7.1.7...v7.1.8
 [7.1.8t]: https://github.com/structuredmerge/structuredmerge-ruby/releases/tag/v7.1.8
 [7.1.7]: https://github.com/structuredmerge/structuredmerge-ruby/compare/v7.1.6...v7.1.7

data/README.md

@@ -794,7 +794,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-11.606-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-11.690-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/structuredmerge/structuredmerge-ruby/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/kettle/jem/cli.rb

@@ -234,6 +234,8 @@ module Kettle
         end
         return result unless %w[setup prepare apply template install].include?(command)
 
+        return result if result.is_a?(Hash) && result.key?(:changelog)
+
         Kettle::Jem::MaintenanceChangelog.record_template_run(
           project_root: project_root,
           report: result,

data/lib/kettle/jem/maintenance_changelog.rb

@@ -95,6 +95,10 @@ module Kettle
           return report.merge(changelog: {status: "skipped", reason: "no_template_changes", changed_files: []})
         end
 
+        unless File.file?(File.join(project_root, "CHANGELOG.md"))
+          return report.merge(changelog: {status: "skipped", reason: "missing_changelog"})
+        end
+
         key = TEMPLATE_CHANGELOG_KEYS.fetch(label, "kettle-jem/template")
         entry = ->(matches) { template_run_entry(changed_files, matches) }
         result = upsert_unreleased_entry(project_root: project_root, section: "Changed", key: key, entry: entry)

data/lib/kettle/jem/tasks/install_task.rb

@@ -8,6 +8,7 @@ require "toml-rb"
 require "uri"
 require "yaml"
 require "kettle/rb/compat_matrix"
+require "kettle/jem/maintenance_changelog"
 
 module Kettle
   module Jem
@@ -48,7 +49,6 @@ module Kettle
           install_steps << rubocop_gradual_autocorrect_step(project_root, env: setup_env, run_options: effective_run_options)
           install_steps << normalize_lockfile_step(project_root, env: setup_env, run_options: effective_run_options)
           install_steps << bundled_handoff_step(project_root: project_root, env: env, run_options: effective_run_options)
-          install_steps << bootstrap_commit_step(project_root, run_options: effective_run_options)
           install_steps = execute_orchestration_steps(install_steps, project_root: project_root, env: setup_env, run_options: effective_run_options, command_runner: command_runner)
 
           final_report = report.merge(
@@ -62,6 +62,26 @@ module Kettle
               message: "kettle:jem:install applied templates, completed local post-template checks, and executed available orchestration steps."
             }]
           )
+          final_report = Kettle::Jem::MaintenanceChangelog.record_template_run(
+            project_root: project_root,
+            report: final_report,
+            run_options: effective_run_options
+          )
+          bootstrap_commit = bootstrap_commit_step(project_root, run_options: effective_run_options)
+          install_steps.concat(
+            execute_orchestration_steps(
+              [bootstrap_commit],
+              project_root: project_root,
+              env: setup_env,
+              run_options: effective_run_options,
+              command_runner: command_runner
+            )
+          )
+          final_report = final_report.merge(
+            install_steps: install_steps,
+            install_phase_reports: install_phase_reports(install_steps),
+            install_summary: install_step_summary(install_steps)
+          )
           Kettle::Jem.emit_summary_event(Kettle::Jem.event_stream_from_options(effective_run_options), final_report)
           final_report
         end

data/lib/kettle/jem/templates/.github/workflows/license-eye.yml.example

@@ -33,7 +33,7 @@ jobs:
           persist-credentials: false
 
       - name: Check Dependencies' License
-        uses: apache/skywalking-eyes/dependency@61275cc80d0798a405cb070f7d3a8aaf7cf2c2c1 # v0.8.0
+        uses: apache/skywalking-eyes/dependency@a196742f472feaffafea537ce5a2a4c3c53a8de4 # v0.9.0
         with:
           config: .licenserc.yaml
           mode: "{KJ|LICENSE_EYE:MODE}"

data/lib/kettle/jem/templates/gem.gemspec.example

@@ -118,7 +118,7 @@ Gem::Specification.new do |spec|
   #       and preferably a modular one (see gemfiles/modular/*.gemfile).
 
   # Dev, Test, & Release Tasks
-  spec.add_development_dependency("kettle-dev", "~> 3.0", ">= 3.0.13")             # ruby >= {KJ|MIN_TEST_RUBY}
+  spec.add_development_dependency("kettle-dev", "~> 3.0", ">= 3.0.17")             # ruby >= {KJ|MIN_TEST_RUBY}
 
   # Security
   spec.add_development_dependency("bundler-audit", "~> 0.9.3")                      # ruby >= 2.0.0
@@ -133,7 +133,7 @@ Gem::Specification.new do |spec|
   # Loads version files in anonymous namespaces for coverage without constant redefinition warnings.
   spec.add_development_dependency("anonymous_loader", "~> 0.1", ">= 0.1.3")         # ruby >= 2.2.0
   spec.add_development_dependency("appraisal2", "~> 3.2", ">= 3.2.2")               # ruby >= 1.8.7, for testing against multiple versions of dependencies
-  spec.add_development_dependency("kettle-test", "~> 2.0", ">= 2.0.20")            # ruby >= {KJ|MIN_TEST_RUBY}
+  spec.add_development_dependency("kettle-test", "~> 2.0", ">= 2.0.21")            # ruby >= {KJ|MIN_TEST_RUBY}
   spec.add_development_dependency("turbo_tests2", "~> 3.2", ">= 3.2.6")           # ruby >= 2.4.0, default kettle-test runner
 
   # Releasing

data/lib/kettle/jem/templates/gemfiles/modular/coverage.gemfile.example

@@ -7,7 +7,7 @@
 if ENV.fetch("KETTLE_DEV_DEV", "false").casecmp("false").zero?
   # Coverage (remote/released)
   platform :mri do
-    gem "kettle-soup-cover", "~> 3.0", ">= 3.0.9", require: false
+    gem "kettle-soup-cover", "~> 3.0", ">= 3.0.10", require: false
   end
 else
   eval_gemfile "coverage_local.gemfile"

data/lib/kettle/jem/templates/gemfiles/modular/templating.gemfile.example

@@ -23,7 +23,7 @@ end
 
 if kettle_remote
   # Template/plugin checks for released installs.
-  gem "kettle-drift", "~> 1.0", ">= 1.0.12", require: false
+  gem "kettle-drift", "~> 1.0", ">= 1.0.13", require: false
 end
 
 # Set STRUCTUREDMERGE_DEV=/path/to/structuredmerge/ruby/gems for local development with path-based dependencies.

data/lib/kettle/jem/templates/shim/Gemfile.example

@@ -6,7 +6,7 @@ shimmed_gem_path = ENV["KETTLE_JEM_SHIMMED_GEM_PATH"].to_s
 gem "{KJ|SHIMMED_GEM_NAME}", path: shimmed_gem_path unless shimmed_gem_path.empty?
 
 # Local workspace dependency wiring for templating_local.gemfile overrides.
-gem "nomono", "~> 1.1", ">= 1.1.4", require: false # ruby >= 3.2.0
+gem "nomono", "~> 1.1", ">= 1.1.5", require: false # ruby >= 3.2.0
 
 # Templating (env-switched: STRUCTUREDMERGE_DEV=/path/to/structuredmerge/ruby/gems for local paths)
 eval_gemfile "gemfiles/modular/templating.gemfile" if ENV.fetch("K_JEM_TEMPLATING", "false").casecmp("true").zero?

data/lib/kettle/jem/templates/shim/gem.gemspec.example

@@ -30,13 +30,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency "{KJ|SHIMMED_GEM_NAME}"
 
   # Dev, Test, & Release Tasks
-  spec.add_development_dependency("kettle-dev", "~> 3.0", ">= 3.0.13")             # ruby >= {KJ|MIN_TEST_RUBY}
+  spec.add_development_dependency("kettle-dev", "~> 3.0", ">= 3.0.17")             # ruby >= {KJ|MIN_TEST_RUBY}
 
   # Tasks
   spec.add_development_dependency "rake", "~> 13.0"
 
   # Testing
-  spec.add_development_dependency("kettle-test", "~> 2.0", ">= 2.0.20")            # ruby >= {KJ|MIN_TEST_RUBY}
+  spec.add_development_dependency("kettle-test", "~> 2.0", ">= 2.0.21")            # ruby >= {KJ|MIN_TEST_RUBY}
   spec.add_development_dependency "rspec", "~> 3.12"
 
   # Releasing

data/lib/kettle/jem/version.rb

@@ -5,7 +5,7 @@ module Kettle
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = "7.1.8"
+      VERSION = "7.1.10"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/kettle/jem.rb

@@ -525,6 +525,7 @@ module Kettle
     APPRAISAL_VERSION_SELECTION_MODES = %w[major minor patch minor-minmax semver].freeze
     DEFAULT_TEST_MINIMUM_RUBY = Gem::Version.new("2.4")
     REQUIRE_RELATIVE_MIN_RUBY = Gem::Version.new("2.2").freeze
+    ANONYMOUS_VERSION_LOADER_MIN_RUBY = Gem::Version.new("2.2").freeze
     MODERN_GEMSPEC_VERSION_LOADER_MIN_RUBY = Gem::Version.new("3.1").freeze
     APPRAISAL_DEFAULT_FRESHNESS_TTL = 604_800
     DECISION_ACTIONS = %w[create merge replace keep delete skip].freeze
@@ -3326,7 +3327,6 @@ module Kettle
       version_path = File.join("lib", entrypoint_require, "version.rb")
       entrypoint_path = File.join("lib", "#{entrypoint_require}.rb")
       configured_namespace = rubygems_config["namespace"].to_s.strip
-      entrypoint_namespace = existing_entrypoint_version_namespace(project_root, entrypoint_path)
       version_namespace = existing_version_namespace(project_root, version_path)
       version_namespace = reconcile_existing_version_namespace(
         project_root,
@@ -3334,27 +3334,38 @@ module Kettle
         version_path,
         version_namespace
       )
+      metadata_namespace = metadata_value(gemspec_metadata, :namespace)
+      default_namespace = classify_namespace(name)
+      namespace_hint = configured_namespace.empty? ? default_namespace : configured_namespace
+      entrypoint_namespace = existing_entrypoint_version_namespace(
+        project_root,
+        entrypoint_path,
+        expected_depth: namespace_hint.split("::").count { |segment| !segment.empty? }
+      )
+      namespace = configured_namespace.empty? ? nil : configured_namespace
+      namespace ||= project_namespace(
+        entrypoint_namespace: entrypoint_namespace,
+        version_namespace: version_namespace,
+        metadata_namespace: metadata_namespace,
+        default_namespace: default_namespace
+      )
       version_namespace_kinds = existing_version_namespace_kinds(
         project_root,
         version_path,
-        version_namespace,
+        namespace,
         entrypoint_path: entrypoint_path
       )
       version_namespace_superclasses = existing_version_namespace_superclasses(
         project_root,
         version_path,
-        version_namespace,
-        entrypoint_path: entrypoint_path
+        namespace
       )
-      metadata_namespace = metadata_value(gemspec_metadata, :namespace)
-      default_namespace = classify_namespace(name)
-      namespace = configured_namespace.empty? ? nil : configured_namespace
-      namespace ||= project_namespace(
-        entrypoint_namespace: entrypoint_namespace,
-        version_namespace: version_namespace,
-        metadata_namespace: metadata_namespace,
-        default_namespace: default_namespace
+      namespace_superclass_details = existing_namespace_superclass_details(
+        project_root,
+        namespace,
+        preferred_path: entrypoint_path
       )
+      entrypoint_namespace_superclasses = namespace_superclass_details.fetch(:superclasses)
       project_version = metadata_value(gemspec_metadata, :version)
       project_version = existing_version_file_value(project_root, version_path) unless valid_gem_version?(project_version)
       project_version = git_version_file_value(project_root, version_path) unless valid_gem_version?(project_version)
@@ -3428,6 +3439,8 @@ module Kettle
           min_ruby: min_ruby,
           version_namespace_kinds: version_namespace_kinds,
           version_namespace_superclasses: version_namespace_superclasses,
+          entrypoint_namespace_superclasses: entrypoint_namespace_superclasses,
+          entrypoint_namespace_superclass_path: namespace_superclass_details[:path],
           version_gem_default_enabled: version_gem_default_enabled_for_project?(rubygems_config, gemspec_metadata),
           engines: ruby_engines_config(kettle_config)
         )
@@ -5383,11 +5396,11 @@ module Kettle
       [
         {name: "appraisal2", source: %(gem "appraisal2", "~> 3.2", ">= 3.2.2"\n)},
         {name: "bundler-audit", source: %(gem "bundler-audit", "~> 0.9.3"\n)},
-        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 3.0", ">= 3.0.13"\n)},
-        {name: "kettle-drift", source: %(gem "kettle-drift", "~> 1.0", ">= 1.0.12"\n)},
-        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.62"\n)},
-        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.1", ">= 7.1.7"\n)},
-        {name: "kettle-test", source: %(gem "kettle-test", "~> 2.0", ">= 2.0.20"\n)},
+        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 3.0", ">= 3.0.17"\n)},
+        {name: "kettle-drift", source: %(gem "kettle-drift", "~> 1.0", ">= 1.0.13"\n)},
+        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.64"\n)},
+        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.1", ">= 7.1.8"\n)},
+        {name: "kettle-test", source: %(gem "kettle-test", "~> 2.0", ">= 2.0.21"\n)},
         {name: "rake", source: %(gem "rake", "~> 13.0"\n)},
         {name: "rspec", source: %(gem "rspec", "~> 3.0"\n)},
         {name: "stone_checksums", source: %(gem "stone_checksums", "~> 1.0", ">= 1.0.8"\n)},
@@ -5469,8 +5482,15 @@ module Kettle
       templated_paths = report.fetch(:recipe_reports, []).map { |recipe_report| recipe_report.fetch(:relative_path, "") }
       version_path = File.join("lib", entrypoint_require, "version.rb")
       signature_path = File.join("sig", "#{entrypoint_require}.rbs")
-      entrypoint_path = File.join("lib", "#{entrypoint_require}.rb")
       namespace = facts.dig(:rubygems, :namespace).to_s
+      entrypoint_path = facts.dig(:rubygems, :entrypoint_namespace_superclass_path).to_s
+      entrypoint_path = File.join("lib", "#{entrypoint_require}.rb") unless File.file?(File.join(project_root, entrypoint_path))
+      namespace_superclass_details = existing_namespace_superclass_details(
+        project_root,
+        namespace,
+        preferred_path: entrypoint_path
+      )
+      entrypoint_path = namespace_superclass_details[:path] if namespace_superclass_details[:path]
       version_gem_bootstrap_step_for_paths(
         project_root,
         facts,
@@ -5511,17 +5531,36 @@ module Kettle
 
       entrypoint_require = package_name.tr("-", "/") if entrypoint_require.to_s.empty?
       namespace = facts.dig(:rubygems, :namespace).to_s
-      namespace = classify_namespace(package_name) if namespace.empty?
       version_path = File.join("lib", entrypoint_require, "version.rb")
       entrypoint_path = File.join("lib", "#{entrypoint_require}.rb")
-      namespace = existing_entrypoint_version_namespace(project_root, entrypoint_path).to_s if namespace.empty?
+      if namespace.empty?
+        namespace = existing_entrypoint_version_namespace(
+          project_root,
+          entrypoint_path,
+          expected_depth: classify_namespace(package_name).split("::").count { |segment| !segment.empty? }
+        ).to_s
+      end
       namespace = existing_version_namespace(project_root, version_path).to_s if namespace.empty?
+      namespace = classify_namespace(package_name) if namespace.empty?
       return {name: "version_bootstrap", status: "unavailable", reason: "missing_package_facts"} if namespace.empty?
 
+      namespace_superclass_details = existing_namespace_superclass_details(
+        project_root,
+        namespace,
+        preferred_path: entrypoint_path
+      )
+      entrypoint_namespace_superclasses = namespace_superclass_details.fetch(:superclasses)
+      entrypoint_namespace_superclasses = entrypoint_namespace_superclasses.merge(
+        entrypoint_namespace_superclasses_from_facts(facts)
+      )
+      fact_superclass_path = facts.dig(:rubygems, :entrypoint_namespace_superclass_path).to_s
+      if entrypoint_namespace_superclasses.any? && File.file?(File.join(project_root, fact_superclass_path))
+        entrypoint_path = fact_superclass_path
+      elsif namespace_superclass_details[:path]
+        entrypoint_path = namespace_superclass_details[:path]
+      end
       templated_paths = report.fetch(:recipe_reports, []).map { |recipe_report| recipe_report.fetch(:relative_path, "") }
       changes = []
-      cleanup = version_gem_cleanup_step(project_root, facts)
-      changes.concat(Array(cleanup[:changed_files]))
       outer_namespace_kind = version_namespace_outer_kind(project_root, entrypoint_path, namespace)
       namespace_kinds = existing_version_namespace_kinds(
         project_root,
@@ -5529,12 +5568,13 @@ module Kettle
         namespace,
         entrypoint_path: entrypoint_path
       )
-      namespace_superclasses = existing_version_namespace_superclasses(
+      cleanup = version_gem_cleanup_step(
         project_root,
-        version_path,
-        namespace,
-        entrypoint_path: entrypoint_path
+        facts,
+        entrypoint_path: entrypoint_path,
+        after_declarations: !entrypoint_namespace_superclasses.empty?
       )
+      changes.concat(Array(cleanup[:changed_files]))
       preserve_version_module_include = existing_version_file_includes_version_module?(project_root, version_path) if preserve_version_module_include.nil?
       unless templated_paths.include?(version_path) && outer_namespace_kind != :class
         version = facts.dig(:project_runtime, :version).to_s
@@ -5549,7 +5589,6 @@ module Kettle
             version: version,
             outer_namespace_kind: outer_namespace_kind,
             namespace_kinds: namespace_kinds,
-            namespace_superclasses: namespace_superclasses,
             preserve_version_module_include: preserve_version_module_include
           )
         )
@@ -5593,13 +5632,13 @@ module Kettle
       }
     end
 
-    def version_gem_cleanup_step(project_root, facts, cleanup_entrypoint: true)
+    def version_gem_cleanup_step(project_root, facts, cleanup_entrypoint: true, after_declarations: false, entrypoint_path: nil)
       package_name = facts.dig(:package, :name).to_s
       return {name: "version_gem_cleanup", status: "unavailable", reason: "missing_package_facts"} if package_name.empty?
 
       entrypoint_require = facts.dig(:rubygems, :entrypoint_require).to_s
       entrypoint_require = package_name.tr("-", "/") if entrypoint_require.empty?
-      entrypoint_path = File.join("lib", "#{entrypoint_require}.rb")
+      entrypoint_path ||= File.join("lib", "#{entrypoint_require}.rb")
       dedicated_entrypoint_path = File.join("lib", entrypoint_require, "version_gem.rb")
       version_spec_path = File.join("spec", entrypoint_require, "version_spec.rb")
       changed_files = []
@@ -5609,7 +5648,8 @@ module Kettle
         cleaned = version_gem_free_entrypoint_content(
           current,
           entrypoint_require: entrypoint_require,
-          ensure_version_require: File.file?(version_path)
+          ensure_version_require: File.file?(version_path),
+          after_declarations: after_declarations
         )
         changed_files << write_if_changed(project_root, entrypoint_path, cleaned)
       end
@@ -6894,10 +6934,12 @@ module Kettle
       modern = Gem::Version.new(min_ruby) >= MODERN_GEMSPEC_VERSION_LOADER_MIN_RUBY
       before_legacy = !gemspec_top_level_gem_version_node(original).nil?
       after_legacy = !gemspec_top_level_gem_version_node(final).nil?
+      superclass_sensitive = gemspec_version_loader_superclass_sensitive?(request[:runtime_context] || request["runtime_context"] || {})
       {
         operation: "rewrite_version_loader",
         min_ruby: min_ruby,
         mode: modern ? "modern" : "legacy",
+        superclass_sensitive: superclass_sensitive,
         legacy_preamble_removed: before_legacy && !after_legacy,
         legacy_preamble_present: after_legacy
       }
@@ -8208,8 +8250,6 @@ module Kettle
         )
       end
       main_gemfile_nomono_requirement_records(output).fetch(:calls).sort_by { |record| -record.fetch(:start_line) }.reduce(output) do |memo, record|
-        next memo unless record.fetch(:source).include?("*nomono_requirements")
-
         replace_source_range_lines(memo, record.fetch(:start_line), record.fetch(:end_line), "#{nomono_gemfile_declaration}\n")
       end
     end
@@ -10526,7 +10566,18 @@ module Kettle
       modern = min_ruby_version >= MODERN_GEMSPEC_VERSION_LOADER_MIN_RUBY
       rhs = modern ? gemspec_modern_version_loader_expression(entrypoint_require: entrypoint_require, namespace: namespace) : "gem_version"
       rewritten = replace_gemspec_version_assignment(content, receiver: receiver, rhs: rhs)
-      modern ? remove_gemspec_legacy_version_loader_preamble(rewritten) : ensure_gemspec_legacy_version_loader_preamble(rewritten, entrypoint_require: entrypoint_require, namespace: namespace, min_ruby: min_ruby_version)
+      if modern
+        remove_gemspec_legacy_version_loader_preamble(rewritten)
+      else
+        ensure_gemspec_legacy_version_loader_preamble(
+          rewritten,
+          entrypoint_require: entrypoint_require,
+          namespace: namespace,
+          min_ruby: min_ruby_version,
+          superclass_sensitive: gemspec_version_loader_superclass_sensitive?(facts),
+          fallback_version: facts.to_h.dig(:project_runtime, :version)
+        )
+      end
     rescue ArgumentError, Ast::Crispr::Error
       content
     end
@@ -10546,7 +10597,48 @@ module Kettle
       %(Module.new.tap { |mod| Kernel.load("\#{__dir__}/lib/#{entrypoint_require}/version.rb", mod) }::#{namespace}::Version::VERSION)
     end
 
-    def gemspec_legacy_version_loader_block(entrypoint_require:, namespace:, min_ruby:)
+    def gemspec_legacy_version_loader_block(entrypoint_require:, namespace:, min_ruby:, superclass_sensitive: false, fallback_version: nil)
+      unless superclass_sensitive
+        return gemspec_standard_legacy_version_loader_block(
+          entrypoint_require: entrypoint_require,
+          namespace: namespace,
+          min_ruby: min_ruby
+        )
+      end
+
+      anonymous_loader = <<~RUBY.chomp
+        require "anonymous_loader"
+        path = File.expand_path("lib/#{entrypoint_require}/version.rb", __dir__)
+        anonymous_namespace = AnonymousLoader.load(files: path)
+        anonymous_namespace::#{namespace}::Version::VERSION
+      RUBY
+      anonymous_loader_lines = anonymous_loader.lines.map { |line| "    #{line.chomp}" }
+      fallback = fallback_version.to_s
+      fallback = "0.0.0" if fallback.empty?
+      lines = [
+        "gem_version =",
+        "  if Gem.ruby_version >= Gem::Version.new(\"3.1\")",
+        "    # Loading Version into an anonymous module allows version.rb to get code coverage from SimpleCov!",
+        "    # See: https://github.com/simplecov-ruby/simplecov/issues/557#issuecomment-2630782358",
+        "    # See: https://github.com/panorama-ed/memo_wise/pull/397",
+        "    #{gemspec_modern_version_loader_expression(entrypoint_require: entrypoint_require, namespace: namespace)}"
+      ]
+      lines << "  # The namesake namespace has a superclass. Directly requiring version.rb"
+      lines << "  # on legacy Ruby could define that namespace with the wrong superclass."
+      if min_ruby < ANONYMOUS_VERSION_LOADER_MIN_RUBY
+        lines << "  elsif Gem.ruby_version >= Gem::Version.new(\"2.2\")"
+        lines.concat(anonymous_loader_lines)
+        lines << "  else"
+        lines << "    #{fallback.dump}"
+      else
+        lines << "  else"
+        lines.concat(anonymous_loader_lines)
+      end
+      lines << "  end"
+      "#{lines.join("\n")}\n"
+    end
+
+    def gemspec_standard_legacy_version_loader_block(entrypoint_require:, namespace:, min_ruby:)
       legacy_require =
         if min_ruby >= REQUIRE_RELATIVE_MIN_RUBY
           %(require_relative "lib/#{entrypoint_require}/version")
@@ -10574,6 +10666,14 @@ module Kettle
       RUBY
     end
 
+    def gemspec_version_loader_superclass_sensitive?(facts)
+      rubygems = facts.to_h[:rubygems]
+      return false unless rubygems.is_a?(Hash)
+
+      value = rubygems[:entrypoint_namespace_superclasses]
+      value.is_a?(Hash) && !value.empty?
+    end
+
     def remove_gemspec_legacy_version_loader_preamble(content)
       node = gemspec_top_level_gem_version_node(content)
       unless node
@@ -10606,8 +10706,8 @@ module Kettle
       {start_line: start_index + 1, end_line: end_line}
     end
 
-    def ensure_gemspec_legacy_version_loader_preamble(content, entrypoint_require:, namespace:, min_ruby:)
-      block = "#{gemspec_legacy_version_loader_block(entrypoint_require: entrypoint_require, namespace: namespace, min_ruby: min_ruby)}\n"
+    def ensure_gemspec_legacy_version_loader_preamble(content, entrypoint_require:, namespace:, min_ruby:, superclass_sensitive: false, fallback_version: nil)
+      block = "#{gemspec_legacy_version_loader_block(entrypoint_require: entrypoint_require, namespace: namespace, min_ruby: min_ruby, superclass_sensitive: superclass_sensitive, fallback_version: fallback_version)}\n"
       node = gemspec_top_level_gem_version_node(content)
       return replace_source_range_lines(content, node.location.start_line, expand_line_range_through_following_blanks(content, node.location.end_line), block) if node
 
@@ -14098,7 +14198,7 @@ module Kettle
               root: ["src", "my", "kettle-dev"]
             )
           elsif Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("4.0.0")
-            gem "kettle-changelog", "~> 1.0", ">= 1.0.3"
+            gem "kettle-changelog", "~> 1.0", ">= 1.0.5"
           end
         end
       RUBY
@@ -15122,7 +15222,7 @@ module Kettle
     def main_gemfile_kettle_family_gem(package_name)
       return "" if package_name.to_s == "kettle-family"
 
-      %(gem "kettle-family", "~> 1.2", ">= 1.2.62"\n)
+      %(gem "kettle-family", "~> 1.2", ">= 1.2.64"\n)
     end
 
     def main_gemfile_nomono_bootstrap(package_name)
@@ -15135,7 +15235,7 @@ module Kettle
     end
 
     def nomono_gemfile_declaration
-      %(gem "nomono", "~> 1.1", ">= 1.1.4", require: false # ruby >= 3.2.0)
+      %(gem "nomono", "~> 1.1", ">= 1.1.5", require: false # ruby >= 3.2.0)
     end
 
     def local_gemfile_nomono_bootstrap(_package_name)
@@ -15143,7 +15243,7 @@ module Kettle
         # Bootstrapping nomono here cannot rely on a plain `gem "nomono", ...` line.
         # Bundler records that dependency during Gemfile evaluation, but it does not
         # activate that exact version before the immediate `require "nomono/bundler"`.
-        nomono_activation_requirements = ["~> 1.1", ">= 1.1.4"]
+        nomono_activation_requirements = ["~> 1.1", ">= 1.1.5"]
         nomono_requirement = Gem::Requirement.new(nomono_activation_requirements)
         nomono_already_activated = Gem.loaded_specs["nomono"]
         nomono_lockfile = File.expand_path("../../Gemfile.lock", __dir__)
@@ -15221,6 +15321,36 @@ module Kettle
       )
       default_entrypoint_path = File.join("lib", "#{entrypoint_require}.rb")
       default_entrypoint = read_project_file(project_root, default_entrypoint_path)
+      version_spec_path = File.join("spec", entrypoint_require, "version_spec.rb")
+      signature_path = File.join("sig", "#{entrypoint_require}.rbs")
+      legacy_signature_paths = legacy_rbs_signature_paths(project_root, entrypoint_require)
+      namespace = facts.dig(:rubygems, :namespace).to_s
+      if namespace.empty?
+        namespace = existing_entrypoint_version_namespace(
+          project_root,
+          entrypoint_path,
+          expected_depth: classify_namespace(package_name).split("::").count { |segment| !segment.empty? }
+        ).to_s
+      end
+      namespace = existing_version_namespace(project_root, version_path).to_s if namespace.empty?
+      namespace = classify_namespace(package_name) if namespace.empty?
+      return {name: "version_gem_bootstrap", status: "unavailable", reason: "missing_package_facts"} if namespace.empty?
+
+      namespace_superclass_details = existing_namespace_superclass_details(
+        project_root,
+        namespace,
+        preferred_path: entrypoint_path
+      )
+      entrypoint_namespace_superclasses = namespace_superclass_details.fetch(:superclasses)
+      entrypoint_namespace_superclasses = entrypoint_namespace_superclasses.merge(
+        entrypoint_namespace_superclasses_from_facts(facts)
+      )
+      fact_superclass_path = facts.dig(:rubygems, :entrypoint_namespace_superclass_path).to_s
+      if entrypoint_namespace_superclasses.any? && File.file?(File.join(project_root, fact_superclass_path))
+        entrypoint_path = fact_superclass_path
+      elsif namespace_superclass_details[:path]
+        entrypoint_path = namespace_superclass_details[:path]
+      end
       default_entrypoint_loads_version = entrypoint_path != default_entrypoint_path &&
         entrypoint_loads_version_file?(
           default_entrypoint,
@@ -15228,25 +15358,20 @@ module Kettle
           entrypoint_path: default_entrypoint_path,
           version_path: version_path
         )
-      version_spec_path = File.join("spec", entrypoint_require, "version_spec.rb")
-      signature_path = File.join("sig", "#{entrypoint_require}.rbs")
-      legacy_signature_paths = legacy_rbs_signature_paths(project_root, entrypoint_require)
-      namespace = existing_version_namespace(project_root, version_path).to_s
-      namespace = facts.dig(:rubygems, :namespace).to_s if namespace.empty?
-      namespace = classify_namespace(package_name) if namespace.empty?
-      namespace = existing_entrypoint_version_namespace(project_root, entrypoint_path).to_s if namespace.empty?
-      return {name: "version_gem_bootstrap", status: "unavailable", reason: "missing_package_facts"} if namespace.empty?
-
       version = facts.dig(:project_runtime, :version).to_s
       version = project_gemspec_version(project_root) if version.empty?
       version = "0.0.1.pre" if version.empty?
       changes = []
       current_entrypoint = read_project_file(project_root, entrypoint_path)
       outer_namespace_kind = ruby_entrypoint_outer_namespace_kind(current_entrypoint, namespace)
-      namespace_kinds = existing_version_namespace_kinds(project_root, version_path, namespace)
-      namespace_kinds = namespace_kinds.merge(version_namespace_kinds_from_facts(facts))
-      namespace_superclasses = existing_version_namespace_superclasses(project_root, version_path, namespace)
-      namespace_superclasses = namespace_superclasses.merge(version_namespace_superclasses_from_facts(facts))
+      namespace_kinds = version_namespace_kinds_from_facts(facts).merge(
+        existing_version_namespace_kinds(
+          project_root,
+          version_path,
+          namespace,
+          entrypoint_path: entrypoint_path
+        )
+      )
       preserve_version_module_include = existing_version_file_includes_version_module?(project_root, version_path) if preserve_version_module_include.nil?
 
       if manage_version_file
@@ -15259,7 +15384,6 @@ module Kettle
             version: version,
             outer_namespace_kind: outer_namespace_kind,
             namespace_kinds: namespace_kinds,
-            namespace_superclasses: namespace_superclasses,
             preserve_version_module_include: preserve_version_module_include
           )
         )
@@ -15271,6 +15395,7 @@ module Kettle
           current_entrypoint,
           entrypoint_require: entrypoint_require,
           ensure_version_require: !default_entrypoint_loads_version,
+          after_declarations: !entrypoint_namespace_superclasses.empty?,
           version_require_path: version_require_path_for_entrypoint(entrypoint_path, version_path)
         )
       elsif current_entrypoint.empty?
@@ -15280,6 +15405,7 @@ module Kettle
           current_entrypoint,
           namespace: namespace,
           entrypoint_require: entrypoint_require,
+          namespace_superclasses: entrypoint_namespace_superclasses,
           version_require_path: version_require_path_for_entrypoint(entrypoint_path, version_path)
         )
       end
@@ -15662,7 +15788,7 @@ module Kettle
       version_gem_require_insertion_index(content)
     end
 
-    def version_gem_version_file_content(existing_version:, namespace:, version:, outer_namespace_kind: :module, namespace_kinds: {}, namespace_superclasses: {}, preserve_version_module_include: false)
+    def version_gem_version_file_content(existing_version:, namespace:, version:, outer_namespace_kind: :module, namespace_kinds: {}, preserve_version_module_include: false)
       resolved_version = existing_version.to_s.empty? ? version.to_s : existing_version.to_s
       body = [
         "# Version namespace for this gem.",
@@ -15678,7 +15804,7 @@ module Kettle
       <<~RUBY
         # frozen_string_literal: true
 
-        #{wrap_ruby_namespace(namespace, body, outer_namespace_kind: outer_namespace_kind, namespace_kinds: namespace_kinds, namespace_superclasses: namespace_superclasses).join("\n")}
+        #{wrap_ruby_namespace(namespace, body, outer_namespace_kind: outer_namespace_kind, namespace_kinds: namespace_kinds).join("\n")}
       RUBY
     end
 
@@ -15705,11 +15831,12 @@ module Kettle
       "#{wrap_ruby_namespace(namespace, body).join("\n")}\n"
     end
 
-    def version_gem_bootstrap_entrypoint_content(content, namespace:, entrypoint_require:, version_require_path: nil)
+    def version_gem_bootstrap_entrypoint_content(content, namespace:, entrypoint_require:, namespace_superclasses: {}, version_require_path: nil)
       current = normalize_entrypoint_version_require(
         content,
         entrypoint_require: entrypoint_require,
-        version_require_path: version_require_path
+        version_require_path: version_require_path,
+        after_declarations: !namespace_superclasses.empty?
       )
       current = remove_version_gem_class_eval_references(current) unless ruby_version_class_eval_namespaces(current).include?(namespace.to_s)
       lines = current.lines
@@ -15730,7 +15857,7 @@ module Kettle
       collapse_excess_blank_lines(updated)
     end
 
-    def version_gem_free_entrypoint_content(content, entrypoint_require:, ensure_version_require: true, version_require_path: nil)
+    def version_gem_free_entrypoint_content(content, entrypoint_require:, ensure_version_require: true, after_declarations: false, version_require_path: nil)
       current = remove_version_gem_entrypoint_references(content)
       unless ensure_version_require
         relative_path = version_require_path.to_s.empty? ? File.join(File.basename(entrypoint_require), "version") : version_require_path.to_s
@@ -15745,17 +15872,23 @@ module Kettle
       normalize_entrypoint_version_require(
         current,
         entrypoint_require: entrypoint_require,
-        version_require_path: version_require_path
+        version_require_path: version_require_path,
+        after_declarations: after_declarations
       )
     end
 
-    def normalize_entrypoint_version_require(content, entrypoint_require:, version_require_path: nil)
+    def normalize_entrypoint_version_require(content, entrypoint_require:, version_require_path: nil, after_declarations: false)
       relative_path = version_require_path.to_s.empty? ? File.join(File.basename(entrypoint_require), "version") : version_require_path.to_s
       absolute_path = File.join(entrypoint_require, "version")
       legacy_relative_path = File.join(File.basename(entrypoint_require), "version")
       current = [relative_path, legacy_relative_path].uniq.reduce(content) do |value, path|
         remove_entrypoint_version_requires(value, relative_path: path, absolute_path: absolute_path)
       end
+      if after_declarations
+        current = trim_trailing_blank_lines(collapse_excess_blank_lines(current))
+        return "#{current}\n\nrequire_relative \"#{relative_path}\"\n" unless current.empty?
+      end
+
       lines = current.lines
       lines.insert(version_gem_require_insertion_index(current), %(require_relative "#{relative_path}"\n), "\n")
       trim_trailing_blank_lines(collapse_excess_blank_lines(lines.join))
@@ -15923,6 +16056,9 @@ module Kettle
       kind = version_namespace_outer_kind(project_root, entrypoint_path, namespace)
       return kind if kind == :class
 
+      entrypoint_kind = ruby_namespace_declaration_kind(read_project_file(project_root, entrypoint_path), namespace)
+      return entrypoint_kind if entrypoint_kind == :class
+
       configured_kinds = version_namespace_kinds_from_facts(facts)
       target_index = namespace.to_s.split("::").count { |element| !element.empty? } - 1
       configured_kind = configured_kinds[target_index]
@@ -15951,6 +16087,16 @@ module Kettle
       end
     end
 
+    def entrypoint_namespace_superclasses_from_facts(facts)
+      raw = facts.dig(:rubygems, :entrypoint_namespace_superclasses)
+      return {} unless raw.is_a?(Hash)
+
+      raw.each_with_object({}) do |(index, superclass), superclasses|
+        value = superclass.to_s.strip
+        superclasses[index.to_i] = value unless value.empty?
+      end
+    end
+
     def ruby_entrypoint_outer_namespace_kind(content, namespace)
       first_segment = namespace.to_s.split("::").reject(&:empty?).first
       return :module if first_segment.to_s.empty?
@@ -16064,6 +16210,27 @@ module Kettle
       end
     end
 
+    def existing_namespace_superclass_details(project_root, namespace, preferred_path: nil)
+      library_paths = [preferred_path, *ruby_library_source_paths(project_root)].compact.uniq
+      library_paths.each do |relative_path|
+        superclasses = existing_version_namespace_superclasses(project_root, relative_path, namespace)
+        next if superclasses.empty?
+
+        return {path: relative_path, superclasses: superclasses}
+      end
+
+      {path: nil, superclasses: {}}
+    end
+
+    def ruby_library_source_paths(project_root)
+      Dir.glob(File.join(project_root, "lib", "**", "*.rb")).sort.filter_map do |path|
+        relative_path = Pathname(path).relative_path_from(Pathname(project_root)).to_s
+        next if relative_path.end_with?("/version.rb", "/version_gem.rb")
+
+        relative_path
+      end
+    end
+
     def ruby_namespace_declaration_kind(content, namespace)
       target = namespace.to_s.split("::").reject(&:empty?)
       body = prism_parse_success(content)&.value&.statements&.body || []
@@ -16154,8 +16321,13 @@ module Kettle
       node&.slice.to_s.split("::").reject(&:empty?)
     end
 
-    def existing_entrypoint_version_namespace(project_root, relative_path)
+    def existing_entrypoint_version_namespace(project_root, relative_path, expected_depth: nil)
       content = read_project_file(project_root, relative_path)
+      if expected_depth
+        return ruby_entrypoint_module_namespace(content, expected_depth: expected_depth) ||
+            ruby_version_class_eval_namespaces(content).first
+      end
+
       ruby_version_class_eval_namespaces(content).first || ruby_entrypoint_module_namespace(content)
     end
 
@@ -16169,24 +16341,27 @@ module Kettle
       end
     end
 
-    def ruby_entrypoint_module_namespace(content)
+    def ruby_entrypoint_module_namespace(content, expected_depth: nil)
       body = prism_parse_success(content)&.value&.statements&.body || []
       body.each do |node|
-        namespace = ruby_entrypoint_module_namespace_for(node, [])
+        namespace = ruby_entrypoint_module_namespace_for(node, [], expected_depth: expected_depth)
         return namespace if namespace
       end
       nil
     end
 
-    def ruby_entrypoint_module_namespace_for(node, namespace)
+    def ruby_entrypoint_module_namespace_for(node, namespace, expected_depth: nil)
       return unless node.is_a?(::Prism::ModuleNode) || node.is_a?(::Prism::ClassNode)
 
       current = namespace + ruby_constant_path_segments(node.constant_path)
+      return current.join("::") if expected_depth && current.length == expected_depth
+      return if expected_depth && current.length > expected_depth
+
       node.body&.body&.each do |child|
-        child_namespace = ruby_entrypoint_module_namespace_for(child, current)
+        child_namespace = ruby_entrypoint_module_namespace_for(child, current, expected_depth: expected_depth)
         return child_namespace if child_namespace
       end
-      current.join("::") unless current.empty?
+      current.join("::") unless expected_depth || current.empty?
     end
 
     def read_project_file(project_root, relative_path)
@@ -19639,11 +19814,11 @@ module Kettle
         "actions/upload-artifact" => "actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1",
         "amancevice/setup-code-climate" => "amancevice/setup-code-climate@0daf2985a225e8ac15975b4d233010e94d65b76a # v2",
         "actions/dependency-review-action" => "actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0",
-        "github/codeql-action/init" => "github/codeql-action/init@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8",
-        "github/codeql-action/autobuild" => "github/codeql-action/autobuild@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8",
-        "github/codeql-action/analyze" => "github/codeql-action/analyze@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8",
+        "github/codeql-action/init" => "github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9",
+        "github/codeql-action/autobuild" => "github/codeql-action/autobuild@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9",
+        "github/codeql-action/analyze" => "github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9",
         "pozil/auto-assign-issue" => "pozil/auto-assign-issue@af6beea6bdf1e8eb373f061c5bc168681fc6d011 # v4.0.1",
-        "apache/skywalking-eyes/dependency" => "apache/skywalking-eyes/dependency@61275cc80d0798a405cb070f7d3a8aaf7cf2c2c1 # v0.8.0",
+        "apache/skywalking-eyes/dependency" => "apache/skywalking-eyes/dependency@a196742f472feaffafea537ce5a2a4c3c53a8de4 # v0.9.0",
         "sarisia/actions-status-discord" => "sarisia/actions-status-discord@eb045afee445dc055c18d3d90bd0f244fd062708 # v1.16.0"
       }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-jem
 version: !ruby/object:Gem::Version
-  version: 7.1.8
+  version: 7.1.10
 platform: ruby
 authors:
 - Peter H. Boling
@@ -676,7 +676,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.20
+        version: 2.0.21
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -686,7 +686,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.20
+        version: 2.0.21
 - !ruby/object:Gem::Dependency
   name: turbo_tests2
   requirement: !ruby/object:Gem::Requirement
@@ -976,10 +976,10 @@ licenses:
 - PolyForm-Small-Business-1.0.0
 metadata:
   homepage_uri: https://structuredmerge.org
-  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.8
-  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.8/CHANGELOG.md
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.10
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.10/CHANGELOG.md
   bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-jem/7.1.8
+  documentation_uri: https://www.rubydoc.info/gems/kettle-jem/7.1.10
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
   news_uri: https://www.railsbling.com/tags/kettle-jem