ibex 0.2.0 → 0.4.0

data/lib/ibex/cli/error_messages.rb

@@ -19,6 +19,8 @@ module Ibex
     #   private def same_file_target?: (String, String) -> bool
     #   private def normalize_grammar_path: (String) -> IR::Grammar
     #   private def record_generation_input: (String, String) -> GenerationInput
+    #   private def select_configuration_mode: (String) -> void
+    #   private def set_configuration_option: (Symbol, Object?) -> void
 
     private
 
@@ -61,9 +63,9 @@ module Ibex
         options.on("--from=FORMAT", %w[grammar-ir automaton-ir], "resume from IR JSON") do |value|
           @options[:from] = value
         end
-        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| @options[:mode] = value.to_sym }
+        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| select_configuration_mode(value) }
         options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
-          @options[:algorithm] = value.to_sym
+          set_configuration_option(:algorithm, value.to_sym)
           @options[:messages_algorithm_explicit] = true
         end
         options.on("--warnings=CATEGORIES", "all, error, all,error, or none") do |value|
@@ -80,6 +82,7 @@ module Ibex
 
       report_status("reading #{input_path}")
       grammar = normalize_grammar_path(input_path)
+      grammar = activate_analysis_grammar(grammar)
       handle_grammar_warnings(grammar, input_path)
       build_automaton(grammar, input_path)
     end
@@ -95,14 +98,14 @@ module Ibex
       end
 
       grammar = if value.is_a?(IR::Grammar)
-                  value
+                  activate_analysis_grammar(value)
                 elsif value.is_a?(IR::Automaton)
                   value.grammar
                 else
                   raise Ibex::Error, "#{input_path}:1:1: expected #{@options[:from]} input"
                 end
       handle_grammar_warnings(grammar, input_path)
-      return build_automaton(value, input_path) if value.is_a?(IR::Grammar)
+      return build_automaton(grammar, input_path) if value.is_a?(IR::Grammar)
 
       if value.is_a?(IR::Automaton)
         prepare_loaded_automaton(value, input_path)
@@ -173,5 +176,9 @@ module Ibex
 
       0o666 & ~File.umask
     end
+
+    # @rbs!
+    #   private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?],
+    #     ?explicit_keys: Array[Symbol]) -> IR::Grammar
   end
 end

data/lib/ibex/cli/explain.rb

@@ -12,6 +12,8 @@ module Ibex
     #   private def input_path: (Array[String]) -> String
     #   private def positive_counterexample_limit: (Integer, String) -> Integer
     #   private def normalize_grammar_path: (String) -> IR::Grammar
+    #   private def configuration_value: (String) -> untyped
+    #   private def set_configuration_option: (Symbol, Object?) -> void
 
     private
 
@@ -22,9 +24,10 @@ module Ibex
       return print_help(parser) if @options[:help]
 
       path = input_path(remaining)
-      grammar = normalize_grammar_path(path)
+      grammar = activate_analysis_grammar(normalize_grammar_path(path))
       automaton = LALR::Builder.new(
-        grammar, algorithm: @options[:algorithm] || :lalr, entry_isolation: @options[:entry_isolation] == true
+        grammar, algorithm: configuration_value("parser.algorithm"),
+                 entry_isolation: configuration_value("parser.entries") == :isolated
       ).build
       explanation = Codegen::Explain.new(
         automaton, state: @options[:explain_state], token: @options[:explain_token],
@@ -48,12 +51,14 @@ module Ibex
           @options[:explain_format] = value
         end
         options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
-          @options[:algorithm] = value.to_sym
+          set_configuration_option(:algorithm, value.to_sym)
         end
         options.on("--entry-isolation", "build independent state sets for each start symbol") do
-          @options[:entry_isolation] = true
+          set_configuration_option(:entry_isolation, true)
+        end
+        options.on("--mode=MODE", %w[default extended], "grammar mode") do |value|
+          set_configuration_option(:mode, value.to_sym)
         end
-        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| @options[:mode] = value.to_sym }
         add_explain_search_options(options)
         options.on("--help", "show help") { @options[:help] = true }
       end
@@ -72,5 +77,9 @@ module Ibex
         )
       end
     end
+
+    # @rbs!
+    #   private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?],
+    #     ?explicit_keys: Array[Symbol]) -> IR::Grammar
   end
 end

data/lib/ibex/cli/fix.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+require_relative "../fix"
+
+module Ibex
+  # CLI entry point for bounded conflict-repair proposals.
+  # rubocop:disable Metrics/ModuleLength -- CLI option wiring and output projections share one closed contract.
+  module CLIFix
+    # @rbs!
+    #   type fix_options = Hash[Symbol, untyped]
+    #   private def normalize_grammar_path: (String) -> IR::Grammar
+    #   private def activate_cli_feature: (Symbol) -> void
+    #   private def configuration_value: (String) -> untyped
+    #   private def set_configuration_option: (Symbol, Object?) -> void
+    #   private def local_configuration_value: (Hash[Symbol, Object?], String) -> Object?
+    #   private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_fix_command(arguments)
+      settings = fix_options(arguments)
+      if settings[:help]
+        @stdout.puts(settings.fetch(:help))
+        return 0
+      end
+      paths = settings.fetch(:paths)
+      raise Ibex::Error, "(fix):1:1: fix requires exactly one grammar source file" unless paths.length == 1
+
+      path = paths.fetch(0)
+      source, fixer = prepare_fixer(path, settings)
+      report = fixer.run
+      apply_fix!(path, source, report, fixer, settings.fetch(:apply)) if settings[:apply]
+      write_fix_report(report, settings.fetch(:format))
+      proposals = report.fetch(:proposals) #: Array[Hash[Symbol, untyped]]
+      proposals.empty? ? 1 : 0
+    rescue Fix::BudgetExceeded => e
+      report = { ibex_report: "fix", schema_version: Fix::SCHEMA_VERSION }.merge(e.details)
+      write_fix_report(report, settings&.fetch(:format) || "json")
+      2
+    end
+
+    # @rbs (String path, Hash[Symbol, untyped] settings) -> [String, Fix]
+    def prepare_fixer(path, settings)
+      source = File.binread(path)
+      if BisonImport.bison_source?(source)
+        imported = BisonImport::Importer.new(source, file: path).run
+        unless imported.structurally_complete?
+          names = imported.structural_unsupported.map(&:name).uniq.sort.join(", ")
+          raise Ibex::Error,
+                "(fix):1:1: Bison import is structurally incomplete due to: #{names}"
+        end
+        raise Ibex::Error,
+              "(fix):1:1: import Bison source to a canonical analysis file before requesting source repairs"
+      end
+      grammar = normalize_grammar_path(path)
+      grammar, algorithm, automaton = fixer_construction(grammar, settings)
+      message_file = settings[:messages]
+      messages = ErrorMessages.load(message_file) if message_file
+      mode = configuration_value("grammar.mode") #: Symbol
+      fixer = Fix.new(
+        source,
+        file: path, grammar: grammar, automaton: automaton,
+        algorithm: algorithm, mode: mode,
+        state: settings[:state], conflict_index: settings[:conflict_index],
+        max_candidates: settings.fetch(:max_candidates), max_builds: settings.fetch(:max_builds),
+        equiv_samples: settings.fetch(:equiv_samples),
+        equiv_max_tokens: settings.fetch(:equiv_max_tokens),
+        equiv_max_configurations: settings.fetch(:equiv_max_configurations),
+        verify_max_states: settings.fetch(:verify_max_states),
+        verify_max_items: settings.fetch(:verify_max_items),
+        messages: messages, message_file: message_file
+      )
+      [source, fixer]
+    end
+
+    # Keep command-local construction settings separate from reusable CLI state.
+    # @rbs (Array[String] arguments) -> Hash[Symbol, untyped]
+    def fix_options(arguments)
+      settings = {
+        paths: [], algorithm: Configuration::Registry.fetch("parser.algorithm").default,
+        mode: Configuration::Registry.fetch("grammar.mode").default, format: "json",
+        max_candidates: 32, max_builds: 32, equiv_samples: 100,
+        equiv_max_tokens: 8, equiv_max_configurations: 50_000,
+        verify_max_states: 100_000, verify_max_items: 1_000_000, configuration_explicit: []
+      } #: Hash[Symbol, untyped]
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: ibex fix [options] GRAMMAR"
+        add_fix_target_options(options, settings)
+        add_fix_budget_options(options, settings)
+        options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "current construction algorithm") do |value|
+          set_local_configuration_option(settings, :algorithm, value.to_sym)
+        end
+        options.on("--mode=MODE", %w[default extended], "grammar mode") do |value|
+          set_local_configuration_option(settings, :mode, value.to_sym)
+          set_configuration_option(:mode, value.to_sym)
+        end
+        options.on("--apply[=ID]", "atomically apply one safe source proposal") do |value|
+          settings[:apply] = value || true
+        end
+        options.on("--messages=FILE", "measure effects on an error-message catalog") do |value|
+          settings[:messages] = value
+        end
+        options.on("--format=FORMAT", %w[json text], "json or text") { |value| settings[:format] = value }
+        options.on("--help", "show help") { settings[:help] = options.to_s }
+      end
+      settings[:paths] = parser.parse(arguments)
+      settings[:algorithm] = local_configuration_value(settings, "parser.algorithm")
+      settings
+    end
+
+    # @rbs (OptionParser options, Hash[Symbol, untyped] settings) -> void
+    def add_fix_target_options(options, settings)
+      options.on("--state=N", Integer, "target state (default first unresolved conflict)") do |value|
+        raise OptionParser::InvalidArgument, "--state must be nonnegative" if value.negative?
+
+        settings[:state] = value
+      end
+      options.on("--conflict-index=N", Integer, "target conflict index within the state") do |value|
+        raise OptionParser::InvalidArgument, "--conflict-index must be nonnegative" if value.negative?
+
+        settings[:conflict_index] = value
+      end
+    end
+
+    # @rbs (OptionParser options, Hash[Symbol, untyped] settings) -> void
+    def add_fix_budget_options(options, settings)
+      {
+        "max-candidates" => :max_candidates,
+        "max-builds" => :max_builds,
+        "equiv-samples" => :equiv_samples,
+        "equiv-max-tokens" => :equiv_max_tokens,
+        "equiv-max-configurations" => :equiv_max_configurations,
+        "verify-max-states" => :verify_max_states,
+        "verify-max-items" => :verify_max_items
+      }.each do |name, key|
+        options.on("--#{name}=N", Integer, "positive bounded-search limit") do |value|
+          raise OptionParser::InvalidArgument, "--#{name} must be positive" unless value.positive?
+
+          settings[key] = value
+        end
+      end
+    end
+
+    # @rbs (IR::Grammar grammar, Hash[Symbol, untyped] settings) -> [IR::Grammar, Symbol, IR::Automaton]
+    def fixer_construction(grammar, settings)
+      explicit_keys = settings.fetch(:configuration_explicit) & [:algorithm]
+      construct_analysis_automaton(grammar, { algorithm: settings.fetch(:algorithm) }, explicit_keys)
+    end
+
+    # @rbs!
+    #   private def construct_analysis_automaton: (IR::Grammar, Hash[Symbol, Object?], Array[Symbol]) ->
+    #     [IR::Grammar, Symbol, IR::Automaton]
+
+    # @rbs (String path, String original, Hash[Symbol, untyped] report, Fix fixer, String | true selector) -> void
+    def apply_fix!(path, original, report, fixer, selector)
+      proposal = selected_fix_proposal(report.fetch(:proposals), selector)
+      unless proposal.fetch(:applyable)
+        raise Ibex::Error, "(fix):1:1: proposal #{proposal.fetch(:id)} changes invocation options, not source"
+      end
+      if File.symlink?(path) || File.stat(path).nlink > 1
+        raise Ibex::Error, "(fix):1:1: --apply refuses symlink aliases and files with multiple hard links"
+      end
+
+      replacement = fixer.sources.fetch(proposal.fetch(:id))
+      activate_cli_feature(:CLIFormatting)
+      results = [{
+        path: path, label: path, source: original, formatted: replacement
+      }]
+      targets = send(:formatting_targets, results)
+      send(:transactionally_write_formatted, targets)
+      report[:applied] = proposal.fetch(:id)
+    end
+
+    # @rbs (Array[Hash[Symbol, untyped]] proposals, String | true selector) -> Hash[Symbol, untyped]
+    def selected_fix_proposal(proposals, selector)
+      proposal = if selector == true
+                   proposals.find { |entry| entry.fetch(:applyable) }
+                 else
+                   proposals.find { |entry| entry.fetch(:id) == selector }
+                 end
+      proposal || raise(Ibex::Error, "(fix):1:1: no matching applyable safe proposal")
+    end
+
+    # @rbs (Hash[Symbol, untyped] report, String format) -> void
+    def write_fix_report(report, format)
+      if format == "json"
+        @stdout.puts(JSON.pretty_generate(report))
+        return
+      end
+
+      @stdout.puts("result=#{report.fetch(:result)} proposals=#{report.fetch(:proposals, []).length}")
+      report.fetch(:proposals, []).each do |proposal|
+        @stdout.puts("#{proposal.fetch(:id)} #{proposal.fetch(:description)}")
+      end
+      @stdout.puts(report.fetch(:statement, Equiv::CAVEAT))
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/ibex/cli/formatting.rb

@@ -9,14 +9,7 @@ module Ibex
   # rubocop:disable Metrics/ModuleLength -- transaction lifecycle stays cohesive and auditable.
   module CLIFormatting
     # @rbs!
-    #   type formatting_settings = {
-    #     paths: Array[String],
-    #     mode: Symbol,
-    #     check: bool,
-    #     write: bool,
-    #     ?stdin_filename: String,
-    #     ?help: bool
-    #   }
+    #   type formatting_settings = Hash[Symbol, untyped]
     #   type formatting_result = {
     #     path: String,
     #     label: String,
@@ -40,6 +33,8 @@ module Ibex
     #     errors: Array[String],
     #     remaining: Array[String]
     #   }
+    #   private def local_configuration_value: (Hash[Symbol, Object?], String) -> Object?
+    #   private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
 
     private
 
@@ -68,8 +63,12 @@ module Ibex
 
     # @rbs (Array[String] arguments) -> formatting_settings
     def formatting_options(arguments)
-      settings = { paths: [], mode: :default, check: false, write: false } #: formatting_settings
+      settings = {
+        paths: [], mode: Configuration::Registry.fetch("grammar.mode").default, check: false, write: false,
+        configuration_explicit: []
+      } #: formatting_settings
       settings[:paths] = formatting_option_parser(settings).parse(arguments)
+      settings[:mode] = local_configuration_value(settings, "grammar.mode")
       settings
     end
 
@@ -79,7 +78,9 @@ module Ibex
         options.banner = "Usage: ibex fmt [--check | --write] [options] grammar.y [...]"
         options.on("--check", "report files that need formatting") { settings[:check] = true }
         options.on("--write", "atomically format files in place") { settings[:write] = true }
-        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| settings[:mode] = value.to_sym }
+        options.on("--mode=MODE", %w[default extended], "grammar mode") do |value|
+          set_local_configuration_option(settings, :mode, value.to_sym)
+        end
         options.on("--stdin-filename=FILE", "diagnostic filename for standard input") do |value|
           settings[:stdin_filename] = value
         end

data/lib/ibex/cli/fuzz.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "shellwords"
+require_relative "../bounded_subprocess"
+require_relative "../fuzz"
+require_relative "fuzz_regressions"
+
+module Ibex
+  # CLI entry point for bounded grammar-derived differential fuzzing.
+  module CLIFuzz
+    include CLIFuzzRegressions
+
+    # @rbs!
+    #   private def print_help: (OptionParser) -> Integer
+    #   private def input_path: (Array[String]) -> String
+    #   private def normalize_grammar_path: (String) -> IR::Grammar
+    #   private def handle_grammar_warnings: (IR::Grammar, String) -> void
+    #   private def warning_categories: (String) -> Array[Symbol]
+    #   private def select_configuration_mode: (String) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_fuzz_command(arguments)
+      parser = fuzz_option_parser
+      remaining = parser.parse(arguments)
+      return print_help(parser) if @options[:help]
+
+      path = input_path(remaining)
+      grammar = normalize_grammar_path(path)
+      handle_grammar_warnings(grammar, path)
+      external = external_fuzz_target
+      fuzzer = Fuzz.new(
+        grammar,
+        seed: @options.fetch(:fuzz_seed, 0), count: @options.fetch(:fuzz_count, 100),
+        max_tokens: @options.fetch(:fuzz_max_tokens, 32), max_depth: @options.fetch(:fuzz_max_depth, 16),
+        max_expansions: @options.fetch(:fuzz_max_expansions, Samples::DEFAULT_MAX_EXPANSIONS),
+        max_actions: @options.fetch(:fuzz_max_actions, Fuzz::DEFAULT_MAX_ACTIONS),
+        max_stack: @options.fetch(:fuzz_max_stack, Fuzz::DEFAULT_MAX_STACK),
+        coverage_guided: @options.fetch(:fuzz_coverage_guided, false),
+        path_length: @options.fetch(:fuzz_path_length, 2),
+        against: external&.[](0), against_description: external&.[](1)
+      )
+      write_fuzz_report(fuzzer.run)
+      0
+    rescue Fuzz::Mismatch => e
+      raise unless fuzzer && path
+
+      begin
+        write_minimized_fuzz_mismatch(fuzzer, e, path, external)
+      rescue Fuzz::BudgetExceeded => budget
+        write_fuzz_budget_report(budget, external, phase: "reduction")
+      end
+    rescue Fuzz::BudgetExceeded => e
+      write_fuzz_budget_report(e, external, phase: "comparison")
+    end
+
+    # @rbs () -> OptionParser
+    def fuzz_option_parser
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex fuzz [options] grammarfile"
+        add_fuzz_generation_options(options)
+        add_fuzz_execution_options(options)
+        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| select_configuration_mode(value) }
+        options.on("--warnings=CATEGORIES", "all, error, all,error, or none") do |value|
+          @options[:warnings] = warning_categories(value)
+        end
+        options.on("--help", "show help") { @options[:help] = true }
+      end
+    end
+
+    # @rbs (OptionParser options) -> void
+    def add_fuzz_generation_options(options)
+      options.on("--count=N", Integer, "generated sentences (default 100)") do |value|
+        @options[:fuzz_count] = positive_fuzz_option!("count", value)
+      end
+      options.on("--seed=N", Integer, "deterministic seed (default 0)") { |value| @options[:fuzz_seed] = value }
+      options.on("--max-tokens=N", Integer, "maximum generated tokens") do |value|
+        @options[:fuzz_max_tokens] = positive_fuzz_option!("max-tokens", value)
+      end
+      options.on("--max-depth=N", Integer, "maximum random expansion depth") do |value|
+        @options[:fuzz_max_depth] = positive_fuzz_option!("max-depth", value)
+      end
+      options.on("--max-expansions=N", Integer, "total derivation work budget") do |value|
+        @options[:fuzz_max_expansions] = positive_fuzz_option!("max-expansions", value)
+      end
+    end
+
+    # @rbs (OptionParser options) -> void
+    def add_fuzz_execution_options(options)
+      options.on("--max-actions=N", Integer, "actions per simulated sentence") do |value|
+        @options[:fuzz_max_actions] = positive_fuzz_option!("max-actions", value)
+      end
+      options.on("--max-stack=N", Integer, "simulated parser stack depth") do |value|
+        @options[:fuzz_max_stack] = positive_fuzz_option!("max-stack", value)
+      end
+      options.on("--coverage-guided", "prefer uncovered production paths") do
+        @options[:fuzz_coverage_guided] = true
+      end
+      options.on("--path-length=N", Integer, "coverage path length: 1 or 2") do |value|
+        raise OptionParser::InvalidArgument, "--path-length must be 1 or 2" unless [1, 2].include?(value)
+
+        @options[:fuzz_path_length] = value
+      end
+      add_fuzz_external_options(options)
+    end
+
+    # @rbs (OptionParser options) -> void
+    def add_fuzz_external_options(options)
+      options.on("--against=COMMAND", "compare with an explicit JSON-token subprocess") do |value|
+        @options[:fuzz_against] = value
+      end
+      options.on("--against-runtime=DESCRIPTION", "required target runtime configuration for --against") do |value|
+        raise OptionParser::InvalidArgument, "--against-runtime must not be empty" if value.empty?
+
+        @options[:fuzz_against_runtime] = value
+      end
+      options.on("--against-timeout=SECONDS", Integer, "target timeout per sentence (default 10)") do |value|
+        @options[:fuzz_against_timeout] = positive_fuzz_option!("against-timeout", value)
+      end
+      options.on("--against-max-output=N", Integer, "target stdout/stderr byte budget") do |value|
+        @options[:fuzz_against_max_output] = positive_fuzz_option!("against-max-output", value)
+      end
+      options.on("--max-reduction-trials=N", Integer, "automatic mismatch-reduction trial budget") do |value|
+        @options[:fuzz_max_reduction_trials] = positive_fuzz_option!("max-reduction-trials", value)
+      end
+      options.on("--regression-dir=DIR", "saved minimized regressions (default test/fuzz/regressions)") do |value|
+        raise OptionParser::InvalidArgument, "--regression-dir must not be empty" if value.empty?
+
+        @options[:fuzz_regression_dir] = value
+      end
+      options.on("--[no-]save-regression", "persist minimized mismatches (default enabled)") do |value|
+        @options[:fuzz_save_regression] = value
+      end
+      options.on("--format=FORMAT", %w[json text], "json or text (default json)") do |value|
+        @options[:fuzz_format] = value
+      end
+    end
+
+    # @rbs () -> fuzz_external_target?
+    def external_fuzz_target
+      command = @options[:fuzz_against]
+      runtime = @options[:fuzz_against_runtime]
+      if command.nil?
+        raise OptionParser::InvalidArgument, "--against-runtime requires --against" if runtime
+
+        return
+      end
+      unless runtime
+        raise OptionParser::InvalidArgument,
+              "--against requires --against-runtime so the comparison target is reproducible"
+      end
+
+      arguments = Shellwords.split(command)
+      raise OptionParser::InvalidArgument, "--against command must not be empty" if arguments.empty?
+
+      timeout = @options.fetch(:fuzz_against_timeout, BoundedSubprocess::DEFAULT_TIMEOUT_SECONDS)
+      max_output = @options.fetch(:fuzz_against_max_output, BoundedSubprocess::DEFAULT_MAX_OUTPUT_BYTES)
+      subprocess = BoundedSubprocess.new(timeout_seconds: timeout, max_output_bytes: max_output)
+      runner = lambda do |tokens|
+        external_fuzz_outcome(subprocess, arguments, tokens, timeout, max_output)
+      end #: ^(Array[String]) -> Symbol
+      description = {
+        command: command, target_runtime: runtime,
+        timeout_seconds: timeout, max_output_bytes: max_output,
+        host_ruby_engine: RUBY_ENGINE, host_ruby_version: RUBY_VERSION,
+        host_platform: RUBY_PLATFORM
+      } #: fuzz_external_description
+      [runner, description]
+    end
+
+    # @rbs (BoundedSubprocess subprocess, Array[String] arguments, Array[String] tokens,
+    #   Integer timeout, Integer max_output) -> Symbol
+    def external_fuzz_outcome(subprocess, arguments, tokens, timeout, max_output)
+      result = subprocess.run(arguments, input: JSON.generate(tokens))
+      if result.timed_out || result.output_limited
+        raise Fuzz::BudgetExceeded.new(
+          message: "external target exceeded its #{result.timed_out ? 'timeout' : 'output limit'}",
+          bounds: { timeout_seconds: timeout, max_output_bytes: max_output }
+        )
+      end
+      unless result.status.exited? && [0, 1].include?(result.status.exitstatus)
+        detail = result.stderr.empty? ? result.stdout : result.stderr
+        raise Ibex::Error,
+              "(fuzz):1:1: external target did not exit with 0 or 1: #{detail}"
+      end
+
+      result.status.success? ? :accepted : :error
+    end
+
+    # @rbs (String name, Integer value) -> Integer
+    def positive_fuzz_option!(name, value)
+      return value if value.positive?
+
+      raise OptionParser::InvalidArgument, "--#{name} must be positive"
+    end
+  end
+end