hecks 0.2.0 → 0.3.0

data/lib/hecks/bluebook/meta_validator/shapes.rb

@@ -0,0 +1,246 @@
+module Hecks
+  module Bluebook
+    module MetaValidator
+      # The leaf shapes of a reconstructed bluebook, and the encodings that go with
+      # them.
+      #
+      # Reconstruction walks the tree; this rebuilds the small hashes at its tips —
+      # an attribute, a rule, a where-clause, a transition — and undoes the two
+      # things the walk encodes on the way in: an attribute's type offered as the ID
+      # of whatever it names, and an append flattened to one row per binding.
+      #
+      # Separate from the traversal because they are different concerns, and because
+      # the two together were 211 code lines against a 200 limit.
+      module Shapes
+        # The type came in as the id of what it names, so it goes back out as the
+        # name — or, for another aggregate's head, as the encoding the IR spells.
+        def attribute(field, aggregate_id)
+          type = text(field[:type]).to_s
+
+          {
+            name:         text(field[:name])&.to_sym,
+            type:         owned_type(type, aggregate_id) || reference_type(type),
+            list:         text(field[:list]).to_s == "true",
+            default:      decode_literal(text(field[:default])),
+            # Read back the same way `list` is — both are booleans about the
+            # attribute, held as text, and dropping either would rebuild a
+            # bluebook that no longer says what it said.
+            optional:     text(field[:optional]).to_s == "true",
+            pattern:      presence(text(field[:pattern])),
+            # THE ROUND TRIP IS THE ONLY WAY IN. The grammar registry keeps the
+            # ASSEMBLED graph — the language as its own judge read it back — so a
+            # fact dropped here is a fact no downstream projection ever sees, no
+            # matter how plainly the .bluebook file declares it.
+            admits:       presence(text(field[:admits])),
+            relationship: presence(text(field[:relationship]))
+          }
+        end
+
+        # A TYPE THIS AGGREGATE OWNS, offered as its id and read back as its name.
+        # Prefixed with the owner and the identity join, because that IS the value
+        # object's identity — the aggregate it belongs to, then its name.
+        def owned_type(type, aggregate_id)
+          prefix = Naming.identity([aggregate_id, ""])
+          return nil unless type.start_with?(prefix)
+
+          type.delete_prefix(prefix)
+        end
+
+        # ONE PART OF AN IDENTITY, read back as the path it went in as. The inverse
+        # of `Marks#identity_path`, and named the same so the two directions read
+        # as one table.
+        def identity_path(part) = text(part[:value]).to_s
+
+        # An argument, a parameter, a piece's attribute — the three places an
+        # attribute is written that carry no owner id to strip.
+        #
+        # A REFERENCE among them came in as the head's ID, because that is what
+        # Command/Entity/Query.Reference offer, so it goes back out as the
+        # encoding the IR spells. A qualified name is the tell : an ordinary
+        # type names something declared beside it (`Money`, `AccountNumber`) and
+        # never carries a chapter, while a head's id always does.
+        def shape_field(field)
+          type = text(field[:type]).to_s
+
+          {
+            name:         text(field[:name])&.to_sym,
+            # A QUALIFIED name is the tell : an ordinary type names something
+            # declared beside it (`Money`, `AccountNumber`) and carries no join at
+            # all, where a head's id always does (chapter + name, joined the way
+            # every derived id is).
+            type:         type.include?(Naming::IDENTITY_JOIN) ? reference_type(type) : text(field[:type]),
+            list:         text(field[:list]).to_s == "true",
+            default:      decode_literal(text(field[:default])),
+            optional:     text(field[:optional]).to_s == "true",
+            pattern:      presence(text(field[:pattern])),
+            admits:       presence(text(field[:admits])),
+            relationship: presence(text(field[:relationship]))
+          }
+        end
+
+        # An ABSENT pattern is nil, not "". The language holds every field as
+        # text, so a field nobody set comes back as the empty string — and ""
+        # is a real regex (it matches everything), so keeping it would turn
+        # "no pattern" into "a pattern that always passes" and quietly cost the
+        # IR its round trip.
+        def presence(text)
+          value = text.to_s
+          value.empty? ? nil : value
+        end
+
+        # A literal, read back from the self-describing form Readings#encode_literal
+        # wrote — the same reader Assembly::Marks uses, because it is the same
+        # spelling. The forms are exactly the five the Primitive vocabulary admits —
+        # String, Integer, Float, TrueClass, FalseClass — plus a symbol, and an
+        # object literal, which is what `to: { value: "good" }` is: a value object's
+        # fields written inline.
+        def decode_literal(text) = Literal.read(text)
+
+        def rule(row) = { description: text(row[:description]), canonical: text(row[:canonical]) }
+
+        # S12, ADR 0025 — `projects :name, from: :"reference.remote_field"`,
+        # read back the same three plain identifiers `rule` above reads
+        # description/canonical as.
+        def projected_field(row)
+          { name: text(row[:name]), reference: text(row[:reference]), remote_field: text(row[:remote_field]) }
+        end
+
+        # `provenance from: {...}` rides the same literal encoding `default:`
+        # does — an object literal, self-describing via Hecks::Literal — one
+        # level up: a whole keyword's argument rather than an attribute's
+        # `default:`.
+        def provenance(row) = decode_literal(text(row[:provenance]))
+
+        # `command "Debit", from: "open"` — the SAME literal encoding
+        # `provenance`/`default:` already ride (S10, ADR 0025), one
+        # state or an array of them, or nil for a command with no
+        # lifecycle guard.
+        def from(row) = decode_literal(text(row[:from]))
+
+        # THE OPTION ROWS, GATHERED BACK into the shapes `extra_options_to_h` spells.
+        #
+        # One row per part, so a compound option is several rows and a repeated one is
+        # several groups told apart by `at`. Grouping by option name and then by `at`
+        # rebuilds both without either knowing which options exist — the whole point
+        # of holding them as an open map.
+        def options_of(row)
+          Array(row[:options])
+            .group_by { |part| text(part[:option]) }
+            .to_h { |option, parts| [option.to_sym, gathered(parts)] }
+        end
+
+        def gathered(parts)
+          repeated, single = parts.partition { |part| !text(part[:at]).to_s.empty? }
+          return single.to_h { |part| [text(part[:key]).to_sym, text(part[:value])] } if repeated.empty?
+
+          repeated.group_by { |part| text(part[:at]) }
+                  .values
+                  .map { |group| group.to_h { |part| [text(part[:key]).to_sym, text(part[:value])] } }
+        end
+
+        # The IR keeps a where's field as a STRING, not a symbol — it is read back
+        # out, never called. The value stays RAW TEXT here on purpose : this
+        # feeds the declaration hash Assembly::Marks#where_clause decodes
+        # from (via `read`), and decoding twice is worse than once — a
+        # kwarg reference (":ceiling") decoded here into the Symbol :ceiling
+        # would have its colon stripped by `read`'s own `.to_s` and come
+        # back out as the plain string "ceiling", indistinguishable from a
+        # literal of the same name. One decode, at the one place that builds
+        # the object every comparator actually reads.
+        def where_clause(row)
+          { field: text(row[:field]), op: text(row[:op]), value: text(row[:value]) }
+        end
+
+        # One object in the IR, two fields in the language.
+        def order_by(row)
+          field = text(row[:order_field])
+          return nil if field.to_s.empty?
+
+          { field: field, direction: text(row[:order_way]) }
+        end
+
+        def limit(row)
+          ceiling = text(row[:limit])
+          return nil if ceiling.to_s.empty?
+
+          { value: ceiling }
+        end
+
+        def transition(row)
+          {
+            command:    text(row[:command]),
+            from_state: text(row[:from_state]),
+            to_state:   text(row[:to_state])
+          }
+        end
+
+        def head(row)
+          {
+            aggregate: text(row[:aggregate]),
+            # A String, like an entity's identified_by. The IR is not uniform about
+            # this and only a round trip says so.
+            as:        text(row[:as]),
+            many:      text(row[:many]).to_s == "true"
+          }
+        end
+
+        def group_by_field(row) = { field: text(row[:field]) }
+
+        # `count`'s own boolean, read back the SAME way `head`'s own
+        # `many` is (`text(row[:many]).to_s == "true"`) — except a
+        # `ReadModel.Count` command is dispatched AT ALL only when
+        # `@count` was truthy (`MetaValidator::Judge#setters` skips a
+        # setter whose every source is absent), so an undeclared read
+        # model's own `count` field never gets written and comes back
+        # `nil` here, never `"false"` — matching `ReadModel#to_h`'s own
+        # `true`/`nil` pair (never `false`) exactly, rather than the
+        # unconditional `true`/`false` `head`'s own `many` needs (every
+        # head DOES get a `Gather` dispatch, declared or derived).
+        def read_model_count(row) = (true if text(row[:count]).to_s == "true")
+
+        # THE APPEND FLATTENING, IN REVERSE.
+        #
+        # An append binds several fields at once and the language's Change holds one
+        # field/kind/source triple, so the walk offers an append once PER BINDING.
+        # Rebuilding groups those rows back into the single mutation the IR keeps —
+        # the only place here that undoes something rather than simply reading it.
+        def mutations(row)
+          Array(row[:mutations])
+            .group_by { |change| [text(change[:target]), text(change[:op])] }
+            .map { |(target, op), bindings| mutation(target, op, bindings) }
+        end
+
+        # `sign:` — read the SAME way the declared side computes it
+        # (`Bluebook::Mutation.sign_for`, item #5 of the whole-project
+        # table-unification survey), not stored on any row here — the
+        # meta-domain's own Change entity carries no `sign` field of its
+        # own (it is a pure function of `op`, nothing to persist), so
+        # reconstruction recomputes it the same way a freshly-built
+        # Mutation's own `to_h` lambda does, rather than leaving the key
+        # silently absent (spec/round_trip_spec's whole point: a field the
+        # language does not hold is a named gap, not a byte-for-byte one).
+        def mutation(target, op, bindings)
+          base = { target: target.to_sym, op: op.to_sym, sign: Hecks::Bluebook::Mutation.sign_for(op) }
+          # `:delegate` (CommandBuilder#delegates_to's own comment) rides
+          # the SAME multi-binding shape `:append` does.
+          return base.merge(fields: appended(bindings)) if ["append", "delegate"].include?(op)
+
+          base.merge(source: classified(bindings.first))
+        end
+
+        def appended(bindings)
+          bindings.to_h { |binding| [text(binding[:field]).to_sym, text(binding[:source])] }
+        end
+
+        def classified(binding)
+          kind  = text(binding[:kind])
+          value = text(binding[:source])
+
+          return { kind: kind, name: value } if %w[argument state].include?(kind)
+
+          { kind: "literal", value: decode_literal(value) }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/meta_validator/syntax_boot.rb

@@ -0,0 +1,255 @@
+module Hecks
+  module Bluebook
+    module MetaValidator
+      # S14, ADR 0026 — DISPATCHES THE LANGUAGE'S OWN GRAMMAR TABLE INTO
+      # ITSELF, once, so `Keyword`/`Argument`'s own `status` genuinely IS a
+      # lifecycle — checked at real dispatch time (the same admission/
+      # coercion/lifecycle-guard door every other command goes through),
+      # not merely declared and never exercised.
+      #
+      # THE SOURCE STAYS STATIC. Aggregate-local `KeywordSeed`/
+      # `ArgumentSeed` value objects (still hand-written `member` rows —
+      # now beside the concepts they spell) are what gets WRITTEN ; this
+      # is what turns them into what gets READ. `Judge`/`Reconstruction`
+      # already draw exactly this line everywhere else in the meta-domain
+      # (a chapter's own DECLARATIONS versus what gets DISPATCHED from
+      # them) — this runs the same distinction one level further out, for
+      # the language's own grammar table.
+      #
+      # A DEDICATED RUNTIME, not `MetaValidator.fresh_runtime`. That one
+      # is reserved for `Judge`'s own bootstrap (dispatching a CHAPTER's
+      # declarations INTO the meta-domain's grammar) — a different act
+      # from this one (dispatching the meta-domain's OWN grammar table
+      # data into a live "Bluebook" domain instance). Sharing the runtime
+      # would let one boot's own repository state leak into the other's.
+      #
+      # Usage:
+      #
+      #   MetaValidator.syntax_table  # => { keywords: [...], arguments: [...] }
+      #
+      # each row a plain Hash, string values, `status` included — the
+      # exact shape `ParserTable`/`syntax_conformance_spec` already read
+      # off the OLD closed-set members, so neither consumer had to change
+      # what it does with a row, only where the row comes from.
+      module SyntaxBoot
+        module_function
+
+        # Memoized the same way `MetaValidator.grammar_registry` itself
+        # is — the ~284-command dispatch sequence below is real work, not
+        # something three separate callers (ParserTable, syntax_
+        # conformance_spec, bin/reference) should each pay for on every
+        # call.
+        #
+        # KEYED BY THE GRAMMAR REGISTRY'S OWN CHAPTER SET, not by a
+        # "ready" flag. `boot` reads exactly two things: the registry's
+        # "Bluebook" chapter (the core seed rows) and every chapter in the
+        # registry that `attaches_to` a core context (Paging's rows). So
+        # the table is a pure function of which chapter OBJECTS the
+        # registry holds — and that is the cache key: the same chapters,
+        # by identity, mean the same table; a chapter replaced (the
+        # fixpoint judge swapping a raw chapter for its assembled self)
+        # or added (`load_attached_grammar_into`) means a fresh boot.
+        #
+        # WHY NOT THE EARLIER `grammar_registry_ready?` GUARD. That guard
+        # was right about the hazard — a snapshot taken mid-build, before
+        # Paging attached, would be missing limit/offset/cursor/nulls
+        # forever — and wrong about the cost of its cure. It refused to
+        # cache ANYTHING until the whole grammar registry had finished
+        # building, calling that window "narrow" and recomputing in it
+        # "cheap". Measured (hecks_ai_training, a six-entity chess domain,
+        # 2026-08-22): every `word_gate_dispatch` landing in that window
+        # re-ran the full ~284-dispatch boot at ~0.76s each — 42 times per
+        # process, 32 of a 35-second `Hecks.boot`, 95% of which had
+        # nothing to do with the domain being booted. Keying on the
+        # chapter set closes the same hazard by construction (a snapshot
+        # can only be served while the chapters it was read from are
+        # still the chapters the registry holds) and lets the window's
+        # own repeated, identical calls share one boot. A registry reset
+        # (fixpoint_spec's own `@grammar_registry = nil`) yields new
+        # chapter objects, so it invalidates this the same way it always
+        # invalidated `grammar_registry_ready?`.
+        #
+        # `equal?`, NOT `==`, on the chapters — identity is the fact being
+        # tracked. Holding the chapter objects themselves (not their ids)
+        # in the key also means a collected chapter can never hand its id
+        # to a newcomer behind this cache's back.
+        def call
+          chapters = MetaValidator.grammar_registry.bluebooks.to_a
+          return @call if @call && same_chapters?(@call_chapters, chapters)
+
+          result = boot
+          @call = result
+          @call_chapters = chapters
+          result
+        end
+
+        def same_chapters?(cached, current)
+          cached.size == current.size &&
+            cached.zip(current).all? { |(cached_name, cached_chapter), (name, chapter)| cached_name == name && cached_chapter.equal?(chapter) }
+        end
+
+        def boot
+          bluebook = MetaValidator.grammar_registry.bluebook("Bluebook")
+          # `MetaValidator.fresh_runtime`, not a brand-new `Runtime::
+          # Registry` — the grammar registry's own copy already has
+          # "Bluebook" registered (`grammar_registry`'s own boot already
+          # ran `registry.add_bluebook`) AND its adapter ports already
+          # loaded ; a standalone registry would need both wired by hand.
+          # `fresh_runtime` resets `@repositories` on the SAME registry —
+          # the identical isolation `Judge.new` already relies on for
+          # every real domain it judges, proven safe by every dispatch
+          # this session has ever made.
+          runtime = MetaValidator.fresh_runtime
+
+          declare_syntax(runtime, bluebook)
+          admit_keywords(runtime, bluebook)
+          admit_arguments(runtime, bluebook)
+
+          read_back(runtime, bluebook)
+        end
+
+        # An Integer stays an Integer — `position` is `Position`-typed
+        # (`attribute :value, Integer`), so stringifying it fails the type
+        # gate rather than feeding it, the same reading `Judge#v` gives.
+        def v(text)
+          return { value: text } if text.is_a?(Integer)
+
+          { value: text.to_s }
+        end
+
+        # ABSENT STAYS ABSENT. A seed row's own optional columns ("was",
+        # "at", "named", ...) are empty strings, not nil — `Literal`/CSV-
+        # shaped grammar data has no `nil` to write — so this is the one
+        # place that decides "" means "not given" for the purpose of an
+        # `optional: true` command argument, the same reading `Judge#v`
+        # makes for the meta-domain's own dispatches.
+        def optional(text)
+          return nil if text.nil? || text.to_s.empty?
+
+          v(text)
+        end
+
+        # `Syntax.Declare`'s own `reference_to Bluebook` names the CHAPTER
+        # it belongs to — the same fact every other top-level aggregate's
+        # own creating command carries (`ProcessManager.Declare`,
+        # `Policy.Declare`, ...). This fresh runtime holds no chapter
+        # record of its own yet (nothing else here needs one), so one is
+        # declared first, named after the real chapter, purely to satisfy
+        # the reference — its own vision/classification are never read
+        # by anything this boot does.
+        def declare_syntax(runtime, bluebook)
+          syntax = bluebook.aggregate("Syntax")
+          runtime.dispatch("Bluebook::Bluebook.Declare", name:           v(bluebook.hecks_name),
+                                                         vision:         v("the language's own grammar table, dispatched into itself"),
+                                                         classification: v("core"))
+          runtime.dispatch("Bluebook::Syntax.Declare", bluebook: bluebook.hecks_name, name: v(syntax.hecks_name))
+        end
+
+        # `to: "Syntax"` NAMES THE RECORD ALREADY OPENED BY `declare_syntax`
+        # ABOVE — an append onto an existing aggregate, not a second creation
+        # of it. This used to smuggle `name: v("Syntax")` into the payload
+        # instead, the pre-routing convention `Judge#appends` (the same
+        # append shape, for `ValueObject.Member`/`ProcessManager.Handler`)
+        # already left behind for `to:`/`with:` — carrying the receiver in
+        # the payload made `Syntax.Keyword`'s own `command.creates?` (true:
+        # it declares no `reference_to`) look like a fresh identity to mint,
+        # which collided with the very "Syntax" row `declare_syntax` had
+        # just opened.
+        def admit_keywords(runtime, bluebook)
+          all_rows(bluebook, "KeywordSeed").each_with_index do |row, index|
+            runtime.dispatch("Bluebook::Syntax.Keyword", to:   "Syntax",
+                                                         with: { position: v(index),
+                                     word: v(row[:word]), context: v(row[:context]), body: v(row[:body]),
+                                     inner: v(row[:inner]), opens: v(row[:opens]), fills: v(row[:fills]),
+                                     was: optional(row[:was]),
+                                     resolves_via: optional(row[:resolves_via]),
+                                     disambiguator: optional(row[:disambiguator]),
+                                     calls: optional(row[:calls]) })
+
+            next unless row[:status].to_s == "deprecated"
+
+            runtime.dispatch("Bluebook::Syntax.Keyword.Deprecate", to: { aggregate: "Syntax", entity: index.to_s })
+          end
+        end
+
+        def admit_arguments(runtime, bluebook)
+          all_rows(bluebook, "ArgumentSeed").each_with_index do |row, index|
+            runtime.dispatch("Bluebook::Syntax.Argument", to:   "Syntax",
+                                                          with: { position: v(index),
+                                     keyword: v(row[:keyword]), context: v(row[:context]),
+                                     at: optional(row[:at]), named: optional(row[:named]),
+                                     kind: v(row[:kind]), required: v(row[:required]), fills: v(row[:fills]),
+                                     selects: optional(row[:selects]), pair_key_fills: optional(row[:pair_key_fills]),
+                                     pair_value_fills: optional(row[:pair_value_fills]),
+                                     pairs_shape: optional(row[:pairs_shape]), variadic: optional(row[:variadic]),
+                                     minimum: optional(row[:minimum]),
+                                     coerce: optional(row[:coerce]), blank_message: optional(row[:blank_message]) })
+
+            next unless row[:status].to_s == "deprecated"
+
+            runtime.dispatch("Bluebook::Syntax.Argument.Deprecate", to: { aggregate: "Syntax", entity: index.to_s })
+          end
+        end
+
+        # EVERY AGGREGATE-LOCAL TABLE IN EVERY LOADED LANGUAGE CHAPTER.
+        # The table's presence is the registration: no chapter, aggregate,
+        # filename, or context catalog is maintained here. This finds the core
+        # Bluebook concepts, the sibling artifact languages (World, Hecksagon,
+        # Port, Adapter, Translation), and attached sub-languages alike.
+        # Concatenated into ONE sequence because `position` is minted from the
+        # walk index and must not collide across concepts.
+        def all_rows(bluebook, name)
+          seed_chapters(bluebook).flat_map { |chapter| rows(chapter, name) }
+        end
+
+        # Keep the core chapter first, then registry insertion order for every
+        # sibling/extension. The name rejection avoids reading the same core
+        # object twice without relying on object identity across fixpoint
+        # assembly.
+        def seed_chapters(bluebook)
+          [bluebook] + MetaValidator.grammar_registry.bluebooks.values.reject { |chapter| chapter.name == bluebook.name }
+        end
+
+        # The seed rows themselves — plain hashes, string values, read from
+        # every aggregate that owns a same-named local value object. Repeating
+        # the value-object shape is deliberate: each concept remains readable
+        # by itself, while this discovery is the only grouping mechanism.
+        def rows(bluebook, name)
+          bluebook.aggregates.flat_map do |aggregate|
+            value_object = aggregate.value_objects.find { |vo| vo.hecks_name == name }
+            next [] unless value_object
+
+            value_object.members.map { |row| row.to_h.transform_values(&:to_s) }
+          end
+        end
+
+        # Reads the dispatched result back into the SAME shape `rows`
+        # above hands the seed data in as — plain hashes, string values,
+        # `status` included — so `ParserTable`/`syntax_conformance_spec`
+        # need not know or care that a real dispatch happened in between.
+        def read_back(runtime, bluebook)
+          syntax = bluebook.aggregate("Syntax")
+          repository = runtime.registry.repository("Bluebook", syntax)
+          instance   = repository.find(Naming.identity([syntax.hecks_name]))
+
+          {
+            keywords:  Array(instance[:keywords]).map { |row| stringify(row) },
+            arguments: Array(instance[:arguments]).map { |row| stringify(row) }
+          }
+        end
+
+        def stringify(row)
+          row.to_h.each_with_object({}) do |(key, cell), out|
+            out[key] = scalar(cell).to_s
+          end
+        end
+
+        def scalar(cell)
+          return cell.to_h.values.first if cell.respond_to?(:to_h) && !cell.is_a?(String)
+
+          cell
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/meta_validator/translation_judge.rb

@@ -0,0 +1,138 @@
+module Hecks
+  module Bluebook
+    module MetaValidator
+      # Offers a built translation (a `translations/*.bluebook` edge,
+      # `Hecks.data_translation`'s own real, established file convention —
+      # there is no separate `.translation` extension) to the language
+      # that describes translations.
+      #
+      # A sibling of a bluebook again, the same shape PortJudge/
+      # AdapterJudge already are — its own file, its own door, judged
+      # through its own self-hosted language (translation.bluebook)
+      # rather than left as plain Ruby structs nothing checks. Walks the
+      # WHOLE built translation in one pass — the top-level Declare/
+      # Retire commands, then every nested aggregate's own Declare plus
+      # one Add* command per rule it carries — the same "one judge, every
+      # nested record" shape WorldJudge already gives Wiring. Field names
+      # throughout read lib/hecks/bluebook/translation.rb's own real
+      # struct/class definitions directly, not the DSL builder's own
+      # local parameter names (`move(old_path, to:)`'s `old_path` reads
+      # back as the struct's own `from`). Whole-project table-
+      # unification survey, item #13's remaining builders.
+      class TranslationJudge
+        attr_reader :refusals
+
+        def initialize(translation)
+          @translation = translation
+          @refusals    = []
+          @runtime     = MetaValidator.fresh_runtime
+          judge!
+        end
+
+        private
+
+        def v(text) = text.nil? ? nil : { value: text.to_s }
+
+        def args(pairs) = pairs.compact
+
+        # `Runtime::AlreadyExists` is rescued HERE but not by World/Port/
+        # Adapter's own sibling judges — found live, not by inspection.
+        # Those three each judge a SINGLE aggregate per build (Port/Adapter)
+        # or a Hash keyed by verb (World's own settings, deduped by
+        # construction), so a duplicate-identity Declare can never reach
+        # their own runtime. `TranslationBuilder#aggregate` appends every
+        # block to a plain Array (`@aggregates << builder.build`) with no
+        # dedup — two `aggregate "Account" do ... end` blocks in the same
+        # translation are syntactically legal and reach here for real. Left
+        # unrescued, the second Declare's `AlreadyExists` crashed straight
+        # through `call_translation` instead of becoming a clean refusal —
+        # confirmed via direct dispatch before this fix.
+        def offer(label)
+          yield
+        rescue Runtime::GivenNotMet, Runtime::InvariantViolation, Runtime::TypeMismatch,
+               Runtime::NotFound, Runtime::AlreadyExists => e
+          @refusals << "#{label}: #{e.message}"
+        rescue Runtime::UnknownVerb
+          nil
+        end
+
+        def send_to(verb, label, to: nil, with: {})
+          offer(label) { @runtime.dispatch(verb, to: to, with: args(with)) }
+        end
+
+        def judge!
+          t = @translation
+          send_to("Translation::Translation.Declare", t.domain,
+                  with: { domain: v(t.domain), from: v(t.from), to: v(t.to) })
+
+          # `id:`, computed the SAME way — `Naming.identity([domain, from,
+          # to])` — Translation's own identity is COMPOSITE
+          # (`identified_by :domain, :from, :to`), the same reason
+          # `Wiring.Set`'s own self-reference dispatch (world.bluebook,
+          # `WorldJudge#judge_wiring`) needs a computed `id:` rather than
+          # a bare field value — a single-field identity (TranslationAggregate's
+          # own `name`) is the ONE case where the bare value itself IS the
+          # id, confirmed live via direct dispatch testing, not assumed.
+          translation_id = Naming.identity([t.domain, t.from, t.to])
+          Array(t.retired).each do |name|
+            send_to("Translation::Translation.Retire", t.domain, to:   translation_id,
+                                                                 with: { value: v(name) })
+          end
+
+          Array(t.aggregates).each { |aggregate| judge_aggregate(t, aggregate) }
+        end
+
+        def judge_aggregate(translation, aggregate)
+          name = aggregate.name
+          parent = {
+            domain: v(translation.domain),
+            from:   v(translation.from),
+            to:     v(translation.to)
+          }
+          send_to("Translation::TranslationAggregate.Declare", name,
+                  with: { translation_ref: parent, name: v(name), was: v(aggregate.was) })
+
+          Hash(aggregate.renames).each do |from, to|
+            send_to("Translation::TranslationAggregate.AddRename", name, to:   name,
+                                                                         with: { from: v(from), to: v(to) })
+          end
+
+          Array(aggregate.moves).each do |move|
+            send_to("Translation::TranslationAggregate.AddMove", name, to:   name,
+                                                                       with: { from: v(move.from), to: v(move.to) })
+          end
+
+          Array(aggregate.converts).each do |convert|
+            send_to("Translation::TranslationAggregate.AddConvert", name, to:   name,
+                                                                          with: { from: v(convert.from), to: v(convert.to), values: v(convert.values.inspect) })
+          end
+
+          Array(aggregate.drops).each do |dropped|
+            send_to("Translation::TranslationAggregate.AddDrop", name, to:   name,
+                                                                       with: { value: v(dropped) })
+          end
+
+          Array(aggregate.retypes).each do |retype|
+            send_to("Translation::TranslationAggregate.AddRetype", name, to:   name,
+                                                                         with: { from: v(retype.from), to: v(retype.to) })
+          end
+
+          Array(aggregate.computes).each do |compute|
+            send_to("Translation::TranslationAggregate.AddCompute", name, to:   name,
+                                                                          with: { from: v(compute.from), to: v(compute.to), sql: v(compute.sql) })
+          end
+
+          Array(aggregate.rekeys).each do |rekey|
+            send_to("Translation::TranslationAggregate.AddRekey", name, to:   name,
+                                                                        with: { sql: v(rekey.sql) })
+          end
+
+          Array(aggregate.backfills).each do |backfill|
+            send_to("Translation::TranslationAggregate.AddBackfill", name, to:   name,
+                                                                           with: { name: v(backfill.name), default: v(backfill.default.inspect) })
+          end
+        end
+      end
+    end
+  end
+end