### The composing page computes fields and conditioned refinements in WebAssembly

- **`wai-web` `compose` bundle** (`src/compose_stage.rs`, with `wai/field_int` and
  `wai/splat_exact` added to the feature): `ComposedField`, a `wai.field.int_grid` base and the
  `wai.field.int_refine` levels offered to it, `wai::int_field::FieldStages` under
  staged-delivery §4.1 with a hold bound of zero, rendered at the field's own view after every
  stage, with a render-work limit checked before anything is rendered (`cost_over_limit`);
  `ComposedStage`, `wai::staged::StageSink` with the side planes a `wai.image.int_cond_refine`
  layer reads held by the page: pictures decoded from `wai.image.png` through an envelope's
  capability or its fallback, splat sets decoded through `wai.splat.int_codec` with the
  parameter set the page holds, and a render entry's frame rendered in the page by
  `wai-splat-render:i1` at its pose; `composeSide`, the side planes a layer names. The decode,
  the levels, the network, the residual, the render and every check are wai-rs's, compiled to
  wasm32; nothing is written a second time in JavaScript.
- **`compose.js`**: a field is presented as the picture, rendered in the tab at the view its
  payload pins, and a picture of an image component is decoded in the tab, each held to its
  signed digest first. A piece whose base has layers presents the base, then takes each layer as
  it arrives: checked against its entry, its next stage computed in WebAssembly, held to the
  stage hash its entry states, and only then presented. A conditioned layer's side planes come
  from the piece's asset entries: an object is held as a plane only where the page decodes it
  under the device's profile, its bytes pass their entry's checks and its output holds its
  digest. A layer refused anywhere (`side-absent`, `side-not-exact`, `layer-gap`,
  `object-hash`, `prefix-digest` and the rest) leaves the stage below presented, and the page
  says why. The dispatch record lists each piece's layers with their outcome, reason, stage,
  stage hash and the side planes each read. A field and the side objects route `wasm` and are
  never put to the user agent (platform-decode maps none of them); the refinement capabilities
  the page applies are in the report's `wasm` leg.
- **`compose/staged/`**: four packages of one image component each (`fields`, `fields-digest`,
  `cond`, `cond-not-exact`), sealed with the package's key from objects of
  `volumetric-conformance/fields/` and `staged-conformance/cond/`, byte for byte, each entry's
  prefix digest computed natively and held to the corpus's statement; the native tests require
  the committed bytes. **`run.mjs`** adds the staged cases (`--only staged` runs them alone):
  every field renders to its scene's frame digest, read back from the canvas; with each level's
  delivery held back and released one at a time, the coarse field is presented before its first
  level is asked for and every stage before the next level; a stage whose signed digest is
  another's, a level with a byte flipped, a side object withheld or flipped, the splat decoder
  left out of the profile, and a plane held only through its fallback are each refused with
  their code and the stage below presented.
- **browser-sink §14**: the layers table names `wai.field.int_grid`; §14.3 the rule for the
  field, its levels, the conditioned layer and its side objects, and the dispatch record's
  `layers`; §14.4 the field's and the picture's digests; a new §14.5, *Refinement layers*, what
  the page computes and checks for each layer, in order; §14.7 the staged packages; §14.8 their
  conformance. The former §14.5 to §14.7 are now §14.6 to §14.8.
- **CI**: `wai-web-wasm.yml` runs the compose bundle's native tests (`compose_stage::`), and
  triggers on `wai/volumetric-conformance/`.