hecks 3.5.0 → 3.6.0

data/lib/hecks/ports/persistence/plugins/era/era_guard.rb

@@ -27,17 +27,7 @@ module Hecks
       #   `was:` declares it, and no translation retires it
       def check_vanished_aggregates!(registry, bluebook, held_bluebook)
         held_bluebook.aggregates.each do |held_aggregate|
-          claimed = bluebook.aggregates.any? do |aggregate|
-            aggregate.name == held_aggregate.name ||
-              registry.translations.any? do |translation|
-                translation.domain == bluebook.name &&
-                  translation.for_aggregate(aggregate.name)&.was == held_aggregate.name
-              end
-          end
-          claimed ||= registry.translations.any? do |translation|
-            translation.domain == bluebook.name && translation.retired.include?(held_aggregate.name)
-          end
-          next if claimed
+          next if explained?(registry, bluebook, held_aggregate)
 
           raise WiringError,
                 "cannot boot #{bluebook.name}: #{held_aggregate.name} existed and now doesn't, " \
@@ -45,6 +35,36 @@ module Hecks
         end
       end
 
+      # Says whether a held aggregate is accounted for: still present, renamed by a `was:`,
+      # or retired by a translation.
+      #
+      # @param registry [Runtime::Registry] the registry whose translations are searched
+      # @param bluebook [Bluebook::Chapter] the bluebook booting now
+      # @param held_aggregate [Bluebook::Aggregate] the aggregate from the held era
+      # @return [Boolean] true when a current aggregate or a translation explains it
+      def explained?(registry, bluebook, held_aggregate)
+        claimed = bluebook.aggregates.any? do |aggregate|
+          aggregate.name == held_aggregate.name || renamed_from?(registry, bluebook, aggregate, held_aggregate)
+        end
+        claimed || registry.translations.any? do |translation|
+          translation.domain == bluebook.name && translation.retired.include?(held_aggregate.name)
+        end
+      end
+
+      # Says whether a translation declares a current aggregate was the held one.
+      #
+      # @param registry [Runtime::Registry] the registry whose translations are searched
+      # @param bluebook [Bluebook::Chapter] the bluebook booting now
+      # @param aggregate [Bluebook::Aggregate] the current aggregate
+      # @param held_aggregate [Bluebook::Aggregate] the aggregate from the held era
+      # @return [Boolean] true when some translation's `was:` names the held aggregate
+      def renamed_from?(registry, bluebook, aggregate, held_aggregate)
+        registry.translations.any? do |translation|
+          translation.domain == bluebook.name &&
+            translation.for_aggregate(aggregate.name)&.was == held_aggregate.name
+        end
+      end
+
       # Raises the refusal naming every changed path no translation rule explains.
       #
       # The Layer-1 coverage refusal — one wording, shared with whoever
@@ -60,7 +80,7 @@ module Hecks
       def refuse_uncovered!(bluebook, aggregate, uncovered)
         raise WiringError,
               "cannot boot #{bluebook.name}::#{aggregate.name}: its shape changed and " \
-              "#{uncovered.map { |path| render_path(path) }.join(', ')} #{uncovered.size == 1 ? 'is' : 'are'} not " \
+              "#{uncovered.map { |path| render_path(path) }.join(", ")} #{uncovered.size == 1 ? "is" : "are"} not " \
               "explained by any rename, move, convert, retype, or drop. Update bluebook/translations/*.bluebook, e.g. " \
               "#{suggestion(uncovered.first)}."
       end
@@ -79,8 +99,8 @@ module Hecks
       # @raise [Runtime::WiringError] always, carrying the refusal wording
       def refuse_unsafe_addition!(bluebook, aggregate, unsafe)
         raise WiringError,
-              "cannot boot #{bluebook.name}::#{aggregate.name}: #{unsafe.map { |name| ":#{name}" }.join(', ')} " \
-              "#{unsafe.size == 1 ? 'is new and required' : 'are new and required'}, with no default: to fill " \
+              "cannot boot #{bluebook.name}::#{aggregate.name}: #{unsafe.map { |name| ":#{name}" }.join(", ")} " \
+              "#{unsafe.size == 1 ? "is new and required" : "are new and required"}, with no default: to fill " \
               "an existing record and no translation explaining what one should read there. Give it a " \
               "default:, make it optional: true or list_of, or declare bluebook/translations/*.bluebook, e.g. " \
               "`backfill :#{unsafe.first}, default: ...`."
@@ -136,18 +156,27 @@ module Hecks
       def parse_bluebook(source, path, shadow:)
         scratch = Registry.new
         loading = Ports::Loading.bootstrap
-        run = lambda do
-          Hecks.with_registry(scratch) do
-            loading.load_library
-            # Held text of a chapter spread over files is several blocks in one string, each
-            # opening the same chapter: judge once after all of them, as a directory load does.
-            Hecks::Bluebook::MetaValidator.defer { Kernel.eval(source, TOPLEVEL_BINDING, path, 1) }
-            Hecks::Bluebook::MetaValidator.judge_deferred!(scratch)
-          end
-        end
+        run = -> { evaluate_into(scratch, loading, source, path) }
         shadow ? Hecks::Bluebook::MetaValidator.while_shadow_parsing(&run) : run.call
         scratch.bluebooks.values.first
       end
+
+      # Loads the library and evaluates the text with the scratch registry current.
+      #
+      # @param scratch [Registry] the throwaway registry the text registers into
+      # @param loading [Object] the bootstrap loader whose `load_library` runs first
+      # @param source [String] the bluebook text to evaluate
+      # @param path [String] the file path reported to `Kernel.eval` as the text's origin
+      # @return [void]
+      def evaluate_into(scratch, loading, source, path)
+        Hecks.with_registry(scratch) do
+          loading.load_library
+          # Held text of a chapter spread over files is several blocks in one string, each
+          # opening the same chapter: judge once after all of them, as a directory load does.
+          Hecks::Bluebook::MetaValidator.defer { Kernel.eval(source, TOPLEVEL_BINDING, path, 1) }
+          Hecks::Bluebook::MetaValidator.judge_deferred!(scratch)
+        end
+      end
     end
   end
 end

data/lib/hecks/ports/persistence/plugins/era/era_tamper.rb

@@ -34,20 +34,26 @@ module Hecks
       #   round-trip; nil when the text declares no bluebook, or when parsing or projecting
       #   raises any `StandardError` or `SyntaxError`
       def project(text, _source_path = nil)
-        file = Tempfile.new(["hecks-tamper-", ".bluebook"])
-        begin
-          file.write(text)
-          file.flush
-          bluebook = EraGuard.shadow_parse(text, file.path)
-        ensure
-          file.close!
-        end
+        bluebook = parse_from_tempfile(text)
         return nil unless bluebook
 
         JSON.parse(JSON.generate(StorageShape.project(bluebook)))
       rescue StandardError, SyntaxError
         nil
       end
+
+      # Parses the text from a tempfile that is removed afterwards.
+      #
+      # @param text [String] the bluebook source
+      # @return [Bluebook::Chapter, nil] the parsed bluebook; nil when the text declares none
+      def parse_from_tempfile(text)
+        file = Tempfile.new(["hecks-tamper-", ".bluebook"])
+        file.write(text)
+        file.flush
+        EraGuard.shadow_parse(text, file.path)
+      ensure
+        file&.close!
+      end
     end
   end
 end

data/lib/hecks/ports/persistence/plugins/era/expected_era.rb

@@ -71,18 +71,29 @@ module Hecks
         # @raise [Unreachable] if the request fails or the status is not `200`
         # @raise [BadResponse] if the body is not JSON or its `era` is not a non-empty string
         def fetch_version(url, timeout:)
-          response = get(version_url(url), timeout)
-          raise Unreachable, "#{version_url(url)} answered #{response.code}" unless response.code == "200"
+          target = version_url(url)
+          response = get(target, timeout)
+          raise Unreachable, "#{target} answered #{response.code}" unless response.code == "200"
 
           document = JSON.parse(response.body)
-          era = document["era"]
-          raise BadResponse, "#{version_url(url)} carries no era" unless era.is_a?(String) && !era.empty?
-
-          { "era" => era, "version" => document["version"].to_s }
+          { "era" => era_in(document, target), "version" => document["version"].to_s }
         rescue JSON::ParserError, TypeError
           raise BadResponse, "#{version_url(url)} did not answer a JSON version document"
         end
 
+        # Reads the era out of a parsed `/version` document.
+        #
+        # @param document [Hash] the parsed document
+        # @param target [String] the URL it came from, named in the refusal
+        # @return [String] the non-empty era
+        # @raise [BadResponse] if the era is not a non-empty string
+        def era_in(document, target)
+          era = document["era"]
+          raise BadResponse, "#{target} carries no era" unless era.is_a?(String) && !era.empty?
+
+          era
+        end
+
         # Compares a reported era with an allow-list.
         #
         # @param era [String] the era the host reported

data/lib/hecks/ports/persistence/plugins/era/lineage/coverage.rb

@@ -0,0 +1,58 @@
+module Hecks
+  module Ports
+    module Persistence
+      class Lineage
+        # Answers whether a translation edge accounts for a path that vanished, or fills one
+        # that arrived; the questions the era diff asks of a lineage.
+        module Coverage
+          # Reports whether some rule accounts for a held path that vanished or changed type.
+          #
+          # A rule covering a whole top-level attribute also covers anything nested
+          # under it; `backfills` only matches a whole name, since a backfill adds an
+          # attribute that is new outright, never a path that existed and moved.
+          #
+          # @param path [String, Symbol] a bare attribute name or a dotted value-object member path
+          # @return [Boolean] true when a rename, move, convert, drop or compute names the path or
+          #   its top-level attribute as its source, or a backfill names the top-level attribute
+          def explains?(path)
+            path = path.to_s
+            top = path.split(".").first
+
+            @renames.key?(top.to_sym) ||
+              sources.any? { |source| source == path || source.split(".").first == top } ||
+              backfilled?(top)
+          end
+
+          # Reports whether some rule gives an existing record a value at a new attribute.
+          #
+          # The destination-side twin of `explains?`, which checks a rule's source; this checks
+          # `@renames.value?` too, since a bare rename fills the destination unconditionally,
+          # the same way a backfill would.
+          #
+          # @param path [String, Symbol] the name of a top-level attribute new in the current shape
+          # @return [Boolean] true when a rename, move, convert or compute lands a value in that
+          #   attribute, or a backfill names it
+          def fills?(path)
+            path = path.to_s
+
+            @renames.value?(path.to_sym) ||
+              destinations.any? { |destination| destination.split(".").first == path } ||
+              backfilled?(path)
+          end
+
+          private
+
+          # Every path a move, convert, compute or drop reads from.
+          def sources
+            [*@moves, *@converts, *@rules.computes].map(&:from) + @drops.map(&:to_s)
+          end
+
+          # Every path a move, convert or compute writes to.
+          def destinations = [*@moves, *@converts, *@rules.computes].map(&:to)
+
+          def backfilled?(name) = @rules.backfills.any? { |backfill| backfill.name.to_s == name }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/lineage/rewrite.rb

@@ -0,0 +1,130 @@
+module Hecks
+  module Ports
+    module Persistence
+      class Lineage
+        # The reference semantics of rename, move, convert, drop and backfill, applied in that
+        # order to a deep copy of one entry's state.
+        module Rewrite
+          private
+
+          def rewrite(state)
+            apply_renames(state, @renames)
+            @moves.each { |move| apply_move(state, move) }
+            @converts.each { |convert| apply_convert(state, convert) }
+            @drops.each { |name| apply_drop(state, name) }
+            # Only fills a gap nothing else already filled; dotted-path aware, like apply_drop.
+            @rules.backfills.each { |backfill| apply_backfill(state, backfill) }
+            state
+          end
+
+          def deep_dup(node)
+            case node
+            when Hash then node.transform_values { |value| deep_dup(value) }
+            when Array then node.map { |item| deep_dup(item) }
+            else node
+            end
+          end
+
+          # Snapshots every rename's old key/value before writing any new key, so a
+          # swap (:a<->:b) applies as one permutation instead of losing data when one
+          # rule's destination is another's source.
+          def apply_renames(state, renames)
+            snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]] if state.key?(old_name) }
+            snapshot.each { |old_name, _new_name, _value| state.delete(old_name) }
+            # Every delete finishes before any write, or a swap's first write becomes its
+            # second delete target.
+            state.merge!(snapshot.to_h { |_old_name, new_name, value| [new_name, value] })
+          end
+
+          def apply_drop(state, name)
+            top, member = name.to_s.split(".", 2)
+            top = top.to_sym
+            return state.delete(top) unless member
+
+            nested = state[top]
+            return unless nested.is_a?(Hash)
+
+            nested.delete(member)
+            state.delete(top) if nested.empty?
+          end
+
+          # Dotted-path aware; must stay in step with `hecks_tr_insert` in rule_compiler.rb.
+          def apply_backfill(state, backfill)
+            name = backfill.name.to_s
+            top, member = name.split(".", 2)
+            top = top.to_sym
+
+            if member
+              nested = (state[top] ||= {})
+              nested[member] = backfill.default unless nested.key?(member)
+            else
+              state[top] = backfill.default unless state.key?(top)
+            end
+          end
+
+          # Runs on raw rows, before the state codec decodes anything — decode is
+          # always the last step, so this never sees an adapter's deep-symbolized entry.
+          def apply_move(state, move)
+            old_top, old_member = move.from.split(".", 2)
+            new_top, new_member = move.to.split(".", 2)
+            old_top = old_top.to_sym
+
+            value, present = extract(state, old_top, old_member)
+            return unless present
+
+            insert(state, new_top.to_sym, new_member, value, rule: "move #{move.from} to: #{move.to}")
+          end
+
+          # A convert is a move whose value has nothing in common with its replacement.
+          def apply_convert(state, convert)
+            old_top, old_member = convert.from.split(".", 2)
+            new_top, new_member = convert.to.split(".", 2)
+
+            raw, present = extract(state, old_top.to_sym, old_member)
+            return unless present
+
+            insert(state, new_top.to_sym, new_member, converted(convert, raw), rule: "convert #{convert.from} to: #{convert.to}")
+          end
+
+          # A value missing from the lookup table refuses loudly rather than carry an
+          # unrecognized value silently into the new era.
+          def converted(convert, raw)
+            return convert.values[raw] if convert.values.key?(raw)
+
+            raise Runtime::WiringError,
+                  "cannot translate #{convert.from}: #{raw.inspect} has no mapping in its " \
+                  "convert's values: table. Add #{raw.inspect} => ... to cover it."
+          end
+
+          def extract(state, top, member)
+            return [nil, false] unless state.key?(top)
+            return [state.delete(top), true] unless member
+
+            nested = state[top]
+            return [nil, false] unless nested.is_a?(Hash) && nested.key?(member)
+
+            value = nested.delete(member)
+            state.delete(top) if nested.empty?
+            [value, true]
+          end
+
+          # A destination already holding a non-Hash value (e.g. a bare reference id)
+          # must not be silently nested under — that would be an undeclared drop. The
+          # SQL half (`hecks_tr_insert`) refuses with identical wording.
+          def insert(state, top, member, value, rule:)
+            return state[top] = value unless member
+
+            if state.key?(top) && !state[top].is_a?(Hash)
+              raise Runtime::WiringError,
+                    "cannot #{rule}: #{top} already holds #{state[top].inspect}, not a value this can nest " \
+                    "under — moving into it would discard that value silently. Rename or drop #{top} first."
+            end
+
+            state[top] ||= {}
+            state[top][member] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/lineage/rules.rb

@@ -0,0 +1,25 @@
+module Hecks
+  module Ports
+    module Persistence
+      class Lineage
+        # The optional rule lists a translation edge carries beyond the four positional ones;
+        # an unknown keyword raises ArgumentError.
+        #
+        # - `retypes` — type names meaning the same shape
+        # - `computes` — SQL-only rules, never applied in process
+        # - `rekeys` — SQL rewrites of identity; only the first is read
+        # - `backfills` — defaults for a new attribute
+        # - `ancestor_name` — the aggregate's name before the edge, if renamed
+        # - `ancestor_storage_name` — snake_case storage name of `ancestor_name`
+        Rules = Struct.new(:retypes, :computes, :rekeys, :backfills, :ancestor_name, :ancestor_storage_name,
+                           keyword_init: true) do
+          # Builds the rules with every list defaulting to empty.
+          #
+          # @param given [Hash] any of the members; an unknown key raises ArgumentError
+          # @return [Rules]
+          def self.build(**given) = new(retypes: [], computes: [], rekeys: [], backfills: [], **given)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/lineage.rb

@@ -1,6 +1,9 @@
 require_relative "../../../../naming"
 require_relative "../../append_only"
 require_relative "../../../../runtime/registry"
+require_relative "lineage/rules"
+require_relative "lineage/coverage"
+require_relative "lineage/rewrite"
 
 module Hecks
   module Ports
@@ -8,11 +11,17 @@ module Hecks
       # Translates a journal entry written under an old shape into the one
       # the current bluebook declares; replay derives the head from unrewritten history.
       class Lineage
+        include Coverage
+        include Rewrite
+
         # `ancestor_name` is the declared name a rename came from (matches
         # the held bluebook's own aggregate names); `ancestor_storage_name`
         # is its derived, snake_case file/table name. Both are nil unless
         # the edge declares a `was:` name that differs from the aggregate's own.
-        attr_reader :ancestor_name, :ancestor_storage_name
+        def ancestor_name = @rules.ancestor_name
+
+        # @return [String, nil] the snake_case storage name of `ancestor_name`
+        def ancestor_storage_name = @rules.ancestor_storage_name
 
         # Builds the rules of the first declared translation that mentions an aggregate.
         #
@@ -59,24 +68,15 @@ module Hecks
         # @param moves [Array<Bluebook::TranslationMove>] from/to paths across a value object
         # @param converts [Array<Bluebook::TranslationConvert>] moves mapped through a values table
         # @param drops [Array<Symbol>] bare or dotted paths whose data is discarded
-        # @param retypes [Array<Bluebook::TranslationRetype>] type names meaning the same shape
-        # @param computes [Array<Bluebook::TranslationCompute>] SQL-only rules, never applied here
-        # @param rekeys [Array<Bluebook::TranslationRekey>] SQL rewrites; only the first is read
-        # @param backfills [Array<Bluebook::TranslationBackfill>] defaults for a new attribute
-        # @param ancestor_name [String, nil] the aggregate's name before the edge, if renamed
-        # @param ancestor_storage_name [String, nil] snake_case storage name of ancestor_name
-        def initialize(renames, moves = [], converts = [], drops = [], retypes: [], computes: [], rekeys: [],
-                       backfills: [], ancestor_name: nil, ancestor_storage_name: nil)
+        # @param rules [Hash] the optional rule lists, as `Rules` names them: `retypes:`,
+        #   `computes:`, `rekeys:`, `backfills:`, `ancestor_name:` and `ancestor_storage_name:`
+        # @raise [ArgumentError] on a keyword `Rules` does not name
+        def initialize(renames, moves = [], converts = [], drops = [], **rules)
           @renames = renames
           @moves = moves
           @converts = converts
           @drops = drops
-          @retypes = retypes
-          @computes = computes
-          @rekeys = rekeys
-          @backfills = backfills
-          @ancestor_name = ancestor_name
-          @ancestor_storage_name = ancestor_storage_name
+          @rules = Rules.build(**rules)
         end
 
         # Reports whether any rule in this edge is a compute.
@@ -85,7 +85,7 @@ module Hecks
         # one refuses to boot anywhere but Postgres.
         #
         # @return [Boolean] true when the edge declares at least one compute rule
-        def computes? = !@computes.empty?
+        def computes? = !@rules.computes.empty?
 
         # Reports whether this edge rewrites the aggregate's identity.
         #
@@ -93,7 +93,7 @@ module Hecks
         # rather than re-deriving it from `declared` themselves.
         #
         # @return [Boolean] true when the edge declares at least one rekey rule
-        def rekey? = !@rekeys.empty?
+        def rekey? = !@rules.rekeys.empty?
 
         # Returns the SQL expression the edge's first rekey rule declares.
         #
@@ -101,7 +101,7 @@ module Hecks
         # `compute` makes; more than one is a DSL-level decision to arbitrate elsewhere.
         #
         # @return [String, nil] the first rekey rule's SQL; nil when the edge declares no rekey
-        def rekey_sql = @rekeys.first&.sql
+        def rekey_sql = @rules.rekeys.first&.sql
 
         # Rewrites one journal entry's state from the held shape into the current one.
         #
@@ -120,58 +120,10 @@ module Hecks
           # Deep, not shallow: a move or convert reaches into a nested
           # value-object hash, and a shallow dup would quietly mutate
           # the caller's copy of the original entry.
-          state = deep_dup(entry.state)
-          apply_renames(state, @renames)
-          @moves.each { |move| apply_move(state, move) }
-          @converts.each { |convert| apply_convert(state, convert) }
-          @drops.each { |name| apply_drop(state, name) }
-          # Only fills a gap nothing else already filled; dotted-path aware, like apply_drop.
-          @backfills.each { |backfill| apply_backfill(state, backfill) }
+          state = rewrite(deep_dup(entry.state))
           Entry.new(operation: entry.operation, id: entry.id, state: state, mirrors: entry.mirrors)
         end
 
-        # Reports whether some rule accounts for a held path that vanished or changed type.
-        #
-        # A rule covering a whole top-level attribute also covers anything nested
-        # under it; `backfills` only matches a whole name, since a backfill adds an
-        # attribute that is new outright, never a path that existed and moved.
-        #
-        # @param path [String, Symbol] a bare attribute name or a dotted value-object member path
-        # @return [Boolean] true when a rename, move, convert, drop or compute names the path or
-        #   its top-level attribute as its source, or a backfill names the top-level attribute
-        # rubocop:disable-next Metrics/CyclomaticComplexity
-        # rubocop:disable-next Metrics/PerceivedComplexity
-        def explains?(path)
-          path = path.to_s
-          top = path.split(".").first
-
-          @renames.key?(top.to_sym) ||
-            @moves.any? { |move| move.from == path || move.from.split(".").first == top } ||
-            @converts.any? { |convert| convert.from == path || convert.from.split(".").first == top } ||
-            @drops.any? { |drop| drop.to_s == path || drop.to_s.split(".").first == top } ||
-            @computes.any? { |compute| compute.from == path || compute.from.split(".").first == top } ||
-            @backfills.any? { |backfill| backfill.name.to_s == top }
-        end
-
-        # Reports whether some rule gives an existing record a value at a new attribute.
-        #
-        # The destination-side twin of `explains?`, which checks a rule's source; this checks
-        # `@renames.value?` too, since a bare rename fills the destination unconditionally,
-        # the same way a backfill would.
-        #
-        # @param path [String, Symbol] the name of a top-level attribute new in the current shape
-        # @return [Boolean] true when a rename, move, convert or compute lands a value in that
-        #   attribute, or a backfill names it
-        def fills?(path)
-          path = path.to_s
-
-          @renames.value?(path.to_sym) ||
-            @moves.any? { |move| move.to.split(".").first == path } ||
-            @converts.any? { |convert| convert.to.split(".").first == path } ||
-            @computes.any? { |compute| compute.to.split(".").first == path } ||
-            @backfills.any? { |backfill| backfill.name.to_s == path }
-        end
-
         # Reports whether a declared retype pairs two type names as the same shape.
         #
         # Nothing in the stored data carries a type name, so this never moves a value;
@@ -181,119 +133,7 @@ module Hecks
         # @param current_type [String, Bluebook::Reference] the type declared now
         # @return [Boolean] true when some retype rule runs from `held_type` to `current_type`
         def retype?(held_type, current_type)
-          @retypes.any? { |retype| retype.from == held_type.to_s && retype.to == current_type.to_s }
-        end
-
-        private
-
-        def deep_dup(node)
-          case node
-          when Hash then node.transform_values { |value| deep_dup(value) }
-          when Array then node.map { |item| deep_dup(item) }
-          else node
-          end
-        end
-
-        # Snapshots every rename's old key/value before writing any new key, so a
-        # swap (:a<->:b) applies as one permutation instead of losing data when one
-        # rule's destination is another's source.
-        def apply_renames(state, renames)
-          snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]] if state.key?(old_name) }
-          snapshot.each { |old_name, _new_name, _value| state.delete(old_name) }
-          # Not combinable: every delete must finish before any write, or a swap's
-          # first write becomes its second delete target.
-          snapshot.each { |_old_name, new_name, value| state[new_name] = value }
-        end
-
-        def apply_drop(state, name)
-          name = name.to_s
-          top, member = name.split(".", 2)
-          top = top.to_sym
-
-          if member
-            nested = state[top]
-            if nested.is_a?(Hash)
-              nested.delete(member)
-              state.delete(top) if nested.empty?
-            end
-          else
-            state.delete(top)
-          end
-        end
-
-        # Dotted-path aware; must stay in step with `hecks_tr_insert` in rule_compiler.rb.
-        def apply_backfill(state, backfill)
-          name = backfill.name.to_s
-          top, member = name.split(".", 2)
-          top = top.to_sym
-
-          if member
-            nested = (state[top] ||= {})
-            nested[member] = backfill.default unless nested.key?(member)
-          else
-            state[top] = backfill.default unless state.key?(top)
-          end
-        end
-
-        # Runs on raw rows, before the state codec decodes anything — decode is
-        # always the last step, so this never sees an adapter's deep-symbolized entry.
-        def apply_move(state, move)
-          old_top, old_member = move.from.split(".", 2)
-          new_top, new_member = move.to.split(".", 2)
-          old_top = old_top.to_sym
-
-          value, present = extract(state, old_top, old_member)
-          return unless present
-
-          insert(state, new_top.to_sym, new_member, value, rule: "move #{move.from} to: #{move.to}")
-        end
-
-        # A convert is a move whose value has nothing in common with its replacement.
-        # A value missing from the lookup table refuses loudly rather than carry an
-        # unrecognized value silently into the new era.
-        def apply_convert(state, convert)
-          old_top, old_member = convert.from.split(".", 2)
-          new_top, new_member = convert.to.split(".", 2)
-          old_top = old_top.to_sym
-
-          raw, present = extract(state, old_top, old_member)
-          return unless present
-
-          unless convert.values.key?(raw)
-            raise Runtime::WiringError,
-                  "cannot translate #{convert.from}: #{raw.inspect} has no mapping in its " \
-                  "convert's values: table. Add #{raw.inspect} => ... to cover it."
-          end
-
-          insert(state, new_top.to_sym, new_member, convert.values[raw], rule: "convert #{convert.from} to: #{convert.to}")
-        end
-
-        def extract(state, top, member)
-          return [nil, false] unless state.key?(top)
-          return [state.delete(top), true] unless member
-
-          nested = state[top]
-          return [nil, false] unless nested.is_a?(Hash) && nested.key?(member)
-
-          value = nested.delete(member)
-          state.delete(top) if nested.empty?
-          [value, true]
-        end
-
-        # A destination already holding a non-Hash value (e.g. a bare reference id)
-        # must not be silently nested under — that would be an undeclared drop. The
-        # SQL half (`hecks_tr_insert`) refuses with identical wording.
-        def insert(state, top, member, value, rule:)
-          return state[top] = value unless member
-
-          if state.key?(top) && !state[top].is_a?(Hash)
-            raise Runtime::WiringError,
-                  "cannot #{rule}: #{top} already holds #{state[top].inspect}, not a value this can nest " \
-                  "under — moving into it would discard that value silently. Rename or drop #{top} first."
-          end
-
-          state[top] ||= {}
-          state[top][member] = value
+          @rules.retypes.any? { |retype| retype.from == held_type.to_s && retype.to == current_type.to_s }
         end
       end
     end