hecks 3.5.0 → 3.7.0

data/lib/hecks/fuzzing/isolated_boot/worlds.rb

@@ -0,0 +1,102 @@
+module Hecks
+  module Fuzzing
+    module IsolatedBoot
+      # Rewrites the `.hecksagon` bindings and `.world` files of a copied domain.
+      module Worlds
+        # The name of a `Hecks.hecksagon` block.
+        HECKSAGON_NAME = /Hecks\.hecksagon\s+"([^"]+)"/
+
+        # The name of a `Hecks.bluebook` block.
+        BLUEBOOK_NAME = /Hecks\.bluebook[\s(]+"([^"]+)"/
+
+        # Replaces every `.world` in the copy with one that declares only `default_adapter`,
+        # so an aggregate left unbound by its hecksagon still falls back to `adapter_name`.
+        def write_default_worlds!(copy, adapter_name)
+          write_worlds!(copy, "hecks_fuzz_default.world") do |name|
+            <<~WORLD
+              Hecks.world "#{name}" do
+                default_adapter "#{adapter_name}"
+              end
+            WORLD
+          end
+        end
+
+        # Gives every chapter with no hecksagon block (so no bind) a world of its own that
+        # falls back to Memory, since the worlds `write_worlds!` wrote require a database
+        # a chapter with no bind can't provide.
+        def write_unbound_chapter_worlds!(copy)
+          named = Dir.glob(File.join(copy, "**", "*.hecksagon")).flat_map { |path| hecksagon_names_in(path) }
+          bluebooks = Dir.glob(File.join(copy, "**", "*.bluebook")).group_by { |path| File.dirname(path) }
+          bluebooks.each do |dir, files|
+            unbound = unbound_names(files, named)
+            named.concat(unbound)
+            write_unbound_world(dir, unbound) unless unbound.empty?
+          end
+        end
+
+        # The bluebook names `files` declare that `named` does not already cover.
+        def unbound_names(files, named)
+          files.flat_map { |path| File.read(path).scan(BLUEBOOK_NAME).flatten }.uniq - named
+        end
+
+        # Writes `dir`'s one world file falling every `unbound` chapter back to Memory.
+        def write_unbound_world(dir, unbound)
+          worlds = unbound.map { |name| %(Hecks.world "#{name}" do\n  default_adapter "Memory"\nend\n) }
+          File.write(File.join(dir, "hecks_fuzz_unbound.world"), worlds.join("\n"))
+        end
+
+        # Writes one `.world` per directory holding a `.hecksagon`, naming every
+        # `Hecks.hecksagon` block found there, and deletes every other `.world` in the
+        # copy. One write per directory, not per file — a domain can split hecksagon
+        # blocks (e.g. `context_map.hecksagon` beside the main one) across sibling files
+        # in the same directory, and a second `File.write` to the same path would drop
+        # the first file's names.
+        def write_worlds!(copy, world_file, &world_for)
+          hecksagon_names_by_dir(copy).each do |dir, names|
+            next if names.empty?
+
+            File.write(File.join(dir, world_file), names.uniq.map(&world_for).join("\n"))
+          end
+
+          Dir.glob(File.join(copy, "**", "*.world")).each do |path|
+            File.delete(path) unless File.basename(path) == world_file
+          end
+        end
+
+        # The `Hecks.hecksagon` names declared in each directory under `copy`.
+        def hecksagon_names_by_dir(copy)
+          names_by_dir = Hash.new { |hash, dir| hash[dir] = [] }
+          Dir.glob(File.join(copy, "**", "*.hecksagon")).each do |hecksagon_path|
+            names_by_dir[File.dirname(hecksagon_path)].concat(hecksagon_names_in(hecksagon_path))
+          end
+          names_by_dir
+        end
+
+        def hecksagon_names_in(path) = File.read(path).scan(HECKSAGON_NAME).flatten
+
+        # Deletes every `translations/*.bluebook` in the copy. A compute/rekey translation
+        # edge refuses to boot under any non-lineage-capable adapter (only `PostgresEra`
+        # answers `lineage_capable? == true`), so every other mode strips it here rather
+        # than tripping that refusal. Safe to drop: an ephemeral, zero-history boot never
+        # has a pre-existing era-1 row to translate — the edge only matters at mint time,
+        # against a real database, never here.
+        def strip_translations!(copy)
+          Dir.glob(File.join(copy, "**", "translations", "*.bluebook")).each { |path| File.delete(path) }
+        end
+
+        # Rewrites every `persisted_by` bind — aggregate-scoped or bare at the hecksagon's
+        # own root, naming its adapter as a literal or through a local variable — to name
+        # `adapter_name`, and drops every `projected_by` bind outright (unread rather than
+        # broken, since `Registry#read_repository` falls back to the authoritative repo).
+        def rewrite_bindings!(copy, adapter_name)
+          Dir.glob(File.join(copy, "**", "*.hecksagon")).each do |path|
+            lines = File.readlines(path).grep_v(/\bprojected_by\s*\(?\s*"/)
+            # Horizontal space only: a newline ends the statement, and the next one must stay.
+            bind = /persisted_by[ \t]*\(?[ \t]*(?:"[^"]+"|[a-z_]\w*)[ \t]*\)?/
+            File.write(path, lines.join.gsub(bind, "persisted_by(\"#{adapter_name}\")"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/isolated_boot.rb

@@ -3,14 +3,29 @@ require "tmpdir"
 require "securerandom"
 require_relative "outside_world"
 require_relative "../runtime/adapter_lookup"
+require_relative "isolated_boot/copying"
+require_relative "isolated_boot/worlds"
+require_relative "isolated_boot/postgres_scratch"
+require_relative "isolated_boot/scratch_schema"
 
 module Hecks
   module Fuzzing
     # Rewrites a copied domain's persistence bindings before an ephemeral
     # fuzz/replay boot; a directory copy alone does not isolate Postgres state.
     module IsolatedBoot
-      # A vendored package named by `attaches "name", from: :vendor`.
-      VENDORED_ATTACHED = /attaches\s*\(?\s*"([\w-]+)"\s*\)?\s*,\s*from:\s*:vendor/
+      # Postgres has no zero-config default (Postgres.connect_for refuses without a
+      # `database` setting), so every domain name gets a fresh `.world` written for it.
+      # One schema per process, dropped and recreated per boot, not a fresh name per call —
+      # a process runs one ephemeral boot at a time. The default is shared by every process that
+      # does not name its own schema in `FUZZ_SCHEMA_ENV`, as a sweep's pool children do.
+      FUZZ_POSTGRES_DATABASE = "hecks_fuzz".freeze
+      FUZZ_POSTGRES_SCHEMA   = "hecks_fuzz".freeze
+      FUZZ_SCHEMA_ENV        = "HECKS_FUZZ_SCHEMA".freeze
+
+      extend Copying
+      extend Worlds
+      extend PostgresScratch
+      extend ScratchSchema
 
       module_function
 
@@ -25,59 +40,22 @@ module Hecks
           copy = File.join(tmp, File.basename(domain_path))
           copy_dereferencing(domain_path, copy)
           FileUtils.rm_rf(File.join(copy, "data"))
-          case adapter
-          when :memory       then rebind_to_memory!(copy)
-          when :sqlite       then rebind_to_sqlite!(copy)
-          when :postgres     then rebind_to_postgres!(copy, **scratch)
-          when :postgres_era then rebind_to_postgres_era!(copy, database: database, schema: schema)
-          else raise ArgumentError,
-                     "unknown fuzz adapter #{adapter.inspect} — :memory, :sqlite, :postgres, or :postgres_era"
-          end
+          rebind!(copy, adapter, database: database, schema: schema, scratch: scratch)
           Runtime::AdapterLookup.standing_in(OutsideWorld) { yield copy }
         end
       end
 
-      # Copies `source` into `destination`, following symlinks rather than reproducing
-      # them (cp_r would copy a symlink as a symlink, dangling once the source tree is
-      # gone), and carries any vendored bluebooks the copy's hecksagons name.
-      def copy_dereferencing(source, destination)
-        copy_files(source, destination)
-        carry_vendored_bluebooks!(source, destination)
-      end
-
-      # Copies every file under `source` into `destination`, following symlinks.
-      def copy_files(source, destination)
-        FileUtils.mkdir_p(destination)
-        Dir.glob(File.join(source, "**", "*"), File::FNM_DOTMATCH).each do |path|
-          next if [".", ".."].include?(File.basename(path))
-
-          target = File.join(destination, path.delete_prefix("#{source}/"))
-          if File.directory?(path)
-            FileUtils.mkdir_p(target)
-          else
-            FileUtils.mkdir_p(File.dirname(target))
-            begin
-              FileUtils.cp(path, target)
-            rescue Errno::ENOENT
-              # A sibling can vanish between listing and copy under parallel workers;
-              # skip a file that's already gone.
-            end
-          end
-        end
-      end
-
-      # Copies vendored bluebook packages a copy's hecksagons name into the copy, since
-      # `Hecks.boot` only sees the domain directory itself, not `vendor/`.
-      def carry_vendored_bluebooks!(source, destination)
-        names = Dir.glob(File.join(destination, "**", "*.hecksagon")).flat_map do |path|
-          text = File.read(path)
-          text.scan(VENDORED_ATTACHED).flatten
-        end
-        names.uniq.each do |name|
-          package = File.join(File.dirname(source), "vendor", "embryonaut_bluebooks", name)
-          next unless File.directory?(package)
-
-          copy_files(package, File.join(File.dirname(destination), "vendor", "embryonaut_bluebooks", name))
+      # Rewrites the copy's bindings for `adapter`.
+      #
+      # @raise [ArgumentError] if `adapter` is not one of the fuzz adapters
+      def rebind!(copy, adapter, database:, schema:, scratch:)
+        case adapter
+        when :memory       then rebind_to_memory!(copy)
+        when :sqlite       then rebind_to_sqlite!(copy)
+        when :postgres     then rebind_to_postgres!(copy, **scratch)
+        when :postgres_era then rebind_to_postgres_era!(copy, database: database, schema: schema)
+        else raise ArgumentError,
+                   "unknown fuzz adapter #{adapter.inspect} — :memory, :sqlite, :postgres, or :postgres_era"
         end
       end
 
@@ -99,207 +77,6 @@ module Hecks
         strip_translations!(copy)
         write_default_worlds!(copy, "SqlitePersistence")
       end
-
-      # Postgres has no zero-config default (Postgres.connect_for refuses without a
-      # `database` setting), so every domain name gets a fresh `.world` written for it.
-      # One shared schema, dropped and recreated per boot, not a fresh name per call —
-      # safe only because callers run one ephemeral boot at a time.
-      FUZZ_POSTGRES_DATABASE = "hecks_fuzz".freeze
-      FUZZ_POSTGRES_SCHEMA   = "hecks_fuzz".freeze
-
-      # Rewrites every `.hecksagon` in the copy to bind through Postgres, against the
-      # shared scratch schema unless the caller names its own via `scratch:`.
-      def rebind_to_postgres!(copy, database: nil, schema: nil)
-        require "pg"
-        database ||= FUZZ_POSTGRES_DATABASE
-        schema   ||= FUZZ_POSTGRES_SCHEMA
-        rewrite_bindings!(copy, "Postgres")
-        strip_translations!(copy)
-        ensure_fuzz_schema!(database, schema)
-
-        # One `.world` per directory a `.hecksagon` lives in, not one at the copy's
-        # root — `Folder#load_domain` globs `*.world` non-recursively.
-        write_worlds!(copy, "hecks_fuzz_postgres.world") do |name|
-          <<~WORLD
-            Hecks.world "#{name}" do
-              default_adapter "Postgres"
-              persisted_by("Postgres") do
-                database "#{database}"
-                schema "#{schema}"
-              end
-            end
-          WORLD
-        end
-        write_unbound_chapter_worlds!(copy)
-      end
-
-      # Creates `database` once per process (memoized) and drops/recreates `schema`
-      # inside it on every call — that's what isolates one ephemeral boot from the next.
-      def ensure_fuzz_schema!(database = FUZZ_POSTGRES_DATABASE, schema = FUZZ_POSTGRES_SCHEMA)
-        # PG::Connection only closes its socket when GC finalizes it, and a tight fuzz
-        # loop opens connections faster than GC reclaims them — without this, a run
-        # exhausts Postgres's max_connections after a few dozen ephemeral boots.
-        GC.start
-
-        @fuzz_databases_ready ||= {}
-        unless @fuzz_databases_ready[database]
-          admin = PG.connect(dbname: "postgres")
-          exists = admin.exec_params(
-            "SELECT 1 FROM pg_database WHERE datname = $1", [database]
-          ).ntuples.positive?
-          admin.exec(%(CREATE DATABASE "#{database}")) unless exists
-          admin.close
-          @fuzz_databases_ready[database] = true
-        end
-
-        db = PG.connect(dbname: database)
-        # Quiet on purpose: an ordinary DROP CASCADE NOTICEs per dropped object, which
-        # would bury hecks fuzz's own output on every boot after the first.
-        db.exec("SET client_min_messages = warning")
-        quoted = db.quote_ident(schema)
-        db.exec("DROP SCHEMA IF EXISTS #{quoted} CASCADE")
-        db.exec("CREATE SCHEMA #{quoted}")
-        db.close
-      end
-
-      # `:postgres_era` is the only mode that exercises era/lineage-bound SQL; plain
-      # `:postgres` never touches that machinery. Unlike `:postgres`, there's no shared
-      # scratch constant here — `database:`/`schema:` are required keyword args because
-      # the caller (`hecks quality_control query sweep.run --persistence-parity`) owns that
-      # database's lifecycle.
-      def rebind_to_postgres_era!(copy, database:, schema:)
-        require "pg"
-        if database.to_s.empty? || schema.to_s.empty?
-          raise ArgumentError,
-                "adapter: :postgres_era requires both database: and schema: — a throwaway database/schema " \
-                "THIS CALLER creates and drops itself (see rebind_to_postgres_era!'s own header). " \
-                "There is no shared default, unlike :postgres, so the caller cannot forget to own the lifecycle."
-        end
-
-        rewrite_bindings!(copy, "PostgresEra")
-        ensure_postgres_era_schema!(database: database, schema: schema)
-
-        # `schema:` isolates one ephemeral boot from the next, the same job
-        # `FUZZ_POSTGRES_SCHEMA` does for `:postgres` (`connect_for` idempotently
-        # creates it; this method only needs to drop it first, in
-        # `ensure_postgres_era_schema!`).
-        #
-        # `allow_superuser true` is deliberate: PostgresEra normally refuses to boot as
-        # a superuser (its era write-fence is row-level security, which a superuser
-        # bypasses), to protect a real ledger from stale writes. This is a throwaway
-        # schema the caller creates and drops, comparing Memory against PostgresEra's
-        # SQL — the era fence isn't under test, so opting in here is safe.
-        write_worlds!(copy, "hecks_fuzz_postgres_era.world") do |name|
-          <<~WORLD
-            Hecks.world "#{name}" do
-              default_adapter "PostgresEra"
-              persisted_by("PostgresEra") do
-                database "#{database}"
-                schema "#{schema}"
-                allow_superuser true
-              end
-            end
-          WORLD
-        end
-        write_unbound_chapter_worlds!(copy)
-      end
-
-      # Replaces every `.world` in the copy with one that declares only `default_adapter`,
-      # so an aggregate left unbound by its hecksagon still falls back to `adapter_name`.
-      def write_default_worlds!(copy, adapter_name)
-        write_worlds!(copy, "hecks_fuzz_default.world") do |name|
-          <<~WORLD
-            Hecks.world "#{name}" do
-              default_adapter "#{adapter_name}"
-            end
-          WORLD
-        end
-      end
-
-      # Gives every chapter with no hecksagon block (so no bind) a world of its own that
-      # falls back to Memory, since the worlds `write_worlds!` wrote require a database
-      # a chapter with no bind can't provide.
-      def write_unbound_chapter_worlds!(copy)
-        named = Dir.glob(File.join(copy, "**", "*.hecksagon")).flat_map do |path|
-          File.read(path).scan(/Hecks\.hecksagon\s+"([^"]+)"/).flatten
-        end
-        bluebooks = Dir.glob(File.join(copy, "**", "*.bluebook")).group_by { |path| File.dirname(path) }
-        bluebooks.each do |dir, files|
-          unbound = files.flat_map { |path| File.read(path).scan(/Hecks\.bluebook[\s(]+"([^"]+)"/).flatten }
-                         .uniq - named
-          named.concat(unbound)
-          next if unbound.empty?
-
-          worlds = unbound.map { |name| %(Hecks.world "#{name}" do\n  default_adapter "Memory"\nend\n) }
-          File.write(File.join(dir, "hecks_fuzz_unbound.world"), worlds.join("\n"))
-        end
-      end
-
-      # Writes one `.world` per directory holding a `.hecksagon`, naming every
-      # `Hecks.hecksagon` block found there, and deletes every other `.world` in the
-      # copy. One write per directory, not per file — a domain can split hecksagon
-      # blocks (e.g. `context_map.hecksagon` beside the main one) across sibling files
-      # in the same directory, and a second `File.write` to the same path would drop
-      # the first file's names.
-      def write_worlds!(copy, world_file, &world_for)
-        names_by_dir = Hash.new { |hash, dir| hash[dir] = [] }
-        Dir.glob(File.join(copy, "**", "*.hecksagon")).each do |hecksagon_path|
-          names = File.read(hecksagon_path).scan(/Hecks\.hecksagon\s+"([^"]+)"/).flatten
-          names_by_dir[File.dirname(hecksagon_path)].concat(names)
-        end
-        names_by_dir.each do |dir, names|
-          next if names.empty?
-
-          File.write(File.join(dir, world_file), names.uniq.map(&world_for).join("\n"))
-        end
-
-        Dir.glob(File.join(copy, "**", "*.world")).each do |path|
-          File.delete(path) unless File.basename(path) == world_file
-        end
-      end
-
-      # Mirrors `ensure_fuzz_schema!`'s GC.start-before-connecting fix for the same
-      # max_connections exhaustion. Creates `database` if missing, but never drops
-      # it — that's the caller's job (see `rebind_to_postgres_era!`).
-      def ensure_postgres_era_schema!(database:, schema:)
-        GC.start
-
-        admin = PG.connect(dbname: "postgres")
-        exists = admin.exec_params(
-          "SELECT 1 FROM pg_database WHERE datname = $1", [database]
-        ).ntuples.positive?
-        admin.exec(%(CREATE DATABASE "#{database}")) unless exists
-        admin.close
-
-        db = PG.connect(dbname: database)
-        db.exec("SET client_min_messages = warning")
-        quoted = db.quote_ident(schema)
-        db.exec("DROP SCHEMA IF EXISTS #{quoted} CASCADE")
-        db.close
-      end
-
-      # Deletes every `translations/*.bluebook` in the copy. A compute/rekey translation
-      # edge refuses to boot under any non-lineage-capable adapter (only `PostgresEra`
-      # answers `lineage_capable? == true`), so every other mode strips it here rather
-      # than tripping that refusal. Safe to drop: an ephemeral, zero-history boot never
-      # has a pre-existing era-1 row to translate — the edge only matters at mint time,
-      # against a real database, never here.
-      def strip_translations!(copy)
-        Dir.glob(File.join(copy, "**", "translations", "*.bluebook")).each { |path| File.delete(path) }
-      end
-
-      # Rewrites every `persisted_by` bind — aggregate-scoped or bare at the hecksagon's
-      # own root, naming its adapter as a literal or through a local variable — to name
-      # `adapter_name`, and drops every `projected_by` bind outright (unread rather than
-      # broken, since `Registry#read_repository` falls back to the authoritative repo).
-      def rewrite_bindings!(copy, adapter_name)
-        Dir.glob(File.join(copy, "**", "*.hecksagon")).each do |path|
-          lines = File.readlines(path).grep_v(/\bprojected_by\s*\(?\s*"/)
-          # Horizontal space only: a newline ends the statement, and the next one must stay.
-          bind = /persisted_by[ \t]*\(?[ \t]*(?:"[^"]+"|[a-z_]\w*)[ \t]*\)?/
-          File.write(path, lines.join.gsub(bind, "persisted_by(\"#{adapter_name}\")"))
-        end
-      end
     end
   end
 end

data/lib/hecks/fuzzing/mutation/checks.rb

@@ -0,0 +1,76 @@
+require_relative "../../cli/run"
+require_relative "../../behaviors"
+require_relative "observation"
+
+module Hecks
+  module Fuzzing
+    module Mutation
+      # What is replayed against a domain and its mutants: the generated sequences, the corpus
+      # script and the domain's own `.behaviors` tests.
+      #
+      # @!attribute [r] sequences
+      #   @return [Array<Array<Hash>>] generated step lists, valid for the unmutated domain
+      # @!attribute [r] corpus
+      #   @return [Hash, nil] the parsed corpus script
+      Plan = Struct.new(:sequences, :corpus)
+
+      # The checks a mutant is held to, each answering what it saw.
+      module Checks
+        module_function
+
+        # What the unmutated domain does under the plan, as values a mutant's run is compared to.
+        #
+        # @param domain [String] the domain directory
+        # @param plan [Plan] what to replay
+        # @return [Hash] `:sequences` an observation per sequence, `:corpus` one for the script and
+        #   `:failing_behaviors` the `.behaviors` tests that already fail
+        def baseline(domain, plan)
+          { sequences:         plan.sequences.map { |steps| Observation.of(Replay.call(domain, steps)) },
+            corpus:            plan.corpus && Observation.of(corpus_report(domain, plan.corpus)),
+            failing_behaviors: failing_behaviors(domain) }
+        end
+
+        # @return [String, nil] why the copy cannot boot, nil when it does
+        def boot_failure(copy)
+          Replay.call(copy, [])
+          nil
+        rescue StandardError, ScriptError => e
+          "#{e.class}: #{e.message.lines.first.to_s.strip}"
+        end
+
+        # @return [String, nil] the first property a history breaks, as `property: <name>`
+        def property_failure(history)
+          broken = Properties.check(history).find { |_, result| result != true }
+          broken && "property: #{broken.first}"
+        end
+
+        # The report `hecks run` would print for the script.
+        def corpus_report(domain, corpus)
+          IsolatedBoot.call(domain) do |copy|
+            CLI::Run.execute(Hecks.boot(copy, environment: nil), corpus.fetch("steps"))
+          end
+        end
+
+        # @return [String, nil] the first expectation of the script the report does not meet
+        def unmet_expectation(corpus, report)
+          unmet = CLI::RunExpectations.unmet(corpus["expectations"] || {}, report).first
+          unmet && unmet.lines.first.strip
+        end
+
+        # The `.behaviors` tests of the domain that do not pass, by description.
+        #
+        # @param domain [String] the domain directory
+        # @return [Array<String>] empty when every test passes or the domain has none
+        def failing_behaviors(domain)
+          Behaviors.run_all(domain).files.flat_map { |file| failures_in(file) }
+        end
+
+        def failures_in(file)
+          return ["#{file.path}: #{file.parse_error}"] if file.parse_error
+
+          file.runs.reject { |run| run.status == :pass }.map(&:description)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/mutation/finders.rb

@@ -0,0 +1,136 @@
+module Hecks
+  module Fuzzing
+    module Mutation
+      # Each finder looks at one line of a `SourceMap` and answers the changes that apply there, as
+      # `{ operator:, removed:, replacement: }` hashes; `Operators` turns them into `Site`s.
+      module Finders
+        # The shape of a change: a line (or block) taken out, or a line written differently.
+        module Change
+          module_function
+
+          def removal(operator, length = 1) = { operator: operator, removed: length, replacement: [] }
+
+          def rewrite(operator, line) = { operator: operator, removed: 1, replacement: [line] }
+        end
+
+        # Rules a command or value object enforces: `given`, `invariant`, comparisons, query bounds,
+        # an attribute's `pattern:` and `one_of:`.
+        module Rules
+          RULE = /\A\s*(given|invariant)\b.*\{.*\}\s*\z/
+          COMPARISONS = { " >= " => " > ", " > " => " >= ", " <= " => " < ", " < " => " <= ",
+                          " == " => " != ", " != " => " == " }.freeze
+          PATTERN = /,\s*pattern:\s*'[^']*'/
+          CLOSED_SET = /,\s*one_of:\s*\[[^\]]*\]/
+          BOUND = /\A\s*where\(.*\b(lt|gt):/
+
+          module_function
+
+          def at(map, index)
+            line = map.lines[index]
+            rule(line) + attribute(line) + query_bound(line)
+          end
+
+          def rule(line)
+            return [] unless line.match?(RULE)
+
+            flipped = flip_comparison(line)
+            [Change.removal(:"drop_#{line[RULE, 1]}"), (Change.rewrite(:flip_comparison, flipped) if flipped)].compact
+          end
+
+          # The first comparison inside the line's braces, moved one step.
+          def flip_comparison(line)
+            body = line[/\{.*\}/]
+            operator = COMPARISONS.keys.find { |candidate| body.include?(candidate) }
+            operator && line.sub(body, body.sub(operator, COMPARISONS.fetch(operator)))
+          end
+
+          def attribute(line)
+            return [] unless line.match?(/\A\s*attribute\b/)
+
+            [[:drop_pattern, PATTERN], [:drop_one_of, CLOSED_SET]].filter_map do |operator, shape|
+              (found = line[shape]) && Change.rewrite(operator, line.sub(found, ""))
+            end
+          end
+
+          def query_bound(line)
+            return [] unless line.match?(BOUND)
+
+            [Change.rewrite(:flip_query_bound, line.sub(/\b(lt|gt):/) { Regexp.last_match(1) == "lt" ? "gt:" : "lt:" })]
+          end
+        end
+
+        # The shape of the domain: `from:` guards, `sets`, lifecycle targets, emitted events.
+        module Structure
+          GUARD = /,\s*from:\s*"[^"]*"/
+
+          module_function
+
+          def at(map, index)
+            line = map.lines[index]
+            scope = map.scope(index)
+            sets(line, scope) + command_guard(line) + transition(map, line, scope) + emits(map, line)
+          end
+
+          def sets(line, scope)
+            line.match?(/\A\s*sets\s+:\w+\s*\z/) && scope == "command" ? [Change.removal(:drop_sets)] : []
+          end
+
+          def command_guard(line)
+            guard = line[GUARD]
+            guard && line.match?(/\A\s*command\b.*\bdo\s*\z/) ? [Change.rewrite(:drop_from_guard, line.sub(guard, ""))] : []
+          end
+
+          def transition(map, line, scope)
+            match = line.match(SourceMap::TRANSITION)
+            return [] unless match && scope == "lifecycle"
+
+            [retarget(map, line, match[3]), guard(line, match[4])].compact
+          end
+
+          def retarget(map, line, target)
+            other = map.states.find { |state| state != target }
+            other && Change.rewrite(:retarget_transition, line.sub("=> \"#{target}\"", "=> \"#{other}\""))
+          end
+
+          def guard(line, rest)
+            found = rest[GUARD]
+            found && Change.rewrite(:drop_from_guard, line.sub(found, ""))
+          end
+
+          def emits(map, line)
+            match = line.match(SourceMap::EMITS)
+            other = match && map.emitted.find { |name| name != match[2] }
+            other ? [Change.rewrite(:swap_emits, "#{match[1]}emits #{other}\n")] : []
+          end
+        end
+
+        # Reactions: whole policies, and what a process manager does on each of its transitions.
+        module Reactions
+          module_function
+
+          def at(map, index)
+            line = map.lines[index]
+            scope = map.scope(index)
+            policy(map, index, line) + saga_transition(map, index, line, scope) + saga_dispatch(line, scope)
+          end
+
+          def policy(map, index, line)
+            length = line.match?(/\A\s*policy\s+"/) && map.block_length(index)
+            length ? [Change.removal(:drop_policy, length)] : []
+          end
+
+          def saga_transition(map, index, line, scope)
+            length = scope == "process_manager" && line.match?(/\A\s*transition\b.*\bdo\s*\z/) && map.block_length(index)
+            length ? [Change.removal(:drop_saga_transition, length)] : []
+          end
+
+          def saga_dispatch(line, scope)
+            scope == "transition" && line.match?(/\A\s*dispatch\s+\S/) ? [Change.removal(:drop_saga_dispatch)] : []
+          end
+        end
+
+        ALL = [Rules, Structure, Reactions].freeze
+      end
+    end
+  end
+end