necropsy 0.1.0 → 0.3.0

data/lib/necropsy/analyzers/static/rta.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 module Necropsy
   module Analyzers
     module Static
@@ -11,67 +13,289 @@ module Necropsy
           reverse_each select sort sort_by take take_while to_a to_h
         ].freeze
         COMPARISON_MESSAGES = %w[< <= > >= between? clamp sort sort_by max min].freeze
+        CORE_ENUMERABLE_RECEIVERS = %w[Array Enumerator Hash Range Set].freeze
+        CORE_COMPARISON_RECEIVERS = %w[Array].freeze
+        KERNEL_OUTPUT_MESSAGES = %w[print puts warn].freeze
+        REFLECTION_HOOK_MESSAGES = %w[method respond_to?].freeze
+        BLOCK_DEPENDENT_ENUMERABLE_MESSAGES = %w[
+          all? any? chunk collect cycle detect drop_while each_cons each_entry each_slice
+          each_with_index each_with_object filter find find_all flat_map group_by
+          map none? one? partition reject reverse_each select sort_by take_while
+        ].freeze
+        BLOCK_COMPARISON_MESSAGES = %w[max min sort].freeze
+
+        attr_reader :pruning, :emit_redundant_edges
+
+        def initialize(pruning: :rank_only, emit_redundant_edges: true)
+          mode = pruning.to_s
+          unless Configuration::RTA_PRUNING_MODES.include?(mode)
+            raise Error, "RTA pruning must be one of: #{Configuration::RTA_PRUNING_MODES.join(', ')}"
+          end
+
+          @pruning = mode.to_sym
+          @emit_redundant_edges = emit_redundant_edges == true
+        end
+
+        def with_pruning(mode, emit_redundant_edges: @emit_redundant_edges)
+          self.class.new(pruning: mode, emit_redundant_edges: emit_redundant_edges)
+        end
+
+        def without_redundant_edges
+          self.class.new(pruning: pruning, emit_redundant_edges: false)
+        end
 
         def analyze(graph, _project)
-          edge_evidences = expanded_call_sites(graph).flat_map do |site|
-            graph.resolve_call_site(site, rta: true).map do |candidate|
+          sites = expanded_call_sites(graph)
+          original_call_site_ids = graph.call_sites.to_set(&:call_site_id)
+          derived_sites = sites.reject { |site| original_call_site_ids.include?(site.call_site_id) }
+          instantiated_metadata = instantiated_classes_metadata(graph)
+          analyses = sites.map do |site|
+            targets = rta_candidates(graph, site)
+            site_edges = targets.filter_map do |candidate|
+              # In rank-only mode CHA/name resolution already materialize the
+              # same conservative edge. Keep the RTA resolution record, but
+              # avoid allocating a duplicate evidence object for an edge that
+              # cannot change reachability. Legacy pruning still emits every
+              # candidate because reconciliation uses those edge identities.
+              next if pruning == :rank_only && !emit_redundant_edges &&
+                      graph.edge_present?(site.caller_id, candidate.graph_id)
+
               EdgeEvidence.new(
                 caller_id: site.caller_id,
-                callee_id: candidate.id,
+                callee_id: candidate.graph_id,
                 evidence: evidence(
                   kind: :call_edge,
                   details: "RTA candidate at #{site.file}:#{site.line}",
-                  metadata: site.to_h.merge('instantiated_classes' => graph.instantiated_classes.to_a.sort)
+                  metadata: site.to_h.merge(instantiated_metadata).merge('target_definition_id' => candidate.graph_id),
+                  grade: :heuristic,
+                  relation: :call_edge,
+                  source: call_site_evidence_source(site).merge('target_definition_id' => candidate.graph_id),
+                  scope: call_site_evidence_scope(site).merge('target_definition_id' => candidate.graph_id)
                 )
               )
             end
+            [site, targets, site_edges]
+          end
+          edge_evidences = analyses.flat_map(&:last)
+          analyses_by_call_site_id = analyses.to_h { |site, targets, edges| [site.call_site_id, [targets, edges]] }
+          resolutions = sites.map do |site|
+            targets, edges = analyses_by_call_site_id.fetch(site.call_site_id)
+            resolution_record(site, targets, edges, unknown_scope: graph.residual_scope_for(site))
           end
 
           AnalyzerResult.new(
             edge_evidences: edge_evidences,
             alive_evidences: [],
             uncertainties: {},
-            observation: {}
+            observation: { 'rta' => { 'pruning' => pruning.to_s, 'analyzed_sites' => sites.map(&:to_h) } },
+            resolutions: resolutions,
+            evidences: result_evidences(edge_evidences),
+            derived_call_sites: derived_sites
           )
         end
 
         def profile
+          description = if pruning == :legacy
+                          'RTA pruning mode legacy removes static candidates without scanned construction evidence.'
+                        else
+                          'RTA pruning mode rank_only records constructed-class hints without removing static edges.'
+                        end
           AnalyzerProfile.new(
             name: :rta,
             kind: :static,
             soundness: :partial,
-            description: 'Narrows instance dispatch to classes that are constructed in the scanned program.'
+            description: description,
+            version: Necropsy::VERSION,
+            assumptions: ['scanned_allocations', "pruning=#{pruning}"]
           )
         end
 
+        def capabilities
+          [:complete_resolution].freeze
+        end
+
         def expanded_call_sites(graph)
           graph.call_sites.flat_map do |site|
-            [site, *implicit_sites(site)]
+            [site, *implicit_sites(site, graph: graph)]
+          end
+        end
+
+        def implicit_sites(site, graph: nil)
+          summaries = []
+          summaries << ['each', :same_receiver] if core_enumerable_receiver?(site) && enumerable_protocol?(site)
+          summaries.concat(comparison_summaries(site)) if core_comparison_receiver?(site)
+          summaries.concat(output_summaries(site)) if kernel_output_call?(site, graph)
+          summaries << ['respond_to_missing?', :same_receiver] if reflection_hook_call?(site, graph)
+          summaries.map.with_index do |(message, receiver), index|
+            derived_protocol_site(site, message, receiver, index: index)
           end
         end
 
-        def implicit_sites(site)
-          implicit_messages(site.message).map do |message|
-            CallSite.new(
-              caller_id: site.caller_id,
+        def implicit_messages(site, graph: nil)
+          implicit_sites(site, graph: graph).map(&:message)
+        end
+
+        private
+
+        def derived_protocol_site(site, message, receiver, index: 0)
+          receiver_kind, receiver_name, receiver_metadata = protocol_receiver(site, receiver)
+          receiver_label = protocol_receiver_label(receiver)
+          CallSite.new(
+            call_site_id: CallSiteIdentity.derived_id(
+              parent_call_site_id: site.call_site_id,
+              derivation: :rta_implicit,
+              caller_definition_id: site.caller_id,
               message: message,
-              receiver_kind: site.receiver_kind,
-              receiver_name: site.receiver_name,
-              file: site.file,
-              line: site.line,
-              test: site.test,
-              dynamic: site.dynamic,
-              metadata: site.metadata.merge('implicit_from' => site.message)
-            )
+              discriminator: index.positive? ? "#{receiver_label}:#{index}" : nil
+            ),
+            caller_id: site.caller_id,
+            message: message,
+            receiver_kind: receiver_kind,
+            receiver_name: receiver_name,
+            file: site.file,
+            line: site.line,
+            test: site.test,
+            dynamic: false,
+            metadata: site.metadata.except('receiver_candidates', 'receiver_value_fact').merge(
+              receiver_metadata,
+              'implicit_from' => site.message,
+              'protocol_receiver' => receiver_label,
+              'derived_from_call_site_id' => site.call_site_id,
+              'derived_via' => 'rta_implicit'
+            ).tap do |metadata|
+              metadata['implicit_private_dispatch'] = true if message == 'respond_to_missing?'
+            end
+          )
+        end
+
+        def protocol_receiver(site, receiver)
+          if receiver == :same_receiver
+            metadata = site.metadata.slice('receiver_candidates', 'receiver_value_fact')
+            return [site.receiver_kind, site.receiver_name, metadata]
+          end
+
+          argument_index = receiver[1] if receiver.is_a?(Array) && receiver.first == :argument
+          fact = Array(site.metadata['argument_value_facts'])[argument_index] if argument_index
+          fact = site.metadata.dig('receiver_value_fact', 'summary', 'element_fact') if receiver == :element_receiver
+          return receiver_from_fact(fact) if fact
+
+          [:unknown, nil, { 'receiver_candidates' => [] }]
+        end
+
+        def receiver_from_fact(fact)
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact.is_a?(Hash)
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact['kind'].to_s == 'instance_types'
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact['exact'] == true
+
+          values = Array(fact['values']).map(&:to_s).reject(&:empty?).uniq.sort
+          return [:unknown, nil, { 'receiver_candidates' => [] }] if values.empty?
+
+          [:instance, values.first, { 'receiver_candidates' => values, 'receiver_value_fact' => fact }]
+        end
+
+        def core_enumerable_receiver?(site)
+          receiver_owners(site).intersect?(CORE_ENUMERABLE_RECEIVERS)
+        end
+
+        def core_comparison_receiver?(site)
+          receiver_owners(site).intersect?(CORE_COMPARISON_RECEIVERS)
+        end
+
+        def enumerable_protocol?(site)
+          return false unless ENUMERABLE_MESSAGES.include?(site.message) && site.message != 'each'
+          return true unless BLOCK_DEPENDENT_ENUMERABLE_MESSAGES.include?(site.message)
+
+          site.metadata['block_kind'] != 'none'
+        end
+
+        def comparison_protocol?(site)
+          return false unless COMPARISON_MESSAGES.include?(site.message)
+          return true unless BLOCK_COMPARISON_MESSAGES.include?(site.message)
+
+          !site.metadata.key?('block_kind') || %w[none nil dynamic].include?(site.metadata['block_kind'])
+        end
+
+        def comparison_summaries(site)
+          if site.message == 'sort_by'
+            return [] if %w[none nil].include?(site.metadata['block_kind'])
+
+            return [['<=>', :block_result_receiver]]
           end
+
+          comparison_protocol?(site) ? [['<=>', :element_receiver]] : []
+        end
+
+        def output_summaries(site)
+          facts = Array(site.metadata['argument_value_facts'])
+          count = [facts.length, site.metadata.dig('arguments', 'positional_count').to_i].max
+          count = 1 if count.zero? && !site.metadata.key?('arguments')
+          count.times.map { |index| ['to_s', [:argument, index]] }
+        end
+
+        def protocol_receiver_label(receiver)
+          return 'first_argument' if receiver == [:argument, 0]
+          return "argument_#{receiver[1]}" if receiver.is_a?(Array) && receiver.first == :argument
+
+          receiver.to_s
         end
 
-        def implicit_messages(message)
-          messages = []
-          messages << 'each' if ENUMERABLE_MESSAGES.include?(message) && message != 'each'
-          messages << '<=>' if COMPARISON_MESSAGES.include?(message)
-          messages << 'to_s' if %w[puts print warn].include?(message)
-          messages
+        def receiver_owners(site)
+          values = Array(site.metadata['receiver_candidates'])
+          values = [container_receiver_owner(site.metadata['receiver_value_fact'])] if values.empty?
+          values = [site.receiver_name] if values.empty?
+          values.compact.map(&:to_s)
+        end
+
+        def container_receiver_owner(fact)
+          return unless fact.is_a?(Hash) && fact['kind'].to_s == 'container' && fact['exact'] == true
+
+          { 'array' => 'Array', 'hash' => 'Hash' }[fact.dig('summary', 'type').to_s]
+        end
+
+        def kernel_output_call?(site, graph)
+          return false unless KERNEL_OUTPUT_MESSAGES.include?(site.message)
+          return false unless %i[implicit self].include?(site.receiver_kind)
+          return true unless graph
+
+          graph.method_lookup(site).targets.empty?
+        end
+
+        def reflection_hook_call?(site, graph)
+          return false unless REFLECTION_HOOK_MESSAGES.include?(site.message)
+          return true unless graph
+
+          graph.cha_method_lookup(site).targets.none? { |target| target.name == site.message }
+        end
+
+        def rta_candidates(graph, site)
+          candidates = graph.cha_method_lookup(site).targets
+          candidates = fallback_candidates(graph, site) if candidates.empty?
+          graph.retain_rta_candidates(candidates, site)
+        end
+
+        def fallback_candidates(graph, site)
+          domain = site.test ? :test : :runtime
+          return graph.candidate_nodes(site.message, domain: domain) if site.receiver_kind == :unknown
+          return [] unless graph.ambiguous_resolution?
+
+          graph.ambiguous_fallback_candidates(site.message, domain: domain)
+        end
+
+        # A full allocation list in every RTA evidence record makes evidence
+        # identity canonicalization quadratic for a repository with many
+        # scanned constructors. Keep the complete list for small fixtures
+        # (preserving the existing diagnostic shape), and use a deterministic
+        # bounded sample plus digest for larger projects.
+        def instantiated_classes_metadata(graph)
+          classes = graph.instantiated_classes.to_a.sort
+          return { 'instantiated_classes' => classes } if classes.length <= 64
+
+          {
+            'instantiated_classes' => classes.first(16),
+            'instantiated_classes_count' => classes.length,
+            'instantiated_classes_truncated' => true,
+            'instantiated_classes_sha256' => Digest::SHA256.hexdigest(classes.join("\0"))
+          }
         end
       end
     end

data/lib/necropsy/ast_scanner/call_recording.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class AstScanner
+    private
+
+    def build_call_sites(node, context)
+      messages = finite_dynamic_messages(node, context)
+      return [build_call_site(node, context)] if messages.empty?
+
+      messages.map { |message| build_call_site(node, context, message_override: message) }
+    end
+
+    def build_call_site(node, context, message_override: nil)
+      message = node.name&.to_s
+      dynamic = false
+      receiver = classify_receiver(node.receiver, context)
+      metadata = { 'original_message' => message, 'receiver_candidates' => receiver[:candidates] }
+      metadata['arguments'] = call_arguments(node, offset: DYNAMIC_SENDS.include?(node.name) ? 1 : 0)
+      metadata['block_kind'] = call_block_kind(node)
+      receiver_fact = context.flow_result&.fact_for(node.receiver)
+      compact_receiver_fact = compact_receiver_fact(receiver_fact)
+      metadata['receiver_value_fact'] = compact_receiver_fact if compact_receiver_fact
+      argument_facts = arguments(node).map do |argument|
+        compact_receiver_fact(context.flow_result&.fact_for(argument))
+      end
+      metadata['argument_value_facts'] = argument_facts if argument_facts.any?
+      load_reference = load_reference_metadata(node)
+      metadata['load_reference'] = load_reference if load_reference
+
+      if DYNAMIC_SENDS.include?(node.name)
+        literal = literal_argument(node, index: 0)
+        message = message_override || literal
+        dynamic = message.nil?
+        metadata['dynamic_dispatch'] = true
+        metadata['finite_dynamic_dispatch'] = true if message_override
+      end
+
+      return nil unless message
+
+      scanned_call_site(
+        source_node: node,
+        context: context,
+        role: :call,
+        message: message,
+        receiver_kind: receiver.fetch(:kind),
+        receiver_name: receiver[:name],
+        dynamic: dynamic,
+        metadata: metadata
+      )
+    end
+
+    def finite_dynamic_messages(node, context)
+      return [] unless DYNAMIC_SENDS.include?(node.name)
+      return [] if literal_argument(node, index: 0)
+
+      argument = Array(node.arguments&.arguments).first
+      fact = context.flow_result&.fact_for(argument)
+      return [] unless fact&.exact && %i[symbol_set string_set].include?(fact.kind)
+
+      Array(fact.values).map(&:to_s).uniq.sort.first(FlowInterpreter::MAX_ATOMS)
+    end
+
+    def load_reference_metadata(node)
+      argument_index = case node.name
+                       when :require, :require_relative then 0
+                       when :autoload then 1
+                       else return
+                       end
+      return unless load_primitive_receiver?(node)
+
+      path = literal_argument(node, index: argument_index)
+      { 'kind' => node.name.to_s, 'literal' => !path.nil?, 'path' => path }.compact
+    end
+
+    def load_primitive_receiver?(node)
+      return true unless node.receiver
+      return true if node.receiver.is_a?(Prism::SelfNode)
+
+      receiver = constant_name(node.receiver)
+      node.name == :autoload ? !receiver.nil? : receiver == 'Kernel'
+    end
+
+    def compact_receiver_fact(fact)
+      return unless fact&.exact
+      return unless %i[instance_types callable_set container].include?(fact.kind)
+
+      fact.to_h.merge('summary' => fact.kind == :container ? fact.summary : nil)
+    end
+
+    def call_block_kind(node)
+      case node.block
+      when nil
+        'none'
+      when Prism::BlockNode
+        'literal'
+      when Prism::BlockArgumentNode
+        case node.block.expression
+        when Prism::NilNode then 'nil'
+        when Prism::SymbolNode then 'symbol_to_proc'
+        else 'dynamic'
+        end
+      else
+        'dynamic'
+      end
+    end
+
+    def record_instantiation(node, context)
+      return record_factory_instantiation(node, context) unless %i[new []].include?(node.name)
+
+      receiver = classify_receiver(node.receiver, context)
+      receiver = implicit_self_constructor(context) if implicit_constructor?(receiver, context)
+      return unless receiver && receiver[:kind] == :constant
+
+      Array(receiver[:candidates] || receiver[:name]).each { |name| instantiated_classes << name }
+      record_initialize_call(node, context, receiver)
+    end
+
+    def implicit_constructor?(receiver, context)
+      return false unless %i[implicit self].include?(receiver[:kind])
+      return false unless context.owner
+
+      context.current_kind == :singleton_method || context.current_caller_id == context.root_id
+    end
+
+    def implicit_self_constructor(context)
+      { kind: :constant, name: context.owner, candidates: [context.owner] }
+    end
+
+    def record_initialize_call(node, context, receiver)
+      return unless node.name == :new
+
+      add_scanned_call_site(
+        source_node: node,
+        context: context,
+        role: :initialize,
+        message: 'initialize',
+        receiver_kind: :instance,
+        receiver_name: receiver[:name],
+        dynamic: false,
+        metadata: { 'original_message' => 'new', 'receiver_candidates' => receiver[:candidates],
+                    'implicit_from' => 'new', 'arguments' => call_arguments(node) }
+      )
+    end
+
+    def record_factory_instantiation(node, context)
+      return unless @factory_methods.include?(node.name.to_s)
+
+      receiver = classify_receiver(node.receiver, context)
+      return unless receiver[:kind] == :constant
+
+      Array(receiver[:candidates] || receiver[:name]).each do |name|
+        instantiated_classes << name
+      end
+    end
+
+    def record_uncertainty(site)
+      uncertainties[site.caller_id] << "Dynamic dispatch at #{site.file}:#{site.line}"
+    end
+
+    def record_uncertainty_at(node, context)
+      uncertainties[context.current_caller_id] << "Dynamic dispatch at #{context.relative_file}:#{node.location.start_line}"
+    end
+
+    def unresolved_dynamic_dispatch?(node)
+      DYNAMIC_SENDS.include?(node.name) && literal_argument(node, index: 0).nil?
+    end
+
+    def record_parse_errors(root_id, relative, result)
+      result.errors.each do |error|
+        uncertainties[root_id] << "Parse warning at line #{error.location.start_line}: #{error.message}"
+        source_errors << SourceError.new(
+          file: relative,
+          line: error.location.start_line,
+          message: error.message,
+          type: error.type
+        )
+      end
+    end
+
+    def record_source_failure(root_id, relative, error)
+      file_statuses[relative] = :failed
+      uncertainties[root_id] << "Could not parse #{relative}: #{error.message}"
+      source_errors << SourceError.new(
+        file: relative,
+        line: 1,
+        message: error.message,
+        type: error.class.name.to_sym
+      )
+    end
+
+    def definition_owner(node, context)
+      return context.owner unless node.receiver
+      return context.owner if node.receiver.is_a?(Prism::SelfNode)
+
+      receiver = classify_receiver(node.receiver, context)
+      receiver[:name]
+    end
+
+    def definition_owner_for_call(node, context)
+      return context.owner unless node.receiver
+      return context.owner if node.receiver.is_a?(Prism::SelfNode)
+
+      classify_receiver(node.receiver, context)[:name]
+    end
+
+    def eval_owner(node, context)
+      return context.owner unless node.receiver
+
+      definition_owner_for_call(node, context)
+    end
+
+    def method_kind_and_separator(context)
+      context.singleton_scope ? [:singleton_method, '.'] : [:instance_method, '#']
+    end
+
+    def update_method_visibility(context, name, visibility, source_node, singleton: false)
+      separator = singleton ? '.' : method_kind_and_separator(context).last
+      id = "#{context.owner}#{separator}#{name}"
+      candidates = nodes.each_index.select { |index| nodes[index].symbol_id == id }
+      local = candidates.select do |index|
+        definition = nodes[index]
+        definition.file == context.relative_file && definition.line <= source_node.location.start_line
+      end
+      index = local.max_by { |candidate| [nodes[candidate].line, nodes[candidate].ordinal] }
+      nodes[index] = nodes[index].with(visibility: visibility) if index
+      return if index && candidates == [index]
+
+      semantic_blockers << Blocker.new(
+        kind: :visibility_activation,
+        scope_kind: :message,
+        scope_value: name,
+        source: 'ast_scanner',
+        reason: "visibility activation for #{id} depends on repository load order",
+        suggested_action: :review_load_order,
+        metadata: {
+          'caller_domain' => context.test ? 'test' : 'runtime',
+          'caller_id' => context.current_caller_id,
+          'owner_scope' => [context.owner],
+          'file' => context.relative_file,
+          'line' => source_node.location.start_line,
+          'message' => name,
+          'reason_code' => 'visibility_activation'
+        }
+      )
+    end
+
+    def defer_module_function(context, name, source_node)
+      instance_id = "#{context.owner}##{name}"
+      privatize_current_module_function_source(instance_id, context.relative_file)
+      copy = add_module_function_definition(context, name, source_node)
+      deferred_module_functions[copy.graph_id] = instance_id
+    end
+
+    def privatize_current_module_function_source(instance_id, relative_file)
+      index = nodes.rindex do |definition|
+        definition.kind == :instance_method && definition.symbol_id == instance_id && definition.file == relative_file
+      end
+      nodes[index] = nodes[index].with(visibility: :private) if index
+    end
+
+    def add_module_function_definition(context, name, source_node)
+      add_definition(
+        symbol_id: "#{context.owner}.#{name}",
+        kind: :singleton_method,
+        source_node: source_node,
+        context: context,
+        defined_via: :module_function,
+        owner: context.owner,
+        name: name,
+        visibility: :public
+      )
+    end
+  end
+end

data/lib/necropsy/ast_scanner/call_site_creation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class AstScanner
+    private
+
+    def scanned_call_site(source_node:, context:, role:, message:, receiver_kind:, receiver_name: nil,
+                          caller_id: context.current_caller_id, dynamic: false, metadata: {})
+      structural_digest = DefinitionIdentity.body_digest(source_node)
+      ordinal_key = [caller_id, context.relative_file, role.to_sym, message.to_s, structural_digest]
+      ordinal = call_site_ordinals[ordinal_key] += 1
+      CallSite.new(
+        call_site_id: CallSiteIdentity.source_id(
+          caller_definition_id: caller_id,
+          relative_path: context.relative_file,
+          role: role,
+          message: message,
+          structural_digest: structural_digest,
+          ordinal: ordinal
+        ),
+        caller_id: caller_id,
+        message: message.to_s,
+        receiver_kind: receiver_kind,
+        receiver_name: receiver_name,
+        file: context.relative_file,
+        line: source_node.location.start_line,
+        test: context.test,
+        dynamic: dynamic,
+        metadata: metadata
+      )
+    end
+
+    def add_scanned_call_site(**attributes)
+      scanned_call_site(**attributes).tap { |site| call_sites << site }
+    end
+
+    def derived_call_site(site, derivation:, caller_id: site.caller_id, message: site.message, metadata: {})
+      site.with(
+        call_site_id: CallSiteIdentity.derived_id(
+          parent_call_site_id: site.call_site_id,
+          derivation: derivation,
+          caller_definition_id: caller_id,
+          message: message
+        ),
+        caller_id: caller_id,
+        message: message.to_s,
+        metadata: site.metadata.merge(
+          'derived_from_call_site_id' => site.call_site_id,
+          'derived_via' => derivation.to_s
+        ).merge(metadata)
+      )
+    end
+  end
+end