hecks 3.13.0 → 4.0.0

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

@@ -14,7 +14,7 @@ module Hecks
     module EraCheck
       module_function
 
-      # Runs both halves of the era gate over every bluebook in a registry.
+      # Runs the era gate over every bluebook in a registry.
       #
       # Looks up each bluebook's own source separately: `attaches` can share a boot between
       # the domain's own bluebook and a differently-sourced one, so one file read once and reused
@@ -23,27 +23,12 @@ module Hecks
       # @param registry [Runtime::Registry] the registry being booted
       # @param directory [String] the domain's bluebook directory, searched for each source
       # @return [void]
-      # @raise [Runtime::WiringError] if a compute rule is bound to a non-lineage-capable adapter,
-      #   a persistence binding cannot be resolved, a lineage-bound bluebook has no findable
-      #   source, or `era_check!` refuses the boot
+      # @raise [Runtime::WiringError] if a persistence binding cannot be resolved, a lineage-bound
+      #   bluebook has no findable source, or `era_check!` refuses the boot
       def check!(registry, directory)
-        check_compute_rules_for_registry!(registry)
         check_lineage!(registry, directory)
       end
 
-      # Refuses the boot when any bluebook's compute rule is bound away from Postgres.
-      #
-      # Runs unconditionally for every registry, unlike check_lineage!'s
-      # capability-gated pass below (ADR 0031).
-      #
-      # @param registry [Runtime::Registry] the registry whose bluebooks are all checked
-      # @return [void]
-      # @raise [Runtime::WiringError] if an aggregate carrying a compute rule is bound to an
-      #   adapter that is not lineage-capable, or its persistence binding cannot be resolved
-      def check_compute_rules_for_registry!(registry)
-        registry.bluebooks.each_value { |bluebook| check_compute_rules!(registry, bluebook) }
-      end
-
       # Hands every bluebook, with its own source text, to its adapter's era check.
       #
       # Capability-gated (ADR 0031): check_bluebook! below still returns
@@ -222,29 +207,6 @@ module Hecks
               "it could be found (checked #{directory.inspect} and the framework registry)"
       end
 
-      # Refuses the boot when one bluebook's compute rule is bound away from Postgres.
-      #
-      # A compute rule's SQL is its only implementation, so it cannot
-      # boot on any adapter but Postgres, independent of shape checks.
-      #
-      # @param registry [Runtime::Registry] the registry holding the declared translations
-      #   and the aggregate's bindings
-      # @param bluebook [Bluebook::Chapter] the bluebook whose aggregates are checked
-      # @return [void]
-      # @raise [Runtime::WiringError] if an aggregate carrying a compute rule is bound to an
-      #   adapter that is not lineage-capable, or its persistence binding cannot be resolved
-      def check_compute_rules!(registry, bluebook)
-        bluebook.aggregates.each do |aggregate|
-          lineage = Ports::Persistence::Lineage.for(registry, bluebook.name, aggregate)
-          next unless lineage&.computes?
-
-          adapter = adapter_for(registry, bluebook.name, aggregate)
-          next if lineage_capable?(registry, adapter)
-
-          raise WiringError, "compute rules require the Postgres adapter; #{aggregate.name} is bound to #{adapter}"
-        end
-      end
-
       # Names the adapter an aggregate's authoritative persistence bind points at.
       #
       # @param registry [Runtime::Registry] the registry holding the domain's hecksagon

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

@@ -12,7 +12,7 @@ module Hecks
           # 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
+          # @return [Boolean] true when a rename, move, convert, or drop 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
@@ -30,8 +30,8 @@ module Hecks
           # 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
+          # @return [Boolean] true when a rename, move, convert or derive lands a value in
+          #   that attribute, or a backfill names it
           def fills?(path)
             path = path.to_s
 
@@ -42,13 +42,13 @@ module Hecks
 
           private
 
-          # Every path a move, convert, compute or drop reads from.
+          # Every path a move, convert or drop reads from.
           def sources
-            [*@moves, *@converts, *@rules.computes].map(&:from) + @drops.map(&:to_s)
+            [*@moves, *@converts].map(&:from) + @drops.map(&:to_s)
           end
 
-          # Every path a move, convert or compute writes to.
-          def destinations = [*@moves, *@converts, *@rules.computes].map(&:to)
+          # Every path a move, convert or derive writes to.
+          def destinations = [*@moves, *@converts, *@rules.derives].map(&:to)
 
           def backfilled?(name) = @rules.backfills.any? { |backfill| backfill.name.to_s == name }
         end

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

@@ -2,12 +2,13 @@ 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.
+        # The reference semantics of derive, 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_derives(state)
             apply_renames(state, @renames)
             @moves.each { |move| apply_move(state, move) }
             @converts.each { |convert| apply_convert(state, convert) }
@@ -17,6 +18,28 @@ module Hecks
             state
           end
 
+          # Every derive reads the state as stored, so the values are all computed before the
+          # first is written; a derive with no value writes nothing.
+          def apply_derives(state)
+            computed = @rules.derives.map { |derive| [derive, Bluebook::TranslationExpression.evaluate(derive.tree, state)] }
+            computed.each do |derive, value|
+              next if value.nil?
+
+              top, member = derive.to.split(".", 2)
+              insert(state, top.to_sym, member, value, rule: "derive #{derive.to}")
+            end
+          end
+
+          # The id a `rekey_to` gives a record: the value of its derive, read from the stored state;
+          # the record keeps its id where the derive has no value or the edge has no `rekey_to`.
+          def rekeyed_id(entry)
+            rekey = @rules.rekeys.first
+            return entry.id unless rekey
+
+            derive = @rules.derives.find { |candidate| candidate.to == rekey.to }
+            Bluebook::TranslationExpression.evaluate(derive.tree, entry.state) || entry.id
+          end
+
           def deep_dup(node)
             case node
             when Hash then node.transform_values { |value| deep_dup(value) }

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

@@ -6,18 +6,18 @@ module Hecks
         # 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
+        # - `derives` — new fields computed from the record's own text
+        # - `rekeys` - the field whose derived value becomes the id
         # - `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,
+        Rules = Struct.new(:retypes, :derives, :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)
+          def self.build(**given) = new(retypes: [], derives: [], rekeys: [], backfills: [], **given)
         end
       end
     end

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

@@ -59,17 +59,23 @@ module Hecks
           ancestor_storage_name = renamed_aggregate ? Naming.snake(declared.was) : nil
 
           new(declared.renames, declared.moves, declared.converts, declared.drops,
-              retypes: declared.retypes, computes: declared.computes, rekeys: declared.rekeys,
-              backfills: declared.backfills,
-              ancestor_name: ancestor_name, ancestor_storage_name: ancestor_storage_name)
+              **optional_rules(declared), ancestor_name: ancestor_name, ancestor_storage_name: ancestor_storage_name)
         end
 
+        # The rule lists an edge carries beyond renames, moves, converts and drops.
+        def self.optional_rules(declared)
+          { retypes: declared.retypes, derives: declared.derives,
+            rekeys: declared.rekeys, backfills: declared.backfills }
+        end
+        private_class_method :optional_rules
+
         # @param renames [Hash{Symbol => Symbol}] old attribute name to new name
         # @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 rules [Hash] the optional rule lists, as `Rules` names them: `retypes:`,
-        #   `computes:`, `rekeys:`, `backfills:`, `ancestor_name:` and `ancestor_storage_name:`
+        #   `derives:`, `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
@@ -79,14 +85,6 @@ module Hecks
           @rules = Rules.build(**rules)
         end
 
-        # Reports whether any rule in this edge is a compute.
-        #
-        # Compute has no in-process implementation; an aggregate carrying
-        # one refuses to boot anywhere but Postgres.
-        #
-        # @return [Boolean] true when the edge declares at least one compute rule
-        def computes? = !@rules.computes.empty?
-
         # Reports whether this edge rewrites the aggregate's identity.
         #
         # The single source of truth for this; other call sites ask here
@@ -95,23 +93,16 @@ module Hecks
         # @return [Boolean] true when the edge declares at least one rekey rule
         def rekey? = !@rules.rekeys.empty?
 
-        # Returns the SQL expression the edge's first rekey rule declares.
-        #
-        # Only the first rule is read, the same one-per-aggregate assumption
-        # `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 = @rules.rekeys.first&.sql
-
-        # Rewrites one journal entry's state from the held shape into the current one.
+        # Rewrites one journal entry from the held shape into the current one.
         #
-        # The reference semantics for rename, move, convert, drop, and the aggregate-level `was:`.
-        # `compute` is not applied here — its SQL is the only implementation, audited separately.
+        # The reference semantics for derive, rename, move, convert, drop, `was:` and the id a
+        # `rekey_to` takes.
         #
         # @param entry [Ports::Persistence::Entry] the entry as stored, with Symbol
         #   top-level keys and String keys nested in a value-object Hash
         # @return [Ports::Persistence::Entry] a new entry with translated state and the same
-        #   `operation`, `id` and `mirrors`; `entry` itself when it is not a save or has no state
+        #   `operation` and `mirrors`, and the same `id` unless a `rekey_to` gives it a value;
+        #   `entry` itself when it is not a save or has no state
         # @raise [Runtime::WiringError] if a convert value is missing from its `values` table, or a
         #   move/convert would nest under a destination already holding a non-Hash value
         def translate(entry)
@@ -120,8 +111,9 @@ 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.
+          id = rekeyed_id(entry)
           state = rewrite(deep_dup(entry.state))
-          Entry.new(operation: entry.operation, id: entry.id, state: state, mirrors: entry.mirrors)
+          Entry.new(operation: entry.operation, id: id, state: state, mirrors: entry.mirrors)
         end
 
         # Reports whether a declared retype pairs two type names as the same shape.

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

@@ -29,18 +29,6 @@ module Hecks
             )
           SQL
 
-          # The Layer-3 approvals of translation edges.
-          APPROVALS_SQL = <<~SQL.freeze
-            CREATE TABLE IF NOT EXISTS hecks_approvals (
-              domain           text NOT NULL,
-              from_label       text NOT NULL,
-              to_label         text NOT NULL,
-              edge_digest      text NOT NULL,
-              reviewed_ordinal bigint NOT NULL,
-              approved_at      timestamptz NOT NULL DEFAULT now()
-            )
-          SQL
-
           # An owned sequence default, not generated always as identity, which
           # partitioned tables only support from Postgres 17.
           JOURNAL_SQL = <<~SQL.freeze

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

@@ -76,7 +76,7 @@ module Hecks
           end
 
           def rename_rows!
-            %w[hecks_eras hecks_era_texts hecks_approvals].each do |table|
+            %w[hecks_eras hecks_era_texts].each do |table|
               @db.exec_params("UPDATE #{table} SET domain = $1 WHERE domain = $2", [@domain, @formerly_known_as])
             end
             # hecks_attestations is created lazily on first reattest!, so it may not exist.

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

@@ -6,8 +6,8 @@ module Hecks
   module Adapters
     class PostgresEra
       class Lineage
-        # CRUD over `hecks_eras`/`hecks_era_texts`/`hecks_approvals`: era text
-        # integrity, archiving, Layer-3 approvals, and once-only era naming.
+        # CRUD over `hecks_eras`/`hecks_era_texts`: era text
+        # integrity, archiving, and once-only era naming.
         module EraStore
           # Verifies each held text's digest before returning it; a missing digest is backfilled.
           def eras
@@ -48,26 +48,6 @@ module Hecks
             )
           end
 
-          # Always inserts a new row; `approval_for` picks the latest for a shape pair.
-          def record_approval!(from:, to:, edge_digest:)
-            @db.exec_params(
-              "INSERT INTO hecks_approvals (domain, from_label, to_label, edge_digest, reviewed_ordinal) " \
-              "VALUES ($1, $2, $3, $4, $5)",
-              [@domain, from, to, edge_digest, last_ordinal]
-            )
-          end
-
-          def approval_for(from:, to:)
-            rows = @db.exec_params(
-              "SELECT edge_digest, reviewed_ordinal FROM hecks_approvals " \
-              "WHERE domain = $1 AND from_label = $2 AND to_label = $3 ORDER BY approved_at DESC, reviewed_ordinal DESC LIMIT 1",
-              [@domain, from, to]
-            )
-            return nil if rows.ntuples.zero?
-
-            { edge_digest: rows[0]["edge_digest"], reviewed_ordinal: rows[0]["reviewed_ordinal"].to_i }
-          end
-
           # Sets hash/label only once; nothing ever recomputes a stored name to verify it.
           def mint_name!(ordinal, hash, label)
             @db.exec_params(

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

@@ -118,7 +118,6 @@ module Hecks
             # NULL reads as 1.
             @db.exec("ALTER TABLE hecks_eras ADD COLUMN IF NOT EXISTS canon_form int")
             @db.exec(ERA_TEXTS_SQL)
-            @db.exec(APPROVALS_SQL)
           end
 
           def create_journal!

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

@@ -28,8 +28,6 @@ module Hecks
         include FieldCache
         include TransformInstaller
 
-        JOURNAL_COLUMNS = "ordinal, era, aggregate, aggregate_id, operation, state, mirrors".freeze
-
         # Longer identifiers are silently truncated by Postgres, so `qualified_name` hashes them.
         POSTGRES_IDENTIFIER_LIMIT = 63
 
@@ -100,7 +98,15 @@ module Hecks
           return full if full.bytesize <= POSTGRES_IDENTIFIER_LIMIT
 
           digest = Digest::SHA256.hexdigest(full)[0, 8]
-          "#{full.byteslice(0, POSTGRES_IDENTIFIER_LIMIT - digest.bytesize - 1)}_#{digest}"
+          "#{whole_characters(full, POSTGRES_IDENTIFIER_LIMIT - digest.bytesize - 1)}_#{digest}"
+        end
+
+        # The longest prefix of `text` made of whole characters that fits in `limit` bytes, so a
+        # multi-byte character is dropped rather than cut in half.
+        def whole_characters(text, limit)
+          bytes = text.byteslice(0, limit)
+          bytes = bytes.byteslice(0, bytes.bytesize - 1) until bytes.valid_encoding?
+          bytes
         end
 
         def quote(name) = PG::Connection.quote_ident(name.to_s)

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage_manager/minter.rb

@@ -2,7 +2,6 @@ require_relative "../../../../../../runtime/registry"
 require_relative "../../storage_shape"
 require_relative "../../translation/audit"
 require_relative "../../translation/scaffold"
-require_relative "../../translation/approval_file"
 require_relative "context"
 require_relative "refusals"
 
@@ -11,7 +10,7 @@ module Hecks
     class PostgresEra
       module LineageManager
         # Names the source era, resolves its one outgoing translation edge, and mints the
-        # next era once approval, coverage and the audited chain all check out.
+        # next era once coverage and the audited chain check out.
         module Minter
           include Refusals
 
@@ -20,8 +19,7 @@ module Hecks
           # @param context [Context] the era check so far; `latest` is the latest held era, named
           #   here if it has no name yet
           # @return [Integer] the ordinal of the era minted
-          # @raise [Runtime::WiringError] if the edge, its approval, its coverage or its audit
-          #   refuses
+          # @raise [Runtime::WiringError] if the edge, its coverage or its audit refuses
           def mint!(context)
             ensure_named!(context.lineage, context.latest)
             context = context.with(latest: context.lineage.eras.last)
@@ -41,29 +39,6 @@ module Hecks
             edges.first
           end
 
-          # Refuses a mint whose edge carries a compute or rekey rule without an approval.
-          #
-          # A compute or rekey's only verification is a human-approved audit sample. Two approvals
-          # satisfy it: one recorded in the journal that matches the edge and the journal's current
-          # tip, or a committed `translations/<edge>.approval` that matches the edge's digest and
-          # records a passed rehearsal on a compatible host release. A committed approval that
-          # applies is written into the journal, so the journal stays the single history.
-          def ensure_compute_rekey_approved!(context, edge)
-            return unless Translation::ApprovalFile.needs_rehearsal?(edge)
-
-            approval = context.lineage.approval_for(from: edge.from, to: edge.to)
-            digest = Translation::Audit.edge_digest(edge)
-            tip = context.lineage.last_ordinal
-            return if approved_at_tip?(approval, digest, tip)
-
-            if Translation::ApprovalFile.applicable(context.directory, edge)
-              context.lineage.record_approval!(from: edge.from, to: edge.to, edge_digest: digest)
-              return
-            end
-
-            refuse_unapproved!(context, edge, approval, tip)
-          end
-
           # Diffs the held era against the current shape and writes the edge file —
           # confident rules inline, ambiguities as parse-refusing `unresolved` lines.
           def scaffold!(_registry, bluebook, lineage, latest, directory)
@@ -104,10 +79,9 @@ module Hecks
             chain
           end
 
-          # The edge leaving the held era, once resolved, approved and found to cover the diff.
+          # The edge leaving the held era, once resolved and found to cover the diff.
           def verified_edge!(context)
             edge = resolve_edge!(context)
-            ensure_compute_rekey_approved!(context, edge)
             check_coverage!(context.registry, context.bluebook, shadow(context.latest[:held_text]), edge)
             edge
           end

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage_manager/refusals.rb

@@ -2,8 +2,8 @@ module Hecks
   module Adapters
     class PostgresEra
       module LineageManager
-        # The refusals a mint raises: toward the scaffold when no edge exists, and for a forked,
-        # stale or unapproved edge. Each is built from the era check's `Context`.
+        # The refusals a mint raises: toward the scaffold when no edge exists, and for a forked or
+        # stale edge. Each is built from the era check's `Context`.
         module Refusals
           # Refuses toward the authoring loop, or, under HECKS_SCAFFOLD=1, scaffolds the
           # missing edge first and names the file it wrote.
@@ -37,30 +37,6 @@ module Hecks
                                        "re-run hecks scaffold_translation", minting: false)
           end
 
-          # Whether the journal already holds an approval of this edge at the journal's tip.
-          def approved_at_tip?(approval, digest, tip)
-            approval && approval[:edge_digest] == digest && approval[:reviewed_ordinal] == tip
-          end
-
-          def refuse_unapproved!(context, edge, approval, tip)
-            if approval && approval[:edge_digest] == Translation::Audit.edge_digest(edge)
-              raise era_refusal(context, "the journal advanced past the approved " \
-                                         "review (ordinal #{approval[:reviewed_ordinal]} reviewed, #{tip} now) — the samples a " \
-                                         "human approved no longer cover the data; re-run hecks audit_translation with --approve")
-            end
-
-            mismatch = Translation::ApprovalFile.host_mismatch(context.directory, edge)
-            raise era_refusal(context, unapproved_reason(mismatch))
-          end
-
-          def unapproved_reason(mismatch)
-            return "the committed approval does not apply — #{mismatch}" if mismatch
-
-            "this edge carries a compute or rekey " \
-              "rule, and the audit's human-approved sample is its only verification — run " \
-              "hecks audit_translation with --approve, then boot again"
-          end
-
           # Builds the refusal; a mint's own refusals say "cannot mint era N of X", the
           # edge-resolution ones say "cannot boot X".
           def era_refusal(context, text, minting: true)

data/lib/hecks/ports/persistence/plugins/era/translation/audit/layer_two.rb

@@ -9,7 +9,7 @@ module Hecks
         # Checks one aggregate's records across the edge for id conservation and, where a
         # per-record comparison is possible, agreement with the reference transform.
         #
-        # Compute paths and rekeyed aggregates are exempt from the comparison.
+        # Rekeyed aggregates are exempt from the comparison.
         #
         # @param violations [Array<String>] collector this method appends messages to
         # @param aggregate [Bluebook::Aggregate] the current era's IR for the aggregate
@@ -24,7 +24,7 @@ module Hecks
           check_id_conservation!(violations, aggregate, before, after, rekeyed: rekeyed)
 
           return unless declared
-          # A rekey's SQL is its only implementation and `after` cannot be looked up by old id.
+          # A rekeyed record's `after` cannot be looked up by its old id.
           return if rekeyed
 
           check_value_preservation!(violations, aggregate, declared, before, after)
@@ -56,12 +56,11 @@ module Hecks
         # @return [void]
         def check_value_preservation!(violations, aggregate, declared, before, after)
           rules = Ports::Persistence::Lineage.from_declared(declared, aggregate.name)
-          compute_paths = compute_paths_of(declared)
 
           before.each do |id, state|
             next unless after.key?(id)
 
-            diverged = divergence(rules, id, state, after[id], compute_paths)
+            diverged = divergence(rules, id, state, after[id])
             next if diverged.empty?
 
             violations << "#{aggregate.name}##{id}: the translated state diverges from the reference " \
@@ -75,28 +74,6 @@ module Hecks
         # @return [Hash{String => Object}, nil] a deep copy with String keys at every depth
         def normalize(state) = JSON.parse(JSON.generate(state))
 
-        # Removes the paths a compute owns from a normalized state, in place.
-        #
-        # A dotted path removes only its own member, never the whole top-level key, so sibling
-        # members stay under the equivalence check and silent loss there is still caught.
-        #
-        # @param state [Hash{String => Object}] a normalized state; mutated
-        # @param paths [Array<String>] bare (`"price_cents"`) or dotted (`"price.cents"`)
-        #   compute paths
-        # @return [Hash{String => Object}] `state` itself, with those paths deleted
-        def strip_compute_paths(state, paths)
-          paths.each do |path|
-            segments = path.split(".")
-            if segments.length == 1
-              state.delete(segments.first)
-            else
-              parent = segments[0..-2].reduce(state) { |node, segment| node.is_a?(Hash) ? node[segment] : nil }
-              parent.delete(segments.last) if parent.is_a?(Hash)
-            end
-          end
-          state
-        end
-
         private
 
         # The message for a rekeying edge whose record count changed, or nil.
@@ -118,15 +95,11 @@ module Hecks
             "(lost #{lost.sort.inspect}, gained #{gained.sort.inspect})"
         end
 
-        def compute_paths_of(declared)
-          declared.computes.flat_map { |compute| [compute.from, compute.to] }.map(&:to_s)
-        end
-
         # The keys at which one record's translated state differs from the reference transform.
-        def divergence(rules, id, state, translated, compute_paths)
+        def divergence(rules, id, state, translated)
           entry = Ports::Persistence::Entry.new(operation: "save", id: id, state: state.transform_keys(&:to_sym))
-          expected = strip_compute_paths(normalize(rules.translate(entry).state), compute_paths)
-          actual = strip_compute_paths(normalize(translated), compute_paths)
+          expected = normalize(rules.translate(entry).state)
+          actual = normalize(translated)
           (expected.keys | actual.keys).reject { |key| expected[key] == actual[key] }
         end
       end

data/lib/hecks/ports/persistence/plugins/era/translation/audit/unfed_report.rb

@@ -8,7 +8,7 @@ module Hecks
         #
         # @param aggregate [Bluebook::Aggregate] the current era's IR for the aggregate
         # @param declared [Bluebook::TranslationAggregate, nil] this edge's rules; the
-        #   destinations of its renames, moves, converts and computes count as fed
+        #   destinations of its renames, moves, converts and derives count as fed
         # @param after [Hash{String => Hash}] translated state per record id
         # @return [Array<String>] names of unfed attributes, in declaration order; `[]` when
         #   every attribute is fed or `after` holds no records
@@ -25,12 +25,12 @@ module Hecks
         # The top-level attribute names an edge's destinations feed.
         #
         # @param declared [Bluebook::TranslationAggregate, nil] this edge's rules
-        # @return [Array<String>] the destinations of renames, moves, converts and computes, cut to
+        # @return [Array<String>] the destinations of renames, moves, converts and derives, cut to
         #   their top-level name; `[]` when there is no edge
         def fed_names(declared)
           return [] unless declared
 
-          rules = [declared.moves, declared.converts, declared.computes].flat_map { |list| list.map(&:to) }
+          rules = [declared.moves, declared.converts, declared.derives].flat_map { |list| list.map(&:to) }
           (declared.renames.values.map(&:to_s) + rules).map { |path| path.to_s.split(".").first }
         end
 

data/lib/hecks/ports/persistence/plugins/era/translation/audit.rb

@@ -3,12 +3,11 @@ require "json"
 require_relative "audit/layer_one"
 require_relative "audit/layer_two"
 require_relative "audit/unfed_report"
-require_relative "audit/approval_digest"
 
 module Hecks
   module Translation
-    # Derives the audit's assertions per layer (audit/layer_one, layer_two, unfed_report,
-    # approval_digest); Layer 3, the human-approved sample, is assembled in `check`.
+    # Derives the audit's assertions per layer (audit/layer_one, layer_two, unfed_report);
+    # Layer 3, the human-approved sample, is assembled in `check`.
     module Audit
       Verdict = Struct.new(:violations, :dropped, :unfed, :samples, keyword_init: true) do
         # Reports whether the mechanical layers found nothing to refuse.
@@ -23,7 +22,6 @@ module Hecks
       extend LayerOne
       extend LayerTwo
       extend UnfedReport
-      extend ApprovalDigest
 
       module_function
 

data/lib/hecks/ports/persistence/plugins/era/translation/expression_sql.rb

@@ -0,0 +1,52 @@
+module Hecks
+  module Translation
+    # Compiles a `Bluebook::TranslationExpression` tree into a Postgres text expression over a
+    # jsonb record. The compiled form yields NULL wherever the expression has no value, and
+    # agrees with `TranslationExpression.evaluate` on every record.
+    module ExpressionSql
+      UPPER = ("A".."Z").to_a.join.freeze
+      LOWER = UPPER.downcase.freeze
+
+      module_function
+
+      # @param tree [Array] a tree `Bluebook::TranslationExpression.parse` returned
+      # @param record [String] the SQL that names the jsonb record the expression reads
+      # @return [String] a SQL expression of type text
+      def compile(tree, record)
+        case tree.first
+        when "lit" then text(tree[1])
+        when "null" then "NULL::text"
+        when "ref" then reference(tree[1], record)
+        else function(tree.first, tree.drop(1), record)
+        end
+      end
+
+      def function(name, arguments, record)
+        return lookup(arguments, record) if name == "lookup"
+
+        parts = arguments.map { |argument| compile(argument, record) }
+        case name
+        when "lower" then "translate(#{parts.first}, #{text(UPPER)}, #{text(LOWER)})"
+        when "upper" then "translate(#{parts.first}, #{text(LOWER)}, #{text(UPPER)})"
+        when "concat" then "(#{parts.join(" || ")})"
+        else "replace(#{parts.join(", ")})"
+        end
+      end
+
+      # Only text counts as a value: a number, object, array or null reads as no value.
+      def reference(path, record)
+        at = RuleCompiler.path_literal(path)
+        "(CASE WHEN jsonb_typeof(#{record} #> #{at}) = 'string' THEN #{record} #>> #{at} END)"
+      end
+
+      def lookup(arguments, record)
+        key, table, fallback = arguments
+        branches = table.map { |from, to| "WHEN #{text(from)} THEN #{text(to)}" }.join(" ")
+        "(SELECT CASE WHEN __v IS NULL THEN NULL ELSE CASE __v #{branches} ELSE #{compile(fallback, record)} END END " \
+          "FROM (SELECT #{compile(key, record)} AS __v) __lookup)"
+      end
+
+      def text(value) = "#{RuleCompiler.text_literal(value)}::text"
+    end
+  end
+end