hecks 2.7.0 → 2.9.0

data/lib/hecks/language/bluebook/process_manager.bluebook

@@ -4,8 +4,7 @@ Hecks.bluebook "Bluebook" do
 
     reference_to Bluebook
 
-    # THE CHAPTER IT IS IN, AND ITS NAME — the same shape a policy takes, and for
-    # the same reason.
+    # The chapter it belongs to, and its name, as for a policy.
     identified_by :bluebook, :name
 
     attribute :name,      ProcessManagerName
@@ -13,10 +12,7 @@ Hecks.bluebook "Bluebook" do
     attribute :starts_on,     ProcessManagerText
     attribute :ends_on,       ProcessManagerText
     attribute :states,    list_of(SagaState)
-    # S17, ADR 0026 — Handler nested here (see `entity "Handler"`, below),
-    # an entity rather than its own root aggregate. `list_of(Handler)`
-    # forward-references it the same way banking's own `attribute :ledger,
-    # list_of(LedgerEntry)` names LedgerEntry before it is declared.
+    # Handler is a nested entity (below); list_of forward-references it.
     attribute :handlers,  list_of(Handler)
 
     value_object "ProcessManagerName" do
@@ -32,15 +28,8 @@ Hecks.bluebook "Bluebook" do
       attribute :name, String
     end
 
-    # S17, ADR 0026 — HandlerText/DispatchText/Binding, hoisted up from
-    # the old standalone `aggregate "Handler"`/`aggregate "Dispatch"`. An
-    # entity cannot declare its own `value_object` (EntityBuilder has no
-    # such method — a piece borrows its owning aggregate's, the same way
-    # LedgerEntry borrows Account's Money), so these live here now, at
-    # the ROOT, where BOTH `entity "Handler"` and its own nested `entity
-    # "Dispatch"` can still reach them — a piece mints no value objects
-    # of its own AT ANY DEPTH, so there is exactly one pool however deep
-    # the nesting goes (`EntityBuilder#entity`'s own comment).
+    # Value objects live at the root: an entity mints none of its own at any depth, so Handler and
+    # its nested Dispatch share this one pool.
     value_object "HandlerText" do
       attribute :value, String
     end
@@ -54,36 +43,15 @@ Hecks.bluebook "Bluebook" do
       attribute :value, String
     end
 
-    # ONE DISPATCH'S OWN ORDER AMONG ITS HANDLER'S SIBLINGS — named
-    # DispatchPosition rather than reusing ProcessManager's own `Position`
-    # four lines below (same discipline as `MemberPosition`/shape.bluebook's
-    # own comment on the identical choice): that one orders process
-    # managers among a CHAPTER's siblings ; this one orders dispatches
-    # within ONE handler. Same shape, different fact.
-    #
-    # Part of `identified_by`, below, alongside `command_name` — a real
-    # handler fans the SAME command out more than once with different
-    # `with:` bindings each leg (item #151's own real example: one
-    # BodyPulse handler dispatching Signal.FireSignal once per organ),
-    # and `command_name` alone collided the instant it did: the Judge's
-    # own `entity_duplicate` check raised the moment a second dispatch of
-    # the same command was declared, an uncaught crash for a legitimate,
-    # common pattern. `position` names WHICH send this is and is safe to
-    # fold into identity exactly where it would not be for Handler's own
-    # `from_state` (a real business value) — a Dispatch is declared once,
-    # at load time, and never re-addressed by identity afterward.
+    # Orders one handler's dispatches; Position orders process managers within a chapter.
+    # Part of Dispatch identity: a handler may send the same command several times with different
+    # `with:` bindings, so command_name alone collides.
     value_object "DispatchPosition" do
       attribute :value, Integer
     end
 
-    # The way back: everything DECLARED IN the chapter above. The parent
-    # reference IS the query.
-    # WHERE IT SITS AMONG ITS SIBLINGS. Declaration order is a FACT ABOUT THE
-    # SOURCE — the IR is a contract read straight from this file,
-    # field for field AND INDEX FOR INDEX. So the language HOLDS it, instead of
-    # inheriting it from whatever order a store happens to iterate: an ask that
-    # does not say how it is ordered is answered in identity order, which is
-    # right for every other ask and fatal for the one that is the SOURCE.
+    # Declaration order among siblings. The IR is read index for index, so the language
+    # holds it rather than inheriting whatever order a store iterates.
     value_object "Position" do
       attribute :value, Integer
     end
@@ -103,12 +71,7 @@ Hecks.bluebook "Bluebook" do
       attribute :name,      ProcessManagerName
       attribute :correlates_by, ProcessManagerText
       attribute :starts_on,     ProcessManagerText
-      # A PROCEDURE NEED NOT DECLARE AN ENDING. The runtime has always held
-      # this optional — ProcessManagerBuilder defaults `@ends_on` to nil,
-      # validates only correlates_by/starts_on/states/handlers,
-      # and fills it only if the line is written. The
-      # language was the one saying it was required, and nothing in the corpus
-      # had to disagree because every procedure in it happens to end.
+      # A procedure need not declare an ending; ProcessManagerBuilder defaults @ends_on to nil.
       attribute :ends_on,       ProcessManagerText, optional: true
 
       attribute :position, Position, optional: true
@@ -132,27 +95,15 @@ Hecks.bluebook "Bluebook" do
       emits SagaStateAttached
     end
 
-    # THE HANDLER'S OWN CREATION. S17, ADR 0026 — Handler is a genuine
-    # ENTITY now (`entity "Handler"`, below), and an entity is never
-    # created through its own dotted verb — banking's own LedgerEntry is
-    # created by `Account.LogEntry`, an ordinary append on the OWNER,
-    # never by a `LedgerEntry.Declare` of its own
-    # (`EntityInterpreter#element_of` only LOCATES an element already on
-    # the list — it has no path that creates one). So Handler's creation
-    # moved here, onto ProcessManager, mirroring `State` beside it: a
-    # bare, aggregate-level append.
+    # Handler creation lives here, not on Handler: an entity is created by an append on its owner,
+    # never by a dotted verb of its own.
     command "Handler" do
       role "Language"
       goal "Open a handler inside a process manager"
 
       attribute :event_type, HandlerText
-      # A LEG ALWAYS SAYS WHERE IT MOVES FROM. There is no wildcard leg to be
-      # optional for: `on "Event", transition: { from => to }` is the only
-      # spelling the runtime reads, and it refuses anything else —
-      # `single_transition` raises unless the hash holds exactly one from => to
-      # pair, so a leg without one
-      # is never built at all. `optional: true` here was
-      # the language admitting a leg the runtime cannot parse.
+      # A leg always names its from state: the runtime refuses a transition without exactly one
+      # from => to pair.
       attribute :from_state, HandlerText
       attribute :to_state,   HandlerText
 
@@ -161,59 +112,27 @@ Hecks.bluebook "Bluebook" do
       emits LegDeclared
     end
 
-    # S17, ADR 0026 — ONE HANDLER, nested rather than its own root
-    # aggregate. No `saga` field. It named the old word for a process
-    # manager, held nothing — ProcessManagerHandler has no such reader,
-    # so every Handler record's saga was empty — and repeated the parent
-    # that its own containment already carries. A field that names the
-    # wrong thing, holds nothing, and duplicates the reference beside it.
-    #
-    # `event_type` is an event name, or one of the Trigger vocabulary's
-    # members when the leg answers something no aggregate announces — but
-    # NOT, alone, Handler's own identity any more (items #151/#152's own
-    # finding): a state machine legitimately answers the SAME event
-    # differently depending on which state it is currently in — one event
-    # name, several distinct legs (a BodyPulse handler that moves
-    # `attentive -> attentive` and, separately, `sleeping_light ->
-    # sleeping_light`) — and `event_type` alone collided the instant a
-    # real corpus declared that shape: the Judge's own `entity_duplicate`
-    # check raised `AlreadyExists` the moment the second leg was declared,
-    # an uncaught crash, not a refusal, for a common, legitimate pattern.
-    # `from_state` joins it below for exactly this reason — a real
-    # business value, not a stand-in for missing meaning, the same
-    # distinction `DispatchPosition`'s own comment (above) draws for its
-    # sibling `Dispatch`. The process manager this leg belongs to stays
-    # structural (which list this element sits in), never a stored field.
+    # One handler, nested under its process manager. event_type alone is not identity: one
+    # event can drive several legs from different states, so from_state joins it.
     entity "Handler" do
       description "One handler inside a process manager — the event it answers, the state move it makes, and the commands it sends. Nested under the process manager because a handler holds nested dispatches, which hold nested bindings."
 
       attribute :event_type, HandlerText
       attribute :from_state, HandlerText
       attribute :to_state,   HandlerText
-      # S17, ADR 0026 — Dispatch nested here too (see `entity "Dispatch"`,
-      # below), one level further in than Handler itself.
       attribute :dispatches, list_of(Dispatch)
 
-      # BOTH FIELDS TOGETHER — see the class-level comment above.
       identified_by :event_type, :from_state
 
-      # THE DISPATCH'S OWN CREATION — same reason Handler's own creation
-      # lives on ProcessManager, one level up: an entity is never created
-      # through its own dotted verb. Reached as a DOTTED verb itself
-      # (`ProcessManager.Handler.Dispatch`) since Handler, the owner
-      # doing the creating here, is an entity too, not a real aggregate
-      # with a bare verb of its own to dispatch into.
+      # Dispatch creation lives on the owner, reached as the dotted verb
+      # ProcessManager.Handler.Dispatch because Handler is an entity.
       command "Dispatch" do
         role "Language"
         goal "Open a dispatch inside a handler"
 
         attribute :command_name, DispatchText
-        # THE WALK INDEX, never author-supplied — the same generic
-        # POSITION handling `ValueObject.Member`'s own creating command
-        # already relies on (`Judge#appends`), which fills this from
-        # where the walk found the dispatch, not from a field the row
-        # happens to hold. No real `.bluebook` author ever calls this
-        # verb directly; only the Judge's own replay does.
+        # The walk index, filled by the Judge's replay from where it found the dispatch; never
+        # author-supplied.
         attribute :position, DispatchPosition
 
         sets :dispatches, append: { command_name: :command_name, position: :position }
@@ -221,19 +140,8 @@ Hecks.bluebook "Bluebook" do
         emits SendDeclared
       end
 
-      # S17, ADR 0026 — ONE COMMAND A HANDLER DISPATCHES, nested two
-      # levels in rather than its own root aggregate — "no life outside
-      # its Handler" (the ADR's own words). The bindings are an open
-      # map, which no value object can hold — that was always a reason
-      # it could not be one, never a reason it could not be an entity.
-      # `command_name` ALONE used to be Dispatch's own identity, the same
-      # shape Handler's own `event_type` took one level up — and collided
-      # the same way, for the same real reason (item #151): one handler
-      # fanning the SAME command out several times with different `with:`
-      # bindings each time (one BodyPulse handler dispatching
-      # Signal.FireSignal once per organ). `position` joins it below —
-      # see `DispatchPosition`'s own comment for why that field, unlike
-      # Handler's `from_state`, is safe to fold into identity.
+      # One command a handler dispatches. Identity is command_name plus position, since a
+      # handler may send the same command several times with different bindings.
       entity "Dispatch" do
         description "One command a handler dispatches, with the arguments it binds. Nested under the handler because the bindings are an open map, which no value object can hold."
 
@@ -256,23 +164,8 @@ Hecks.bluebook "Bluebook" do
           emits BindingAttached
         end
 
-        # THE COMPENSATING DISPATCH THIS ONE COMPENSATES FOR, IF ANY —
-        # FLAT FIELDS on THIS SAME entity, mirroring `command_name`/
-        # `with_spec` above one-for-one, rather than a nested (or
-        # self-referential) second `Dispatch`: an entity's own attribute
-        # type has to resolve against a value object, and neither a
-        # self-reference to `Dispatch` (written from inside its own
-        # block, before it exists to reference) nor a plain nested
-        # entity reference passes that check the way `Handler.
-        # dispatches: list_of(Dispatch)` does — that one resolves a
-        # SIBLING already fully built by the time deferred construction
-        # (ADR 0028) finishes; a dispatch compensating for itself has no
-        # such sibling. `compensates_command_name` absent means no
-        # compensation; present, together with whatever
-        # `compensates_with_spec` holds, is everything
-        # `Reconstruction#dispatch` needs to assemble the SAME
-        # `DispatchSpec` shape `compensates` (the real, author-facing
-        # word) fills.
+        # The dispatch this one compensates for, as flat fields: an entity attribute must
+        # resolve against a value object, so a self-referential Dispatch is not possible.
         attribute :compensates_command_name, DispatchText, optional: true
         attribute :compensates_with_spec,    list_of(Binding)
 
@@ -301,9 +194,7 @@ Hecks.bluebook "Bluebook" do
       end
     end
 
-    # HOW PROCESSMANAGER IS SPELLED. These rows live with the concept
-    # they describe; SyntaxBoot discovers every aggregate-local seed table.
-    # Contexts represented here: ProcessManager, Handler.
+    # Keyword and argument rows for process managers and handlers.
     value_object "KeywordSeed" do
       attribute :word,          String
       attribute :context,       String, admits: "Syntax::Context"
@@ -317,27 +208,13 @@ Hecks.bluebook "Bluebook" do
       attribute :disambiguator, String, default: "", admits: "Syntax::Disambiguator"
 
       member word: "correlates_by",   context: "ProcessManager", body: "none",     inner: "",        opens: "",        fills: "correlates_by"
-      # BARE CONSTANT ACCEPTED (ADR 0025, S6 — "events first-class"),
-      # `starts_on Transfer::TransferRequested` / `ends_on
-      # Transfer::TransferSettled`, same `kind: "constant"` + `kind:
-      # "text"` ArgumentSeed pair `emits`/policy's own `on` already
-      # carry (this row's own comment there). Now `calls:`-routed
-      # (`starts_on_impl`/`ends_on_impl`, hand-written — GenericDispatch's
-      # own `COERCE_BY_KIND` has no "constant" entry, so a bare
-      # constant needs the same `Naming.event_ref` resolution `on_impl`/
-      # `transition_impl` already do, not the plain `.to_s` a single
-      # `kind: "text"` row used to get for free).
+      # starts_on and ends_on accept a bare constant or text; they route through hand-written impls
+      # because COERCE_BY_KIND has no "constant" entry and Naming.event_ref must resolve it.
       member word: "starts_on",       context: "ProcessManager", body: "none",     inner: "",        opens: "",        fills: "", calls: "starts_on_impl"
       member word: "ends_on",         context: "ProcessManager", body: "none",     inner: "",        opens: "",        fills: "", calls: "ends_on_impl"
       member word: "transition",      context: "ProcessManager", body: "keywords", inner: "Handler", opens: "Handler", fills: "", calls: "transition_impl"
       member word: "transition",      context: "ProcessManager", body: "none",     inner: "",        opens: "",        fills: "", calls: "transition_impl"
-      # TWO ROWS, the SAME PAIR SHAPE `transition` takes just above —
-      # `body: "none"` was already the only row (`opens: "Dispatch"`
-      # already anticipated a block, unused until now); `body:
-      # "keywords"` is the new one, opening `compensates` on the
-      # dispatch it sits inside (per-dispatch saga compensation — see
-      # `ProcessManagerBuilder::HandlerBuilder#dispatch_impl`'s own
-      # comment).
+      # Two rows per dispatch: one with a block (opening `compensates`), one without.
       member word: "dispatch",        context: "Handler",        body: "keywords", inner: "Dispatch", opens: "Dispatch", fills: "", calls: "dispatch_impl"
       member word: "dispatch",        context: "Handler",        body: "none",     inner: "",        opens: "Dispatch", fills: "", calls: "dispatch_impl"
       member word: "compensates",     context: "Dispatch",       body: "none",     inner: "",        opens: "",         fills: "", calls: "compensates_impl"

data/lib/hecks/language/bluebook/projection.bluebook

@@ -4,7 +4,7 @@ Hecks.bluebook "Bluebook" do
 
     reference_to Bluebook
 
-    # THE CHAPTER IT IS IN, AND ITS NAME.
+    # The chapter it belongs to, and its name.
     identified_by :bluebook, :name
 
     attribute :name,             ReadModelName
@@ -13,26 +13,23 @@ Hecks.bluebook "Bluebook" do
     attribute :reference_name,   ReadModelText
     attribute :reference_target, ReadModelText
     attribute :aggregate_heads,  list_of(Head)
-    # The same open map a query carries — see Query's AskOption. A read model
-    # inherits every specification option an ask has, so it holds them the same way.
+    # The same open map a query carries (see Query's AskOption).
     attribute :options,          list_of(ProjectionOption)
-    # WHICH of the eligible head's own fields to nest its rows under, in
-    # declared order. Rows, not a single value object with N fields — an
-    # arbitrary NUMBER of fields, the same reason `aggregate_heads`/
-    # `options` are lists rather than fixed attributes.
+    # Fields whose values nest the eligible head's rows, in declared order; a list because the
+    # number of fields is open.
     attribute :group_by,         list_of(GroupByField)
-    # `count`/`median_field` are the OTHER two reductions a read model
-    # may declare over its one eligible head, siblings of `group_by`
-    # rather than of `options` — same permissive `ReadModelText` shape,
-    # and the same UNmarked-optional spelling `reference_name`/
-    # `reference_target` already use just above (permissiveness lives
-    # in `ReadModelText`'s own lack of an invariant, not in an
-    # `optional:` flag this chapter's aggregate-level attributes never
-    # carry) — "true"/"" for `count`, a field name or "" for
-    # `median_field`, both legitimately absent on a read model that
-    # declares neither.
+    # The other reductions over the one eligible head; empty when none is declared
+    # (ADR 0078 — a read model reports one shape, so at most one is ever set).
     attribute :count,            ReadModelText, optional: true
     attribute :median_field,     ReadModelText, optional: true
+    attribute :sum_field,        ReadModelText, optional: true
+    attribute :avg_field,        ReadModelText, optional: true
+    attribute :min_field,        ReadModelText, optional: true
+    attribute :max_field,        ReadModelText, optional: true
+    attribute :percentile_field, ReadModelText, optional: true
+    attribute :percentile_at,    ReadModelText, optional: true
+    attribute :any_field,        ReadModelText, optional: true
+    attribute :all_field,        ReadModelText, optional: true
 
     value_object "ReadModelName" do
       attribute :value, String
@@ -40,8 +37,7 @@ Hecks.bluebook "Bluebook" do
     end
 
     value_object "ReadModelText" do
-      # deliberately permissive : query_name / ref_name / ref_target are
-      # legitimately empty on a read model that has not named them yet
+      # Deliberately permissive: query_name and the reference fields may be legitimately empty.
       attribute :value, String
     end
 
@@ -60,7 +56,7 @@ Hecks.bluebook "Bluebook" do
       attribute :option, String
       attribute :key,    String
       attribute :value,  String
-      # optional: not every projection option carries an `at` (C3.7)
+      # Only some options carry an `at`.
       attribute :at,     String, optional: true
     end
 
@@ -69,14 +65,8 @@ Hecks.bluebook "Bluebook" do
       invariant("a group_by field is named") { !field.to_s.empty? }
     end
 
-    # The way back: everything DECLARED IN the chapter above. The parent
-    # reference IS the query.
-    # WHERE IT SITS AMONG ITS SIBLINGS. Declaration order is a FACT ABOUT THE
-    # SOURCE — the IR is a contract read straight from this file,
-    # field for field AND INDEX FOR INDEX. So the language HOLDS it, instead of
-    # inheriting it from whatever order a store happens to iterate: an ask that
-    # does not say how it is ordered is answered in identity order, which is
-    # right for every other ask and fatal for the one that is the SOURCE.
+    # Declaration order among siblings. The IR is read index for index, so the language
+    # holds it rather than inheriting whatever order a store iterates.
     value_object "Position" do
       attribute :value, Integer
     end
@@ -96,10 +86,7 @@ Hecks.bluebook "Bluebook" do
       attribute :name,             ReadModelName
       attribute :description,      ProjectionPurpose, optional: true
       attribute :query_name,       ReadModelText
-      # Both optional now — a ROOTLESS read model (no `reference_to`
-      # declared at all) has neither. Permanently empty, not "not yet
-      # set" — see Gather's own comment below for why that distinction
-      # matters.
+      # Optional: a rootless read model (no `reference_to`) permanently has neither (see Gather).
       attribute :reference_name,   ReadModelText, optional: true
       attribute :reference_target, ReadModelText, optional: true
 
@@ -118,26 +105,14 @@ Hecks.bluebook "Bluebook" do
       role "Language"
       goal "Attach one aggregate head to the read model"
 
-      # A HEAD IS THE AGGREGATE IT NAMES. There is no head with nothing gathered:
-      # `add_aggregate_head` is only ever reached from an `include Target`,
-      # so the builder cannot produce one
-      # without it — the field is a plain
-      # required, non-empty name. `as` and
-      # `many` are both DERIVED from it when the author does not spell them, which
-      # is the clearest statement that it is the part that cannot be missing.
+      # A head is the aggregate it names; add_aggregate_head is only reached from `include Target`.
+      # `as` and `many` are derived from it when the author does not spell them.
       attribute :aggregate, ReadModelText
       attribute :as,        ReadModelText
       attribute :many,      ReadModelText
 
-      # NOT "reference_target must already be set" anymore — reference_target
-      # is fixed forever at Declare time (nothing ever changes it later), so
-      # that rule was really "this read model must have SOME reference, ever"
-      # — exactly the constraint a ROOTLESS read model (bulk, no root,
-      # `group_by`'s own real use) deliberately doesn't meet, permanently,
-      # on purpose, not by omission. Removed rather than relaxed: there is
-      # no runtime fact left here that distinguishes "forgot to declare a
-      # reference" from "declared rootless on purpose" — both look
-      # identical (`reference_target` empty) by the time Gather is judged.
+      # No "reference_target must be set" given: a rootless read model (bulk, group_by) permanently
+      # lacks one, which is indistinguishable from forgetting to declare it.
 
       sets :aggregate_heads, append: { aggregate: :aggregate, as: :as, many: :many }
 
@@ -157,14 +132,8 @@ Hecks.bluebook "Bluebook" do
       emits GroupByFieldAdded
     end
 
-    # `count`/`median` are LATE-SET scalars, the same shape `Lifecycle`'s
-    # own `state_field`/`state_start` already are on `Aggregate`
-    # (aggregate.bluebook) — a command carrying its own value and a bare
-    # `sets field, to: field` copying it onto the record, rather
-    # than an `append:` (they are not lists, and there is only ever one
-    # of each). `count`/`median_field` are declared here, not folded
-    # into `Declare`, for the same reason `GroupBy` is its own command
-    # above: neither is known until the DSL body runs past `include`.
+    # count and median are late-set scalars, like Lifecycle's state_field: one value each, copied
+    # by `sets`, and unknown until the DSL body runs past `include`.
     command "Count" do
       role "Language"
       goal "Mark the read model as a bare row count over its one eligible collection"
@@ -187,13 +156,91 @@ Hecks.bluebook "Bluebook" do
       emits MedianFieldSet
     end
 
+    command "Sum" do
+      role "Language"
+      goal "Mark the read model as the total of one numeric field across its one eligible collection"
+
+      given("a sum field is named") { !sum_field.value.to_s.empty? }
+
+      sets :sum_field
+
+      emits SumFieldSet
+    end
+
+    command "Avg" do
+      role "Language"
+      goal "Mark the read model as the mean of one numeric field across its one eligible collection"
+
+      given("an avg field is named") { !avg_field.value.to_s.empty? }
+
+      sets :avg_field
+
+      emits AvgFieldSet
+    end
+
+    command "Min" do
+      role "Language"
+      goal "Mark the read model as the smallest value of one numeric field across its one eligible collection"
+
+      given("a min field is named") { !min_field.value.to_s.empty? }
+
+      sets :min_field
+
+      emits MinFieldSet
+    end
+
+    command "Max" do
+      role "Language"
+      goal "Mark the read model as the largest value of one numeric field across its one eligible collection"
+
+      given("a max field is named") { !max_field.value.to_s.empty? }
+
+      sets :max_field
+
+      emits MaxFieldSet
+    end
+
+    command "Percentile" do
+      role "Language"
+      goal "Mark the read model as one interpolated rank of one numeric field across its one eligible collection"
+
+      given("a percentile field is named") { !percentile_field.value.to_s.empty? }
+
+      sets :percentile_field
+      sets :percentile_at
+
+      emits PercentileFieldSet
+    end
+
+    command "Any" do
+      role "Language"
+      goal "Mark the read model as whether any row's boolean field is true across its one eligible collection"
+
+      given("an any field is named") { !any_field.value.to_s.empty? }
+
+      sets :any_field
+
+      emits AnyFieldSet
+    end
+
+    command "All" do
+      role "Language"
+      goal "Mark the read model as whether every row's boolean field is true across its one eligible collection"
+
+      given("an all field is named") { !all_field.value.to_s.empty? }
+
+      sets :all_field
+
+      emits AllFieldSet
+    end
+
     command "Option" do
       role "Language"
       goal "Attach one part of one specification option to the read model"
 
       attribute :option, ReadModelText
       attribute :key,    ReadModelText
-      # Same reading as Query.Option above — an option key may stand alone.
+      # Same reading as Query.Option: an option key may stand alone.
       attribute :value,  ReadModelText, optional: true
       attribute :at,     ReadModelText, optional: true
 
@@ -204,9 +251,7 @@ Hecks.bluebook "Bluebook" do
       emits OptionAttached
     end
 
-    # HOW READMODEL IS SPELLED. These rows live with the concept
-    # they describe; SyntaxBoot discovers every aggregate-local seed table.
-    # Contexts represented here: ReadModel.
+    # Keyword and argument rows for read models; SyntaxBoot discovers every aggregate-local table.
     value_object "KeywordSeed" do
       attribute :word,          String
       attribute :context,       String, admits: "Syntax::Context"
@@ -225,6 +270,13 @@ Hecks.bluebook "Bluebook" do
       member word: "group_by",        context: "ReadModel", body: "none", inner: "", opens: "", fills: "group_by", calls: "group_by_impl"
       member word: "count",           context: "ReadModel", body: "none", inner: "", opens: "", fills: "count"
       member word: "median",          context: "ReadModel", body: "none", inner: "", opens: "", fills: "median_field"
+      member word: "sum",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "sum_field"
+      member word: "avg",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "avg_field"
+      member word: "min",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "min_field"
+      member word: "max",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "max_field"
+      member word: "percentile",      context: "ReadModel", body: "none", inner: "", opens: "", fills: "percentile_field", calls: "percentile_impl"
+      member word: "any",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "any_field"
+      member word: "all",             context: "ReadModel", body: "none", inner: "", opens: "", fills: "all_field"
       member word: "where",           context: "ReadModel", body: "none", inner: "", opens: "", fills: "options", calls: "where_impl"
       member word: "order_by",        context: "ReadModel", body: "none", inner: "", opens: "", fills: "options", calls: "order_by_impl"
       member word: "authorize",       context: "ReadModel", body: "none", inner: "", opens: "", fills: "options", calls: "authorize_impl"
@@ -256,9 +308,23 @@ Hecks.bluebook "Bluebook" do
       member keyword: "include",         context: "ReadModel", at: "",  named: "as",      kind: "symbol",   required: "false", fills: "as"
       member keyword: "group_by",        context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "group_by", variadic: "true"
       member keyword: "median",          context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "median_field"
+      member keyword: "sum",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "sum_field"
+      member keyword: "avg",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "avg_field"
+      member keyword: "min",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "min_field"
+      member keyword: "max",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "max_field"
+      member keyword: "percentile",      context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "percentile_field"
+      member keyword: "percentile",      context: "ReadModel", at: "",  named: "at",      kind: "number",   required: "true",  fills: "percentile_at"
+      member keyword: "any",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "any_field"
+      member keyword: "all",             context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "all_field"
       member keyword: "where",           context: "ReadModel", at: "1", named: "",        kind: "pairs",    required: "true",  fills: ""
+      # ADR 0055: which many-side `include`d aggregate (by type) this option applies to —
+      # only recognized here, in ReadModel context, since a plain Query has no such
+      # disambiguation to make (rust/parser's own query_derive::refuse_on_target keeps
+      # refusing it there instead).
+      member keyword: "where",           context: "ReadModel", at: "",  named: "on",      kind: "constant", required: "false", fills: "target"
       member keyword: "order_by",        context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "field"
       member keyword: "order_by",        context: "ReadModel", at: "2", named: "",        kind: "symbol",   required: "false", fills: "direction"
+      member keyword: "order_by",        context: "ReadModel", at: "",  named: "on",      kind: "constant", required: "false", fills: "target"
       member keyword: "authorize",       context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "true",  fills: "policy"
       member keyword: "authorize",       context: "ReadModel", at: "",  named: "tenant",  kind: "symbol",   required: "false", fills: "tenant"
       member keyword: "inspect_query",   context: "ReadModel", at: "1", named: "",        kind: "symbol",   required: "false", fills: "mode"