### Integer neural fields: `wai.field.int_grid`, a scene the sink computes, refined level by level by `wai.field.int_refine`

- **A computed capability registered** (SPEC §5, *Interactive, temporal & computed content*):
  `wai.field.int_grid`, a volumetric scene held as a multi-resolution integer feature grid and
  a small integer network, `StandardDefined` at field-equivalence. The sink computes the
  content: the field's density and colour at any point of its domain, and its frame at any view
  by integer ray marching. [neural-fields](extensions/neural-fields.md) fixes every integer: a
  level's table is read through a direct index where its vertices fit, and through a spatial
  hash with a stated wrap (each product modulo 2^32) where they do not; the trilinear weights
  are fixed point at 2^48 and sum exactly; each layer is integer-operators' `conv` with a 1 × 1
  kernel, its `rq` rounding half up by `wfrac` bits, a clamp to `i32` and `relu`; the camera is
  splat-exact §5.3's; the samples, their lengths, the transmittance's stop and the compositing
  are pinned. So the values at a point and the frame at a view are the same bytes on every
  machine, and a frame digest can be signed and checked where the frame is presented.
- **The payload `WIG1`** (neural-fields §3): `L` levels declared and the coarsest `K` carried,
  the network's widths and layers, and the view the field is presented at (a pose of
  splat-exact §2's members, the samples a ray takes between `t_near` and `t_far`, and a
  background). A level not carried reads as zero, so a coarse prefix is a presentable field.
  Its checks follow integer-payloads §2's order and refuse with that extension's codes,
  including a network whose input width is not `L · F` and a degenerate pose (`field_range`).
  The emit paths check the framing with the parser a sink runs.
- **Levels as refinements** (neural-fields §7; SPEC §5, *Refinement capabilities* and *Base
  admission*): `wai.field.int_refine`, refinement-only over the one base `wai.field.int_grid`,
  `StandardDefined`, its payload `WIL1` one grid level of the field. A level applies only as the
  field's next level, in the features, table size and side the field declared for it, or it is
  refused (`geometry_mismatch`) and the field is as it was. [staged-delivery](extensions/staged-delivery.md)
  §6.2 registers this **level form** (the former §6.2 and §6.3 are now §6.3 and §6.4): the unit
  is the whole field, layer `k` carries level `K + k − 1`, §4.1 step 9 is the next-level rule,
  the stage hash is the SHA-256 of the render at the field's own view, the tier is
  `decode-equivalence`, and every layer boundary is a truncation point. So a coarse field is
  presented first and every stage is presentable.
- **Reference implementation.** `wai-rs`: `int_field` (feature `field_int`): `parse_wig1`,
  `parse_wil1`, `Field::{query, render, apply_level}`, `View`, the declared cost,
  `FieldStages` (staged-delivery §4.1 for the field's one unit), and `int_field::corpus`; the
  float-free test reads `int_field.rs`. `tools/wai_int_field_export.py` writes the payload from a JSON
  form and builds the corpus's scenes itself: one fitted to a procedural scene by stochastic
  gradient descent on each level's table in turn, through the level's own index and hash, one
  seeded random, one of saturating values.
- **Conformance.** `volumetric-conformance/fields/`: three scenes, the values at 32 points and
  the frame digest at each scene's own view and at further views, at every prefix of the fitted
  scene's levels; a fault payload for every check of `WIG1` and `WIL1`, each with its code;
  levels applied in order, out of order, twice, past the field's levels and in the wrong shape;
  and envelopes offered as layers in five sequences (in order, out of order, a refusal at each
  envelope step, a conflict, a level that fails the next-level rule and then conflicts), each
  with its stage or reason and the final stage hash. Written and checked by
  `wai_int_field_vectors` and `tests/int_field.rs`. `field_verify.py` parses every payload,
  applies every level and computes every value, frame and stage hash with its own integer
  arithmetic, sharing no code with wai-rs. Both plant five faults in their own decode (an
  interpolation weight off by one, a hash multiplier changed, a layer's rounding flipped to
  floor, one ray sample too many, a level applied out of order) and require the corpus to catch
  each.
- **Breaking:** `api:rust:wai::codecs::AppliedForm::Level`: the level form is a staged form of its
  own; a match over `AppliedForm` adds the arm, and `is_refinement_only` already counts it.
- **Breaking:** `api:rust:wai::int_field::Plant::ALL`: the corpus plants a fifth fault, a level
  applied out of order; code that iterates `Plant::ALL` needs no change, code that names its
  length reads 5.
- **Breaking:** `api:rust:wai::int_field::Plant::LevelOrder`: that fault's variant; a match over
  `Plant` adds the arm.
- **Breaking:** `api:rust:wai::int_field::corpus::SCENES`: each scene now names the levels that
  refine it; read the first member of each pair for the scene's name.
- **Breaking:** `api:rust:wai::int_field::corpus::Verified::applications`: `verify` counts the
  level applications it reproduced; a pattern over `Verified` adds the field or `..`.
- **Breaking:** `api:rust:wai::int_field::corpus::Verified::offers`: `verify` counts the layers
  it offered; a pattern over `Verified` adds the field or `..`.