Record phase 5 in CLAUDE.md, and correct two comments (#225)

Three documentation changes. No behaviour, and engine.wasm is unchanged.

CLAUDE.md's Rust engine section stopped at phase 4 and still listed Vulcanus
as future work, so the repo's own map said six ported layers did not exist.
Adds a phase 5 section with the 24 frozen counts' four readings, the biome
layer's real cache and why it is the only one, the pre-volcano split, and the
cliff multisample grid.

Fixes an inverted comment on the ashlands basis leaf, found by review on #285.
It said the input scale "divides by the volcanism scale multiplier" where the
code has that multiplier in the NUMERATOR. The code was right and matched both
the TypeScript and the Lua; only the comment was wrong. Worth more than a typo
fix: scale_multiplier is exactly 1 at the default preset, which is what every
fixture and the poison gate run at, so m/50/3 and 1/50/3/m are bit-identical
throughout and an edit "fixing" the code to match the comment would diverge
from the game only at a non-default volcanism frequency, with a green gate.

Corrects the crack layer's #269 note, which blamed the wrong number. It said
the layer is discriminating because its INPUT scales (0.3 * 0.325 and
0.6 * 0.325) are not f32-exact. That is wrong, and measurement says the
discriminator is the OUTPUT scale alone: basis_noise returns an f32, so a
power-of-two output scale is a pure exponent shift and narrowing the product is
the identity, while any other output scale can leave the f32 grid. Over 90,000
samples at a fixed input scale, output scales 1, 0.5, 0.25, 2, 4 and 64 change
0.00% of products; 0.6 changes 79.88%, 0.75 and 3 change 56.32%, 150 changes
97.46%, 125 changes 98.38%. Holding the output scale at 1 and sweeping input
scales 0.125, 0.205, 0.51, 0.6, 1.5 and 0.002 changes 0.00% every time.

So exactly ONE of the crack layer's twelve basis calls is exposed:
hairline_cracks' first term at output scale 0.6, where 80.10% of products
differ. The other eleven sit at 1, 0.5 or 0.25. That is a one-term explanation
for the one bad count in that layer, and why the four fields built only from
power-of-two sites score 15, 40, 10 and 8 rather than 3.

The wrong reasoning is recorded in the comment rather than quietly replaced,
because it is the plausible guess: the input scale is the number that looks
inexact.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01X2wz8eFazisYuENEkmBvvG

Author: wormeyman

CLAUDE.md

@@ -1159,7 +1159,7 @@ Field labels carry in-game tooltip text via `FInfo` (an `info` prop on
 `EnemyValueRow`, an `info:` entry in `controlCatalog.ts` for the enemy-base
 autoplace rows).
 
-### The Rust/WASM noise engine (`crates/`) - phases 1-3 expressions landed
+### The Rust/WASM noise engine (`crates/`) - phases 1-4 landed, phase 5 in progress
 
 A Cargo workspace at the repository root, landed empty on purpose (#219) so the
 gate was proven green on `main` before any port code depended on it. Two crates:
@@ -1251,6 +1251,85 @@ been red whether or not the argmax had a control at all. `POISONED_TESTS` now
 carries FULL test paths rather than bare `fixtures::` names, so a control can
 live beside its op.
 
+**Phase 5 (#225) ports Vulcanus, and its EXPRESSION chain down to elevation is
+in.** Landed: `vulcanus_helpers`, `vulcanus_cracks`, `vulcanus_climate`,
+`vulcanus_spawn`, `vulcanus_biomes`, `vulcanus_elevation`, plus
+`vulcanus_temperature` on the elevation module. `vulcanus_shared` needed no
+port - it is `starting_spot_at_angle`, done in #279 - and `vulcanus_seed`
+landed in phase 2. Still out: `vulcanus_resources`, `tiles/vulcanus_catalog`,
+and the cliff, resource and rock stacks.
+
+Tier 1 grades **24 named fields** across six fixtures. Every count was measured
+again on the TypeScript side against the same fixture and all 24 agree, so they
+are the distance BOTH ports sit from the game rather than a gap between them.
+
+**Four things this phase measured that are worth more than the counts:**
+
+- **A second, independent fixture points at #269.** `hairline_cracks` scores
+  **3 of 61** and is the shallowest expression in its layer - a bare `plasma`,
+  nothing composed on top - so the weakness cannot come from the crack file.
+  `plasma` subtracts two `basis_noise_expr` results, and that adapter returns
+  the un-narrowed f64 product #269 is about. The crack layer calls it at
+  `0.3 * 0.325` and `0.6 * 0.325`, neither exact in f32, which is exactly the
+  case #269 records `oracle-basis` as blind to by construction. Do not chase
+  the five crack counts before #269 is settled.
+- **A clamp flatters a count, and here it is measurable.** The three clamped
+  biomes score 403, 402 and 408 of 434 against their own unclamped sources at
+  128, 107 and 127 - the same quantity, times 2, clamped. Nothing improved
+  between them: the clamp saturates at 0 or 1 over most of the map and a
+  saturated position is exact for free. Read `*_biome_full` as the port's score
+  and `*_biome` as what the consumer needs. Same effect in `starting_area`
+  (371 of 410) against the unclamped `ashlands_start` (61) feeding it.
+- **The oracle cannot see elevation's `-500` clamp**, and that was checked
+  rather than assumed. `vulcanus_elevation` is `max(-500, elev)` and the
+  captured `elev` bottoms out at **-58.77**, so the two columns are the same
+  field at all 434 positions - 0 of 434 differ - and a port that dropped the
+  `max` would score 113 either way. Both are graded anyway; the clamp's real
+  test lives in the module, constructing the case the fixture does not.
+- **A discrete output scores like one.** `mountain_volcano_spots` at 359 of 434
+  is the highest UNCLAMPED count in the Vulcanus port, because it is dominated
+  by which single candidate survives per region - a choice a sub-ULP error
+  almost never changes. The same property `voronoi_cell_id` has.
+
+**`detailNoise` is the reading to carry out of this phase.** It has the
+SMALLEST residual of its three helper fields (7.778e-5) and the FEWEST exact
+matches (**1 of 38**), where `mountainPlasma` has 2.807e-3 and 7 of 38. A field
+can be uniformly close and almost never right, which is the argument for
+counting matches rather than bounding error, stated in one number.
+
+Read elevation's worst residual of 1.332e-1 against its scale before reacting:
+the field spans -58 to +1024, so that is ~1.3e-4 relative, the same order as
+every layer above it. An absolute bound would need re-tuning per field for
+scale alone - a third reason not to use one.
+
+**`vulcanus_biomes` keeps a REAL cache, and it is the only layer that does.**
+Every other ported layer evaluates top to bottom into locals, because every read
+is at the same `(x, y)`. `raw_spots` is not: it reads selected spots from up to
+four neighbouring regions, which is genuine cross-position state. The region
+cache is a `RefCell<BTreeMap>` so `eval` can stay `&self` while the density and
+favorability closures handed to `select_spots` borrow it. `BTreeMap` rather than
+`HashMap` deliberately - nothing iterates it today, but a determinism-critical
+port should not carry a container whose iteration order is unspecified.
+
+`volcano_area` is evaluated at every spot candidate and pulls the whole
+pre-volcano chain at that candidate; the TypeScript memoizes those and the port
+recomputes them. **Nothing on the render path reaches this layer yet**, so it is
+correct-first on purpose. If it ever joins a per-pixel render that is the first
+measurement to take - `multioctave_noise`'s own docs record what happened last
+time a per-call rebuild went unmeasured, which was 20x.
+
+**The mountains pre-volcano split is load-bearing.** `mountain_volcano_spots`
+depends on the mountains biome and the mountains biome folds the volcano field
+back in; the Lua breaks that with a PRE-volcano stage that `volcano_area` reads.
+Collapsing the two is an infinite recursion, which announces itself - reading
+`volcano_area` off the POST-volcano raw does not.
+
+**`cliff_elevation` is a separate entry point, not a convenience.**
+`multisample`'s offsets are in the CONSUMING program's grid units, so the cliff
+generator's 4-tile lattice moves the field 16 tiles for a `dx` of 4 (#83). The
+tile and terrain channels pass 1; cliffs pass 4; both go through one code path
+with the grid as a parameter.
+
 **Tier 3 now covers both preview PNGs**, which is what #224's gate asks for.
 `test/wasmFulgoraRenderParity.spec.ts` renders through the real boundary and
 compares against the images Factorio itself produced:

crates/fmw-noise/src/expressions/vulcanus_elevation.rs

@@ -141,8 +141,16 @@ impl<'a> VulcanusElevation<'a> {
             biomes,
             climate,
             mountain_basis: BasisLeaf::new(seed0, 13_423, 1.0 / 500.0, 250.0),
-            // Note the input scale divides by the ashlands LOCAL scale of 3, and
-            // by the volcanism scale multiplier - not by the crack scale.
+            // The input scale MULTIPLIES by the volcanism scale multiplier and
+            // divides by 50 and by the ashlands LOCAL scale of 3 - not by the
+            // crack scale, and the multiplier is not a divisor.
+            //
+            // Spelled out because no test here can tell the two apart:
+            // `scale_multiplier` is exactly 1 at the default preset, which is
+            // what every fixture and the poison gate run at, so
+            // `m / 50 / 3` and `1 / 50 / 3 / m` are bit-identical throughout.
+            // The forms only diverge at a non-default volcanism FREQUENCY
+            // slider, and they would diverge with the whole gate green.
             ashlands_basis: BasisLeaf::new(
                 seed0,
                 12_643,

crates/fmw-noise/src/fixtures.rs

@@ -2434,14 +2434,39 @@ fn reproduces_the_vulcanus_crack_layer_at_every_captured_position() {
     // 5.460e-4, 6.387e-4.
     //
     // `hairlineCracks` at 3 of 61 is the weakest and it is the SHALLOWEST
-    // expression in the layer - a bare `plasma` with nothing composed on top.
-    // That points at the plasma adapter rather than at anything this file
-    // builds, and specifically at #269: `basis_noise_expr` returns an
-    // un-narrowed f64 product where the game narrows to f32, and `plasma` is
-    // two of those subtracted. The crack layer's scales are 0.3 * 0.325 and
-    // 0.6 * 0.325, neither exact in f32, so this layer is exactly the case the
-    // #269 comment says the existing `oracle-basis` fixture is blind to. Do not
-    // chase these five counts before that one is settled.
+    // expression in the layer - a bare `plasma` with nothing composed on top -
+    // so the weakness cannot come from anything this file builds. It points at
+    // the plasma adapter, and specifically at #269: `basis_noise_expr` returns
+    // an un-narrowed f64 product where the game narrows to f32, and `plasma` is
+    // two of those subtracted.
+    //
+    // **Which call sites #269 can reach is decided by the OUTPUT scale alone,
+    // and it is a clean rule.** `basis_noise` returns an f32, so multiplying by
+    // a POWER OF TWO is a pure exponent shift and can never leave the f32 grid:
+    // narrowing that product is the identity. Any other output scale can.
+    // Measured over 90,000 samples at a fixed input scale, output scale
+    // 1 / 0.5 / 0.25 / 2 / 4 / 64 each change **0.00%** of products, while 0.6
+    // changes 79.88%, 0.75 and 3 change 56.32%, 150 changes 97.46% and 125
+    // changes 98.38%. Holding the output scale at 1 and sweeping the INPUT
+    // scale over 0.125, 0.205, 0.51, 0.6, 1.5 and 0.002 changes 0.00% every
+    // time - the input scale decides which noise value you get, never whether
+    // the product is representable.
+    //
+    // So of the twelve `basis_noise_expr` calls this layer makes, exactly ONE
+    // is exposed: `hairline_cracks`'s first term, at output scale 0.6, where
+    // 80.10% of products differ. The other eleven sit at 1, 0.5 or 0.25 and are
+    // blind by construction. That is a one-term explanation for the one bad
+    // count here, and it is why the four fields built only from power-of-two
+    // sites score 15, 40, 10 and 8 rather than 3.
+    //
+    // It also explains why `oracle-basis` cannot grade this: that fixture was
+    // captured at output scale 1. Do not chase `hairlineCracks` before #269 is
+    // settled, and do not expect the other four to move when it is.
+    //
+    // An earlier draft of this comment blamed the layer's INPUT scales
+    // (0.3 * 0.325 and 0.6 * 0.325, neither exact in f32). That was wrong, and
+    // it is recorded rather than quietly deleted because it is the plausible
+    // guess: the input scale is the number that looks inexact.
     type C = CrackFields;
     for (key, want_exact, select) in [
         (