ibex 0.1.0 → 0.2.0

data/lib/ibex/cli/ir_tools.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require_relative "../ir"
+
+module Ibex
+  # @rbs!
+  #   type migrate_ir_options = {
+  #     paths: Array[String],
+  #     ?to: Integer,
+  #     ?output: String
+  #   }
+
+  # CLI validation and structural comparison for versioned IR documents.
+  module CLIIRTools
+    # @rbs!
+    #   private def same_file_target?: (String left, String right) -> bool
+    #   private def atomic_write_ir: (String path, String source) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_validate_ir_command(arguments)
+      path = single_ir_path(arguments, "validate-ir")
+      value = IR::Validator.validate(File.read(path))
+      kind = if value.is_a?(IR::Grammar)
+               "grammar"
+             elsif value.is_a?(IR::Lexer)
+               "lexer"
+             else
+               "automaton"
+             end
+      @stdout.puts("valid #{kind} IR v#{value.schema_version}")
+      0
+    end
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_compare_command(arguments)
+      raise Ibex::Error, "(cli):1:1: compare requires exactly two IR files" unless arguments.length == 2
+
+      before = IR::Validator.validate(File.read(arguments.fetch(0)))
+      after = IR::Validator.validate(File.read(arguments.fetch(1)))
+      compatible = (before.is_a?(IR::Grammar) && after.is_a?(IR::Grammar)) ||
+                   (before.is_a?(IR::Automaton) && after.is_a?(IR::Automaton)) ||
+                   (before.is_a?(IR::Lexer) && after.is_a?(IR::Lexer))
+      raise Ibex::Error, "(cli):1:1: cannot compare different IR kinds" unless compatible
+
+      @stdout.puts(JSON.pretty_generate(compare_ir(before, after)))
+      0
+    end
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_migrate_ir_command(arguments)
+      settings = migrate_ir_options(arguments)
+      input = single_ir_path(settings.fetch(:paths), "migrate-ir")
+      output = settings[:output]
+      if output && same_file_target?(input, output)
+        raise Ibex::Error, "(cli):1:1: migrate-ir input and output paths must be distinct"
+      end
+
+      value = IR::Validator.validate(File.read(input))
+      target = settings[:to] || raise(Ibex::Error, "(cli):1:1: migrate-ir requires --to=VERSION")
+      if value.is_a?(IR::Lexer)
+        raise Ibex::Error, "(cli):1:1: lexer IR is already at its only supported schema version" unless
+          target == value.schema_version
+
+        source = IR::Serialize.dump(value)
+        output ? atomic_write_ir(output, source) : @stdout.write(source)
+        return 0
+      end
+      unless IR::SUPPORTED_SCHEMA_VERSIONS.include?(target)
+        raise Ibex::Error, "(cli):1:1: unsupported migration target schema_version #{target}"
+      end
+      if target < value.schema_version
+        raise Ibex::Error,
+              "(cli):1:1: downgrading schema_version #{value.schema_version} to #{target} is not supported"
+      end
+
+      source = IR::Serialize.dump(IR::Migration.to_version(value, to: target))
+      output ? atomic_write_ir(output, source) : @stdout.write(source)
+      0
+    end
+
+    # @rbs (Array[String] arguments) -> migrate_ir_options
+    def migrate_ir_options(arguments)
+      settings = { paths: [] } #: migrate_ir_options
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: ibex migrate-ir INPUT --to=VERSION [-o FILE]"
+        options.on("--to=VERSION", Integer, "target schema version") { |value| settings[:to] = value }
+        options.on("-o FILE", "--output=FILE", "write atomically to FILE") { |value| settings[:output] = value }
+      end
+      settings[:paths] = parser.parse(arguments)
+      settings
+    end
+
+    # @rbs (Array[String] arguments, String command) -> String
+    def single_ir_path(arguments, command)
+      return arguments.first if arguments.length == 1
+
+      raise Ibex::Error, "(cli):1:1: #{command} requires exactly one IR file"
+    end
+
+    # @rbs (IR::Grammar | IR::Automaton | IR::Lexer before,
+    #   IR::Grammar | IR::Automaton | IR::Lexer after) -> Hash[Symbol, untyped]
+    def compare_ir(before, after)
+      return compare_grammars(before, after) if before.is_a?(IR::Grammar) && after.is_a?(IR::Grammar)
+      if before.is_a?(IR::Automaton) && after.is_a?(IR::Automaton)
+        return {
+          kind: "automaton",
+          algorithm: { before: before.algorithm, after: after.algorithm },
+          states: numeric_change(before.states.length, after.states.length),
+          transitions: numeric_change(transition_count(before), transition_count(after)),
+          conflicts: %i[sr resolved_sr rr].to_h do |kind|
+            [kind, numeric_change(summary_count(before, kind), summary_count(after, kind))]
+          end,
+          grammar: compare_grammars(before.grammar, after.grammar)
+        }
+      end
+      return compare_lexers(before, after) if before.is_a?(IR::Lexer) && after.is_a?(IR::Lexer)
+
+      raise Ibex::Error, "(cli):1:1: unsupported IR comparison"
+    end
+
+    # @rbs (IR::Lexer before, IR::Lexer after) -> Hash[Symbol, untyped]
+    def compare_lexers(before, after)
+      before_rules = before.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
+      after_rules = after.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
+      {
+        kind: "lexer",
+        states: { added: after.states - before.states, removed: before.states - after.states },
+        rules: {
+          added: after_rules - before_rules, removed: before_rules - after_rules,
+          count: numeric_change(before.rules.length, after.rules.length)
+        },
+        warnings: numeric_change(before.warnings.length, after.warnings.length)
+      }
+    end
+
+    # @rbs (IR::Grammar before, IR::Grammar after) -> Hash[Symbol, untyped]
+    def compare_grammars(before, after)
+      before_symbols = before.symbols.map(&:name)
+      after_symbols = after.symbols.map(&:name)
+      before_productions = production_shapes(before)
+      after_productions = production_shapes(after)
+      {
+        kind: "grammar",
+        symbols: { added: (after_symbols - before_symbols).sort, removed: (before_symbols - after_symbols).sort },
+        productions: {
+          added: (after_productions - before_productions).sort,
+          removed: (before_productions - after_productions).sort,
+          count: numeric_change(before.productions.length, after.productions.length)
+        },
+        warnings: numeric_change(before.warnings.length, after.warnings.length)
+      }
+    end
+
+    # @rbs (IR::Grammar grammar) -> Array[String]
+    def production_shapes(grammar)
+      grammar.productions.map do |production|
+        lhs = grammar.symbol_by_id(production.lhs)&.name || production.lhs.to_s
+        rhs = production.rhs.map { |id| grammar.symbol_by_id(id)&.name || id.to_s }
+        "#{lhs} -> #{rhs.join(' ')}"
+      end
+    end
+
+    # @rbs (IR::Automaton automaton) -> Integer
+    def transition_count(automaton)
+      automaton.states.sum { |state| state.transitions.length }
+    end
+
+    # @rbs (IR::Automaton automaton, Symbol kind) -> Integer
+    def summary_count(automaton, kind)
+      value = automaton.conflict_summary.fetch(kind)
+      return value if value.is_a?(Integer)
+
+      raise Ibex::Error, "(ir):1:1: conflict count #{kind} must be an integer"
+    end
+
+    # @rbs (Integer before, Integer after) -> Hash[Symbol, Integer]
+    def numeric_change(before, after)
+      { before: before, after: after, delta: after - before }
+    end
+  end
+end

data/lib/ibex/cli/lsp.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../lsp"
+
+module Ibex
+  # CLI boundary for the stdio-only language server.
+  module CLILSP
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_lsp_command(arguments)
+      settings = { help: false, stdio: false } #: Hash[Symbol, bool]
+      remaining = lsp_option_parser(settings).parse(arguments)
+      raise Ibex::Error, "(cli):1:1: ibex lsp does not accept file arguments" unless remaining.empty?
+
+      if settings.fetch(:help)
+        @stdout.puts(lsp_option_parser(settings))
+        return 0
+      end
+
+      LSP::Server.new(stdin: @stdin, stdout: @stdout, stderr: @stderr).run
+    end
+
+    # @rbs (Hash[Symbol, bool] settings) -> OptionParser
+    def lsp_option_parser(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex lsp [--stdio]"
+        options.on("--stdio", "use Content-Length framed JSON-RPC on standard IO") { settings[:stdio] = true }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+  end
+end

data/lib/ibex/cli/outputs.rb

@@ -3,14 +3,24 @@
 module Ibex
   # Files, warnings, and progress emitted by CLI pipeline stages.
   module CLIOutputs
+    # @rbs!
+    #   private def register_artifact: (Symbol, String, String, ?mode: Integer?, ?status: bool) -> Artifact
+
     WARNING_MESSAGES = {
       undeclared_terminal: ->(warning) { "undeclared terminal #{warning[:symbol]}" },
       unused_terminal: ->(warning) { "unused terminal #{warning[:symbol]}" },
+      unused_precedence: ->(warning) { "unused precedence #{warning[:symbol]}" },
+      unreachable_terminal: ->(warning) { "declared terminal #{warning[:symbol]} is unreachable" },
       unreachable_nonterminal: ->(warning) { "unreachable nonterminal #{warning[:symbol]}" },
       duplicate_production: lambda do |warning|
         "duplicate production #{warning[:production]} (first defined as #{warning[:original]})"
       end,
-      empty_language: ->(warning) { "start symbol #{warning[:symbol]} derives no terminal sentence" }
+      implicit_empty: ->(_warning) { "implicit empty alternative; write %empty to document intent" },
+      empty_language: ->(warning) { "start symbol #{warning[:symbol]} derives no terminal sentence" },
+      lexer_redos: lambda do |warning|
+        subject = warning[:symbol] ? " for #{warning[:symbol]}" : ""
+        "lexer pattern#{subject} may exhibit excessive backtracking"
+      end
     }.freeze #: Hash[Symbol, ^(IR::grammar_warning) -> String]
 
     private
@@ -55,34 +65,107 @@ module Ibex
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def report_conflicts(automaton, input_path)
-      summary = automaton.conflict_summary
+      messages = conflict_messages(automaton.conflict_summary, input_path)
+      if @options[:warnings]&.include?(:error) && messages.any?
+        raise Ibex::Error, messages.map { |message| "#{message}; conflict treated as error" }.join("\n")
+      end
+
+      messages.each { |message| @stderr.puts(message) }
+    end
+
+    # @rbs (IR::conflict_summary summary, String input_path) -> Array[String]
+    def conflict_messages(summary, input_path)
+      messages = [] #: Array[String]
       unless summary[:expectation_met]
-        @stderr.puts("#{input_path}:1:1: #{summary[:sr]} shift/reduce conflicts; expected #{summary[:expected_sr]}")
+        messages << "#{input_path}:1:1: #{summary[:sr]} shift/reduce conflicts; expected #{summary[:expected_sr]}"
+      end
+      if summary.key?(:rr_expectation_met)
+        unless summary[:rr_expectation_met]
+          messages << "#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts; expected #{summary[:expected_rr]}"
+        end
+      elsif summary[:rr].positive?
+        messages << "#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts"
       end
-      @stderr.puts("#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts") if summary[:rr].positive?
+      messages
+    end
+
+    # @rbs (IR::Automaton automaton, String input_path) -> void
+    def suggest_ielr(automaton, input_path)
+      return unless @options[:suggest_ielr]
+      return unless automaton.algorithm == "lalr1"
+      return unless [nil, :lalr].include?(@options[:algorithm])
+
+      summary = automaton.conflict_summary
+      return if summary[:expectation_met] && summary.fetch(:rr_expectation_met, summary[:rr].zero?)
+
+      ielr = LALR::Builder.new(
+        automaton.grammar, algorithm: :ielr, entry_isolation: @options[:entry_isolation] == true
+      ).build
+      removed_sr = [summary[:sr] - ielr.conflict_summary[:sr], 0].max
+      removed_rr = [summary[:rr] - ielr.conflict_summary[:rr], 0].max
+      avoided = [] #: Array[String]
+      avoided << conflict_count(removed_sr, "shift/reduce") if removed_sr.positive?
+      avoided << conflict_count(removed_rr, "reduce/reduce") if removed_rr.positive?
+      return if avoided.empty?
+
+      @stderr.puts("#{input_path}:1:1: note: --algorithm=ielr avoids #{avoided.join(' and ')}; " \
+                   "consider --algorithm=ielr")
+    end
+
+    # @rbs (Integer count, String kind) -> String
+    def conflict_count(count, kind)
+      "#{count} #{kind} conflict#{'s' unless count == 1}"
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def write_report(automaton, input_path)
+      require_relative "../codegen/report"
       path = @options[:log_file] || default_output_path(input_path, ".output")
       report = Codegen::Report.render(
         automaton,
         max_tokens: @options[:counterexample_max_tokens],
         max_configurations: @options[:counterexample_max_configurations]
       )
-      File.write(path, report)
-      report_status("wrote #{path}")
+      register_artifact(:report, path, report, status: true)
     end
 
     # @rbs (String input_path, String extension) -> String
     def default_output_path(input_path, extension)
-      replaced = input_path.sub(/\.[^.]+\z/, extension)
-      replaced == input_path ? "#{input_path}#{extension}" : replaced
+      directory = File.dirname(input_path)
+      basename = File.basename(input_path)
+      replaced = basename.sub(/\.[^.]+\z/, extension)
+      replaced = "#{basename}#{extension}" if replaced == basename
+      directory == "." ? replaced : File.join(directory, replaced)
     end
 
     # @rbs (String message) -> void
     def report_status(message)
       @stderr.puts("ibex: #{message}") if @options[:status]
     end
+
+    # @rbs (String path, String source) -> void
+    def atomic_write_ir(path, source)
+      require "tempfile"
+
+      target_path = File.symlink?(path) ? File.realpath(path) : path
+      directory = File.dirname(File.expand_path(target_path))
+      basename = File.basename(target_path)
+      Tempfile.create([".#{basename}.", ".tmp"], directory) do |temporary|
+        temporary.binmode
+        temporary.write(source)
+        temporary.flush
+        temporary.fsync
+        temporary.chmod(ir_file_mode(target_path))
+        temporary.close
+        File.rename(temporary.path, target_path)
+      end
+    end
+
+    # @rbs (String path) -> Integer
+    def ir_file_mode(path)
+      return File.stat(path).mode & 0o777 if File.exist?(path)
+
+      0o666 & ~File.umask
+    end
   end
 end

data/lib/ibex/cli/racc_migration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+require_relative "../racc_migration"
+
+module Ibex
+  # Static racc migration checks and differential harness generation.
+  module CLIRaccMigration
+    # @rbs!
+    #   type migration_check_settings = {
+    #     format: String,
+    #     ?help: bool
+    #   }
+    #   type migration_harness_settings = {
+    #     ?output: String,
+    #     ?help: bool
+    #   }
+    #
+    #   private def input_path: (Array[String]) -> String
+    #   private def atomic_write_ir: (String path, String source) -> void
+    #   private def same_file_target?: (String left, String right) -> bool
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_migrate_check_command(arguments)
+      settings = { format: "text" } #: migration_check_settings
+      parser = migrate_check_options(settings)
+      paths = parser.parse(arguments)
+      if settings[:help]
+        @stdout.puts(parser)
+        return 0
+      end
+
+      path = input_path(paths)
+      report = RaccMigration::Checker.new.check(File.binread(path), file: path)
+      @stdout.write(settings.fetch(:format) == "json" ? "#{report.to_json}\n" : report.to_text)
+      report.compatible? ? 0 : 1
+    end
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_migrate_harness_command(arguments)
+      settings = {} #: migration_harness_settings
+      parser = migrate_harness_options(settings)
+      paths = parser.parse(arguments)
+      if settings[:help]
+        @stdout.puts(parser)
+        return 0
+      end
+
+      path = input_path(paths)
+      report = RaccMigration::Checker.new.check(File.binread(path), file: path)
+      unless report.compatible? && report.class_name
+        raise Ibex::Error, "(migration):1:1: grammar must pass migrate-check before harness generation"
+      end
+
+      source = RaccMigration::Harness.generate(report.class_name)
+      output = settings[:output]
+      if output && same_file_target?(path, output)
+        raise Ibex::Error, "(migration):1:1: grammar and harness output paths must be distinct"
+      end
+
+      output ? atomic_write_ir(output, source) : @stdout.write(source)
+      0
+    end
+
+    # @rbs (migration_check_settings settings) -> OptionParser
+    def migrate_check_options(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex migrate-check [--format=text|json] grammarfile"
+        options.on("--format=FORMAT", %w[text json], "text or json") { |value| settings[:format] = value }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+
+    # @rbs (migration_harness_settings settings) -> OptionParser
+    def migrate_harness_options(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex migrate-harness [-o FILE] grammarfile"
+        options.on("-o FILE", "--output=FILE", "write the harness atomically") { |value| settings[:output] = value }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+  end
+end

data/lib/ibex/cli/samples.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "../samples"
+
+module Ibex
+  # CLI entry point for bounded grammar sentence generation.
+  module CLISamples
+    # @rbs!
+    #   private def print_help: (OptionParser) -> Integer
+    #   private def input_path: (Array[String]) -> String
+    #   private def handle_grammar_warnings: (IR::Grammar, String) -> void
+    #   private def warning_categories: (String) -> Array[Symbol]
+    #   private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_samples_command(arguments)
+      parser = samples_option_parser
+      remaining = parser.parse(arguments)
+      return print_help(parser) if @options[:help]
+
+      path = input_path(remaining)
+      grammar = grammar_for_samples(path)
+      handle_grammar_warnings(grammar, path)
+      generator = Samples.new(
+        grammar,
+        seed: @options.fetch(:sample_seed, 0),
+        max_tokens: @options.fetch(:sample_max_tokens, 32),
+        max_depth: @options.fetch(:sample_max_depth, 16),
+        max_expansions: @options.fetch(:sample_max_expansions, Samples::DEFAULT_MAX_EXPANSIONS)
+      )
+      generator.generate(count: @options.fetch(:sample_count, 5)).each do |sample|
+        @stdout.puts(JSON.generate(sample))
+      end
+      0
+    end
+
+    # @rbs () -> OptionParser
+    def samples_option_parser
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex samples [options] grammarfile"
+        options.on("--count=N", Integer, "number of samples (default 5)") do |value|
+          @options[:sample_count] = positive_sample_option!("count", value)
+        end
+        options.on("--seed=N", Integer, "deterministic random seed (default 0)") do |value|
+          @options[:sample_seed] = value
+        end
+        options.on("--max-tokens=N", Integer, "maximum tokens per sample (default 32)") do |value|
+          @options[:sample_max_tokens] = positive_sample_option!("max-tokens", value)
+        end
+        options.on("--max-depth=N", Integer, "random expansion depth (default 16)") do |value|
+          @options[:sample_max_depth] = positive_sample_option!("max-depth", value)
+        end
+        options.on("--max-expansions=N", Integer, "total expansion steps (default 100000)") do |value|
+          @options[:sample_max_expansions] = positive_sample_option!("max-expansions", value)
+        end
+        options.on("--from=FORMAT", %w[grammar-ir automaton-ir], "read versioned 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("--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 (String path) -> IR::Grammar
+    def grammar_for_samples(path)
+      return normalize_grammar_path(path) unless @options[:from]
+
+      value = IR::Validator.validate(File.read(path))
+      expected = @options[:from] == "grammar-ir" ? IR::Grammar : IR::Automaton
+      raise Ibex::Error, "#{path}:1:1: expected #{@options[:from]} input" unless value.is_a?(expected)
+
+      return value if value.is_a?(IR::Grammar)
+      return value.grammar if value.is_a?(IR::Automaton)
+
+      raise Ibex::Error, "#{path}:1:1: expected #{@options[:from]} input"
+    end
+
+    # @rbs (String name, Integer value) -> Integer
+    def positive_sample_option!(name, value)
+      return value if value.positive?
+
+      raise OptionParser::InvalidArgument, "--#{name} must be positive"
+    end
+  end
+end

data/lib/ibex/cli/watch.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "../watch"
+require_relative "../generation_transaction"
+
+module Ibex
+  # Long-running CLI generation over stable source snapshots.
+  module CLIWatch
+    # @rbs!
+    #   private def process_grammar: (String) -> Integer
+    #   private def generation_artifacts: () -> ArtifactSet
+    #   private def report_status: (String) -> void
+
+    # Rendered watch generation awaiting its stability-guarded publication.
+    class Build
+      attr_reader :artifacts #: ArtifactSet
+      attr_reader :statuses #: Array[String]
+      attr_reader :source_paths #: Array[String]
+      attr_reader :attempted_paths #: Array[String]
+      attr_reader :source_records #: Array[GenerationInput]
+
+      # rubocop:disable Layout/LineLength
+      # @rbs (artifacts: ArtifactSet, statuses: Array[String], source_paths: Array[String], attempted_paths: Array[String], source_records: Array[GenerationInput]) -> void
+      def initialize(artifacts:, statuses:, source_paths:, attempted_paths:, source_records:)
+        @artifacts = artifacts
+        @statuses = statuses.freeze
+        @source_paths = source_paths.freeze
+        @attempted_paths = attempted_paths.freeze
+        @source_records = source_records.freeze
+        freeze
+      end
+      # rubocop:enable Layout/LineLength
+    end
+
+    private
+
+    # @rbs (String path) -> Integer
+    def run_watch(path)
+      raise Ibex::Error, "(cli):1:1: --watch requires a grammar file, not stdin" if path == "-"
+
+      paths = [path]
+      paths << @options[:messages] if @options[:messages]
+      Watch::Runner.new(
+        paths: paths,
+        build: -> { prepare_watch_generation(path) },
+        publish: ->(build, snapshot, continue) { publish_watch_generation(build, snapshot, continue) },
+        failure_paths: -> { watch_failure_paths(path) },
+        stderr: @stderr,
+        clock: @watch_clock,
+        sleeper: @watch_sleeper,
+        iteration_hook: @watch_iteration_hook
+      ).run
+    end
+
+    # @rbs (String path) -> Build
+    def prepare_watch_generation(path)
+      @defer_generation_publication = true
+      status = process_grammar(path)
+      raise Ibex::Error, "(watch):1:1: generation returned status #{status}" unless status.zero?
+
+      Build.new(
+        artifacts: generation_artifacts,
+        statuses: @generation_statuses.dup,
+        source_paths: @generation_sources.dup,
+        attempted_paths: @last_resolver&.attempted_paths || [],
+        source_records: @generation_inputs.dup
+      )
+    ensure
+      @defer_generation_publication = false
+    end
+
+    # @rbs (Build build, Watch::SourceSnapshot snapshot, ^() -> bool continue) -> void
+    def publish_watch_generation(build, snapshot, continue)
+      stable = lambda do
+        continue.call && build.source_records.all?(&:current?) &&
+          Watch::SourceSnapshot.new(snapshot.paths) == snapshot
+      end
+      GenerationTransaction.new(
+        build.artifacts,
+        warning: ->(message) { @stderr.puts("ibex: warning: #{message}") },
+        stability_check: stable,
+        source_records: build.source_records,
+        lock_sleeper: @watch_sleeper
+      ).commit
+      build.statuses.each { |message| report_status(message) }
+    end
+
+    # @rbs (String path) -> Array[String]
+    def watch_failure_paths(path)
+      paths = [path]
+      paths << @options[:messages] if @options[:messages]
+      paths.concat(@last_resolver.attempted_paths) if @last_resolver
+      unless @generation_artifacts.nil?
+        generation_artifacts.each do |artifact|
+          paths << artifact.path
+          paths << File.dirname(artifact.path)
+        end
+      end
+      paths.compact
+    end
+  end
+end