# `mutation` — the kind that carries a mutation surface into a test target
One declaration in; one module out, delivered as deferred cargo the consumer's test target invokes.
The module carries three things: the policy the surface is lowered under, the site whose alternatives a selection chooses between, and the dispatch that answers an evaluation.
## Every fact here is the declaration's
An owner fact is a name the consumer declares.
An operator family is a slug the consumer declares.
An alternative is DATA: the semantic bytes that identify the operation, and the value it means.
Nothing here holds a roster of facts that exist or families that can be applied, and nothing in this vocabulary invents an alternative.
A producer that computed pressure from what a declaration MEANS would be a producer that knew the thing it does not know; the declared-order door below computes its alternatives from the declaration's own order, and from nothing beside it.
What this home checks is shape: a mapping is one fact and one claim, a permission is one claim and a non-empty roster of families, two alternatives never carry one operation, and every roster stands inside its declared magnitude.
## Two halves, and where they meet
A helper body states what an author can state: the module, the refusal type, the optional support address, the evaluation family, the point, the owner fact, the mappings, and the permissions.
Everything else a site carries — the type its alternatives are values of, the production the unchanged declaration answers with, the unchanged operation bytes, and the alternatives themselves — is token material and semantic bytes computed by the door that captured the declaration this helper sits on.
[`Declaration::completed`] is where the two halves meet, and it is the only road to a [`Surface`].
## The declared-order door, for the door that owns no semantics
[`completed`] is this home's own computation of the second half, for the generic attribute: the item the helper sits on must be an enum, its variant list in authored order is the declared order, the unchanged operation is that order as written, and each alternative is one adjacent transposition of it under the [`DECLARED_ORDER_FAMILY`] operator family.
The reading is structural on purpose — variant names and their order, never fields or meanings — because transposing two neighbors of an order somebody declared is the one pressure a door can compute without knowing what the declaration means.
What a transposition surviving says is the consumer's to judge, exactly as every other survivor is.
A door that does know its declaration's semantics — an adopter's own derive — computes richer site material and calls [`Declaration::completed`] directly.
## The alternatives and their meanings travel together
Each alternative carries both its operation bytes and the tokens of the value it means.
A rendering that carried the meaning without the bytes would emit a value nothing could select.
One that carried the bytes without the meaning would select a value nothing renders.
One type, both seats required, and neither case is writable.
## An unmapped site is still a site
Where the policy maps the site's owner fact to a claim, the rendered discovery carries that claim.
Where it does not, the discovery carries the unmapped posture and says so.
Neither is a refusal here.
Whether an unmapped discovery may become executable is the harness's ruling, made where the lowering is admitted, and a producer that decided it would be a second authority.
## Ownership
This home owns the mutation declaration shape, the structural declared-order completion, the carried policy and site material, the deferred projection, and every refusal required to establish them.
The consumer owns the meaning of facts, claims, operators, alternatives, and evaluation; the harness owns whether a rendered discovery becomes executable evidence.