hecks 1.3.0 → 1.5.0

data/lib/hecks.rb

@@ -22,16 +22,17 @@ require_relative "hecks/router"
 require_relative "hecks/runtime"
 require_relative "hecks/adapters"
 require_relative "hecks/projector"
-# AFTER the projector registry and its `Target` mixin are both real —
-# every target registers itself as it loads, so this require IS the
+# After the projector registry and its `Target` mixin are both real —
+# every target registers itself as it loads, so this require is the
 # installation of them.
 require_relative "hecks/projections"
-# AFTER `Projector` (dispatches against the `:cli` projection) and
+# After `Projector` (dispatches against the `:cli` projection) and
 # `Ports::Clock` (fills a staleness rule's `now` at the door) both exist.
 require_relative "hecks/facade/cli_door"
 require_relative "hecks/facade/cli_runner"
 require_relative "hecks/storehouse"
 require_relative "hecks/framework"
+require_relative "hecks/corpus"
 require_relative "hecks/embryonaut_bluebook"
 
 # The root namespace and public facade of the whole DSL/runtime: `Hecks.boot`/
@@ -44,14 +45,14 @@ module Hecks
   class LoadOutsideBoot < StandardError; end
 
   class << self
-    # The loading words below collect into the registry the RUNTIME is
+    # The loading words below collect into the registry the runtime is
     # holding open ; booting and that ambient state belong to the runtime
     # layer, so this module is their facade and Hecks::Runtime is where
     # they live.
     # `install_facade:` — see Runtime::Loader.boot. Defaults on; a caller
     # that only dispatches by FQN string can skip the global sugar.
     #
-    # `environment:` — RECOVERED, not new: this parameter (and the
+    # `environment:` — recovered, not new: this parameter (and the
     # `environments/<name>.hecksagon` / `.world` overlay it loads —
     # see Adapters::Folder#load_domain) existed on a prior commit of
     # this repo (933d1dd), was vendored out to a real consumer
@@ -65,6 +66,16 @@ module Hecks
     # resolves its own env var name and passes the resulting string
     # straight through, e.g. `Hecks.boot(path, environment:
     # ENV.fetch("MYAPP_ENV", "development"))`.
+    #
+    # @param path [String] path to a domain directory, or a file inside one
+    # @param shared [String, nil] a shared-root override; see `Runtime::Loader.boot`
+    # @param install_facade [Boolean] whether to install the `Widget::Item.Add`-style
+    #   Ruby facade constants for this boot
+    # @param environment [String, nil] the environment name whose
+    #   `environments/<name>.hecksagon`/`.world` overlay, if present, loads after the
+    #   domain's own
+    # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the dispatcher bound
+    #   to the booted domain
     def boot(path, shared: nil, install_facade: true, environment: nil)
       Runtime.boot(path, shared: shared, install_facade: install_facade, environment: environment)
     end
@@ -73,12 +84,30 @@ module Hecks
     # `.hecksagon`, optionally a `.world`), loaded in place from wherever
     # they actually live — see Runtime::Loader.boot_files's own header for
     # why this exists beside `boot` rather than as a special case of it.
+    #
+    # @param paths [String, Array<String>] one or more file paths within the domain
+    #   to load, instead of the whole directory
+    # @param shared [String, nil] a shared-root override; see `Runtime::Loader.boot_files`
+    # @param install_facade [Boolean] whether to install the `Widget::Item.Add`-style
+    #   Ruby facade constants for this boot
+    # @param environment [String, nil] the environment name passed through to the
+    #   selected-file loader
+    # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the dispatcher bound
+    #   to the booted domain
     def boot_files(paths, shared: nil, install_facade: true, environment: nil)
       Runtime.boot_files(paths, shared: shared, install_facade: install_facade, environment: environment)
     end
 
+    # Binds the ambient registry for the duration of the block.
+    #
+    # @param registry [Runtime::Registry] the registry to make current for the block
+    # @yield the code that should see `registry` as `current_registry`
+    # @return [Object] the block's result
     def with_registry(registry, &) = Runtime.with_registry(registry, &)
 
+    # Reads the ambient registry a declaration is currently landing in.
+    #
+    # @return [Runtime::Registry, nil] the current registry, or nil outside a boot
     def current_registry = Runtime.current_registry
 
     # Bind who is dispatching for the duration of the block — checked
@@ -86,25 +115,50 @@ module Hecks
     # default), a command's role stays exactly what it is without this:
     # decoration.
     #
-    # `actor_id` is OPTIONAL — a caller naming only a role is checked by
+    # `actor_id` is optional — a caller naming only a role is checked by
     # string equality against the command's own `role`, exactly as
-    # before. A caller that also names WHO it is lets the check run
+    # before. A caller that also names who it is lets the check run
     # against a real Governance `RoleAssignment` instead, once the
     # command's domain has Governance attached — see
     # `CommandRules::Authorization`'s own header.
     #
-    # `as_of` and `scope` are OPTIONAL too, same shape — see
+    # `as_of` and `scope` are optional too, same shape — see
     # `Runtime.as_caller`'s own header for what each does.
+    #
+    # @param role [String, Symbol] the role to check the caller against
+    # @param actor_id [String, nil] who is calling, checked against a real Governance
+    #   `RoleAssignment` when given; string-equality only against `role` when nil
+    # @param as_of [Integer, nil] Unix epoch seconds to check a matching `RoleAssignment`'s
+    #   own `starts_at` against; unchecked when nil
+    # @param scope [String, nil] the scope to check a matching `RoleAssignment`'s own
+    #   `scope` against; unchecked when nil
+    # @yield the code to run with this caller bound
+    # @return [Object] the block's result
     def as_caller(role:, actor_id: nil, as_of: nil, scope: nil, &)
       Runtime.as_caller(role: role, actor_id: actor_id, as_of: as_of, scope: scope, &)
     end
 
+    # Declares a chapter — a `.bluebook` file's top-level word.
+    #
+    # @param name [String] the chapter's declared name
+    # @param version [String, nil] the chapter's pinned version, or nil for unversioned
+    # @yield the chapter's body, evaluated against a `Bluebook::DSL::BluebookBuilder`
+    # @return [Bluebook::Chapter] the built, judged chapter
+    # @raise [LoadOutsideBoot] if called outside `Hecks.boot`/`.boot_files`
+    # @raise [Bluebook::DSL::Malformed] if the chapter fails the language's own judgment
     def bluebook(name, version: nil, &)
       collect(:add_bluebook, Bluebook::DSL::BluebookBuilder.build(name, version: version, &))
     end
 
+    # Declares a hecksagon — a `.hecksagon` file's top-level word, binding a
+    # domain's aggregates to adapters.
+    #
+    # @param name [String, Symbol] the domain's name the hecksagon binds
+    # @yield the hecksagon's body, evaluated against a `Bluebook::DSL::HecksagonBuilder`
+    # @return [Bluebook::Hecksagon] the built hecksagon
+    # @raise [LoadOutsideBoot] if called outside `Hecks.boot`/`.boot_files`
     def hecksagon(name, &) = collect(:add_hecksagon, Bluebook::DSL::HecksagonBuilder.build(name, &))
-    # REPOINTED TO DomainPortBuilder — the migration DomainPort's own
+    # Repointed to DomainPortBuilder — the migration DomainPort's own
     # class comment names as its goal, now landed for the top-level
     # `.port` file callers too (the aggregate-scoped `Thing.port(...)`,
     # binding_proxy.rb, already went through this builder). Every real
@@ -115,19 +169,45 @@ module Hecks
     # identity check) — a pure repoint, no behavior change for any
     # existing caller reading `.verb`/`.signal` off what comes back.
     #
-    # `legacy_bare_port: true` — the ONE real semantic gap this repoint
+    # `legacy_bare_port: true` — the one real semantic gap this repoint
     # would otherwise open: `PortBuilder#build` never refused a
     # completely empty build (no verb, no signal even), a real shape
     # dsl_spec.rb's own "a port" tests exercise (`signal`-only, no
     # `verb`). `DomainPortBuilder`'s own "declares no verb and no
-    # operations" refusal is real and correct for its OTHER two callers
+    # operations" refusal is real and correct for its other two callers
     # (`BindingProxy#port`, `HecksagonBuilder#port_impl`) — only this,
     # the literal top-level `.port` file entry point, keeps the older,
     # looser rule (see `DomainPortBuilder#initialize`'s own comment).
     def port(name, &) = collect(:add_port, Bluebook::DSL::DomainPortBuilder.build(name, legacy_bare_port: true, &))
+
+    # Declares an adapter — an `.adapter` file's top-level word.
+    #
+    # @param name [String] the adapter's name
+    # @yield the adapter's body, evaluated against a `Bluebook::DSL::AdapterBuilder`
+    # @return [Bluebook::Adapter] the built, judged adapter
+    # @raise [LoadOutsideBoot] if called outside `Hecks.boot`/`.boot_files`
     def adapter(name, &)   = collect(:add_adapter, Bluebook::DSL::AdapterBuilder.build(name, &))
+
+    # Declares a world — a `.world` file's top-level word, naming a domain's
+    # deployment realm.
+    #
+    # @param name [String, Symbol] the domain's name the world describes
+    # @yield the world's body, evaluated against a `Bluebook::DSL::WorldBuilder`
+    # @return [Bluebook::World] the built, judged world
+    # @raise [LoadOutsideBoot] if called outside `Hecks.boot`/`.boot_files`
     def world(name, &)     = collect(:add_world, Bluebook::DSL::WorldBuilder.build(name, &))
 
+    # Declares a data translation — a `.translation` file's top-level word,
+    # migrating one domain's stored shape from one era to the next.
+    #
+    # @param name [String, Symbol] the domain this translation carries forward
+    # @param from [String, Symbol] the origin era
+    # @param to [String, Symbol] the destination era
+    # @yield the translation's body, evaluated against a
+    #   `Bluebook::DSL::TranslationBuilder`
+    # @return [Bluebook::Translation] the built, judged translation
+    # @raise [LoadOutsideBoot] if called outside `Hecks.boot`/`.boot_files`
+    # @raise [Bluebook::DSL::Malformed] if `name`, `from`, or `to` is empty
     def data_translation(name, from:, to:, &)
       collect(:add_translation, Bluebook::DSL::TranslationBuilder.build(name, from: from, to: to, &))
     end

data/lib/rubocop/cop/hecks/fallback_hash_lookup.rb

@@ -1,11 +1,11 @@
 module RuboCop
   module Cop
     module Hecks
-      # FLAGS THE EXACT SHAPE behind 8+ real bugs already fixed one at a
+      # Flags the exact shape behind 8+ real bugs already fixed one at a
       # time across this codebase (Tiers 1-5): `holder[a] || holder[b]` —
-      # the SAME receiver looked up by two different keys, falling back to
+      # the same receiver looked up by two different keys, falling back to
       # the second lookup whenever the first is falsy. `||` cannot tell a
-      # genuinely STORED `false` from a MISSING key — both are falsy in
+      # genuinely stored `false` from a missing key — both are falsy in
       # Ruby — so a real `false` sitting at `holder[a]` is silently
       # discarded and `holder[b]` (usually absent, so `nil`) is returned
       # instead. Every one of those 8+ instances was the identical
@@ -13,26 +13,30 @@ module RuboCop
       # `h[k.to_sym] || h[k]`, reading a value that could arrive keyed
       # either by symbol or by string off the wire).
       #
-      # THE FIX THIS CODEBASE ALREADY CONVERGED ON — see
+      # ## The fix
+      #
+      # The fix this codebase already converged on — see
       # `lib/hecks/query_specification/field_path.rb#read`, the shared
       # digger this whole bug class got consolidated behind: check
-      # `key?` FIRST, never fall back through `||`.
+      # `key?` first, never fall back through `||`.
       #
       #   sym = segment.to_sym
       #   return current.key?(sym) ? current[sym] : current[segment]
       #
       # That method's own comment says it plainly: "`key?` first, never
       # `||`, because `||` falls through a genuinely-stored `false` to
-      # the OTHER spelling (usually absent) and returns `nil` instead."
-      # This cop exists so the NEXT `holder[a] || holder[b]` gets caught
+      # the other spelling (usually absent) and returns `nil` instead."
+      # This cop exists so the next `holder[a] || holder[b]` gets caught
       # mechanically, before it becomes bug #9, rather than found by
       # hand again in a future audit.
       #
-      # SCOPED TO THE `[]`/`[]` SHAPE ONLY, deliberately — a receiver
+      # ## Scope
+      #
+      # Scoped to the `[]`/`[]` shape only, deliberately — a receiver
       # method-call is compared by AST structure (`==`, which ignores
       # source location), so `hash[a] || hash[b]` is flagged whether
       # `hash` is a local variable, a method call, or a constant, but
-      # `a[k] || b[k]` (DIFFERENT receivers) and `value || default`
+      # `a[k] || b[k]` (different receivers) and `value || default`
       # (an ordinary default, not a second lookup at all) are both left
       # alone — neither one can silently drop a stored `false` the way
       # a same-receiver double-lookup can.
@@ -58,6 +62,10 @@ module RuboCop
         # @!method bracket_lookup(node)
         def_node_matcher :bracket_lookup, "(send $_receiver :[] $_key)"
 
+        # Flags an `a[k] || a[k2]` double bracket-lookup on the same receiver.
+        #
+        # @param node [RuboCop::AST::OrNode] the `||` node being visited
+        # @return [void]
         def on_or(node)
           lhs_receiver, lhs_key = bracket_lookup(node.lhs)
           return unless lhs_receiver
@@ -65,11 +73,11 @@ module RuboCop
           rhs_receiver, rhs_key = bracket_lookup(node.rhs)
           return unless rhs_receiver
 
-          # THE STRUCTURAL EQUALITY CHECK — `==` on an AST node (from the
+          # **The structural equality check** — `==` on an AST node (from the
           # `ast` gem `Node` this compiles down to) compares `type` and
           # `children` recursively and ignores source location, so
           # `hash[a] || hash[b]` matches even though the two `hash`
-          # sub-nodes are two distinct node OBJECTS parsed from two
+          # sub-nodes are two distinct node objects parsed from two
           # different source ranges. A different receiver on each side
           # (`a[k] || b[k]`) fails this check and is correctly left alone.
           return unless lhs_receiver == rhs_receiver

data/lib/rubocop/cop/hecks/sequential_hash_rename_in_loop.rb

@@ -1,47 +1,54 @@
 module RuboCop
   module Cop
     module Hecks
-      # FLAGS `hash[new] = hash.delete(old)` INSIDE A LOOP — a method that
-      # both READS and WRITES the same hash across a loop's iterations,
+      # Flags `hash[new] = hash.delete(old)` inside a loop — a method that
+      # both reads and writes the same hash across a loop's iterations,
       # in the specific rename/permutation shape this codebase has
       # already lost real data to once.
       #
-      # THE BUG THIS IS THE MECHANICAL FOLLOW-UP TO (M27,
+      # ## The bug this follows up on
+      #
+      # The bug this is the mechanical follow-up to (M27,
       # docs/audits/2026-08-10-main-bug-audit.md,
       # docs/audits/2026-08-11-bug-triage.md; fixed in
       # `Hecks::Ports::Persistence::Lineage#apply_renames`,
       # lib/hecks/ports/persistence/plugins/era/lineage.rb): a rename
       # rule set applied one rule at a time, `state[new_name] =
-      # state.delete(old_name)` per rule, against the SAME hash it was
+      # state.delete(old_name)` per rule, against the same hash it was
       # reading from — so a swap (`rename :a, to: :b` alongside `rename
       # :b, to: :a`) on `{a: 1, b: 2}` collapsed to `{a: 1}`. The first
       # rule wrote `b: 1` (clobbering the real `b: 2`) before the second
       # rule ever got a chance to read the value that was supposed to
       # move to `:a` — sequential edits stepping on each other, not the
       # simultaneous permutation a rename set actually means. The same
-      # shape loses data identically for ANY chain longer than one link
+      # shape loses data identically for any chain longer than one link
       # (`a->b->c->a`), not just a two-element swap.
       #
-      # THE FIX THIS COP POINTS AT — snapshot every old key's value
-      # FIRST, delete all old keys, THEN write all new keys, so no
+      # ## The fix this cop points at
+      #
+      # Snapshot every old key's value
+      # first, delete all old keys, then write all new keys, so no
       # rename in the pass ever reads a key this same pass has already
       # written:
       #
-      #   snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]] if state.key?(old_name) }
+      #   snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]]
+      #   if state.key?(old_name) }
       #   snapshot.each { |old_name, _new_name, _value| state.delete(old_name) }
       #   snapshot.each { |_old_name, new_name, value| state[new_name] = value }
       #
-      # WHAT THIS COP DOES NOT ATTEMPT — the general checklist item is
+      # ## What this cop does not attempt
+      #
+      # The general checklist item is
       # broader than any AST pattern can safely automate ("any method
       # that both reads and writes the same collection across a loop"
       # covers plenty of correct code too — accumulating into a result
       # hash, memoizing into a cache). This cop stays narrow and
-      # precise: only the EXACT `recv[x] = recv.delete(y)` shape, same
+      # precise: only the exact `recv[x] = recv.delete(y)` shape, same
       # receiver both sides, inside something that iterates. A single
       # rename outside any loop is not this bug (nothing else can have
       # run first); `hash.store(...)` instead of `hash[...] =`, or
       # `hash.delete(...)` whose result is not immediately written back
-      # into the SAME hash, are not this shape either and are left to
+      # into the same hash, are not this shape either and are left to
       # the broader code-review checklist item, not this cop.
       #
       # @example
@@ -51,7 +58,8 @@ module RuboCop
       #   end
       #
       #   # good — snapshot first, then delete, then write: one permutation
-      #   snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]] if state.key?(old_name) }
+      #   snapshot = renames.filter_map { |old_name, new_name| [old_name, new_name, state[old_name]]
+      #   if state.key?(old_name) }
       #   snapshot.each { |old_name, _new_name, _value| state.delete(old_name) }
       #   snapshot.each { |_old_name, new_name, value| state[new_name] = value }
       class SequentialHashRenameInLoop < Base
@@ -82,6 +90,10 @@ module RuboCop
           (send $_recv :[]= _new_key (send $_recv2 :delete _old_key))
         PATTERN
 
+        # Flags a `recv[new] = recv.delete(old)` write inside a loop, same receiver both sides.
+        #
+        # @param node [RuboCop::AST::SendNode] the `[]=` send node being visited
+        # @return [void]
         def on_send(node)
           rename_write?(node) do |recv, recv2|
             next unless same_receiver?(recv, recv2)

data/lib/rubocop/cop/hecks/thread_shared_ivar_mutation.rb

@@ -1,7 +1,7 @@
 module RuboCop
   module Cop
     module Hecks
-      # FLAGS PLAIN `@ivar` MUTATION inside a class this codebase already
+      # Flags plain `@ivar` mutation inside a class this codebase already
       # knows is a thread-shared singleton — one `Dispatcher`/`Registry`
       # instance lives for the life of a boot and is dispatched through
       # from every thread of a Puma worker pool (or any other multi-
@@ -9,29 +9,35 @@ module RuboCop
       # shared, mutable state with no per-thread or mutex-guarded
       # isolation at all.
       #
-      # THIS IS THE MECHANICAL FOLLOW-UP to a real bug already fixed here
+      # ## The bug this follows up on
+      #
+      # This is the mechanical follow-up to a real bug already fixed here
       # (see `dispatcher.rb`'s own `#reenter` comment, and
-      # `spec/runtime/dispatcher_spec.rb`): `@reaction_depth` used to be a
-      # plain ivar on `Dispatcher`, so two threads' concurrent top-level
-      # dispatches corrupted each other's view of "how deep into a
+      # `spec/runtime/dispatcher_spec.rb`): a plain `@reaction_depth` ivar on
+      # `Dispatcher` let two threads' concurrent top-level
+      # dispatches corrupt each other's view of "how deep into a
       # reaction cascade am I". The fix moved that one ivar to
       # `Thread.current[:hecks_reaction_depth]`. This cop exists so the
-      # NEXT plain ivar someone adds to either class gets flagged before
+      # next plain ivar someone adds to either class gets flagged before
       # it becomes the next instance of the same bug, rather than after.
       #
-      # SCOPED NARROWLY ON PURPOSE — by class name
+      # ## Scoped narrowly on purpose
+      #
+      # By class name
       # (`Hecks::Runtime::Dispatcher`/`Hecks::Runtime::Registry`), not by
       # blanket-flagging every ivar mutation in the codebase. Most classes
-      # in this codebase are NOT shared across threads (a fresh value
+      # in this codebase are not shared across threads (a fresh value
       # object per call, a builder used once at boot) and ivar mutation
       # there is completely ordinary Ruby with no hazard behind it at
       # all — flagging it everywhere would be noise nobody trusts, the
       # same reasoning `.rubocop.yml`'s own header gives for every other
       # cop in this repo.
       #
-      # WHAT COUNTS AS "PLAIN": `@ivar = ...`, `@ivar ||= ...`, `@ivar +=
+      # ## What counts as "plain"
+      #
+      # `@ivar = ...`, `@ivar ||= ...`, `@ivar +=
       # ...`, `@ivar << ...`, `@ivar[k] = v`. `initialize` is exempt — an
-      # ivar being SET UP for the first time, before any other thread can
+      # ivar being set up for the first time, before any other thread can
       # possibly hold a reference to this object, is not the hazard (see
       # `Registry#initialize`'s own `@saga_mutex = Mutex.new`, which this
       # cop must not flag). `Thread.current[...]`-backed state and a
@@ -67,9 +73,13 @@ module RuboCop
 
         RESTRICT_ON_SEND = [:<<, :[]=].freeze
 
+        # Flags a plain `@ivar = ...` assignment inside a thread-shared class.
+        #
+        # @param node [RuboCop::AST::IvasgnNode] the ivar-assignment node being visited
+        # @return [void]
         def on_ivasgn(node)
-          # A PLAIN `@x = 1` parses as `(ivasgn :@x (int 1))` — two
-          # children. The commissioner also visits the BARE `(ivasgn :@x)`
+          # A plain `@x = 1` parses as `(ivasgn :@x (int 1))` — two
+          # children. The commissioner also visits the bare `(ivasgn :@x)`
           # node nested one level inside an `op_asgn`/`or_asgn` (`@x += 1`,
           # `@x ||= 1`) as its own `ivasgn` node with only one child — that
           # one is handled by `on_op_asgn`/`on_or_asgn` below instead, so
@@ -79,9 +89,14 @@ module RuboCop
           check(node, node.children.first)
         end
 
+        # Flags a plain `@ivar += ...` (or similar) compound assignment inside a
+        # thread-shared class.
+        #
+        # @param node [RuboCop::AST::OpAsgnNode] the compound-assignment node being visited
+        # @return [void]
         def on_op_asgn(node)
           # `@x += 1` parses as `(op_asgn (ivasgn :@x) :+ (int 1))` — the
-          # target is an `ivasgn` node carrying JUST the name (no value
+          # target is an `ivasgn` node carrying just the name (no value
           # child, unlike a plain `@x = 1`), not an `ivar` node.
           ivar_node = node.children.first
           return unless ivar_node.is_a?(RuboCop::AST::Node) && ivar_node.ivasgn_type?
@@ -89,17 +104,26 @@ module RuboCop
           check(node, ivar_node.children.first)
         end
 
+        # Flags a plain `@ivar ||= ...` assignment inside a thread-shared class.
+        #
+        # @param node [RuboCop::AST::OrAsgnNode] the `||=` assignment node being visited
+        # @return [void]
         def on_or_asgn(node)
           on_op_asgn(node)
         end
 
+        # Flags a plain `@ivar << ...` or `@ivar[k] = v` mutation inside a thread-shared
+        # class.
+        #
+        # @param node [RuboCop::AST::SendNode] the `<<` or `[]=` send node being visited
+        # @return [void]
         def on_send(node)
           return unless RESTRICT_ON_SEND.include?(node.method_name)
 
           receiver = node.receiver
           return unless receiver
 
-          # `@ivar << x` — the receiver IS the ivar.
+          # `@ivar << x` — the receiver is the ivar.
           # `@ivar[k] = v` — the receiver is a `send(@ivar, :[], k)`, whose
           # own receiver is the ivar (`node.receiver.receiver`).
           ivar_node = if receiver.ivar_type?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Chris Young
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -55,6 +55,8 @@ files:
 - lib/hecks/adapters/driven/identity_registry.adapter
 - lib/hecks/adapters/driven/identity_registry.rb
 - lib/hecks/adapters/driven/in_memory_ordering.rb
+- lib/hecks/adapters/driven/in_process_key_vault.adapter
+- lib/hecks/adapters/driven/in_process_key_vault.rb
 - lib/hecks/adapters/driven/lambda.adapter
 - lib/hecks/adapters/driven/lambda.rb
 - lib/hecks/adapters/driven/lambda/client.rb
@@ -83,6 +85,8 @@ files:
 - lib/hecks/adapters/driven/sqlite/schema_builder.rb
 - lib/hecks/adapters/driven/system_clock.adapter
 - lib/hecks/adapters/driven/system_clock.rb
+- lib/hecks/adapters/driven/tenant_provisioner.adapter
+- lib/hecks/adapters/driven/tenant_provisioner.rb
 - lib/hecks/adapters/driving/github_webhook.rb
 - lib/hecks/behaviors.rb
 - lib/hecks/behaviors/dsl.rb
@@ -114,6 +118,7 @@ files:
 - lib/hecks/bluebook/behaviour/read_model.rb
 - lib/hecks/bluebook/behaviour/traits.rb
 - lib/hecks/bluebook/behaviour/value_object.rb
+- lib/hecks/bluebook/capabilities.rb
 - lib/hecks/bluebook/chapter.rb
 - lib/hecks/bluebook/command.rb
 - lib/hecks/bluebook/domain_port.rb
@@ -125,6 +130,7 @@ files:
 - lib/hecks/bluebook/dsl/binding_proxy.rb
 - lib/hecks/bluebook/dsl/bluebook_builder.rb
 - lib/hecks/bluebook/dsl/bluebook_builder/validation.rb
+- lib/hecks/bluebook/dsl/bootstrap_table.rb
 - lib/hecks/bluebook/dsl/command_builder.rb
 - lib/hecks/bluebook/dsl/const_shim.rb
 - lib/hecks/bluebook/dsl/domain_port_builder.rb
@@ -183,6 +189,7 @@ files:
 - lib/hecks/bluebook/value_object.rb
 - lib/hecks/codemod.rb
 - lib/hecks/construct.rb
+- lib/hecks/corpus.rb
 - lib/hecks/deploy/bluebook/deploy.bluebook
 - lib/hecks/deploy/bluebook/deploy.hecksagon
 - lib/hecks/deploy/oidc.json
@@ -220,15 +227,22 @@ files:
 - lib/hecks/framework/bluebook/framework.hecksagon
 - lib/hecks/framework/bluebook/governance.bluebook
 - lib/hecks/framework/bluebook/identity.bluebook
+- lib/hecks/framework/bluebook/privacy.bluebook
 - lib/hecks/framework/oidc.json
 - lib/hecks/freezer.rb
 - lib/hecks/fuzzing.rb
 - lib/hecks/fuzzing/bounded_exhaustive_expressions.rb
+- lib/hecks/fuzzing/combination_miner.rb
 - lib/hecks/fuzzing/concurrent_dispatch.rb
+- lib/hecks/fuzzing/coverage_campaign.rb
+- lib/hecks/fuzzing/differential.rb
+- lib/hecks/fuzzing/domain_generator.rb
 - lib/hecks/fuzzing/era_boundary.rb
 - lib/hecks/fuzzing/form_census.rb
+- lib/hecks/fuzzing/generated_domain_check.rb
 - lib/hecks/fuzzing/invalid_value_generator.rb
 - lib/hecks/fuzzing/isolated_boot.rb
+- lib/hecks/fuzzing/nondeterministic.rb
 - lib/hecks/fuzzing/persistence_parity.rb
 - lib/hecks/fuzzing/properties.rb
 - lib/hecks/fuzzing/properties/corrections.rb
@@ -238,8 +252,10 @@ files:
 - lib/hecks/fuzzing/properties/lifecycle_and_replay.rb
 - lib/hecks/fuzzing/properties/outbox.rb
 - lib/hecks/fuzzing/properties/querying.rb
+- lib/hecks/fuzzing/qa_settings.rb
 - lib/hecks/fuzzing/replay.rb
 - lib/hecks/fuzzing/rotation_priority.rb
+- lib/hecks/fuzzing/rust_gap_manifest.rb
 - lib/hecks/fuzzing/self_consistency.rb
 - lib/hecks/fuzzing/sequence_generator.rb
 - lib/hecks/fuzzing/sequence_generator/adversary.rb
@@ -247,6 +263,7 @@ files:
 - lib/hecks/fuzzing/sequence_generator/outcome_tracker.rb
 - lib/hecks/fuzzing/sequence_generator/picker.rb
 - lib/hecks/fuzzing/sequence_generator/step_builder.rb
+- lib/hecks/fuzzing/shrinker.rb
 - lib/hecks/fuzzing/structural_skips.rb
 - lib/hecks/fuzzing/sweep_depth.rb
 - lib/hecks/fuzzing/target_capabilities.rb
@@ -305,12 +322,15 @@ files:
 - lib/hecks/ports/identity_generation.rb
 - lib/hecks/ports/identity_resolution.port
 - lib/hecks/ports/identity_resolution.rb
+- lib/hecks/ports/key_vault.port
+- lib/hecks/ports/key_vault.rb
 - lib/hecks/ports/loading.port
 - lib/hecks/ports/loading.rb
 - lib/hecks/ports/persistence.port
 - lib/hecks/ports/persistence.rb
 - lib/hecks/ports/persistence/append_only.rb
 - lib/hecks/ports/persistence/binding_policy.rb
+- lib/hecks/ports/persistence/codec_boundary.rb
 - lib/hecks/ports/persistence/execution.rb
 - lib/hecks/ports/persistence/null_saga_store.rb
 - lib/hecks/ports/persistence/plugin.rb
@@ -350,12 +370,14 @@ files:
 - lib/hecks/ports/persistence/plugins/era/translation/scaffold/writer.rb
 - lib/hecks/ports/persistence/remote_runtime.rb
 - lib/hecks/ports/persistence/repository_factory.rb
+- lib/hecks/ports/persistence/state_codec.rb
 - lib/hecks/ports/projection.port
 - lib/hecks/ports/projection.rb
 - lib/hecks/ports/query.rb
 - lib/hecks/ports/query/in_memory.rb
 - lib/hecks/ports/query/ordering.rb
 - lib/hecks/projections.rb
+- lib/hecks/projections/bootstrap_table.rb
 - lib/hecks/projections/diagrams.rb
 - lib/hecks/projections/glossary.rb
 - lib/hecks/projections/glossary/html.rb
@@ -371,6 +393,7 @@ files:
 - lib/hecks/projections/oidc.rb
 - lib/hecks/projections/parser_table.rb
 - lib/hecks/projections/reference.rb
+- lib/hecks/projections/rust_vocabulary.rb
 - lib/hecks/projections/shape.rb
 - lib/hecks/projections/statements.rb
 - lib/hecks/projections/vocabulary.rb
@@ -426,6 +449,7 @@ files:
 - lib/hecks/runtime/identity.rb
 - lib/hecks/runtime/instance.rb
 - lib/hecks/runtime/interpreting.rb
+- lib/hecks/runtime/invocation.rb
 - lib/hecks/runtime/loader.rb
 - lib/hecks/runtime/outbox.rb
 - lib/hecks/runtime/policy_interpreter.rb
@@ -452,6 +476,8 @@ files:
 - lib/hecks/runtime/value/entity_list_coercion.rb
 - lib/hecks/runtime/value/invariant_violation.rb
 - lib/hecks/storehouse.rb
+- lib/hecks/tenancy/bluebook/tenancy.bluebook
+- lib/hecks/tenancy/bluebook/tenancy.hecksagon
 - lib/hecks/version.rb
 - lib/hecks/vocabulary.rb
 - lib/rubocop/cop/hecks/fallback_hash_lookup.rb