hecks 1.0.2 → 1.1.0

data/lib/hecks/fuzzing/replay.rb

@@ -57,6 +57,20 @@ module Hecks
       # DISPATCH_ORDER.
       GUARD_REFUSAL_CLASSES = [Runtime::GivenNotMet, Runtime::LifecycleRefused].freeze
 
+      # One tightly ordered loop over steps, with several "oracle" snapshots
+      # (reaction_mark, fan_out_snapshot, guard_check, mutation_trace) that
+      # must be taken at very specific points RELATIVE TO dispatch — see
+      # fan_out_snapshot's own comment above for the real, previously-
+      # shipped bug this exact before/after ordering fixes. Splitting this
+      # into smaller methods would mean threading five-plus oracle-state
+      # locals across method boundaries as parameters/return values, and
+      # would let a future editor silently reorder a snapshot relative to
+      # `dispatch` without any single method looking wrong — the ordering
+      # invariant is only visible with the whole sequence in one place.
+      # rubocop:disable-next Metrics/AbcSize
+      # rubocop:disable-next Metrics/CyclomaticComplexity
+      # rubocop:disable-next Metrics/MethodLength
+      # rubocop:disable-next Metrics/PerceivedComplexity
       def call(domain_path, steps, adapter: :memory)
         # See isolated_boot.rb's own header: resets data/ AND rebinds
         # persistence to the chosen adapter (Memory by default), since a
@@ -106,8 +120,8 @@ module Hecks
                 begin
                   rows = run_filter(runtime, question)
                   queries << { query: question, rows: rows, instances_at: snapshot_instances(runtime) }
-                rescue => e
-                  refusals << { verb: filter_label(question), error: e.message }
+                rescue StandardError => e
+                  refusals << { verb: filter_label(question), error: e.message, kind: refusal_kind(e) }
                 end
                 next
               end
@@ -160,7 +174,7 @@ module Hecks
               end
               queries << entry
 
-              refusals << { verb: question, error: native_error.message, kind: native_error.class.name } if native_error
+              refusals << { verb: question, error: native_error.message, kind: refusal_kind(native_error) } if native_error
               next
             end
 
@@ -256,9 +270,7 @@ module Hecks
               # so there is no "after" to compare (and #build_mutation_
               # trace already skipped anything with no mutations to
               # trace in the first place).
-              if mutation_trace
-                mutation_traces << mutation_trace.merge(after: read_mutation_after(runtime, mutation_trace))
-              end
+              mutation_traces << mutation_trace.merge(after: read_mutation_after(runtime, mutation_trace)) if mutation_trace
             rescue *Runtime::DOMAIN_REFUSALS, Bluebook::Expression::EvaluationError => e
               # `kind:` — the RAISED CLASS, not re-derived from the message.
               # `GivenNotMet`/`EnsuresNotMet` share their exact wording
@@ -269,7 +281,7 @@ module Hecks
               # would misread every one of those as a guard, or a guard as
               # one of those. The class is unambiguous where the string
               # is not.
-              refusals << { verb: step["verb"], error: e.message, kind: e.class.name }
+              refusals << { verb: step["verb"], error: e.message, kind: refusal_kind(e) }
               # ONLY a refusal raised BY THE GUARD ITSELF counts here —
               # measured, not assumed: a step whose args were simply
               # incomplete (AbsentArgument, from normalize_args — which
@@ -287,16 +299,17 @@ module Hecks
               # two guard classes is left OUT of guard_checks entirely —
               # inconclusive, not a claimed pass.
               if guard_check && GUARD_REFUSAL_CLASSES.include?(e.class)
-                guard_checks << guard_check.merge(actual_refused: true, actual_kind: e.class.name)
+                guard_checks << guard_check.merge(actual_refused: true,
+                                                  actual_kind:    e.class.name)
               end
             end
           end
 
           instances = snapshot_instances(runtime)
 
-          events = runtime.events.map { |event|
+          events = runtime.events.map do |event|
             { name: event.name, aggregate: event.aggregate, id: event.id, payload: event.payload }
-          }
+          end
 
           # THE LIVE PROCESS-MANAGER STORE, materialised to inert data —
           # `{ pm_name => { correlation => { state:, memory: } } }`, the
@@ -397,6 +410,16 @@ module Hecks
         instances
       end
 
+      # One early-return chain resolving "which record, if any" (see the
+      # long comment above), feeding a two-stage guard replay
+      # (enforce_givens then admissible_transition) that must run in that
+      # order to mirror the real DISPATCH_ORDER. Splitting the resolution
+      # out would still require passing domain_name/aggregate_name/
+      # aggregate/command/record back in, for no gain — every early
+      # return already reads as "nothing to check" at its own site.
+      # rubocop:disable-next Metrics/AbcSize
+      # rubocop:disable-next Metrics/CyclomaticComplexity
+      # rubocop:disable-next Metrics/PerceivedComplexity
       def build_guard_check(runtime, verb, args)
         domain_name, aggregate_name, command_name = Naming.split_verb(verb)
         return nil unless command_name && !command_name.include?(".")
@@ -412,7 +435,7 @@ module Hecks
         # counts as something to check now that `admissible_transition`
         # is reproduced below; skipping it here would just move the
         # exact gap that call was added to close one line earlier.
-        has_transition = aggregate.lifecycle && aggregate.lifecycle.transitions_for(command.hecks_name).any?
+        has_transition = aggregate.lifecycle&.transitions_for(command.hecks_name)&.any?
         return nil if command.givens.empty? && !command.from && !has_transition
 
         reference_key = command.references.to_s.empty? ? nil : Naming.reference_key(command.references)
@@ -477,9 +500,17 @@ module Hecks
       # `nil` for anything out of scope: an aggregate-level command, an
       # entity command with no mutations at all, or one whose identity
       # args (parent OR element) don't resolve.
+      # Same shape as build_guard_check just above: one early-return chain
+      # resolving the entity/element this step's args address (see the
+      # comment above), each step depending on the previous one's
+      # resolved value. Threading those locals out to smaller methods
+      # would cost more than the cop gains.
+      # rubocop:disable-next Metrics/AbcSize
+      # rubocop:disable-next Metrics/CyclomaticComplexity
+      # rubocop:disable-next Metrics/PerceivedComplexity
       def build_mutation_trace(runtime, verb, args)
         domain_name, aggregate_name, command_name = Naming.split_verb(verb)
-        return nil unless command_name && command_name.include?(".")
+        return nil unless command_name&.include?(".")
 
         aggregate = runtime.registry.bluebook(domain_name)&.aggregate(aggregate_name)
         return nil unless aggregate
@@ -487,7 +518,7 @@ module Hecks
         entity_name, entity_command_name = command_name.split(".", 2)
         entity  = aggregate.entities.find { |candidate| candidate.hecks_name == entity_name }
         command = entity&.command(entity_command_name)
-        return nil unless command && command.mutations.any?
+        return nil unless command&.mutations&.any?
 
         reference_key = command.references.to_s.empty? ? nil : Naming.reference_key(command.references)
         parent_id = Runtime::Identity.of(aggregate, args) ||
@@ -634,17 +665,30 @@ module Hecks
       # Sorted by id ascending regardless — `Ports::Query::Ordering`'s own
       # header explains why an ask with no declared order still needs
       # this tier ("the identity tier is what makes an ask total").
+      # THE OUTCOME CLASS a recorded refusal row names (C8.2/C8.3,
+      # docs/semantics/bluebook-semantics.md): a domain refusal is its own
+      # class; an evaluation FAULT — the language refusing to interpret a
+      # broken rule or input — is `"Fault"`, the same word the Rust kernel
+      # emits (`Refusal::Fault`), never a refusal class and never a raw
+      # Ruby exception name.
+      def refusal_kind(error)
+        error.is_a?(Bluebook::Expression::EvaluationError) ? "Fault" : error.class.name
+      end
+
       def run_filter(runtime, filter)
         aggregate_ref = filter["aggregate"].to_s
         field         = filter["field"].to_s
         op            = filter["op"].to_s
         value         = filter["value"]
 
-        raise "unknown query comparator #{op.inspect}" unless FILTER_COMPARATORS.include?(op)
+        # A malformed ad-hoc ask is a FAULT (C8.3), not a bare RuntimeError.
+        unless FILTER_COMPARATORS.include?(op)
+          raise Bluebook::Expression::EvaluationError, "unknown query comparator #{op.inspect}"
+        end
 
         domain_name, aggregate_name = aggregate_ref.split("::", 2)
         aggregate = runtime.registry.bluebook(domain_name)&.aggregate(aggregate_name)
-        raise "unknown aggregate #{aggregate_ref.inspect}" unless aggregate
+        raise Bluebook::Expression::EvaluationError, "unknown aggregate #{aggregate_ref.inspect}" unless aggregate
 
         clause  = QuerySpecification::Common::WhereClause.new(field: field, op: op, value: value)
         records = runtime.registry.repository(domain_name, aggregate).all
@@ -662,7 +706,7 @@ module Hecks
       # own `filter_label` builds from the same three raw fields, tolerant
       # of any of them being missing (Ruby's own nil-to-"" interpolation)
       # the same way that Rust port is.
-      def filter_label(filter) = "filter #{filter["aggregate"]}.#{filter["field"]} #{filter["op"]}"
+      def filter_label(filter) = "filter #{filter['aggregate']}.#{filter['field']} #{filter['op']}"
     end
   end
 end

data/lib/hecks/fuzzing/sequence_generator/catalog.rb

@@ -8,7 +8,11 @@ module Hecks
         private
 
         def build_catalog(runtime)
-          creating, instance, entity_commands, queries, entity_queries = [], [], [], [], []
+          creating = []
+          instance = []
+          entity_commands = []
+          queries = []
+          entity_queries = []
           read_models = []
 
           runtime.registry.bluebooks.each do |domain_name, bluebook|
@@ -54,7 +58,7 @@ module Hecks
             populators: populators(runtime),
             # Which aggregates this corpus can actually make one of — the ones
             # `satisfiable?` is entitled to wait for.
-            creatable: creating.map { |entry| entry[:aggregate].hecks_name }.to_set }
+            creatable: creating.to_set { |entry| entry[:aggregate].hecks_name } }
         end
 
         # Which command, on which aggregate, appends to which entity list — so a

data/lib/hecks/fuzzing/sequence_generator/step_builder.rb

@@ -175,7 +175,8 @@ module Hecks
             # `:id` the runtime itself never declared as an attribute
             # either), which still needs exactly the old minting behavior.
             unless composite_identity?(aggregate)
-              args[parent_key] ||= identity_shaped(aggregate, aggregate.identified_by, ValueGenerator.random_id(@random), aggregate)
+              args[parent_key] ||= identity_shaped(aggregate, aggregate.identified_by, ValueGenerator.random_id(@random),
+                                                   aggregate)
             end
           else
             scalar = pick_known(aggregate.hecks_name)

data/lib/hecks/fuzzing/sequence_generator.rb

@@ -1,5 +1,4 @@
 require "fileutils"
-require "set"
 require "tmpdir"
 require_relative "isolated_boot"
 require_relative "invalid_value_generator"

data/lib/hecks/fuzzing/value_generator.rb

@@ -128,9 +128,9 @@ module Hecks
       # admitted rows — deliberately, to exercise the refusal a `one_of`
       # exists to enforce, not just its happy path.
       def invalid_member(value_object, random:)
-        value_object.attributes.to_h { |field|
+        value_object.attributes.to_h do |field|
           [field.name.to_s, primitive(field.type.to_s, random: random, name: field.name.to_s)]
-        }
+        end
       end
 
       # THE ID ITSELF. This minted `{"value" => id}` back when a reference was

data/lib/hecks/grammar/evolve.rb

@@ -83,7 +83,12 @@ module Hecks
       end
 
       def propose(word:, context:, body: "none", inner: "", opens: "", fills: "", path: nil)
-        raise Refusal, "#{context}.#{word} is already declared — one row per (word, context, form)" if keyword_rows(path).any? { |row| row[:word] == word && row[:context] == context }
+        if keyword_rows(path).any? do |row|
+          row[:word] == word && row[:context] == context
+        end
+          raise Refusal,
+                "#{context}.#{word} is already declared — one row per (word, context, form)"
+        end
 
         path = owner_path(context: context, word: word, opens: opens, paths: paths_for(path))
         source = File.read(path)
@@ -101,7 +106,8 @@ module Hecks
       end
 
       def set_status(word:, context:, to:, path: nil)
-        raise Refusal, "#{to.inspect} is not a station a word's life admits" unless %w[proposed admitted deprecated retired].include?(to)
+        raise Refusal, "#{to.inspect} is not a station a word's life admits" unless %w[proposed admitted deprecated
+                                                                                       retired].include?(to)
 
         path = path_holding_keyword(word, context, paths_for(path))
         source = File.read(path)
@@ -131,7 +137,12 @@ module Hecks
         row = keyword_rows(path).find { |r| r[:word] == word && r[:context] == context }
         raise Refusal, "#{context}.#{word} is not declared" unless row
         raise Refusal, "#{context}.#{word} was already #{row[:was]} — one rename hop, then eras" if row[:was]
-        raise Refusal, "#{context}.#{to} is already declared — a rename cannot land on a living word" if keyword_rows(path).any? { |r| r[:word] == to && r[:context] == context }
+        if keyword_rows(path).any? do |r|
+          r[:word] == to && r[:context] == context
+        end
+          raise Refusal,
+                "#{context}.#{to} is already declared — a rename cannot land on a living word"
+        end
 
         paths = paths_for(path)
         path = path_holding_keyword(word, context, paths)
@@ -161,7 +172,11 @@ module Hecks
 
       def path_holding_argument(keyword, context, at, named, paths = syntax_paths)
         paths.find do |candidate|
-          argument_blocks(File.read(candidate)).any? { |block| block.lines.any? { |line| argument_row?(line, keyword, context, at, named) } }
+          argument_blocks(File.read(candidate)).any? do |block|
+            block.lines.any? do |line|
+              argument_row?(line, keyword, context, at, named)
+            end
+          end
         end || raise(Refusal, "#{context}.#{keyword}'s argument at #{at.inspect}/named #{named.inspect} is not declared")
       end
 
@@ -251,7 +266,9 @@ module Hecks
 
         path = owner_path(context: context, word: keyword, paths: paths_for(path))
         source = File.read(path)
-        block  = argument_blocks(source).find { |candidate| candidate.include?(%(context: "#{context}")) } || argument_block(source)
+        block  = argument_blocks(source).find do |candidate|
+          candidate.include?(%(context: "#{context}"))
+        end || argument_block(source)
         indent = block[/^(\s*)member /, 1] || "        "
         shape = pairs_shape.to_s.empty? ? "" : %(pairs_shape: "#{pairs_shape}", )
         row = %(#{indent}member keyword: "#{keyword}", context: "#{context}", at: "#{at}", ) +
@@ -264,14 +281,21 @@ module Hecks
       end
 
       def set_argument_status(keyword:, context:, to:, at: "", named: "", path: nil)
-        raise Refusal, "#{to.inspect} is not a station an argument's life admits" unless %w[proposed admitted deprecated retired].include?(to)
+        raise Refusal, "#{to.inspect} is not a station an argument's life admits" unless %w[proposed admitted deprecated
+                                                                                            retired].include?(to)
 
         path = path_holding_argument(keyword, context, at, named, paths_for(path))
         source = File.read(path)
-        block  = argument_blocks(source).find { |candidate| candidate.lines.any? { |line| argument_row?(line, keyword, context, at, named) } }
-        rows   = block.lines.select { |line| argument_row?(line, keyword, context, at, named) }
-        raise Refusal, "#{context}.#{keyword}'s argument at #{at.inspect}/named #{named.inspect} is not " \
-                       "declared" if rows.empty?
+        block  = argument_blocks(source).find do |candidate|
+          candidate.lines.any? do |line|
+            argument_row?(line, keyword, context, at, named)
+          end
+        end
+        rows = block.lines.select { |line| argument_row?(line, keyword, context, at, named) }
+        if rows.empty?
+          raise Refusal, "#{context}.#{keyword}'s argument at #{at.inspect}/named #{named.inspect} is not " \
+                         "declared"
+        end
 
         updated = block.lines.map do |line|
           next line unless argument_row?(line, keyword, context, at, named)

data/lib/hecks/grammar/expression_operators.json

@@ -1643,6 +1643,130 @@
           "value": "length_to_size"
         }
       }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".set?"
+        },
+        "category": {
+          "value": "presence"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 21
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".set?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.set?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".set?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.set? -> !nil?(a)"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".set?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Propose",
+      "args": {
+        "symbol": {
+          "value": ".unset?"
+        },
+        "category": {
+          "value": "presence"
+        },
+        "precedence": {
+          "value": 7
+        },
+        "arity": {
+          "value": 1
+        },
+        "grammar": {
+          "value": "inner"
+        },
+        "strategy": {
+          "value": "suffix_match"
+        },
+        "position": {
+          "value": 22
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".unset?"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "a.unset?"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Render",
+      "args": {
+        "symbol": {
+          "value": ".unset?"
+        },
+        "target": {
+          "value": "rust"
+        },
+        "form": {
+          "value": "a.unset? -> nil?(a)"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Operator.Admit",
+      "args": {
+        "symbol": {
+          "value": ".unset?"
+        }
+      }
     }
   ]
 }

data/lib/hecks/grammar.rb

@@ -43,9 +43,9 @@ module Hecks
         args = symbolize(step.fetch("args"))
         begin
           dispatcher.dispatch(step.fetch("verb"), **args)
-        rescue *Runtime::DOMAIN_REFUSALS => refusal
+        rescue *Runtime::DOMAIN_REFUSALS => e
           raise Runtime::WiringError,
-                "the admission ledger refused at #{step['verb']} #{step['args']} — #{refusal.message}"
+                "the admission ledger refused at #{step['verb']} #{step['args']} — #{e.message}"
         end
       end
 
@@ -119,7 +119,7 @@ module Hecks
     # Every grammar/*.bluebook chapter, booted the same way the corpus
     # boots them — each alone, in a scratch registry.
     def grammar_chapters
-      Dir[File.join(DIR, "*.bluebook")].sort.map do |chapter|
+      Dir[File.join(DIR, "*.bluebook")].map do |chapter|
         registry = Runtime::Registry.new
         root = File.expand_path("../..", __dir__)
         Hecks.with_registry(registry) do
@@ -138,14 +138,24 @@ module Hecks
     # walked for the resolver's arithmetic.
     def operators_in(canonical)
       evaluator = Bluebook::Expression::Evaluator
-      node = begin
-        evaluator.parse(canonical)
+      begin
+        node = evaluator.parse(canonical)
       rescue StandardError
         return []
       end
       walk_operators(node, evaluator).uniq
     end
 
+    # A recursive descent over a CLOSED, declared set of AST node types
+    # (Evaluator's boolean/compare/include nodes, Resolver's arithmetic
+    # nodes, and the generic Struct fallback) — each branch does the
+    # same one thing (name the node's own operator, recurse into its
+    # children) and the branches don't interact, but the ABC score adds
+    # every branch's cost together. Splitting the case out per node type
+    # would trade one place that shows the whole operator vocabulary for
+    # several that each show a fragment, with no reduction in real
+    # complexity.
+    # rubocop:disable-next Metrics/AbcSize
     def walk_operators(node, evaluator)
       resolver = Bluebook::Expression::Resolver
       case node

data/lib/hecks/ir.rb

@@ -73,6 +73,11 @@ module Hecks
     # crash on an undeclared lifecycle.
     One  = Struct.new(:source)
 
+    # The declaration side: `emits_ir(**spec)` records a construct's field ->
+    # rule map, `many`/`one` wrap a source name so a field can recurse into a
+    # list or a single nested construct, and `ir_spec` reads the declaration
+    # back — walking the superclass chain so an anonymous `Class.new(base)`
+    # inherits its base's shape instead of redeclaring it.
     module Declares
       def emits_ir(**spec)
         @ir_spec = spec
@@ -92,6 +97,10 @@ module Hecks
       end
     end
 
+    # The emission side: `to_h` reads the declaring construct's `ir_spec` and
+    # applies each field's rule (`Many#to_h`, `One&.to_h`, a plain Symbol
+    # send, or an instance-`exec`'d Proc) in declaration order to build the
+    # actual Hash.
     module Emits
       def to_h
         spec = ir_spec_for(self)

data/lib/hecks/language/bluebook/aggregate.bluebook

@@ -83,7 +83,8 @@ Hecks.bluebook "Bluebook" do
       # Without this an aggregate attribute's default was simply dropped, and the
       # reconstruction hardcoded nil, which happened to match every corpus member
       # and would have lied about the first one that declared a default.
-      attribute :default, String
+      # optional: a declaration with no default has none (C3.7 — a value object's fields arrive or it refuses)
+      attribute :default, String, optional: true
       # THE CLOSED SET THIS VALUE MUST BELONG TO, named where it was already
       # declared — `Vocabulary::QueryComparator`. Qualified by the aggregate that
       # holds it, because a closed set is a value object INSIDE an aggregate and
@@ -103,7 +104,8 @@ Hecks.bluebook "Bluebook" do
 
     value_object "Transition" do
       attribute :command,    String
-      attribute :from_state, String
+      # optional: a transition declared with no `from:` matches any state (C3.7)
+      attribute :from_state, String, optional: true
       attribute :to_state,   String
     end
 

data/lib/hecks/language/bluebook/command.bluebook

@@ -82,7 +82,8 @@ Hecks.bluebook "Bluebook" do
       attribute :list,    String
       attribute :optional, String, optional: true
       attribute :pattern,  String, optional: true
-      attribute :default, String
+      # optional: a declaration with no default has none (C3.7 — a value object's fields arrive or it refuses)
+      attribute :default, String, optional: true
       # The closed set this value must belong to — see Aggregate::Field, which is
       # the same declaration, spelled for a command's arguments.
       attribute :admits, String, optional: true

data/lib/hecks/language/bluebook/entity.bluebook

@@ -61,7 +61,8 @@ Hecks.bluebook "Bluebook" do
       attribute :list,    String
       attribute :optional, String, optional: true
       attribute :pattern,  String, optional: true
-      attribute :default, String
+      # optional: a declaration with no default has none (C3.7 — a value object's fields arrive or it refuses)
+      attribute :default, String, optional: true
       # The closed set this value must belong to — see Aggregate::Field.
       attribute :admits, String, optional: true
       attribute :relationship, String, optional: true

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

@@ -60,7 +60,8 @@ Hecks.bluebook "Bluebook" do
       attribute :option, String
       attribute :key,    String
       attribute :value,  String
-      attribute :at,     String
+      # optional: not every projection option carries an `at` (C3.7)
+      attribute :at,     String, optional: true
     end
 
     value_object "GroupByField" do

data/lib/hecks/language/bluebook/query.bluebook

@@ -59,7 +59,8 @@ Hecks.bluebook "Bluebook" do
       attribute :list,    String
       attribute :optional, String, optional: true
       attribute :pattern,  String, optional: true
-      attribute :default, String
+      # optional: a declaration with no default has none (C3.7 — a value object's fields arrive or it refuses)
+      attribute :default, String, optional: true
       # The closed set this value must belong to — see Aggregate::Field.
       attribute :admits, String, optional: true
       attribute :relationship, String, optional: true
@@ -74,7 +75,8 @@ Hecks.bluebook "Bluebook" do
       attribute :option, String
       attribute :key,    String
       attribute :value,  String
-      attribute :at,     String
+      # optional: only a repeated option (an index hint) carries an `at` (C3.7)
+      attribute :at,     String, optional: true
     end
 
     # The way back: everything DECLARED IN the aggregate above. The parent

data/lib/hecks/language/bluebook/shape.bluebook

@@ -34,7 +34,8 @@ Hecks.bluebook "Bluebook" do
       attribute :list,    String, pattern: '[^ \t\n\r]'
       attribute :optional, String, optional: true
       attribute :pattern,  String, optional: true
-      attribute :default, String
+      # optional: a declaration with no default has none (C3.7 — a value object's fields arrive or it refuses)
+      attribute :default, String, optional: true
       # The closed set this value must belong to — see Aggregate::Field.
       attribute :admits, String, optional: true
       attribute :relationship, String, optional: true

data/lib/hecks/language/bluebook/vocabulary.bluebook

@@ -294,6 +294,8 @@ Hecks.bluebook "Bluebook" do
              template: "{type}.{field} expects {expected}, got {offered}"
       member refusal: "TypeMismatch", site: "non_finite_field",
              template: "{type}.{field} must be a finite number, got {offered}"
+      member refusal: "TypeMismatch", site: "integer_range",
+             template: "{type}.{field} must fit in a 64-bit integer, got {offered}"
       member refusal: "TypeMismatch", site: "pattern_mismatch",
              template: "{type}.{field} must match {pattern}, got {offered}"
       member refusal: "TypeMismatch", site: "arithmetic_amount",