hecks 2.9.0 → 3.0.1

data/lib/hecks/runtime/registry/verification.rb

@@ -13,8 +13,10 @@ module Hecks
           verify_world_defaults!
           verify_singleton_port_answers!
           refuse_cross_package_bluebook_merge!
+          refuse_reserved_chapter_names!
           refuse_membership_without_identity!
           refuse_unresolved_port_operations!
+          refuse_unanswerable_queries!
 
           @hecksagons.each_value do |hexagon|
             refuse_ungoverned_roles!(hexagon)
@@ -95,6 +97,13 @@ module Hecks
         # each bind above; a singleton port is never bound to an aggregate at all.
         PER_AGGREGATE_PORTS = %w[persistence projection loading].freeze
 
+        # The directory holding the gem's own Hecks chapter, the only place a chapter named
+        # `Hecks` may be declared from.
+        GEM_CHAPTER_DIR = File.expand_path("../../hecks", __dir__).freeze
+
+        # The chapter names only the gem itself may declare (ADR 0080, section 9).
+        RESERVED_CHAPTER_NAMES = %w[Hecks].freeze
+
         # Checks every singleton port with exactly one wired adapter against its own
         # declared `answers` methods.
         def verify_singleton_port_answers!
@@ -180,14 +189,14 @@ module Hecks
           end
         end
 
-        # `uses_framework` loads a bounded context; the consumer must declare the sibling
-        # hecksagon that is its ACL (Governance/Identity/Privacy already do).
+        # `uses_framework` and `attaches` load a bounded context; the consumer must declare the
+        # sibling hecksagon that is its ACL (Governance/Identity/Privacy already do).
         def refuse_unwired_framework_members!(hexagon)
-          Array(hexagon.framework_members).each do |member|
+          hexagon.member_chapters.each do |member|
             next if hecksagon(member)
 
             raise WiringError,
-                  "#{hexagon.domain} attaches framework member #{member.inspect} " \
+                  "#{hexagon.domain} attaches #{member.inspect} " \
                   "(bounded context) but never declared Hecks.hecksagon " \
                   "#{member.inspect} — put that sibling (and any `translates` " \
                   "ACL) in context_map.hecksagon; same-name blocks merge, " \
@@ -229,6 +238,130 @@ module Hecks
           end
         end
 
+        # A query has exactly one answer path. It is derivable when the bluebook says which of the
+        # aggregate's own records it wants (a where, order_by, limit or offset, or no arguments at
+        # all: the plain list) and returns no value object of its own; it is bound when it
+        # `returns` a value object and the hecksagon names the port whose adapter answers it. None
+        # of the two is "no answer path"; both is "two answer paths". A bound query also needs an
+        # adapter behind its port that implements it, found here so it fails at boot rather than
+        # on the first ask.
+        def refuse_unanswerable_queries!
+          @bluebooks.each_value do |chapter|
+            chapter.aggregates.each do |aggregate|
+              refuse_misbound_queries!(chapter, aggregate)
+
+              aggregate.queries.each { |query| refuse_answer_paths!(chapter, aggregate, query) }
+              aggregate.entities.each do |entity|
+                entity.queries.each { |query| refuse_entity_answer_path!(chapter, aggregate, entity, query) }
+              end
+            end
+          end
+        end
+
+        # Counts the query's answer paths (the bindings, plus the derived answer when it exists)
+        # and refuses any count but one, then checks a bound query's shape and adapter.
+        def refuse_answer_paths!(chapter, aggregate, query)
+          where  = "#{chapter.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
+          ports  = aggregate.query_bindings(query.hecks_name)
+          paths  = ports.size + (derivable?(query) ? 1 : 0)
+
+          if paths > 1
+            raise WiringError, "#{where} has two answer paths: #{answer_path_names(query, ports)} — " \
+                               "a query is answered from records or from outside, not both"
+          end
+          return check_bound_query!(chapter, aggregate, query, ports.first) if ports.any?
+          return if paths == 1
+
+          raise WiringError, no_answer_path_message(chapter, aggregate, query, where)
+        end
+
+        # A query that returns nothing and says something about which records it wants, or wants
+        # all of them. One that takes arguments but filters, orders and bounds nothing reads none
+        # of them, so it derives no answer.
+        def derivable?(query)
+          return false if query.returns
+
+          filters_records?(query) || query.attributes.empty?
+        end
+
+        def answer_path_names(query, ports)
+          names = ports.map { |port| "the #{port.name} port" }
+          names.unshift("its records") if derivable?(query)
+          names.join(" and ")
+        end
+
+        def no_answer_path_message(chapter, aggregate, query, where)
+          if query.returns
+            "#{where} has no answer path: it returns #{query.returns}, which only an adapter can " \
+              "answer, and no hecksagon port binds it. Bind it: `#{chapter.name}::#{aggregate.hecks_name}" \
+              ".port \"Port\" do answers_query \"#{query.hecks_name}\" end`."
+          else
+            "#{where} has no answer path: it declares no where and returns nothing, and no hecksagon " \
+              "binds it — its arguments (#{query.attributes.map(&:name).join(', ')}) select nothing. " \
+              "Add a where, or declare what it returns and bind it in the hecksagon."
+          end
+        end
+
+        # Checks what a binding needs to be answerable: a returned value object the aggregate
+        # declares, and one adapter behind the port that implements the query's method.
+        def check_bound_query!(chapter, aggregate, query, port)
+          where = "#{chapter.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
+          unless query.returns
+            raise WiringError, "#{where} is bound to the #{port.name} port but returns nothing — " \
+                               "declare the value object its answer takes with `returns`"
+          end
+          if filters_records?(query)
+            raise WiringError, "#{where} has two answer paths: it is bound to the #{port.name} port but " \
+                               "also declares where, order_by or limit over stored records"
+          end
+          if query.authorization
+            raise WiringError, "#{where} is bound to the #{port.name} port but declares authorize — " \
+                               "an outside answer is never tenant-scoped or authorized, so drop the " \
+                               "authorize or answer the query from records"
+          end
+          unless Value.value_object_for(aggregate, query.returns_name)
+            raise WiringError, "#{where} returns #{query.returns_name}, but #{aggregate.hecks_name} " \
+                               "declares no such value object"
+          end
+
+          klass = AdapterLookup.adapter_class(self, port.name, asked: where)
+          AdapterLookup.check_answers!(klass, port.name, Naming.snake(query.hecks_name), query, asked: where)
+        end
+
+        # An entity's query reads the elements of its aggregate's list, and nothing outside can
+        # be bound to one, so declaring a value object to return leaves it no answer.
+        def refuse_entity_answer_path!(chapter, aggregate, entity, query)
+          where = "#{chapter.name}::#{aggregate.hecks_name}.#{entity.hecks_name}.#{query.hecks_name}"
+          if query.returns
+            raise WiringError, "#{where} has no answer path: it returns #{query.returns}, but " \
+                               "only an aggregate's queries can be bound to a port"
+          end
+          return if derivable?(query)
+
+          raise WiringError, "#{where} has no answer path: it declares no where and returns nothing — its " \
+                             "arguments (#{query.attributes.map(&:name).join(', ')}) select nothing"
+        end
+
+        # Refuses a binding that names a query its aggregate does not declare, or names one twice
+        # on a single port (the DSL already refuses that, so this guards a hand-built port).
+        def refuse_misbound_queries!(chapter, aggregate)
+          aggregate.ports.each do |port|
+            names = port.answered_queries.map(&:name)
+            names.each do |name|
+              where = "#{chapter.name}::#{aggregate.hecks_name}.#{name}"
+              unless aggregate.query(name)
+                raise WiringError, "the #{port.name} port binds #{where}, which the aggregate does not declare"
+              end
+              raise WiringError, "#{where} has two answer paths: the #{port.name} port twice" if names.count(name) > 1
+            end
+          end
+        end
+
+        # A query that says anything about which stored records it wants.
+        def filters_records?(query)
+          !(query.wheres.empty? && query.order_by.nil? && query.limit.nil? && query.offset.nil?)
+        end
+
         def port_operation_declared?(chapter, verb)
           aggregate_name, port_name, operation_name = verb.split(".", 3)
           ports = chapter.aggregate(aggregate_name)&.ports || []
@@ -263,6 +396,32 @@ module Hecks
           bluebook_ir.aggregates.flat_map { |aggregate| aggregate.commands + aggregate.entities.flat_map(&:commands) }
         end
 
+        # Refuses a chapter whose name is reserved unless every file that declared it sits under
+        # the gem's own chapter directory. A rename is the only fix, so the message says so.
+        #
+        # @raise [WiringError] naming the reserved word and the offending file(s)
+        def refuse_reserved_chapter_names!
+          RESERVED_CHAPTER_NAMES.each do |reserved|
+            next unless @bluebooks.key?(reserved)
+
+            sources = Array(@bluebook_sources[reserved]).compact
+            foreign = sources.reject { |path| gem_chapter_source?(path) }
+            next if foreign.empty? && !sources.empty?
+
+            where = foreign.empty? ? "" : " (declared in #{foreign.join(', ')})"
+            raise WiringError,
+                  "a chapter named #{reserved.inspect} is refused: #{reserved.inspect} is a reserved " \
+                  "word, the name of the gem's own chapter, and only the gem may declare it#{where}. " \
+                  "Rename the chapter (for example to your app's name) in its " \
+                  "`Hecks.bluebook #{reserved.inspect}` line and in its hecksagon."
+          end
+        end
+
+        # Whether `path` is a file of the gem's own chapter directory.
+        def gem_chapter_source?(path)
+          File.expand_path(path.to_s).start_with?("#{GEM_CHAPTER_DIR}/")
+        end
+
         # Two packages can share a chapter name by coincidence (found live: a stale
         # vendor/hecksagain fork of Governance/Identity/Deploy, still on 4 apps' load
         # paths). Intentional accumulation (several files declaring the same chapter on

data/lib/hecks/runtime/registry.rb

@@ -17,6 +17,9 @@ module Hecks
       include SagaPersistence
       include WorldDefaults
 
+      # The thread-local key under which open reaction collections are kept.
+      REACTION_SINKS = :hecks_reaction_sinks
+
       attr_reader :root, :bluebooks, :hecksagons, :ports, :adapters, :worlds, :event_log,
                   :reaction_log, :saga_log, :saga_instances, :translations, :saga_mutex,
                   :saga_dispatch_log, :policy_dispatch_log, :bluebook_sources,
@@ -37,6 +40,7 @@ module Hecks
         @translations = []
         @event_log    = []
         @reaction_log = []
+        @reaction_events = {}.compare_by_identity
         @saga_log = []
         # Recorded at hecksagon-build time (AggregateDoor#mark_sensitive); Loader.boot's
         # post-dispatch step turns each entry into a real Privacy::Marking.Mark, idempotently.
@@ -102,6 +106,17 @@ module Hecks
       # @return [Bluebook::Chapter] `item`, unchanged
       def add_bluebook(item) = @bluebooks[item.name] = item
 
+      # Drops a chapter and the open builder and source record that accumulated it, so the
+      # chapter can be loaded again from nothing.
+      #
+      # @param name [String, Symbol] the chapter name to forget
+      # @return [void]
+      def forget_chapter(name)
+        @bluebooks.delete(name.to_s)
+        @bluebook_builders.delete(name.to_s)
+        @bluebook_sources.delete(name.to_s)
+      end
+
       # Tracks which .bluebook file(s) contributed to a chapter name (a boot-time loading
       # fact, never Rust-mirrored) so refuse_cross_package_bluebook_merge! can catch two
       # unrelated packages accumulating into the same name by coincidence.
@@ -233,7 +248,7 @@ module Hecks
       # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s role
       #   checks, or nil if none does
       def authorization_provider_for(domain)
-        names = [domain.to_s, *Array(hecksagon(domain)&.framework_members)]
+        names = [domain.to_s, *Array(hecksagon(domain)&.member_chapters)]
         names.filter_map { |name| bluebook(name) }
              .find { |chapter| chapter.provides?(Bluebook::Capabilities::AUTHORIZATION) }
       end
@@ -254,7 +269,7 @@ module Hecks
       # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s identity
       #   questions, or nil if none does
       def identity_provider_for(domain)
-        names = [domain.to_s, *Array(hecksagon(domain)&.framework_members)]
+        names = [domain.to_s, *Array(hecksagon(domain)&.member_chapters)]
         attached = names.filter_map { |name| bluebook(name) }
                         .find { |chapter| chapter.provides?(Bluebook::Capabilities::IDENTITY) }
         return attached if attached
@@ -350,7 +365,7 @@ module Hecks
       def vendored_provider_for(domain, capability)
         hexagon = hecksagon(domain)
         vendored = Array(hexagon&.vendored_bluebooks).map { |name| Naming.pascal(name) }
-        names = [domain.to_s, *Array(hexagon&.framework_members), *vendored]
+        names = [domain.to_s, *Array(hexagon&.member_chapters), *vendored]
         attached = names.filter_map { |name| bluebook(name) }
                         .find { |chapter| chapter.provides?(capability) }
         return attached if attached
@@ -373,6 +388,43 @@ module Hecks
         @repositories[[domain.to_s, aggregate.hecks_name]] ||= Ports::Persistence.repository(self, domain, aggregate)
       end
 
+      # Records one policy reaction on the shared log, and on every collection open on this
+      # thread (see `collecting_reactions`).
+      #
+      # The event that triggered a reaction is kept beside the log, not in the record: the record
+      # is the byte-for-byte shape the Rust kernel also writes.
+      #
+      # @param record [Hash{Symbol => Object}] the reaction's outcome
+      # @param event [String, Integer, nil] identity of the event instance the reaction answered
+      # @return [void]
+      # rubocop:disable-next Hecks/ThreadSharedIvarMutation
+      def log_reaction(record, event: nil)
+        @reaction_log << record
+        @reaction_events[record] = event if event
+        Array(Thread.current[REACTION_SINKS]).each { |sink| sink << record }
+      end
+
+      # The identity of the event instance a logged reaction answered.
+      #
+      # @param record [Hash{Symbol => Object}] a record `log_reaction` was given
+      # @return [String, Integer, nil] nil for a record logged without its event
+      def reaction_event(record) = @reaction_events[record]
+
+      # Collects the reactions logged on this thread while the block runs, so one dispatch
+      # reads exactly its own even when other threads dispatch on the same registry. Nested
+      # dispatches (a reaction that dispatches) each collect, and the outer one sees theirs too.
+      #
+      # @yield [Array<Hash>] the collection, filled as reactions are logged
+      # @return [Object] what the block returns
+      def collecting_reactions
+        sinks = (Thread.current[REACTION_SINKS] ||= [])
+        sink  = []
+        sinks << sink
+        yield sink
+      ensure
+        sinks&.delete_if { |candidate| candidate.equal?(sink) }
+      end
+
       # Clears everything a dispatch produced (logs, saga instances, repositories); leaves
       # what booting the files produced (bluebooks, hecksagons, ports, adapters, worlds,
       # resolved eras) untouched.
@@ -386,6 +438,7 @@ module Hecks
       def reset_runtime_state!
         @event_log.clear
         @reaction_log.clear
+        @reaction_events.clear
         @saga_log.clear
         @saga_dispatch_log.clear
         @policy_dispatch_log.clear
@@ -469,6 +522,7 @@ module Hecks
           subscriptions:      (base.subscriptions + overlay.subscriptions).uniq,
           framework_members:  (base.framework_members + overlay.framework_members).uniq,
           vendored_bluebooks: (base.vendored_bluebooks + overlay.vendored_bluebooks).uniq,
+          attached_chapters:  (base.attached_chapters + overlay.attached_chapters).uniq,
           bounded:            base.bounded? || overlay.bounded?,
           translates:         (base.translates + overlay.translates).uniq
         )

data/lib/hecks/runtime/remote_dispatcher.rb

@@ -16,7 +16,22 @@ module Hecks
     # already Lambda-backed. Writes cannot: givens and constraints must run in Rust,
     # not be pre-checked here against incomplete local state.
     class RemoteDispatcher
-      Result = Struct.new(:verb, :instance, :events, keyword_init: true) do
+      Result = Struct.new(:verb, :instance, :events, :refused_reactions, :blocking_reactions,
+                          :reaction_defects, keyword_init: true) do
+        # Lists the policy reactions this dispatch caused that the routed runtime refused.
+        #
+        # @return [Array<Hash{Symbol => Object}>] one `{ policy:, trigger:, reason: }` per refused
+        #   reaction, oldest first; empty when every reaction was delivered
+        def refused_reactions = self[:refused_reactions] || []
+
+        # Lists the refused reactions that block the run, as opposed to a benign non-match.
+        #
+        # @return [Array<Hash{Symbol => Object}>] the subset of `refused_reactions` that blocks
+        def blocking_reactions = self[:blocking_reactions] || []
+
+        # @return [Array<Hash{Symbol => Object}>] the reactions the host reported as crashed
+        def reaction_defects = self[:reaction_defects] || []
+
         # The settled record's identity.
         #
         # @return [String]
@@ -96,7 +111,10 @@ module Hecks
         instance = Instance.new(aggregate: aggregate, id: mutation["id"],
                                 state: JSON.parse(JSON.generate(mutation["state"]), symbolize_names: true))
 
-        Result.new(verb: verb, instance: instance, events: step_events(response))
+        Result.new(verb: verb, instance: instance, events: step_events(response),
+                   refused_reactions: refused_reactions_of(response),
+                   blocking_reactions: ReactionOutcome.blocking(step_reactions(response)),
+                   reaction_defects: ReactionOutcome.defects(step_reactions(response)))
       end
 
       # Delegates to the local `Dispatcher`; see `Dispatcher#query`.
@@ -116,6 +134,17 @@ module Hecks
 
       private
 
+      # The newest step's reactions the remote runtime refused, from its `reactions_per_step`
+      # log (the whole-run `reactions` would also carry the replayed history's).
+      def refused_reactions_of(response)
+        step_reactions(response)
+          .select { |entry| entry["delivered"] == false }
+          .map { |entry| { policy: entry["policy"], trigger: entry["trigger"], reason: entry["reason"] } }
+      end
+
+      # Every reaction the newest step caused, delivered or not.
+      def step_reactions(response) = Array(response.fetch("reactions_per_step", []).last)
+
       def step_events(response)
         response.fetch("events", []).map { |e| build_event(e) }
       end

data/lib/hecks/runtime/value/coercion.rb

@@ -12,7 +12,7 @@ module Hecks
       # as `Value.for`, `Value.build`, and so on.
       module Coercion
         # The complete set of attribute value shapes. Mirrored by hand into a
-        # generated Rust enum (bin/project_kernel_capabilities) — adding a shape
+        # generated Rust enum (hecks project_kernel_capabilities) — adding a shape
         # here without a matching Rust file leaves the kernel unaware of it.
         SHAPES = %i[scalar list optional composite].freeze
 
@@ -309,6 +309,7 @@ module Hecks
           check_required_fields(value_object, fields)
           admit_member(value_object, fields)
           check_admitted(value_object, fields)
+          check_list_shapes(value_object, fields)
           check_numeric_fields(value_object, fields)
           check_scalar_shapes(value_object, fields)
           check_patterns(value_object, fields)
@@ -453,6 +454,26 @@ module Hecks
                                            known_by: known_by(attribute))
         end
 
+        # A list argument is an Array whatever its element type, so a lone scalar offered for
+        # it is refused; nil stays legitimate, as for any optional argument. The single-element
+        # form belongs to the `append`/`remove` effects, which take one element and are
+        # coerced against the aggregate's own list, never through this gate.
+        #
+        # @param command [#hecks_name] what `attribute` is declared on, named in a refusal
+        # @param attribute [Bluebook::Attribute] the attribute to check; a no-op unless list-typed
+        #   (a `has_many` reference list has its own refusal)
+        # @param value [Object] the offered value
+        # @return [void]
+        # @raise [Runtime::TypeMismatch] if `value` is neither nil nor an Array
+        def refuse_scalar_list(command, attribute, value)
+          return unless attribute.list? && !attribute.reference? && !value.nil? && !value.is_a?(Array)
+
+          raise TypeMismatch, RefusalWording.render_site(
+            "TypeMismatch", "numeric_field", type: command.hecks_name, field: attribute.name,
+            expected: "list_of(#{attribute.type})", offered: Rendering.describe(value)
+          )
+        end
+
         # "an object" for the Hash/Value shape; `Rendering.describe` otherwise —
         # the same rendering every other TypeMismatch in this file uses.
         #
@@ -518,7 +539,7 @@ module Hecks
 
         # Converts a derived numeric identity string back before `check_numeric_fields` runs.
         private def coerce_identifier(field, identifier)
-          return identifier unless identifier.is_a?(String) && NUMERIC.key?(field.type.to_s)
+          return identifier unless identifier.is_a?(String) && FieldChecks::NUMERIC.key?(field.type.to_s)
 
           case field.type.to_s
           when "Integer" then Integer(identifier)
@@ -537,139 +558,6 @@ module Hecks
         def canonical_fields(fields)
           JSON.generate(fields.sort_by { |name, _| name.to_s }.to_h)
         end
-
-        # C3.8 boundary check — refuses a mistyped argument before it breaks a predicate.
-        private def check_bare_primitive(owner, attribute, value)
-          type = attribute.type.to_s
-          expected = NUMERIC[type]
-          mistyped = if expected
-                       !value.is_a?(expected)
-                     elsif NON_NUMERIC_SCALARS.include?(type)
-                       COMPOSITE_SHAPES.any? { |shape| value.is_a?(shape) }
-                     else
-                       false
-                     end
-          if mistyped
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                             type: owner.hecks_name, field: attribute.name,
-                                             expected: type, offered: Rendering.describe(value))
-          end
-
-          check_numeric_bounds(owner.hecks_name, attribute.name, value)
-        end
-
-        # C3.3/C3.4 — value bounds enforced at every boundary: an Integer must fit
-        # signed 64 bits, a Float must be finite.
-        INT64_RANGE = (-(2**63))..((2**63) - 1)
-
-        private def check_numeric_bounds(type_name, field_name, given)
-          if given.is_a?(Integer) && !INT64_RANGE.cover?(given)
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "integer_range",
-                                             type: type_name, field: field_name, offered: Rendering.describe(given))
-          end
-          return unless given.is_a?(Float) && !given.finite?
-
-          raise TypeMismatch,
-                RefusalWording.render_site("TypeMismatch", "non_finite_field",
-                                           type: type_name, field: field_name, offered: Rendering.describe(given))
-        end
-
-        # A value object refuses an undeclared key the same way a command's own
-        # payload does, checked before any other field-content check.
-        private def check_unknown_fields(value_object, fields)
-          known   = value_object.attributes.map { |attribute| attribute.name.to_sym }
-          unknown = (fields.keys.map(&:to_sym) - known).sort
-          return if unknown.empty?
-
-          declared = value_object.attributes.map(&:name)
-          raise UnknownArgument,
-                RefusalWording.render_site("UnknownArgument", "unknown_args",
-                                           command: value_object.hecks_name, unknown: unknown,
-                                           declared: declared)
-        end
-
-        # C3.7 — every non-optional, non-list field must arrive (or construction
-        # refuses); a `default:` has already been filled in by `apply_defaults`.
-        private def check_required_fields(value_object, fields)
-          value_object.attributes.each do |attribute|
-            next if attribute.optional? || attribute.list?
-            next unless fields[attribute.name].nil?
-
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                             type: value_object.hecks_name, field: attribute.name,
-                                             expected: attribute.type, offered: "nil")
-          end
-        end
-
-        # Checked before invariants, because an invariant reading a mistyped field
-        # is exactly the thing that would otherwise explode.
-        NUMERIC = { "Integer" => Integer, "Float" => Numeric }.freeze
-        private def check_numeric_fields(value_object, fields)
-          value_object.attributes.each do |attribute|
-            expected = NUMERIC[attribute.type.to_s]
-            next unless expected
-
-            given = fields[attribute.name]
-            next if given.nil?
-
-            unless given.is_a?(expected)
-              raise TypeMismatch,
-                    RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                               type: value_object.hecks_name, field: attribute.name,
-                                               expected: attribute.type, offered: Rendering.describe(given))
-            end
-
-            # `is_a?(expected)` alone waves NaN/Infinity through — both are real
-            # Floats. `-0.0` is deliberately left unchecked: finite and legitimate.
-            check_numeric_bounds(value_object.hecks_name, attribute.name, given)
-          end
-        end
-
-        # A scalar field (String, or a boolean) must not arrive as a composite
-        # (Array/Hash) standing in for a leaf value. A String field additionally
-        # must not arrive as any other scalar, except inside `judge_bootstrapping?`.
-        COMPOSITE_SHAPES = [Array, ::Hash].freeze
-        NON_NUMERIC_SCALARS = %w[String TrueClass FalseClass].freeze
-        private def check_scalar_shapes(value_object, fields)
-          value_object.attributes.each do |attribute|
-            type = attribute.type.to_s
-            next unless NON_NUMERIC_SCALARS.include?(type)
-
-            given = fields[attribute.name]
-            next if given.nil?
-
-            composite = COMPOSITE_SHAPES.any? { |shape| given.is_a?(shape) }
-            non_string_scalar = type == "String" && !composite && !given.is_a?(String) && !judge_bootstrapping?
-            next unless composite || non_string_scalar
-
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "numeric_field",
-                                             type: value_object.hecks_name, field: attribute.name,
-                                             expected: attribute.type, offered: Rendering.describe(given))
-          end
-        end
-
-        # A field declared with a pattern must match it, refused as a TypeMismatch
-        # rather than surfacing later as a broken predicate. The pattern itself is
-        # already vetted by PatternSubset when the bluebook is declared.
-        private def check_patterns(value_object, fields)
-          value_object.attributes.each do |attribute|
-            pattern = attribute.pattern
-            next unless pattern
-
-            given = fields[attribute.name]
-            next if given.nil?
-            next if given.is_a?(String) && Regexp.new(pattern).match?(given)
-
-            raise TypeMismatch,
-                  RefusalWording.render_site("TypeMismatch", "pattern_mismatch",
-                                             type: value_object.hecks_name, field: attribute.name,
-                                             pattern: pattern, offered: Rendering.describe(given))
-          end
-        end
       end
     end
   end