### The WAISM profile's two checkers, and fixed validation limits for R2

- **Two checkers of [extensions/waism.md](extensions/waism.md).**
  `wai/wai-module-check` gives a module's verdict (§4.3) at the integer or the float level under caps: R1 on its
  length, R2 by a WebAssembly 3.0 validator, then R3 to R12 over its items in binary order and the absences R6 and
  R10. The Rust checker is built on wasmparser, pinned at 0.262.0, with the features of WebAssembly 3.0 and no
  others; a command prints a verdict, the level a sink holds a module at (§6, check 9b), or checks a corpus.
  `check-module.mjs` is the second: written from the text with no dependency and sharing no code with the first,
  it decodes and validates every construct of WebAssembly 3.0 itself, garbage collection, exception handling and
  typed function references included, and is the ES module a page imports before it instantiates a decoder
  module. It generalises wai-vector's `check-mvp.mjs`, which stays as it is for that crate's own package check.
- **The corpora.** `planted/build.py` builds the checker corpus of §9.1 from each module's construction, byte for
  byte, and takes each verdict's offset from the item it marks while building, never from a checker. Both checkers
  give every module its stated verdict; `tests/module_rules.rs` also requires every planted module to break exactly
  its row's rule, every rule R1 to R12 to have one, and the levels to differ only in R3. `build.py --limits`
  generates the validation limits' corpus, each limit at its value and one past it. The differential writes
  10,000 modules from wasm-smith from a committed seed, with two mutated copies of each, and requires the two
  checkers to give every one the same verdict at both levels; `examples/spectest.rs` does the same with the
  modules of the specification's test scripts, a pinned copy of them in `spec-tests/`, and
  fails if a script goes unread, an invalid module is not refused or a valid one is.
- **waism §4.1 and §4.2.** R2's module is valid within a table of validation limits that §4.2 now
  fixes (the counts of a module's parts, the sizes of a name, a body, a function type and a struct, the catches of
  a `try_table`, the depth of a subtype chain, and the sum its imports and exports weigh): WebAssembly 3.0 lets an
  implementation limit these, so without them two conforming checkers could differ on a module within the caps. A
  module beyond one is refused R2. R3 states that an instruction whose types a block type or a typed `select`
  fixes is refused through that value type, which follows its opcode, and §9.1 gains a planted module for each
  (`float-block-type`, `float-select-type`); an item is also an instruction of a constant expression and the
  value type of a declaration of no locals; and R7's `funcref` is either of its encodings.
- **CI.** `wai-conformance.yml` runs both checkers on the corpus, the limits and the differential, from
  `.github/wai-conformance/verifiers/module-check.sh`.
