hecks 2.8.0 → 2.9.0

data/lib/hecks/adapters/driven/heki.rb

@@ -35,12 +35,9 @@ module Hecks
         @aggregate = aggregate
         @path      = resolve_path(settings, root)
         @journal_path = "#{@path}.journal"
-        @events    = []
-        # The optional saga-persistence capability's own scoping (§2/§4)
-        # — falls back to the aggregate's own name for a directly-
-        # instantiated adapter (specs), same fallback shape Postgres's
-        # own @domain already uses.
-        @domain    = (
+        @events = []
+        # Saga scope; falls back to the aggregate's name for a directly built adapter.
+        @domain = (
           if settings.key?(:domain)
             settings[:domain]
           elsif settings.key?("domain")
@@ -81,13 +78,7 @@ module Hecks
 
       # Answers a declared query specification against the projected records.
       #
-      # `registry: context[:registry]` — Memory's own `query` already
-      # threads this through; Heki's own never did, which made
-      # `none_in_state?` (Ports::Query::InMemory) unconditionally
-      # return `true` (its own graceful "no registry, no way to look
-      # the target up" default) for every `none_in_state` where-clause
-      # against a Heki-backed aggregate — silently excluding nothing,
-      # always, no matter the actual target state.
+      # The registry is passed through so `none_in_state` clauses can look up their target.
       #
       # @param specification [QuerySpecification::Common::Options,
       #   Bluebook::Behaviour::ReadModel::FilteredOptions] the declared query specification
@@ -113,17 +104,11 @@ module Hecks
 
       # Applies one journaled entry to the current-state snapshot.
       #
-      # Reads fresh rather than trusting the memoized `store` — under
-      # `with_lock`, another process may have projected a snapshot since
-      # this one last read it, and mutating *its* stale copy would
-      # overwrite that write on disk rather than layer on top of it.
+      # Reads fresh, not the memoized `store`: another process may have projected since,
+      # and a stale copy would overwrite that write.
       #
-      # On a delete, though, the record `current.delete` finds is already
-      # gone: every caller (`#delete` above, `AppendOnly#delete`) appends
-      # before it projects, so the fresh read above has already replayed
-      # this very entry off the journal. What the memoized `store` last
-      # held — from before this call — is read up front, for the return
-      # value only; it plays no part in what gets written.
+      # On a delete the fresh read has already replayed the entry, so the returned record
+      # comes from the memoized `store`, read up front.
       #
       # @param entry [Persistence::Entry] the save or delete to materialize
       # @return [Runtime::Instance, nil] on a save, the newly stored record; on a delete, the
@@ -178,10 +163,7 @@ module Hecks
       # @return [Array<Runtime::Event>] the adapter's in-memory event log, including `event`
       def record_event(event) = @events << event
 
-      # ── the optional saga-persistence capability (§2) — Heki's own
-      # shape (a sibling snapshot+journal file pair, `SagaStore`,
-      # heki/saga_store.rb) rather than a table in a store this adapter
-      # doesn't have.
+      # Checkpoints one saga instance in a sibling file pair (`SagaStore`).
       #
       # @param process_manager [String, Symbol] the process manager's name, compared as
       #   `.to_s`
@@ -209,18 +191,15 @@ module Hecks
         saga_store.delete_saga(@domain, process_manager.to_s, correlation.to_s)
       end
 
-      # Yields every checkpointed saga instance of this domain, for `Registry
-      # #rehydrate_sagas!` to restore at boot.
+      # Yields every checkpointed saga instance of this domain, for boot-time rehydration.
       #
       # @yieldparam process_manager [String] the process manager's name
       # @yieldparam correlation [String] the instance's correlation value
       # @yieldparam state [String] the saga's state name
       # @yieldparam memory [Hash{Symbol => Object}] the saga's memory, Symbol keys at every
       #   depth
-      # @yieldparam completed_compensations [Array] the completed-compensation ledger, `[]`
-      #   when none was recorded
-      # @return [Enumerator, Hash{String => Hash}] an enumerator over the same five values
-      #   when no block is given; otherwise `SagaStore`'s internal records Hash
+      # @yieldparam completed_compensations [Array] the completed-compensation ledger
+      # @return [Enumerator, Hash{String => Hash}] an enumerator when no block is given
       def each_saga(&) = saga_store.each_saga(@domain, &)
 
       private
@@ -229,8 +208,6 @@ module Hecks
         @saga_store ||= SagaStore.new(File.dirname(@path))
       end
 
-      # `record` is the snapshot/journal's own string-keyed JSON — decoded
-      # deep through the state codec, never symbolized one level by hand.
       def instance(id, record)
         Runtime::Instance.new(
           aggregate: @aggregate,
@@ -248,13 +225,7 @@ module Hecks
         replay_journal(snapshot)
       end
 
-      # `dir: :default` — a bare Symbol, the framework's own convention
-      # for "a declared value that resolves by convention, never a silent
-      # fallback" — would otherwise crash `File.join` outright
-      # (`TypeError: no implicit conversion of Symbol into String`):
-      # `resolve_path` only ever checked for a missing `dir` setting,
-      # never a Symbol one. Treated the same as no setting at all — falls
-      # back to the existing "data" default, not a new special case.
+      # `dir: :default` means no setting; a Symbol would make `File.join` raise TypeError.
       def resolve_path(settings, root)
         declared =
           if settings.key?(:dir)

data/lib/hecks/adapters/driven/identity_registry.rb

@@ -1,22 +1,13 @@
 module Hecks
   module Adapters
-    # The `identity_resolution` port, fulfilled by the Identity framework
-    # bluebook — same registry, same boot, so this is a dispatch against
-    # records already sitting in the store this adapter is handed, not a
-    # bridge to a second runtime. Same reasoning `GovernanceAuthorization`
-    # gives for itself, one port over.
+    # The `identity_resolution` port, fulfilled by the Identity framework bluebook
+    # through a dispatch on the same registry.
     module IdentityRegistry
       module_function
 
       # Looks up the id of the identity an authenticated (issuer, subject) pair is linked to,
       # querying the Identity framework bluebook's own `ResolvedBy`.
       #
-      # `nil` for a pair nothing has linked, the first match otherwise —
-      # `ResolvedBy` is a lookup by the exact (issuer, subject) an
-      # authenticated token carries, not a listing, so more than one row
-      # would mean two links share a pair, which `Link`'s own natural
-      # key already prevents by construction.
-      #
       # @param registry [Runtime::Registry] the booted registry, queried for the linked
       #   identity's id
       # @param issuer [String] the OIDC issuer that authenticated the caller, compared as a
@@ -24,9 +15,7 @@ module Hecks
       # @param subject [String] the OIDC subject the issuer vouches for, compared as a String
       # @return [String, nil] the linked identity's id, or nil if nothing has linked this pair
       def resolve(registry, issuer:, subject:)
-        # The resolve verb this registry's declared identity provider names
-        # (`provides "identity", resolve:`), never a hard-coded chapter —
-        # same declared-not-named shape GovernanceAuthorization already holds.
+        # The verb comes from the declared identity provider (`provides "identity", resolve:`).
         provider = registry.bluebooks.values.find { |chapter| chapter.provides?(::Hecks::Bluebook::Capabilities::IDENTITY) }
         verb = provider&.provided_verb(::Hecks::Bluebook::Capabilities::IDENTITY, :resolve) ||
                "Identity::ExternalIdentifier.ResolvedBy"

data/lib/hecks/adapters/driven/in_memory_ordering.rb

@@ -6,32 +6,20 @@ require_relative "../../runtime/errors"
 
 module Hecks
   module Adapters
-    # Shared by every adapter that holds decoded Ruby records rather than
-    # running real SQL (Memory, Lambda, Heki) — the identical dotted-path
-    # value-object member-picking Postgres/Sqlite/D1's own
-    # order_expression does (numeric member wins, else the one-field
-    # convention "value"), just walked in Ruby instead of compiled to a
-    # JSONB/json_extract path, because there is no query engine
-    # underneath any of these three to hide that walk inside.
+    # Ordering for adapters that hold decoded Ruby records (Memory, Lambda, Heki),
+    # mirroring the SQL adapters' value-object member picking.
     module InMemoryOrdering
       module_function
 
-      # Orders decoded records by a declared attribute, then by id as the total-order
-      # tiebreaker.
+      # Orders decoded records by a declared attribute, then by id as the tiebreaker.
       #
-      # order_by is a runtime value (an HTTP query param, in the
-      # console's case), not framework-authored bluebook source — see
-      # postgres.rb's own all for the full reasoning. Whitelisted the
-      # identical way before FieldPath.dig ever runs.
+      # `order_by` may come from an HTTP query param, so it is checked before `FieldPath.dig`.
       #
       # @param records [Array<Runtime::Instance>] the records to order
-      # @param aggregate [Bluebook::Aggregate] the aggregate `records` belong to, checked for
-      #   `order_by`'s attribute
-      # @param order_by [String, Symbol, nil] a dotted attribute path to sort by; nil returns
-      #   `records` unchanged
+      # @param aggregate [Bluebook::Aggregate] the aggregate `records` belong to
+      # @param order_by [String, Symbol, nil] a dotted attribute path; nil returns `records` as-is
       # @param direction [Symbol] `:asc` or `:desc`
-      # @return [Array<Runtime::Instance>] `records`, ordered by `order_by` then id; unchanged
-      #   when `order_by` is nil
+      # @return [Array<Runtime::Instance>] `records`, ordered by `order_by` then id
       # @raise [Runtime::WiringError] if `order_by` names no attribute of `aggregate` and is
       #   not its lifecycle field
       def ordered(records, aggregate:, order_by:, direction:)
@@ -68,13 +56,8 @@ module Hecks
         vo = aggregate.value_object(attribute.type)
         return field.to_s unless vo
 
-        # Numeric member first, then the sole attribute whatever it is
-        # named (single-attribute value objects strictly answer `.value`
-        # — the same generalization `SqlQueryBuilder#query_expression`
-        # makes for the column side, kept in lockstep so Memory and SQL
-        # order the identical rows identically), and only then the bare
-        # `value` convention — now purely a backstop for the multi-field
-        # non-numeric shape neither rule can honestly pick a field for.
+        # Numeric member, else the sole attribute, else `value`; kept in lockstep with
+        # `SqlQueryBuilder#query_expression` so Memory and SQL order rows identically.
         member = vo.attributes.find { |a| %w[Integer Float].include?(a.type) }&.name ||
                  vo.sole_attribute&.name || "value"
         "#{name}.#{member}"

data/lib/hecks/adapters/driven/in_process_key_vault.rb

@@ -2,20 +2,8 @@ require "securerandom"
 
 module Hecks
   module Adapters
-    # The real `key_vault` fulfillment for a single running process — a
-    # table of key material, keyed by an opaque reference never exposed to
-    # a bluebook or an event. Cryptoshredding only works if the key
-    # genuinely leaves memory when destroyed: `destroy` deletes the Hash
-    # entry outright, not merely a flag, so a `fetch` afterward has
-    # nothing left to decrypt with.
-    #
-    # **Not crash-durable** — a process restart loses every key this
-    # adapter ever issued, along with every ciphertext under it. A
-    # deployment that needs destruction to survive a restart (or to leave
-    # a physical-destruction audit trail) backs this port with a real
-    # `KMS` or `HSM` instead; this default asks for nothing external to
-    # run, the same tradeoff `SecureRandomIdentity` already makes for
-    # identity minting.
+    # In-process `key_vault` fulfillment: key material held under opaque references.
+    # Not crash-durable; use a KMS or HSM when destruction must survive a restart.
     module InProcessKeyVault
       module_function
 

data/lib/hecks/adapters/driven/lambda/client.rb

@@ -3,48 +3,13 @@ require "json"
 module Hecks
   module Adapters
     class Lambda
-      # **The thin AWS client** — shared by this adapter's own read methods
-      # (Lambda#find/#all/#count/#query) and Runtime::RemoteDispatcher's
-      # write methods. One Lambda invoke, one JSON round trip, nothing
-      # domain-specific: neither caller needs to know an AWS SDK is
-      # involved at all.
+      # The thin AWS client shared by this adapter's read methods and
+      # Runtime::RemoteDispatcher's writes: one Lambda invoke, one JSON round trip.
       #
-      # ## Resolving the function name
-      #
-      # Function name is computed unless it is named — `"hecks-#{domain}"`,
-      # lowercased, matches bin/project_deploy's own `stack_name`
-      # exactly (bin/project_deploy: `stack_name = "hecks-#{domain_name}"`,
-      # `domain_name = File.basename(domain)`). `domain` here is the
-      # bluebook's own declared name (`Embryonaut`, not the directory);
-      # today's real corpus has directory name == declared name
-      # lowercased for every domain that deploys, so `.downcase` alone
-      # reproduces the same string bin/project_deploy computes from the
-      # directory.
-      #
-      # ## When the assumption breaks
-      #
-      # That assumption is not always true, and when it breaks nothing
-      # about it is recoverable from here. `bin/project_deploy` honours
-      # a `.world`'s own `stack_prefix`/`stack_name` — settings that
-      # exist precisely so a domain whose AWS identity predates a rename
-      # keeps targeting the stack that is actually live rather than
-      # standing up a second, empty one beside it. A real one:
-      # a client site deploys under a fixed stack name, and no
-      # value of `domain` (or of `DOMAIN_NAME`, the deployed-Lambda
-      # override callers already pass) can make this computation produce
-      # a name with no dash after "hecks". Every Ruby-side read and
-      # dispatch for that app has therefore been invoking a function
-      # that does not exist — found live, and visible in the deployed
-      # journal having never received a single row.
-      #
-      # ## Naming it explicitly
-      #
-      # So the name can be named, in the one place the rest of this
-      # deployment is already described: the `.world`'s own
-      # `persisted_by("Lambda")`/`dispatched_by("Lambda")` block, beside
-      # `region`. Given, it wins outright; absent, the computation above
-      # is unchanged, which is every domain whose stack name was never
-      # pinned.
+      # The function name defaults to `"hecks-#{domain.downcase}"`, matching
+      # `bin/project_deploy`'s `stack_name` computation. A domain whose stack
+      # name doesn't follow that pattern must pass `function` explicitly, via
+      # a `.world`'s `persisted_by("Lambda")`/`dispatched_by("Lambda")` block.
       class Client
         # @param domain [String, Symbol] the bluebook's own declared domain name; computes
         #   the function name when `function` is not given
@@ -58,20 +23,14 @@ module Hecks
           @client = Aws::Lambda::Client.new(region: region)
         end
 
-        # The function this client actually invokes — read by
-        # `Runtime::WiringError` messages and worth asserting on
-        # directly, since "which function did we call" is otherwise
-        # unanswerable from outside.
+        # The function this client actually invokes; used in `Runtime::WiringError`
+        # messages and worth asserting on directly in tests.
         attr_reader :function_name
 
         # Reads the whole domain's current state and event log from the remote function.
         #
-        # **The whole domain, every time** — matches dispatch::read's own
-        # rehydrate-the-full-journal design (Phase 1, rust/host). No
-        # caching here, deliberately: memoizing this across calls once
-        # silently served stale reads for a warm web process's whole
-        # lifetime after a write happened elsewhere — see Lambda#instances's
-        # own comment on the real, live bug that caught it.
+        # No caching here, deliberately: a memoized read would go stale the
+        # moment a write happens elsewhere in a long-lived process.
         #
         # @return [Hash{String => Object}] the parsed JSON response; the deployed function's
         #   own top-level keys (`"instances"`, `"events"`, …)

data/lib/hecks/adapters/driven/lambda.rb

@@ -6,24 +6,8 @@ require_relative "../../runtime/instance"
 
 module Hecks
   module Adapters
-    # **The read-side half of lambda routing** — `persisted_by("Lambda")`'s
-    # own adapter, resolved through the same `Ports::Persistence`
-    # machinery `persisted_by("Postgres")`/`persisted_by("Memory")`
-    # already use (`Runtime::Registry#repository`, `RepositoryFactory
-    # .build`) — no new framework plumbing, just a new adapter class at
-    # the name the existing lookup already expects. See
-    # `Runtime::RemoteDispatcher` for the write-side half; the two
-    # compose through one shared `Client` per domain rather than each
-    # inventing its own AWS wiring.
-    #
-    # **Read-only, deliberately** — `append`/`project` raise rather than
-    # silently no-op. A write reaching this class would mean
-    # `Runtime::CommandInterpreter` ran locally against a Lambda-routed
-    # domain, which is exactly the bypass `Runtime::RemoteDispatcher`
-    # exists to prevent (business-rule validation must happen in Rust
-    # for these domains, not be pre-computed here against an
-    # incomplete local view). A loud failure here is the correct
-    # outcome, not a bug to route around.
+    # Read-side adapter for `persisted_by("Lambda")`; writes go through Runtime::RemoteDispatcher.
+    # Read-only: `append`/`project` raise, since a local write would bypass remote validation.
     class Lambda
       include Ports::Persistence::RemoteRuntime
 
@@ -50,41 +34,11 @@ module Hecks
             aggregate.name
           end
         region = setting(settings, :region, "us-east-1")
-        # Named, when this deployment's function isn't `hecks-<domain>`
-        # — `Client`'s own comment has the real case that needs it.
-        # Absent (every domain whose stack name was never pinned), the
-        # computation below is exactly as it was.
+        # Explicit function name, for deployments whose function is not `hecks-<domain>`.
         function = setting(settings, :function, nil)
-        # Two different "domain"s, deliberately not conflated: `domain`
-        # (this aggregate's own bluebook name — "Identity", "Governance")
-        # only ever prefixes the instances lookup, since that's how
-        # rust/host's own `Store::instances()` keys every record
-        # (`registry.rb`'s own `"#{a[:domain_name]}::#{a[:name]}#"`
-        # dump format, unchanged by which chapter attached it). The
-        # function to actually call is a different question: Governance
-        # and Identity aggregates are compiled into the attaching
-        # domain's own Lambda (one merged `Store` per target — Phase 0's
-        # framework-bluebook work), never a function of their own, so
-        # `settings[:domain]` is the wrong signal for `Client.new`.
-        # `root` is the boot's own directory (`Registry#root`, shared by
-        # every bluebook in one registry regardless of which one
-        # attached it) — `File.basename(root)` reproduces the exact
-        # same string `bin/project_deploy`'s own `stack_name` computes
-        # from the domain path, so the two can never name two
-        # different functions for the same deploy... on a local boot,
-        # where `root` is a real project directory. Inside the deployed
-        # Lambda itself `root` is always `/var/task` (every Lambda's own
-        # fixed code root, regardless of domain) — `File.basename` gives
-        # "task", not the domain name, and invokes the wrong function
-        # entirely. A real, live AccessDeniedException on
-        # "hecks-task" caught this: invisible through every earlier
-        # phase's own verify step, all run from a local boot, until
-        # WebFunction became the first Ruby process to ever make this
-        # exact call from inside a deployed Lambda. `DOMAIN_NAME` (set
-        # by bin/project_deploy's own WebFunction Environment) is the
-        # real, unambiguous signal in that specific context; the
-        # root-basename heuristic stays as the local-boot fallback,
-        # unchanged.
+        # `domain` only prefixes the instances lookup; the function to call is named by
+        # DOMAIN_NAME (set in a deployed Lambda, where root is always /var/task), else by
+        # root's basename, which matches bin/project_deploy's stack name on a local boot.
         function_domain = ENV["DOMAIN_NAME"] || (root ? File.basename(root) : domain)
         @client = Client.new(domain: function_domain, region: region, function: function)
         @prefix = "#{domain}::#{aggregate.hecks_name}#"
@@ -128,21 +82,9 @@ module Hecks
         Ports::Query::InMemory.execute(instances.values, specification, args)
       end
 
-      # `entries`/`append`/`project` — the append-only contract
-      # `Ports::Persistence::AppendOnly` requires of every adapter
-      # (raises at construction if any are missing). Answered by
-      # `Ports::Persistence::RemoteRuntime`, included above: `entries` is
-      # `[]` unconditionally (Lambda's own Postgres is already the
-      # durable store — rust/host's rehydrate-and-replay journal, Phase
-      # 1 — there is no local write-ahead log for `recover!` to replay),
-      # `append`/`project` raise rather than silently no-op.
-
       # Reads a world setting under either a Symbol or a String key, with a fallback.
       #
-      # A `.world` block's settings arrive symbol-keyed from the DSL and
-      # string-keyed from a round-tripped export, so every read has to
-      # accept both — one helper rather than the same five lines per
-      # key.
+      # Settings arrive symbol-keyed from the DSL and string-keyed from a round-tripped export.
       #
       # @param settings [Hash] the world settings Hash to read from
       # @param key [Symbol] the setting name, tried as itself and as `key.to_s`
@@ -157,21 +99,8 @@ module Hecks
 
       private
 
-      # Re-fetched every call, deliberately not memoized across them —
-      # this adapter itself is long-lived (one instance per aggregate,
-      # held by the registry `RUNTIME = Hecks.boot(...)` builds once
-      # per Lambda web process — WebFunction's own top-level constant,
-      # reused warm across every HTTP request that process serves, not
-      # rebuilt per request the way memoizing here would wrongly assume).
-      # A real, live bug caught this: a mutation
-      # dispatched fine (RemoteDispatcher always calls the dispatch
-      # Lambda fresh) and the very next `.all` on the same warm
-      # container kept returning the state from before that mutation,
-      # forever, until the container cold-started — memoizing here
-      # made every write invisible to every read on a warm container.
-      # Keyed by bare id (the part after "Domain::Aggregate#"), not the
-      # full "Domain::Aggregate#id" string — callers already know which
-      # aggregate they're asking this instance about.
+      # Never memoized: the adapter outlives requests on a warm container, so a cached read
+      # would hide every later write. Keyed by the bare id after "Domain::Aggregate#".
       def instances
         @client.read.fetch("instances", {}).filter_map do |key, state|
           next unless key.start_with?(@prefix)
@@ -180,10 +109,7 @@ module Hecks
         end.to_h
       end
 
-      # Lambda's own JSON response is already Ruby-decoded with string
-      # keys (plain `JSON.parse`, no `symbolize_names:`) — decoded through
-      # the state codec (PR A3), the same IR-driven spelling every other
-      # adapter's read produces.
+      # The response is string-keyed JSON; the state codec decodes it as every adapter's read does.
       def build_instance(id, state)
         Runtime::Instance.new(aggregate: @aggregate, id: id, state: Ports::Persistence::StateCodec.decode(@aggregate, state))
       end

data/lib/hecks/adapters/driven/local_storage.rb

@@ -5,36 +5,10 @@ require_relative "../../runtime/instance"
 
 module Hecks
   module Adapters
-    # **A browser-hosted domain's own declared intent** — not a second Memory
-    # wearing a different name. Ruby has no way to reach a real browser's
-    # `window.localStorage` at all (it is per-tab, per-origin, JS-only,
-    # unreachable over any network the way D1's own REST API is) — so
-    # this Ruby-side adapter is honestly a stand-in: in-process, ephemeral,
-    # mechanically identical to Memory. What earns it a name of its own
-    # is what it declares, not what it happens to do in Ruby: `persisted_by
-    # "LocalStorage"` says "this domain expects real, durable, single-
-    # device storage the moment it's actually running where it's meant to
-    # run" — the same distinction Heki (real local durability) already
-    # draws against Memory (deliberately ephemeral, test/example-only),
-    # one adapter over. `bin/console`, the fuzzer, `spec/`, `bin/
-    # model_check` all get a domain that boots and behaves correctly
-    # against this adapter; only a real browser gets the real durability.
-    #
-    # The real browser half lives outside this file entirely: `rust/web`'s
-    # `dispatch(json)` (docs/implemented/decisions/0015) takes an optional
-    # `"seed"` (the exact `"instances"` shape it also answers with) plus
-    # `"steps"` — a host rehydrates from a prior snapshot and replays only
-    # the new command(s), rather than the whole history every call. A
-    # page bound to this adapter is expected to hold that snapshot in
-    # `window.localStorage` itself (get on load, set after every
-    # `dispatch`) — the seed/instances round trip is the adapter, once
-    # you're in the one runtime that can actually reach the storage this
-    # name promises.
+    # Declares browser-local storage; in Ruby it behaves like Memory (in-process, ephemeral).
+    # Only a real browser page, holding the rust/web `dispatch` snapshot, gets durability.
     class LocalStorage
-      # Tenant-capable trivially, same reasoning as Memory's own — a
-      # browser tab is exactly one origin, exactly one user; there is no
-      # second tenant this in-process Hash could ever confuse a first
-      # one with.
+      # Trivially tenant-capable, as Memory is: a browser tab is one origin and one user.
       #
       # @return [Boolean] true, always
       def self.tenant_capable? = true
@@ -79,10 +53,7 @@ module Hecks
 
       # Answers a declared query specification against the projected records.
       #
-      # The decision the guide asks for, made explicitly: no compiled
-      # dialect of its own, same as Heki/Memory — a personal-scale local
-      # store answering by walking `all` is correct on day one, and
-      # nothing about a browser tab's own data volume asks for pushdown.
+      # No compiled dialect, as with Heki and Memory: walking `all` suffices at tab-sized volumes.
       #
       # @param specification [QuerySpecification::Common::Options,
       #   Bluebook::Behaviour::ReadModel::FilteredOptions] the declared query specification
@@ -181,13 +152,7 @@ module Hecks
 
       def copy(state) = Ports::Persistence::StateCodec.copy(@aggregate, state)
 
-      # Not lineage_capable? — deliberately absent, the same trade Heki
-      # makes and states plainly (writing-an-adapter.md's own section on
-      # it): a domain bound here has no edge for its own shape to travel
-      # across if it ever changes; that must be hand-migrated, or the
-      # shape must not change. A browser-local personal store is exactly
-      # the small-adapter case that guide names as a fine place to make
-      # that trade.
+      # Deliberately not lineage_capable?, as with Heki: a shape change must be hand-migrated.
     end
   end
 end