ibex 0.1.0 → 0.3.0

data/lib/ibex/rake_task.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "rake/tasklib"
+require_relative "cli"
+
+# @rbs!
+#   module Rake
+#     class TaskLib
+#       def initialize: () -> void
+#     end
+#
+#     class Task
+#       def self.define_task: (Hash[String | Symbol, String | Array[String]]) -> Task
+#                           | (Hash[String | Symbol, String | Array[String]]) {
+#                               (Object?, Object?) -> void
+#                             } -> Task
+#     end
+#
+#     class FileTask < Task
+#     end
+#   end
+
+module Ibex
+  # Declares grammar-to-parser generation in a Rakefile.
+  class RakeTask < Rake::TaskLib
+    attr_accessor :grammar #: String?
+    attr_accessor :output #: String?
+    attr_accessor :options #: Array[String]
+    attr_accessor :action_source #: String | true | nil
+
+    # @rbs (String | Symbol name) ?{ (RakeTask) -> void } -> void
+    def initialize(name, &configuration)
+      super()
+      @name = name
+      @grammar = nil
+      @output = name.to_s.end_with?(".rb") ? name.to_s : nil
+      @options = []
+      @action_source = nil
+      configuration&.call(self)
+      define
+    end
+
+    private
+
+    # @rbs () -> void
+    def define
+      source = @grammar || raise(ArgumentError, "grammar is required")
+      reject_watch_option!
+      target = @output || source.sub(/\.[^.]+\z/, ".rb")
+      target = "#{source}.rb" if target == source
+      prerequisites = grammar_prerequisites(source)
+      action_target = configured_action_source(target)
+      arguments = [*@options]
+      arguments << (@action_source == true ? "--action-source" : "--action-source=#{action_target}") if action_target
+      generate = lambda do |_task, _task_arguments|
+        status = CLI.start([*arguments, "--output-file=#{target}", source])
+        raise "parser generation failed for #{source}" unless status.zero?
+      end
+
+      if action_target
+        Rake::FileTask.define_task(action_target => prerequisites, &generate)
+        Rake::FileTask.define_task(target => [*prerequisites, action_target], &generate)
+      else
+        Rake::FileTask.define_task(target => prerequisites, &generate)
+      end
+
+      Rake::Task.define_task(@name => target) unless @name.to_s == target
+    end
+
+    # @rbs () -> void
+    def reject_watch_option!
+      return unless @options.any? { |option| option == "--watch" || option.start_with?("--watch=") }
+
+      raise ArgumentError, "RakeTask options must not include --watch"
+    end
+
+    # @rbs (String target) -> String?
+    def configured_action_source(target)
+      return nil unless @action_source
+
+      path = @action_source == true ? default_action_source_path(target) : @action_source
+      raise ArgumentError, "action_source must be true or a non-empty String" unless
+        path.is_a?(String) && !path.empty?
+      if File.expand_path(path) == File.expand_path(target)
+        raise ArgumentError, "action_source and output must be distinct"
+      end
+
+      path
+    end
+
+    # @rbs (String target) -> String
+    def default_action_source_path(target)
+      directory = File.dirname(target)
+      basename = File.basename(target)
+      replaced = basename.sub(/\.[^.]+\z/, ".actions.rb")
+      replaced = "#{basename}.actions.rb" if replaced == basename
+      directory == "." ? replaced : File.join(directory, replaced)
+    end
+
+    # @rbs (String source) -> Array[String]
+    def grammar_prerequisites(source)
+      dependencies = Frontend::Resolver.new(source, mode: configured_mode).dependencies
+      [source, *dependencies.drop(1)]
+    end
+
+    # @rbs () -> Symbol
+    def configured_mode
+      explicit = @options.find { |option| option.start_with?("--mode=") }
+      return explicit.delete_prefix("--mode=").to_sym if explicit
+
+      index = @options.index("--mode")
+      index ? @options.fetch(index + 1, "default").to_sym : :default
+    end
+  end
+end

data/lib/ibex/samples.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  # Generates bounded terminal sentences from Grammar IR.
+  class Samples
+    DEFAULT_MAX_EXPANSIONS = 100_000 #: Integer
+
+    # @rbs (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer,
+    #   ?max_expansions: Integer, ?strategy: Symbol | String, ?path_length: Integer) -> void
+    def initialize(grammar, seed: 0, max_tokens: 32, max_depth: 16, max_expansions: DEFAULT_MAX_EXPANSIONS,
+                   strategy: :random, path_length: 1)
+      raise ArgumentError, "max_tokens must be positive" unless max_tokens.positive?
+      raise ArgumentError, "max_depth must be positive" unless max_depth.positive?
+      raise ArgumentError, "max_expansions must be positive" unless max_expansions.positive?
+
+      normalized_strategy = strategy.to_sym
+      unless %i[random coverage].include?(normalized_strategy)
+        raise ArgumentError, "strategy must be :random or :coverage"
+      end
+      raise ArgumentError, "path_length must be 1 or 2" unless [1, 2].include?(path_length)
+
+      @grammar = grammar
+      @random = Random.new(seed)
+      @max_tokens = max_tokens
+      @max_depth = max_depth
+      @max_expansions = max_expansions
+      @strategy = normalized_strategy
+      @path_length = path_length
+      @path_coverage = Hash.new(0) #: Hash[Array[Integer], Integer]
+      @productions = grammar.productions.group_by(&:lhs)
+      @minimum_costs = compute_minimum_costs
+      @minimum_heights = compute_minimum_heights
+    end
+
+    # @rbs (?count: Integer) -> Array[Array[String]]
+    def generate(count: 1)
+      raise ArgumentError, "count must be positive" unless count.positive?
+
+      start = @grammar.symbol(@grammar.start) || raise(Ibex::Error, "(samples):1:1: missing start symbol")
+      minimum = @minimum_costs.fetch(start.id, nil)
+      raise Ibex::Error, "(samples):1:1: start symbol #{@grammar.start} derives no terminal sentence" unless minimum
+
+      if minimum > @max_tokens
+        raise Ibex::Error, "(samples):1:1: minimum sentence needs #{minimum} tokens; limit is #{@max_tokens}"
+      end
+      if count > @max_expansions
+        raise Ibex::Error, "(samples):1:1: count #{count} exceeds expansion limit #{@max_expansions}"
+      end
+
+      remaining_expansions = @max_expansions
+      Array.new(count) do
+        sample, remaining_expansions = expand(start, remaining_expansions)
+        sample
+      end
+    end
+
+    private
+
+    # @rbs () -> Hash[Integer, Integer?]
+    def compute_minimum_costs
+      compute_minimum_values(1) do |production, values|
+        rhs_values = resolved_rhs_values(production, values)
+        rhs_values&.sum
+      end
+    end
+
+    # @rbs () -> Hash[Integer, Integer?]
+    def compute_minimum_heights
+      compute_minimum_values(0) do |production, values|
+        rhs_values = resolved_rhs_values(production, values)
+        rhs_values && ((rhs_values.max || 0) + 1)
+      end
+    end
+
+    # @rbs (Integer terminal_value) { (IR::Production, Hash[Integer, Integer?]) -> Integer? }
+    #   -> Hash[Integer, Integer?]
+    def compute_minimum_values(terminal_value)
+      values = @grammar.symbols.to_h { |symbol| [symbol.id, nil] } #: Hash[Integer, Integer?]
+      dependents = {} #: Hash[Integer, Array[IR::Production]]
+      queue = seed_terminal_values(values, terminal_value)
+
+      @grammar.productions.each do |production|
+        update_minimum(values, queue, production.lhs, yield(production, values)) if production.rhs.empty?
+        production.rhs.uniq.each do |symbol_id|
+          (dependents[symbol_id] ||= []) << production
+        end
+      end
+
+      index = 0
+      while index < queue.length
+        dependents.fetch(queue.fetch(index), []).each do |production|
+          update_minimum(values, queue, production.lhs, yield(production, values))
+        end
+        index += 1
+      end
+
+      values
+    end
+
+    # @rbs (Hash[Integer, Integer?] values, Integer terminal_value) -> Array[Integer]
+    def seed_terminal_values(values, terminal_value)
+      @grammar.symbols.filter_map do |symbol|
+        next unless symbol.terminal? && !symbol.reserved
+
+        values[symbol.id] = terminal_value
+        symbol.id
+      end
+    end
+
+    # @rbs (Hash[Integer, Integer?] values, Array[Integer] queue, Integer symbol_id, Integer? candidate) -> void
+    def update_minimum(values, queue, symbol_id, candidate)
+      return unless candidate
+
+      current = values.fetch(symbol_id)
+      return if current && current <= candidate
+
+      values[symbol_id] = candidate
+      queue << symbol_id
+    end
+
+    # @rbs (IR::Production production, Hash[Integer, Integer?] values) -> Array[Integer]?
+    def resolved_rhs_values(production, values)
+      rhs_values = production.rhs.map { |symbol_id| values.fetch(symbol_id) }
+      return nil if rhs_values.any?(&:nil?)
+
+      rhs_values.compact
+    end
+
+    # @rbs (IR::GrammarSymbol start, Integer remaining_expansions) -> [Array[String], Integer]
+    def expand(start, remaining_expansions)
+      result = [] #: Array[String]
+      work = [[start.id, 0, []]] #: Array[[Integer, Integer, Array[Integer]]]
+      pending_minimum = minimum_cost!(start.id)
+
+      while (entry = work.pop)
+        if remaining_expansions.zero?
+          raise Ibex::Error, "(samples):1:1: expansion limit of #{@max_expansions} steps exceeded"
+        end
+
+        remaining_expansions -= 1
+        symbol_id, depth, path = entry
+        pending_minimum -= minimum_cost!(symbol_id)
+        symbol = @grammar.symbol_by_id(symbol_id) ||
+                 raise(Ibex::Error, "(samples):1:1: missing symbol #{symbol_id}")
+        if symbol.terminal?
+          result << symbol.name
+          next
+        end
+
+        budget = @max_tokens - result.length - pending_minimum
+        production = choose_production(symbol_id, budget, depth, path)
+        production_path = (path + [production.id]).last(@path_length)
+        @path_coverage[production_path] += 1
+        pending_minimum += production_cost(production) ||
+                           raise(Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{symbol_id}")
+        production.rhs.reverse_each { |child_id| work << [child_id, depth + 1, production_path] }
+      end
+
+      [result, remaining_expansions]
+    end
+
+    # @rbs (Integer nonterminal_id, Integer budget, Integer depth, Array[Integer] path) -> IR::Production
+    def choose_production(nonterminal_id, budget, depth, path)
+      candidates = bounded_productions(nonterminal_id, budget)
+      candidates = minimum_height_productions(candidates) if depth >= @max_depth
+      return candidates.fetch(@random.rand(candidates.length)) if @strategy == :random
+
+      minimum_coverage = candidates.map { |production| path_count(path, production) }.min
+      least_covered = candidates.select { |production| path_count(path, production) == minimum_coverage }
+      least_covered.fetch(@random.rand(least_covered.length))
+    end
+
+    # @rbs (Integer nonterminal_id, Integer budget) -> Array[IR::Production]
+    def bounded_productions(nonterminal_id, budget)
+      productions = @productions[nonterminal_id]
+      raise Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{nonterminal_id}" unless productions
+
+      candidates = productions.select do |production|
+        cost = production_cost(production)
+        cost && cost <= budget
+      end
+      raise Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{nonterminal_id}" if candidates.empty?
+
+      candidates
+    end
+
+    # @rbs (Array[IR::Production] candidates) -> Array[IR::Production]
+    def minimum_height_productions(candidates)
+      minimum = candidates.filter_map { |production| production_height(production) }.min
+      candidates.select { |production| production_height(production) == minimum }
+    end
+
+    # @rbs (Array[Integer] path, IR::Production production) -> Integer
+    def path_count(path, production)
+      @path_coverage[(path + [production.id]).last(@path_length)]
+    end
+
+    # @rbs (Integer symbol_id) -> Integer
+    def minimum_cost!(symbol_id)
+      @minimum_costs.fetch(symbol_id) ||
+        raise(Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{symbol_id}")
+    end
+
+    # @rbs (IR::Production production) -> Integer?
+    def production_cost(production)
+      resolved_rhs_values(production, @minimum_costs)&.sum
+    end
+
+    # @rbs (IR::Production production) -> Integer?
+    def production_height(production)
+      child_heights = resolved_rhs_values(production, @minimum_heights)
+      child_heights && ((child_heights.max || 0) + 1)
+    end
+  end
+end

data/lib/ibex/table_artifact/builder.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Ibex
+  module TableArtifact
+    # Projects validated Automaton IR into an action-free executable sidecar.
+    class Builder
+      # @rbs!
+      #   type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+      #   type json_hash = Hash[String, untyped]
+      #   type action_rows = Array[Hash[Integer, IR::runtime_action]]
+      #   type action_table = action_rows | Tables::CompactActions
+      #   type goto_rows = Array[Hash[Integer, Integer]]
+      #   type goto_table = goto_rows | Tables::Compact
+
+      include CSTProjection
+
+      REPRESENTATIONS = %i[plain compact].freeze #: Array[Symbol]
+
+      # @rbs (IR::Automaton automaton, ?representation: Symbol | String, ?cst_trivia: Symbol | String?,
+      #   ?omit_action_call: bool?) -> void
+      def initialize(automaton, representation: :compact, cst_trivia: nil, omit_action_call: nil)
+        @automaton = automaton
+        @grammar = automaton.grammar
+        @representation = representation.to_sym
+        @cst_trivia = effective_cst_trivia(cst_trivia)
+        @omit_action_call = omit_action_call.nil? ? @grammar.options.fetch(:omit_action_call) : omit_action_call
+        return if REPRESENTATIONS.include?(@representation)
+
+        raise ArgumentError, "representation must be :plain or :compact"
+      end
+
+      # @rbs () -> Document
+      def build
+        source_identity = {
+          "grammar_digest" => @automaton.grammar_digest,
+          "automaton_digest" => automaton_digest
+        }
+        payload = build_payload(source_identity)
+        cost = build_cost(payload)
+        identity = source_identity.merge(
+          "payload_digest" => Serializer.digest(payload),
+          "cst_metadata_digest" => Serializer.digest(payload.fetch("cst")),
+          "recovery_metadata_digest" => Serializer.digest(payload.fetch("recovery"))
+        )
+        Document.new(
+          "artifact_type" => ARTIFACT_TYPE,
+          "schema_version" => SCHEMA_VERSION,
+          "identity" => identity,
+          "payload" => payload,
+          "cost" => cost
+        )
+      end
+
+      private
+
+      # @rbs (Hash[String, String] source_identity) -> json_hash
+      def build_payload(source_identity)
+        {
+          "table_format" => table_format,
+          "source" => source_identity,
+          "state_count" => @automaton.states.length,
+          "symbols" => symbols,
+          "tokens" => tokens,
+          "entry_states" => entry_states,
+          "tables" => tables,
+          "productions" => productions,
+          "cst" => cst,
+          "recovery" => recovery,
+          "semantic_actions" => semantic_actions
+        }
+      end
+
+      # @rbs () -> String
+      def automaton_digest
+        "sha256:#{Digest::SHA256.hexdigest(IR::Serialize.dump(@automaton))}"
+      end
+
+      # @rbs () -> json_hash
+      def table_format
+        {
+          "family" => "ibex-runtime-parser-table",
+          "version" => Runtime::PARSER_TABLE_FORMAT_VERSION,
+          "representation" => @representation.to_s,
+          "action_encoding" => @representation == :compact ? "signed-row-displacement-v1" : "signed-sparse-rows-v1",
+          "goto_encoding" => @representation == :compact ? "row-displacement-v1" : "sparse-rows-v1"
+        }
+      end
+
+      # @rbs () -> Array[json_hash]
+      def symbols
+        @grammar.symbols.sort_by(&:id).map do |symbol|
+          {
+            "id" => symbol.id,
+            "name" => symbol.name,
+            "kind" => symbol.kind.to_s,
+            "display_name" => symbol.display_name
+          }
+        end
+      end
+
+      # @rbs () -> Array[json_hash]
+      def tokens
+        @grammar.terminals.sort_by(&:id).map do |symbol|
+          { "id" => symbol.id, "name" => symbol.name, "display_name" => symbol.display_name }
+        end
+      end
+
+      # @rbs () -> Array[json_hash]
+      def entry_states
+        @automaton.entry_states.map { |name, state| { "name" => name, "state" => state } }
+      end
+
+      # @rbs () -> json_hash
+      def tables
+        table_set = Tables.build(@automaton, format: @representation) #: Tables::TableSet
+        {
+          "actions" => action_table(table_set.actions),
+          "gotos" => goto_table(table_set.gotos),
+          "default_actions" => table_set.default_actions.map { |action| Tables::CompactActions.pack(action) }
+        }
+      end
+
+      # @rbs (action_table table) -> json_hash
+      def action_table(table)
+        return compact_action_table(table) if table.is_a?(Tables::CompactActions)
+
+        {
+          "encoding" => "signed-sparse-rows-v1",
+          "rows" => table.map do |row|
+            row.sort.map { |token_id, action| { "token_id" => token_id, "code" => Tables::CompactActions.pack(action) } }
+          end
+        }
+      end
+
+      # @rbs (Tables::CompactActions table) -> json_hash
+      def compact_action_table(table)
+        {
+          "encoding" => "signed-row-displacement-v1",
+          "row_count" => table.row_count,
+          "column_count" => table.column_count,
+          "offsets" => table.offsets,
+          "codes" => table.codes,
+          "checks" => table.checks
+        }
+      end
+
+      # @rbs (goto_table table) -> json_hash
+      def goto_table(table)
+        return compact_goto_table(table) if table.is_a?(Tables::Compact)
+
+        {
+          "encoding" => "sparse-rows-v1",
+          "rows" => table.map do |row|
+            row.sort.map { |symbol_id, state| { "symbol_id" => symbol_id, "state" => state } }
+          end
+        }
+      end
+
+      # @rbs (Tables::Compact table) -> json_hash
+      def compact_goto_table(table)
+        {
+          "encoding" => "row-displacement-v1",
+          "row_count" => table.row_count,
+          "dense_width" => table.dense_width,
+          "offsets" => table.offsets,
+          "values" => table.values,
+          "checks" => table.checks
+        }
+      end
+
+      # @rbs () -> Array[json_hash]
+      def productions
+        @grammar.productions.sort_by(&:id).map do |production|
+          {
+            "id" => production.id,
+            "lhs" => production.lhs,
+            "rhs" => production.rhs,
+            "rhs_length" => production.rhs.length,
+            "action_slot" => action_slot?(production) ? production.id : nil
+          }
+        end
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def action_slot?(production)
+        !!(production.node || production.action || !@omit_action_call)
+      end
+
+      # @rbs () -> json_hash
+      def semantic_actions
+        {
+          "binding" => "opaque-wrapper-production-id-v1",
+          "verified" => false,
+          "slots" => @grammar.productions.select { |production| action_slot?(production) }.map(&:id)
+        }
+      end
+
+      # @rbs () -> json_hash
+      def recovery
+        sync_tokens = @grammar.recovery.fetch(:sync_tokens) #: Array[String]
+        on_error_reduce = @grammar.recovery.fetch(:on_error_reduce) #: Array[Array[String]]
+        {
+          "sync_token_ids" => sync_tokens.map { |name| @grammar.symbol(name).id },
+          "on_error_reduce_symbol_ids" => on_error_reduce.map do |group|
+            group.map { |name| @grammar.symbol(name).id }
+          end
+        }
+      end
+
+      # @rbs (json_hash payload) -> json_hash
+      def build_cost(payload)
+        tables = payload.fetch("tables") #: json_hash
+        action_table = tables.fetch("actions") #: json_hash
+        goto_table = tables.fetch("gotos") #: json_hash
+        {
+          "canonical_payload_bytes" => Serializer.compact(payload).bytesize,
+          "action_cells" => occupied_cells(action_table, "codes"),
+          "goto_cells" => occupied_cells(goto_table, "values"),
+          "lookup_cost" => lookup_cost,
+          "recognition_cost" => recognition_cost,
+          "measurement" => "not-measured",
+          "bounded_by_max_steps" => true
+        }
+      end
+
+      # @rbs (json_hash table, String values_key) -> Integer
+      def occupied_cells(table, values_key)
+        if table.key?("rows")
+          rows = table.fetch("rows") #: Array[json_value]
+          return rows.sum { |row| row.is_a?(Array) ? row.length : 0 }
+        end
+
+        values = table.fetch(values_key) #: Array[json_value]
+        values.compact.length
+      end
+
+      # @rbs () -> String
+      def lookup_cost
+        return "O(1) row-displacement probe" if @representation == :compact
+
+        "O(log row width) binary search"
+      end
+
+      # @rbs () -> String
+      def recognition_cost
+        prefix = if @representation == :compact
+                   "O(input tokens + reductions)"
+                 else
+                   "O((input tokens + reductions) * log maximum row width)"
+                 end
+        "#{prefix}; lexer, recovery search, and semantic actions excluded"
+      end
+
+      # @rbs (Symbol | String? requested) -> Symbol
+      def effective_cst_trivia(requested)
+        contract_entry = @grammar.parser_contract&.cst_trivia
+        persisted = contract_entry.value if contract_entry&.explicit
+        if requested && persisted && requested.to_sym != persisted
+          raise ArgumentError, "cst_trivia conflicts with the persisted parser contract"
+        end
+
+        (requested || persisted || :leading).to_sym
+      end
+    end
+  end
+end

data/lib/ibex/table_artifact/cst_projection.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Ibex
+  module TableArtifact
+    # Converts code-generation CST metadata into closed JSON records.
+    module CSTProjection
+      # @rbs!
+      #   private def cst: () -> Hash[String, Builder::json_value]?
+      #   private def normalize_cst: (Codegen::CSTMetadata::metadata metadata) -> Hash[String, Builder::json_value]
+      #   private def normalize_cst_kinds: (Codegen::CSTMetadata::kinds kinds) -> Hash[String, Builder::json_value]
+      #   private def named_kinds: (Hash[String, Integer] values) -> Array[Hash[String, String | Integer]]
+      #   private def normalize_cst_slot: (Integer production_id,
+      #     Codegen::CSTMetadata::slot slot) -> Hash[String, Builder::json_value]
+
+      private
+
+      # @rbs skip
+      def cst
+        return unless @grammar.options[:cst]
+
+        normalize_cst(Codegen::CSTMetadata.new(@grammar, trivia_policy: @cst_trivia).build)
+      end
+
+      # @rbs skip
+      def normalize_cst(metadata)
+        kinds = metadata.fetch(:kinds)
+        {
+          "version" => metadata.fetch(:version),
+          "trivia_policy" => metadata.fetch(:trivia_policy).to_s,
+          "kinds" => normalize_cst_kinds(kinds),
+          "slots" => metadata.fetch(:slots).sort.map { |production_id, slot| normalize_cst_slot(production_id, slot) }
+        }
+      end
+
+      # @rbs skip
+      def normalize_cst_kinds(kinds)
+        {
+          "names" => kinds.fetch(:names),
+          "terminal_range" => kinds.fetch(:terminal_range),
+          "nonterminal_range" => kinds.fetch(:nonterminal_range),
+          "named" => named_kinds(kinds.fetch(:named)),
+          "named_nonterminals" => kinds.fetch(:named_nonterminals).sort.map do |kind_id, symbol_id|
+            { "kind_id" => kind_id, "symbol_id" => symbol_id }
+          end,
+          "trivia" => named_kinds(kinds.fetch(:trivia)),
+          "synthetic" => named_kinds(kinds.fetch(:synthetic))
+        }
+      end
+
+      # @rbs skip
+      def named_kinds(values)
+        values.sort_by { |_name, id| id }.map { |name, id| { "name" => name, "id" => id } }
+      end
+
+      # @rbs skip
+      def normalize_cst_slot(production_id, slot)
+        fields = slot.fetch(:fields).map do |name, value|
+          value = { index: value, extraction: nil } if value.is_a?(Integer)
+          { "name" => name, "index" => value.fetch(:index), "extraction" => value[:extraction]&.to_s }
+        end
+        {
+          "production_id" => production_id,
+          "node_kind_id" => slot.fetch(:node_kind),
+          "node_name" => slot.fetch(:node_name),
+          "fields" => fields
+        }
+      end
+    end
+  end
+end