rigortype 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 231749c95c76ed2647fb26973b926e0330953a1eb818b2f363acfbd241cab418
-  data.tar.gz: 46a2f8dd756c64c1f49996d5a84716c2089f7af9d3f8d4f0e1af079fad72da54
+  metadata.gz: 2fb4015697adf7cbc9d65b2ca6ff954c8cac5f784ffb9616153d4af8d2505ccc
+  data.tar.gz: 52ee5acb7d233c0e86c8cdca45151c5f745b4c13d7155fcb15fafdaaed1d6dc9
 SHA512:
-  metadata.gz: bfd342d93895c61d6afbac3323ea7e7b79648ca0fec370e05c68b864769107ef2dbe0c9540ea0410c73499b7fdde3187166edcb01158ce9c9991a114ff63ffa8
-  data.tar.gz: 5a5b01c1fb25acc2f2fb416e5e4eb7ceb9dd15a90975ad7851aa6183c28716059d5331c58b95b8ec09936db43275118934ebbea84d64d443d35b0296e9dcf906
+  metadata.gz: 4f4b64afe3dbca26f6224762a2f1a3dd0bd4cade2ea9a61a30e2fba28ed29d3bb6d68bdfa73fb450536e5c7fef45e07a10a6fd0cec693ad228a828ff30905f8e
+  data.tar.gz: 4b5faa0d8c7295067f5a0f3d335c1800f22659e47b0428942405b07c1d38649163090f3a461e942a82aecaab6172e774ef88ca44f9a569b1392cdeee0be04086

data/README.md

@@ -265,10 +265,12 @@ In-source suppression: `# rigor:disable <rule>` silences a single line;
 
 ## Status
 
-Current released version: **`v0.1.8`** (2026-05-21). The analyzer is
+Current released version: **`v0.1.15`** (2026-05-29). The analyzer is
 usable on real Ruby code today; the rule catalogue is deliberately
 conservative — Rigor's stance is to surface zero false positives while
-the inference surface stabilises.
+the inference surface stabilises. The `0.1.x` preview line has been
+hardened against real OSS Rails codebases (Mastodon / Redmine / GitLab
+FOSS); `v0.2.0` will open the first evaluation release.
 
 Release history: [`CHANGELOG.md`](CHANGELOG.md). Forward-looking
 commitments: [Roadmap](https://rigor.typedduck.fail/reference/roadmap/).

data/exe/rigor

@@ -1,6 +1,25 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# ADR-39 slice 5 — the `ruby_box` plugin-isolation strategy needs the
+# experimental `Ruby::Box` feature, which is a process-start flag
+# (`RUBY_BOX=1`, not toggleable at runtime). When a project selects that
+# strategy (`RIGOR_PLUGIN_ISOLATION=ruby_box`, or the legacy `RIGOR_BOX`
+# alias) we re-exec the same command with the flag set before anything
+# else loads. The `RUBY_BOX` guard prevents an infinite re-exec, and the
+# inherited environment (RUBYOPT / BUNDLE_*) preserves the Bundler
+# context across the exec. The `none` (default) and `process` strategies
+# need no flag, so this is a no-op for them — behaviour is unchanged
+# unless a project opts into `ruby_box`.
+rigor_isolation = ENV["RIGOR_PLUGIN_ISOLATION"].to_s
+rigor_wants_box = rigor_isolation == "ruby_box" || !ENV["RIGOR_BOX"].to_s.empty?
+if rigor_wants_box && ENV["RUBY_BOX"].to_s.empty?
+  require "rbconfig"
+  ENV["RUBY_BOX"] = "1"
+  ENV["RIGOR_PLUGIN_ISOLATION"] = "ruby_box" if rigor_isolation.empty?
+  exec(RbConfig.ruby, __FILE__, *ARGV)
+end
+
 lib = File.expand_path("../lib", __dir__)
 $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 

data/lib/rigor/analysis/check_rules.rb

@@ -383,7 +383,16 @@ module Rigor
           # its model). Flagging an undefined method on a class
           # with an open dynamic surface is unsound, so the rule
           # skips it.
-          return nil if open_receiver?(class_name, scope)
+          # An unbounded receiver surface: either a plugin-declared
+          # open receiver (ADR-26 — e.g. `ActiveRecord::Relation`), or
+          # a type Rigor synthesized (a missing-namespace module / a
+          # stub for a referenced-but-undeclared type) to keep a
+          # malformed project signature buildable. A synthesized stub's
+          # method table is empty only because Rigor invented it, not
+          # because the real type is empty (the real `DRb` has
+          # `start_service`), so enumerating it to prove a call
+          # "undefined" would be a false positive.
+          return nil if unbounded_receiver_surface?(class_name, scope)
 
           # Slice 7 phase 12 — suppress when the user has
           # declared the method in source (`def` /
@@ -566,6 +575,14 @@ module Rigor
         # loaded plugin (manifest `open_receivers:`). An open
         # class responds beyond its RBS surface, so the
         # `call.undefined-method` rule must not fire for it.
+        # True when the receiver class responds beyond an enumerable
+        # RBS method table, so proving a call "undefined" against it is
+        # unsound: a plugin-declared open receiver, or a Rigor-
+        # synthesized stub type (see `RbsLoader#synthesized_type_names`).
+        def unbounded_receiver_surface?(class_name, scope)
+          open_receiver?(class_name, scope) || synthesized_stub_receiver?(class_name, scope)
+        end
+
         def open_receiver?(class_name, scope)
           registry = scope.environment&.plugin_registry
           return false if registry.nil?
@@ -573,6 +590,13 @@ module Rigor
           registry.open_receiver?(class_name)
         end
 
+        def synthesized_stub_receiver?(class_name, scope)
+          loader = scope.environment&.rbs_loader
+          return false if loader.nil? || !loader.respond_to?(:synthesized_type_names)
+
+          loader.synthesized_type_names.include?(class_name.to_s.sub(/\A::/, ""))
+        end
+
         def definition_available?(receiver_type, class_name, scope)
           if receiver_type.is_a?(Type::Singleton)
             !Rigor::Reflection.singleton_definition(class_name, scope: scope).nil?

data/lib/rigor/analysis/diagnostic.rb

@@ -59,6 +59,46 @@ module Rigor
         @project_definition_site = project_definition_site
       end
 
+      # Builds a Diagnostic positioned at a Prism node. Internalises
+      # the load-bearing convention every caller otherwise repeats:
+      # the line is the node's 1-based `start_line` and the column is
+      # `start_column + 1` (Prism columns are 0-based; Rigor reports
+      # 1-based). Pass any node responding to `#location`; all other
+      # fields forward to `#initialize` unchanged.
+      #
+      # `Plugin::Base#diagnostic` wraps this for plugin authors (who
+      # must not set `source_family` — the runner stamps it); core
+      # rules and other producers call it directly.
+      def self.from_node(node, path:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
+                         source_family: DEFAULT_SOURCE_FAMILY,
+                         receiver_type: nil, method_name: nil, project_definition_site: nil)
+        from_location(
+          node.location, path: path, message: message, severity: severity, rule: rule,
+                         source_family: source_family, receiver_type: receiver_type,
+                         method_name: method_name, project_definition_site: project_definition_site
+        )
+      end
+
+      # Builds a Diagnostic from an explicit Prism location, applying
+      # the same 1-based `line` / `start_column + 1` convention as
+      # {.from_node}. Use this when the diagnostic should point at a
+      # *sub-location* rather than the whole node — most often a call's
+      # `message_loc` (the matcher / method name) instead of the
+      # receiver-spanning `node.location`. {.from_node} is sugar for
+      # `from_location(node.location, …)`.
+      def self.from_location(location, path:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
+                             source_family: DEFAULT_SOURCE_FAMILY,
+                             receiver_type: nil, method_name: nil, project_definition_site: nil)
+        new(
+          path: path,
+          line: location.start_line,
+          column: location.start_column + 1,
+          message: message, severity: severity, rule: rule, source_family: source_family,
+          receiver_type: receiver_type, method_name: method_name,
+          project_definition_site: project_definition_site
+        )
+      end
+
       def error?
         severity == :error
       end

data/lib/rigor/analysis/runner.rb

@@ -106,6 +106,7 @@ module Rigor
         # nil-guards.
         @class_decl_paths_snapshot = {}.freeze
         @signature_paths_snapshot = [].freeze
+        @synthesized_namespaces_snapshot = [].freeze
         @cached_plugin_prepare_diagnostics = [].freeze
         @project_discovered_classes = {}.freeze
         @project_discovered_def_nodes = {}.freeze
@@ -113,6 +114,7 @@ module Rigor
         @project_discovered_superclasses = {}.freeze
         @project_discovered_includes = {}.freeze
         @project_discovered_method_visibilities = {}.freeze
+        @project_discovered_methods = {}.freeze
       end
 
       # ADR-pending editor mode — present when the runner is wired
@@ -141,6 +143,7 @@ module Rigor
         expansion = expand_paths(paths)
         @class_decl_paths_snapshot = {}.freeze
         @signature_paths_snapshot = []
+        @synthesized_namespaces_snapshot = []
 
         if @prebuilt
           adopt_prebuilt_project_scan(@prebuilt)
@@ -150,6 +153,7 @@ module Rigor
 
         diagnostics = pre_file_diagnostics(expansion)
         diagnostics += analyze_files(target_files(expansion))
+        diagnostics += rbs_synthesized_namespace_diagnostics
         diagnostics += rbs_extended_reporter_diagnostics
         diagnostics += boundary_cross_diagnostics
         diagnostics += source_rbs_synthesis_diagnostics
@@ -263,6 +267,7 @@ module Rigor
         @project_discovered_superclasses = def_index.fetch(:superclasses)
         @project_discovered_includes = def_index.fetch(:includes)
         @project_discovered_method_visibilities = def_index.fetch(:method_visibilities)
+        @project_discovered_methods = def_index.fetch(:methods)
       end
 
       # Internal: adopts a frozen {ProjectScan} snapshot supplied
@@ -303,6 +308,16 @@ module Rigor
           dispatch_pool(files)
         else
           environment = resolve_sequential_environment(source_files: files)
+          # Snapshot the small synthesized-namespace name list (NOT the
+          # env — see the method comment) so #run can surface the
+          # malformed-RBS `:info` diagnostic without rebuilding the env.
+          # Gated on the project actually declaring `signature_paths:`:
+          # synthesis only matters for the project's own RBS, and
+          # `#synthesized_namespaces` forces the (otherwise-lazy) RBS env
+          # to build — doing so when there is no project sig set would
+          # warm `.rigor/cache` on a bare `--no-stats` run.
+          @synthesized_namespaces_snapshot =
+            project_signature_paths? ? (environment.rbs_loader&.synthesized_namespaces || []) : []
           result = files.flat_map { |path| analyze_file(path, environment) }
           if @collect_stats
             loader = environment.rbs_loader
@@ -1116,6 +1131,48 @@ module Rigor
         [build_rbs_coverage_missing_diagnostic(missing)]
       end
 
+      # Robustness uplift companion (ADR-5) — when the project's
+      # `signature_paths:` RBS declared qualified names without their
+      # enclosing namespace, `RbsLoader` synthesizes the missing
+      # `module`s so the otherwise-inert signatures resolve. Surface a
+      # single `:info` diagnostic naming them so the user knows their
+      # sig set is malformed (`rbs validate` rejects it) and can fix it
+      # at the source. Authored `:info`: the analysis already succeeded;
+      # this is advisory, never a gate. Empty for a well-formed sig set.
+      def rbs_synthesized_namespace_diagnostics
+        synthesized = @synthesized_namespaces_snapshot
+        return [] if synthesized.nil? || synthesized.empty?
+
+        [build_rbs_synthesized_namespace_diagnostic(synthesized)]
+      end
+
+      # True when the project declares its own `signature_paths:` (the
+      # only place the qualified-name-without-namespace mistake lives).
+      def project_signature_paths?
+        paths = @configuration.signature_paths
+        !(paths.nil? || paths.empty?)
+      end
+
+      def build_rbs_synthesized_namespace_diagnostic(synthesized)
+        sample_size = 5
+        sample = synthesized.first(sample_size)
+        suffix = synthesized.size > sample_size ? ", and #{synthesized.size - sample_size} more" : ""
+        Diagnostic.new(
+          path: ".rigor.yml",
+          line: 1,
+          column: 1,
+          message: "#{synthesized.size} RBS namespace(s) under `signature_paths:` are " \
+                   "referenced by qualified declarations (e.g. `class Foo::Bar`) but never " \
+                   "declared: #{sample.join(', ')}#{suffix}. `rbs validate` rejects this; " \
+                   "Rigor synthesized the missing `module`(s) so the signatures still " \
+                   "resolve. Declare each (`module <name>` / `class <name>`) in your RBS to " \
+                   "make the sig set valid upstream.",
+          severity: :info,
+          rule: "rbs.coverage.synthesized-namespace",
+          source_family: :builtin
+        )
+      end
+
       def build_rbs_coverage_missing_diagnostic(missing)
         sample_size = 5
         sample = missing.first(sample_size).map(&:gem_name)
@@ -1328,8 +1385,9 @@ module Rigor
       end
 
       def collect_plugin_diagnostics(plugin, path, root, scope)
-        raw = plugin.diagnostics_for_file(path: path, scope: scope, root: root)
-        Array(raw).map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
+        raw = Array(plugin.diagnostics_for_file(path: path, scope: scope, root: root))
+        raw += plugin.node_rule_diagnostics(path: path, scope: scope, root: root)
+        raw.map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
       rescue StandardError => e
         [plugin_runtime_error_diagnostic(path, plugin, e)]
       end
@@ -1463,6 +1521,7 @@ module Rigor
         unless @project_discovered_method_visibilities.empty?
           scope = scope.with_discovered_method_visibilities(@project_discovered_method_visibilities)
         end
+        scope = scope.with_discovered_methods(@project_discovered_methods) unless @project_discovered_methods.empty?
         scope
       end
 

data/lib/rigor/analysis/worker_session.rb

@@ -284,8 +284,9 @@ module Rigor
       end
 
       def collect_plugin_diagnostics(plugin, path, root, scope)
-        raw = plugin.diagnostics_for_file(path: path, scope: scope, root: root)
-        Array(raw).map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
+        raw = Array(plugin.diagnostics_for_file(path: path, scope: scope, root: root))
+        raw += plugin.node_rule_diagnostics(path: path, scope: scope, root: root)
+        raw.map { |diagnostic| stamp_plugin_diagnostic(diagnostic, plugin.manifest.id) }
       rescue StandardError => e
         [plugin_runtime_error_diagnostic(path, plugin, e)]
       end

data/lib/rigor/cache/descriptor.rb

@@ -26,8 +26,12 @@ module Rigor
       # mixes this into the cache key, so a bump implicitly
       # invalidates every cached value. v2 added the
       # `dependencies` slot for ADR-10 per-gem-version cache slice
-      # invalidation.
-      SCHEMA_VERSION = 2
+      # invalidation. v3: `RbsLoader.build_env_for` now synthesizes
+      # `module`s for namespaces a project's `signature_paths:` RBS
+      # references but never declares, so the marshalled RBS env
+      # cached by an older Rigor (which would leave those signatures
+      # inert) MUST be rebuilt for the synthesis to take effect.
+      SCHEMA_VERSION = 3
 
       # Per-slot entry value objects. Constructors validate enums /
       # required fields and freeze the resulting struct so no caller

data/lib/rigor/cli/plugins_command.rb

@@ -32,7 +32,15 @@ module Rigor
     #   `trait_registries:` / `external_files:` /
     #   `type_node_resolvers:` / `hkt_registrations:` /
     #   `hkt_definitions:` / `protocol_contracts:` /
-    #   `source_rbs_synthesizer:`).
+    #   `source_rbs_synthesizer:`);
+    # - the ADR-37 narrow extension protocols read off the plugin
+    #   class — `node_rule` node types, `dynamic_return` receivers,
+    #   `type_specifier` methods.
+    #
+    # `--capabilities` switches to a focused catalogue of just the
+    # narrow-protocol gate values + produced/consumed facts (ADR-37
+    # § "Machine-readable capability catalogue") — the AI-legibility
+    # surface that lets an agent enumerate what every plugin does.
     #
     # Output formats: `text` (default, human-readable table) and
     # `json` (for tooling — SKILLs, CI gates, editor integrations).
@@ -52,7 +60,7 @@ module Rigor
     #   the RBS environment without conflict (requires constructing
     #   the Environment, which is heavier than the loader-only
     #   pass this slice does).
-    class PluginsCommand
+    class PluginsCommand # rubocop:disable Metrics/ClassLength
       USAGE = "Usage: rigor plugins [options]"
 
       def initialize(argv:, out: $stdout, err: $stderr)
@@ -69,7 +77,7 @@ module Rigor
         rows = build_rows(configuration)
 
         renderer = PluginsRenderer.new(rows: rows, configuration_path: config_path)
-        @out.puts(options.fetch(:format) == "json" ? renderer.json : renderer.text)
+        @out.puts(render(renderer, options))
 
         any_load_errors = rows.any? { |row| row.fetch(:status) == :load_error }
         return 1 if any_load_errors && options.fetch(:strict)
@@ -79,13 +87,32 @@ module Rigor
 
       private
 
+      # Picks the renderer view. `--capabilities` switches to the
+      # focused extension-protocol catalogue (ADR-37 § "Machine-readable
+      # capability catalogue") — per plugin, only the gate values that
+      # tell a reader (or an AI agent) exactly what the plugin
+      # contributes: the node-rule node types, the dynamic-return
+      # receivers, the type-specifier methods, and the produced /
+      # consumed facts. The default view stays the full activation report.
+      def render(renderer, options)
+        json = options.fetch(:format) == "json"
+        if options.fetch(:capabilities)
+          json ? renderer.capabilities_json : renderer.capabilities_text
+        else
+          json ? renderer.json : renderer.text
+        end
+      end
+
       def parse_options
-        options = { config: nil, format: "text", strict: false }
+        options = { config: nil, format: "text", strict: false, capabilities: false }
         OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
           opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
           opts.on("--strict", "Exit 1 if any plugin failed to load (CI gate)") { options[:strict] = true }
+          opts.on("--capabilities", "Emit the per-plugin extension-protocol catalogue (ADR-37)") do
+            options[:capabilities] = true
+          end
         end.parse!(@argv)
         validate!(options)
         options
@@ -165,9 +192,25 @@ module Rigor
         manifest = plugin.manifest
         identity_fields(gem_name, manifest, config)
           .merge(extension_fields(plugin, manifest))
+          .merge(narrow_protocol_fields(plugin))
           .merge(load_error: nil)
       end
 
+      # ADR-37 narrow extension protocols. Unlike the 10 declarative
+      # manifest fields, these are class-level DSLs (`node_rule` /
+      # `dynamic_return` / `type_specifier`), so they are read off the
+      # plugin class rather than the manifest. The gate values — node
+      # types, receiver class names, specified method names — are the
+      # greppable, enumerable surface the capability catalogue exposes.
+      def narrow_protocol_fields(plugin)
+        klass = plugin.class
+        {
+          node_rule_types: klass.node_rules.map { |r| r[:node_type].name }.uniq,
+          dynamic_return_receivers: klass.dynamic_returns.flat_map { |r| r[:receivers] }.uniq,
+          type_specifier_methods: klass.type_specifiers.flat_map { |r| r[:methods] }.map(&:to_s).uniq
+        }
+      end
+
       def identity_fields(gem_name, manifest, config)
         {
           gem: gem_name,
@@ -225,6 +268,9 @@ module Rigor
           hkt_definitions: 0,
           protocol_contracts: 0,
           source_rbs_synthesizer: false,
+          node_rule_types: [],
+          dynamic_return_receivers: [],
+          type_specifier_methods: [],
           load_error: error&.message || "plugin did not register or could not be matched to a registered class"
         }
       end
@@ -299,6 +345,7 @@ module Rigor
             external_files: 0, type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,
             protocol_contracts: 0, source_rbs_synthesizer: false,
+            node_rule_types: [], dynamic_return_receivers: [], type_specifier_methods: [],
             load_error: error.message
           }
         end

data/lib/rigor/cli/plugins_renderer.rb

@@ -13,7 +13,7 @@ module Rigor
     # tooling (SKILLs, CI, editor integrations) while text is
     # for interactive inspection. Rows are printed in the order
     # the loader resolved them.
-    class PluginsRenderer
+    class PluginsRenderer # rubocop:disable Metrics/ClassLength
       def initialize(rows:, configuration_path:)
         @rows = rows
         @configuration_path = configuration_path
@@ -42,8 +42,74 @@ module Rigor
         )
       end
 
+      # ADR-37 § "Machine-readable capability catalogue" — the focused
+      # per-plugin extension-protocol dump. Only loaded plugins appear
+      # (a plugin that failed to load contributes no capabilities), and
+      # each carries only the gate values an agent enumerates to learn
+      # what the plugin does: node-rule node types, dynamic-return
+      # receivers, type-specifier methods, and produced / consumed facts.
+      def capabilities_json
+        JSON.pretty_generate(
+          {
+            "configuration" => @configuration_path,
+            "capabilities" => loaded_rows.map { |row| capabilities_json_for(row) }
+          }
+        )
+      end
+
+      def capabilities_text
+        lines = ["Plugin capability catalogue (ADR-37 narrow extension protocols)", ""]
+        loaded = loaded_rows
+        if loaded.empty?
+          lines << "  (no plugins loaded)"
+        else
+          loaded.each_with_index do |row, index|
+            lines.concat(capability_lines(row))
+            lines << "" unless index == loaded.size - 1
+          end
+        end
+        lines.join("\n")
+      end
+
       private
 
+      def loaded_rows
+        @rows.select { |r| r[:status] == :loaded }
+      end
+
+      def capability_lines(row)
+        lines = ["  #{row[:id]}  v#{row[:version]}  (#{row[:gem]})"]
+        capability_surfaces(row).each { |surface| lines << "        #{surface}" }
+        lines << "        (no narrow extension protocols declared)" if lines.size == 1
+        lines
+      end
+
+      # The non-empty capability surfaces for a plugin, each as a
+      # `label: a, b, c` string. Data-driven so the catalogue stays a
+      # single source of truth shared between the text and JSON views.
+      def capability_surfaces(row)
+        [
+          ["node_rule", row[:node_rule_types]],
+          ["dynamic_return receivers", row[:dynamic_return_receivers]],
+          ["type_specifier methods", row[:type_specifier_methods]],
+          ["produces", row[:produces]],
+          ["consumes", row[:consumes]]
+        ].filter_map { |label, values| "#{label}: #{values.join(', ')}" if values.any? }
+      end
+
+      def capabilities_json_for(row)
+        {
+          "id" => row[:id],
+          "gem" => row[:gem],
+          "version" => row[:version],
+          "node_rule_types" => row[:node_rule_types],
+          "dynamic_return_receivers" => row[:dynamic_return_receivers],
+          "type_specifier_methods" => row[:type_specifier_methods],
+          "produces" => row[:produces],
+          "consumes" => row[:consumes]
+        }
+      end
+
       def header
         loaded = @rows.count { |r| r[:status] == :loaded }
         errored = @rows.count { |r| r[:status] == :load_error }
@@ -99,6 +165,22 @@ module Rigor
         lines << "        owns_receivers: #{row[:owns_receivers].join(', ')}" if row[:owns_receivers].any?
         lines << "        produces: #{row[:produces].join(', ')}" if row[:produces].any?
         lines << "        consumes: #{row[:consumes].join(', ')}" if row[:consumes].any?
+        lines.concat(narrow_protocol_lines(row))
+        lines
+      end
+
+      # ADR-37 narrow extension protocols (node_rule / dynamic_return /
+      # type_specifier). Surfaced in the full report alongside the
+      # declarative surfaces; `--capabilities` is the focused view.
+      def narrow_protocol_lines(row)
+        lines = []
+        lines << "        node_rule: #{row[:node_rule_types].join(', ')}" if row[:node_rule_types].any?
+        if row[:dynamic_return_receivers].any?
+          lines << "        dynamic_return receivers: #{row[:dynamic_return_receivers].join(', ')}"
+        end
+        if row[:type_specifier_methods].any?
+          lines << "        type_specifier methods: #{row[:type_specifier_methods].join(', ')}"
+        end
         lines
       end
 
@@ -157,6 +239,9 @@ module Rigor
           "hkt_definitions" => row[:hkt_definitions],
           "protocol_contracts" => row[:protocol_contracts],
           "source_rbs_synthesizer" => row[:source_rbs_synthesizer],
+          "node_rule_types" => row[:node_rule_types],
+          "dynamic_return_receivers" => row[:dynamic_return_receivers],
+          "type_specifier_methods" => row[:type_specifier_methods],
           "load_error" => row[:load_error]
         }
       end