# Settlements, landmarks and new trades: frozen interfaces (8 Oct 2026, round 2)

Extends `TYPES.md` (read it first: building frame, BuildingSpec, Layout, render). Metres, Y up, +Z = street side of a
building, X along its front. A world plan uses world X/Z with Y up; **east = +X** (churches face east: altar at +X,
west front at -X).

## 1. New kits (Astra, Blender) and their atom names

Every kit = `browse/kits/<kit>/kit.glb + kit.json (forge.atom-kit.v2) + materials.json`, loaded with
`loadStyleKit(THREE, {base: './kits/<kit>/'})`. Atom node names below are EXACT. Code must run with a kit missing (atom
absent -> a plain grey box of the stated size, plus a finding), so code and Blender proceed in parallel.

### medieval-trades (smithy, baker, market)  (origins: wall-attached atoms = bottom centre ON the wall face, body to +Z)
| atom | size W x D x H (m) | origin / notes |
|---|---|---|
| forge_shed | 4.0 x 3.5 x 3.6 | open lean-to workshop against a wall: high side 3.6 at the wall, low eaves 2.4 at +Z, oak posts, tiled mono roof, hearth + hood, bellows, anvil, quench tub, tool rack inside |
| chimney_forge | 1.0 x 0.9 x 7.5 | free-standing forge stack, bottom centre; code puts it against the gable beside forge_shed |
| door_workshop | clear 2.4 x 2.4 | opening atom (contract v2), two plank leaves |
| sign_smith | 0.9 x 0.6 x 1.0 | iron bracket + hanging horseshoe/anvil board (Sign_paint), wall-attached, origin = bracket fixing point |
| bread_oven | 2.0 x 1.8 x 2.2 | domed oven projecting from a wall at ground, own small tiled roof + flue |
| window_bakery | clear 1.8 x 1.4 | same clear size as window_shop; counter with loaves |
| sign_baker | 0.8 x 0.6 x 0.9 | pretzel / loaf sign, like sign_smith |
| hall_post | 0.35 x 0.35 x 3.4 | market-hall oak post on a stone pad, two curved braces in the X plane rising to y 3.4 (plate height); code generates plates/tie beams as beam boxes and lays the roof |
| stall_a, stall_b, stall_c | 2.4 x 1.5 x 2.4 | market stalls (cloth awning + produce / bread + cheese / pottery + cloth), origin ground centre, front = +Z |
| well_roofed | 1.8 x 1.8 x 3.2 | village well, stone ring, timber roof, winch + bucket |
| cart_hand, crate_stack, basket_produce, firewood_stack, hay_bale, anvil, grindstone | small | props, origin ground centre |

### medieval-church (Romanesque village church, ref /tmp/medieval3.jpeg)  axis along X, west = -X
Modules are SLICES joined on planes x = const; each origin = ground centre of its slice; a slice of length L spans
x in [-L/2, L/2]. Nave outer width 8.0 (z -4..4), eaves 6.0, roof 50 deg. Chancel outer width 6.0, eaves 4.8.
| atom | slice / size | notes |
|---|---|---|
| church_nave_bay | L 4.0 | both side walls with a round-arch window each, pilaster buttress at x=+2 both sides, roof both slopes + ridge |
| church_nave_bay_door | L 4.0 | same, south side (+Z) has the Romanesque door instead of the window |
| church_nave_west | 8.0 wide gable, 0.9 deep | west wall: Romanesque west door + small round window; origin on the joint plane, body extends to -X |
| church_nave_east | 8.0 wide gable, 0.9 deep | east wall of the nave above/around the chancel arch; origin on the joint plane, body to +X |
| church_chancel_bay | L 3.0 | 6.0 wide slice, a lancet window each side, roof |
| church_chancel_east | 6.0 wide, 0.9 deep | flat east end with a triple lancet; body to +X |
| church_apse | radius 3.0 | semicircular apse with half-cone roof; origin on the joint plane, body to +X |
| church_tower_base | 5.0 x 5.0 x 6.0 | west tower ground stage with a doorway on -X; origin ground centre |
| church_tower_stage | 5.0 x 5.0 x 4.5 | plain stage, slit windows, origin = bottom centre (stack by y) |
| church_tower_belfry | 5.0 x 5.0 x 4.0 | paired louvred arch openings on each side |
| church_tower_roof | 5.4 x 5.4 x 5.5 | pyramid roof + cross; church_tower_spire: octagonal spire variant 5.4 x 5.4 x 9 |
| church_porch | 3.0 x 3.0 x 3.6 | timber porch on dwarf stone walls, wall-attached (origin on the wall face, body to +Z) |
| lychgate | 3.0 x 2.0 x 3.2 | roofed churchyard gate |
| churchyard_wall_2m | 2.0 x 0.5 x 1.2 | rubble wall segment along X |
| gravestone_a/b/c, churchyard_cross | small | props |

### medieval-cathedral (Gothic, ref /tmp/medieval2.jpeg)  axis along X, west = -X
Cross-section: nave 12 m wide (z -6..6), aisles 6 m each (outer aisle walls at z = +-12), flying buttresses to z = +-16.
Nave eaves 22, ridge ~30; aisle eaves 10, lean-to aisle roofs. Bay length 6.0.
| atom | slice / size | notes |
|---|---|---|
| cath_nave_bay | L 6.0 | the full cross-section slice: aisle walls with tracery windows, clerestory lancet pair, flying buttresses + pinnacles both sides, nave roof + aisle roofs |
| cath_west_front | 26 wide x 8 deep, towers 45 | twin towers, 3 portals, rose window 7 m; origin on the joint plane, body to -X |
| cath_tower_spire | 9 x 9 x 22 | octagonal spire with corner pinnacles, sits on a west tower top (sockets in kit.json) |
| cath_crossing | 12 x 12 slice (L 12) | crossing square + lantern tower 12 m above the nave ridge |
| cath_transept_bay | L 6.0 along Z | a transept slice (12 wide, nave height), joins the crossing on +-Z |
| cath_transept_end | 12 wide | transept gable end: rose window + portal |
| cath_apse | 24 wide | polygonal chevet with radiating buttresses, ends the choir; origin on the joint plane, body to +X |

### medieval-walls (town walls, terraces, street furniture, ground shelf)
| atom | size | notes |
|---|---|---|
| town_wall_4m | 4.0 x 2.0 x 7.0 | crenellated curtain, wall walk; origin ground centre; +Z = OUTSIDE the town |
| town_wall_tower | dia 6, h 11 | round tower, conical slate pepper-pot roof (Collonges) |
| town_gate | 9 x 8 x 14 | gatehouse, arch passage 4 x 5 along Z, timber-framed top storey + bell turret (Riquewihr Dolder) |
| retaining_wall_2m | 2.0 x 0.6 x 1.0 | dry-stone terrace wall row, stackable in Y (code stacks rows); +Z = downhill face |
| stair_flight | 2.0 wide, rise 2.0, run 4.0 | stone steps, origin bottom centre of the lowest step, climbs toward -Z |
| garden_wall_2m, fence_wattle_2m, fence_picket_2m | 2 m long | plot boundaries |
| market_cross, fountain | small | square furniture |
| shelf materials | Cobble_street, Dirt_track, Grass_meadow, Paving_square | tileable ground (code drapes roads and squares) |

## 2. New building types (medieval style) - `styles/medieval.mjs`
`smithy` (house + forge_shed on a gable side + chimney_forge, door_workshop on the street, sign_smith),
`bakery` (window_bakery ground shop, bread_oven on the back or a gable, chimney, sign_baker),
`market_hall` (open: hall_post at every bay axis on both long sides + gable ends, no walls, beam plates, the medieval
tile roof laid by the existing roof code; 3-5 bays of 3.5 m, depth 8-10), plus existing house/tavern/shop.
New spec overrides every style honours: `party: ['left'|'right']` (side facades become blank party walls, no windows,
no chimney there, no gap: neighbours touch), `plinth: m` (height of the ground under the uphill edge minus the lowest
footprint corner; the ground storey wall continues DOWN that far as a stone base; doors stay on the uphill/street side),
`gableFront: bool` (ridge along Z, gable to the street; town houses). Lean-to roofs: implemented (one slope, high side
against the main volume).

## 3. Landmarks - `landmarks.mjs`
```js
church(seed, { bays = 3..5, tower: 'west'|'none', top: 'pyramid'|'spire', east: 'flat'|'apse', porch: true }, kitInfo) -> Layout
cathedral(seed, { navesBays = 5..8, choirBays = 2..3, spires: 0|1|2, crossing: true, transepts: true }, kitInfo) -> Layout
landmarkFootprint(layoutOrKind) -> { w, d, frontDir: '-X' }   // for the planner
```
Same Layout format as TYPES.md (instances only, no panels), origin = centre of the footprint on the ground, axis along X.

## 4. Settlement model - `settlement.mjs` (pure, no THREE)
```js
settle({ seed, tier: 'hamlet'|'village'|'town'|'city', site: 'plain'|'river'|'crossroads'|'hill'|'spur'|'coast',
         style: 'medieval'|'breton', heightAt?: (x, z) => y, size?: m }) -> Plan
Plan = { seed, tier, site, bounds, terrain: { size, res, heights } | null,  // null when the game passed heightAt
  roads:   [{ id, kind: 'main'|'street'|'lane'|'stair'|'track', pts: [[x, z]...], width }],
  squares: [{ id, kind: 'market'|'church'|'parvis', poly: [[x, z]...] }],
  plots:   [{ id, x, z, yaw, w, d, y, plinth, use, party: [], gableFront, district, road }],
  //  use: house|tavern|smithy|bakery|shop|market_hall|barn|church|cathedral|castle(=reserved, empty)
  walls:   [{ kind: 'town'|'churchyard'|'terrace'|'garden', pts: [[x, z]...], gates: [{ x, z, yaw }] }],
  props:   [{ kind, x, z, y, yaw }],   fields: [{ poly, crop }],
  findings: [] }
heightOf(plan)(x, z) -> y
```
`buildSettlement(THREE, { kits, styles, plan }) -> { group, colliders: [{ x, z, w, d, yaw, y0, y1 }], stats }`
(in `settlement-render.mjs`): plots -> makeSpec/layout (or church/cathedral), roads and squares draped on the terrain,
walls from atoms, props, one batch per kit.

### The placement law (sources: lance1d20 2021, the 10 Drivalia village photos, operator refs; numbers are ours)
- Tiers: hamlet 5-12 buildings (no church: a cross or chapel, a well); village 20-60 (church + churchyard, one square
  with a well, 1 smithy, 1 bakery, 1-2 taverns); town 60-200 (walls + 2-4 gates on the main roads, market square with a
  market hall, 2+ churches, trades in districts); city 200-400 for a game (cathedral on the main square with a parvis
  in front of its west front, several squares, castle reserved on the high point).
- Site: water first (river, spring, coast); main roads meet at a crossroads or a river crossing; the square sits there.
- Landmark on the high point: church/castle at the TOP of a hill or spur; on a plain the church sits on the square.
  Churches face east (west front toward the square or the main road).
- Houses line the roads: plot frontage village 6-10 m, town 4-7 m, depth 20-40 m (garden behind); the house sits at the
  FRONT of its plot on the street line. Towns: continuous frontage (party walls, `party` override), 3-4 storeys,
  gable to the street (`gableFront`) on narrow plots. Villages: detached, 1.5-3 m gaps, 2 storeys.
- Trades: smithy at the edge on the main road in (fire, horses, travellers); tavern on the square or at the entrance;
  bakery near the square; market hall in the middle of the market square; tanners/dyers downstream at the edge; barns at
  the back of plots and at the edge; fields ring the outside.
- Hills (perched villages: Gordes, Eze, Rocamadour, Saint-Cirq, Mont-Saint-Michel): streets follow the contours (rings,
  switchbacks), stair lanes go straight up the slope; ridges run PARALLEL to the contours; the street front sits at the
  uphill street level and the downhill side shows a tall stone base (`plinth` up to 1 storey, else terrace it with a
  retaining wall); terraces step down; the wall rings the foot of the hill.
- Towns: gate towers close the main streets (Riquewihr), wall towers every 40-60 m, wall circuit around the built area.
- Squares are enclosed by houses (Perouges); a square is 20-40 m across, a parvis 20-30 m in front of a cathedral.
- Streets: main 5-8 m, street 4-5, lane 2-3, stair 2; cobbles in town, dirt in a hamlet.

### Round 3 changes (operator review, 8 Oct 2026)
- Density x3: hamlet 6-18, village 60-170, town 200-520, city 500-1200 buildings. Towns and cities build wall to wall
  on every street and back to back between parallel streets (street spacing town 26 m, city 24 m, plot depth 8.5-13 m),
  lanes cut long blocks every 46-62 m; villages join houses in their core (party walls within 0.45 R), small gaps
  further out. A street runs round the landmark's other three sides and a main road leaves its far side, so the town
  grows past the church. The planner keeps the best of its 4 attempts, not the last.
- Hills are not cones: an elongated, lobed, lopsided hill (a steep side, a long shoulder). Only the street round the
  summit closes; the other contour streets are arcs (45-80 % of the way round) centred on a wandering side, one double
  row of houses apart; a plot takes at most half the gap so both sides of a contour street are built.
- Walls follow the ground: each wall piece is sheared so its foot and parapet climb with the slope (continuous, no
  4 m steps); towers and gates stand on the lowest corner of their footprint. Churchyard walls the same.
- Ovens, forge sheds and forge chimneys on a back wall get a rubble footing down to the ground on a falling slope.

### 4.9 The props law (round 3)
- A prop has a footprint (FOOT in settlement.mjs). It is placed only where the footprint is clear of buildings (the
  house body from its front line 7.6 m deep, plus oven or forge shed), landmarks, water, roads and other props (15 cm
  apart; fence pieces abut), and where the ground under its corners varies by less than 35 cm (60 cm for fences). It
  stands on its lowest corner. A prop that does not fit is dropped, never squeezed or left floating.
- Front props (only on streets 4.5 m wide or more): against the facade at the plot's corners, never in front of the
  middle of the house (the door): tavern a barrel and a bench, shop crates and a basket, bakery a basket and crates, a
  few village and town houses a bench. They may stand on the outer 0.9 m of the street.
- Back and yard: firewood against the back wall (35 % of village and town houses, 15 % in cities); the smithy's anvil
  and grindstone in its yard (else at its front corners) and a hand cart when the yard is 4 m deep; barns two hay bales
  and a cart. Village and hamlet yards 3 m deep or more are fenced (back line with a gate gap, both sides up to the
  house; a fence shared with a neighbour is drawn once).
- Squares: the fountain (towns, cities) and the market cross near the middle, the well toward an edge or corner,
  stalls in rows along the two long edges 4 m in from the house fronts, facing the middle, hand carts at the ends;
  nothing on a road that crosses the square, nothing under the market hall.
- Churchyard: gravestones in two rows each side of the church, facing east, a path kept from the lychgate; the
  churchyard cross by the west path.

## Round 4: city layout and grounded doors (8 Oct 2026)

The planner now follows CITY-LAYOUT.md: square-front patricians, main-road burghers and corner towers, craftsmen in
the inner town, cottages and hovels near the actual wall, and hovel/workshop suburbs along gate roads. Wealth falls
with distance from the square, with small seeded differences. Floor counts and trade signs follow place and use.
Three consecutive plots on one street side cannot have the same archetype, floor count and width.

Church west fronts meet a square corner. Cathedrals keep their 25 m parvis between that corner and the west front.
Coastal churches use the inland corner. Hills keep the landmark on the summit and move the square beside its corner.
A village without a hall reserves a council tavern corner before side streets grow. If steep ground or roads leave
no safe corner, a finding records the missing square tavern instead of forcing an overlap.

Town/city squares have a pillory near the hall and a wheel well. Their footprints are 1.2 x 1.2 m and 2.6 x 2.6 m;
rendered atom heights are 2.4 m and 3.2 m. Both belong to `medieval-town`, with grey-box fallbacks and findings when
missing. Two or three fish stalls sit near one gate, not on the main square. A wide far-corner house becomes a plain
two-floor, three/four-bay shelter beside a vegetable garden. Suburbs use existing gate roads for roughly 30-60 m,
with hovels, smithies, tannery-like barns and vegetable patches. The original density limits remain unchanged.
Unsafe props, gardens and suburban plots are dropped with findings where appropriate, never forced onto roads or water.

Road ribbons and door sampling share the same pure `roadGeometry` triangles. Their lift is 0.07 m; square paving is
0.10 m above ground. `plot.y` samples the nearest road surface to the centre of the front wall, not the middle of the
plot. `plot.backGrade` is ground at the nominal back wall centre minus street grade. A rear-wall strip 3 m deep tests
other plots and walls; blocked plots always have `backDoor: false`, otherwise seeded permission is about 60 percent.
All plots have finite `backGrade` and a boolean `backDoor`, including landmarks (0 and false).

The renderer uses `typeof mod.catalogue === 'function'` before requesting measured variants. It matches archetype
and building use, takes the closest width that fits, and rebuilds with the catalogue seed and overrides. If no variant
fits, or the style has no catalogue, it reduces the existing bay count until the house fits. It preserves contour
ridges and shelter floor counts. An internal far-detail footprint probe leaves the public layout hook at one call
per house. The six house inputs are passed through: archetype, wealth, trade, storeys, backDoor and backGrade.
After fitting, the renderer refines street grade at the actual door axis and rear grade at the actual rear-door axis.
That avoids side-to-side slope errors and catalogue-depth errors. Intermediate rear grades have no door; falling
rear grades use the house module's cellar door. Colliders include the extended cellar base.

### Optional interface additions only
- Plot: `archetype`, `wealth`, `trade`, `storeys`, `backGrade`, `backDoor`, `buildDepth`, `institution: 'shelter'`,
  `council`, `suburb`, `gate: [x,z]`, `frontage: { row, along }`.
- Plan: `wallRing` is the continuous unsplit wall polygon, before water/gate gaps.
- Prop: `market: 'fish'`; field: `garden` is its owning plot id; crop may be `vegetables`.
- Render stats: `byArchetype`, `catalogueBuildings`.
- Render result: `doorGrades` records actual fitted door inputs for inspection, without changing the plan.
- Pure helpers: `roadGeometry`, `roadSurface`, `frontOf`, `backBlocked`, `groundInputs`, and shared road/square lifts.
- Page: wealth-ring plan toggle, archetype counts, optional town-kit loading and `window.__built()` inspection hook.
No frozen field or required argument was renamed or removed.

### Evidence and limits
Viewed GPU city top/wealth-plan views and hill town seed 5 rear/front door views, including the same rear camera
before and after. Accepted street-door close-up shows the threshold meeting the cobbles. Artifacts:
`/tmp/w-plan-shots-before/` and `/tmp/w-plan-shots-after/` (the accepted close-up is
`hill-street-door-accepted.png`). GPU preview is disposable, loopback only, port 8984. Town-kit atoms were absent in
this worktree, so town props, shutters and rich add-ons used their documented missing-kit fallback. No kit assets
were modified. Barns still use the existing house stand-in; the tannery is a plot/use approximation, not a new type.
A few steep sites still report a short density, incomplete suburb or missing square tavern. No push or deploy.

## Round 5: carved ground and continuous fronts (8 Oct 2026)

Ground is built after choosing the best placement attempt. `heightOf(plan)` returns that carved ground for every
consumer, including a game-supplied natural terrain function. Natural terrain remains unchanged beyond the grade.
Road crossings share a small level landing; sharp bends get level landings too. The road graph's smoothed height
profiles use a 9 percent working limit for streets and main roads, below the 12 percent maximum, and 16 percent for
lanes. Stair roads keep their separate rise allowance. Squares are one plane. Pads are flat behind the facade, with
0.4 m clearance at their sides and back. Cut/fill blends have at least 3 m run, extended with the height difference.
Exposed road cuts/fills above 1 m create retaining walls using the existing walls kit and its grey-box fallback.

Optional fields only: `plan.grade = { cell: 1, x0, z0, nx, nz, heights, patches }`, `road.grade` (heights paired with
`road.pts`), `plot.pad` (oriented flat ground rectangle), and retaining wall `cut`, `bottom`, `top` (endpoint heights).
The grid stores the transition ground. Exact road triangles and pad planes supplement it at sub-cell boundaries so
small lips cannot appear at a door or curved road edge. These patches are plain serializable data; the lookup cache
is private to the module. No frozen name or required argument changed. Terrain uses 2 m cells in the graded region
and 4 m cells outside, on shared grid axes so there are no cracks at the resolution change.

Road ends now meet another road, a square, a loop, a low terminal garden wall, or continue as a rural road to the world
boundary. This is recorded in optional `road.ends`; terminal walls carry optional `terminal` (their road id). Fields
conflicting with a continued road are dropped. Optional `plan.paving` records town/city front aprons, joining each
facade to its road edge. Villages retain their verges. Fields and gardens are subdivided in both directions at metre
spacing rather than spanning a whole sloping garden in one striped quad.

Urban rows reserve 1.6 m alleys every six plot slots and a deterministic 0 to 0.4 m facade setback. Straight neighbouring
plots with small residual frontage gaps are fitted to the common party-wall line, without widening into another plot
or street. The renderer passes the exact `w` override first; only a generator that returns another width uses the old
bay-fitting fallback, with a named finding. Curved rows retain the existing safe rectangle placement: a rejected
inward-curving plot can still leave a break rather than overlapping its neighbour. This is a known round-5 limit,
not an irregular footprint extension to the frozen house generator.

Ground allocation and prop placement are deferred until the best density attempt is selected. Props are chosen on the
carved ground, not moved blindly from the natural hill. Their corner-height and lowest-foot checks remain unchanged.
JSON reconstruction keeps the same grade; no game needs the private spatial lookup cache. Missing-atom findings name
all missing atoms, including civic furniture even when many wall atoms are also absent.

Door clearance is enforced with conservative 1.6 m strips across each front facade and every permitted rear facade.
Wall segments are clipped with their physical thickness included, never laid across a house body; rear doors are
removed when their approach is blocked by another footprint. Props in those strips are omitted. West and south
landmark doors get the same strips. These pure helpers are optional exports: `doorZones` and `freeDoors`.

Optional plot and house overrides: `ground: { back: [min,max], left: [min,max], right: [min,max] }`, `irregular`,
`stepUp` (0 to 3). Ranges are metres relative to the actual street floor and sampled at metre spacing along the real
spec footprint in the renderer, not the parcel boundary. `groundInputs` additionally accepts optional `w` and `doorW`.
The renderer forwards these to the house generator and retains them in `doorGrades`. The older `backGrade` and
`backDoor` remain supported. House depth is capped to the available pad when no measured catalogue profile is found.

Every urban road with at least eight households receives a shop, bakery, smithy or tavern; street ends are favoured for
an added shop. Town/city squares retain a tavern where a plot fits, and a tavern is kept near a gate. Missing suitable
plots produce findings rather than overlaps. Gate suburbs now search each trade independently, so a late-fitting
smithy does not consume the barn's only opportunity. Barn plots still map to style type `barn`, with the existing
house fallback until the parallel house/style work is integrated. HUD counts by use and archetype already existed and
are preserved; no new page interface was needed.

House colliders use the ground-floor body, not a roof or upper-storey jetty projected onto the street. Low front
`prop.*` add-ons from a house style are omitted too, including missing-kit grey boxes. Stair flight scaling uses the
actual rise, with no artificial minimum rise on nearly level segments. A terrain-clipping experiment was rejected
because GPU views showed gaps; the committed renderer retains draped ribbons, front aprons and subdivided fields.
Some paving joins still expose grass, especially curved inner rows; exact facade-to-facade paving is not complete.

The runtime grade height buffer is Float32 to keep exhaustive seed checks within Node's memory limit. Its `toJSON`
returns an ordinary array, so the documented JSON grid and height sampling after reconstruction are unchanged.
Spatial rear-door checks reuse indexed footprints rather than repeatedly scanning every plot in a city.

The exhaustive placement-law test cache stores compressed grade JSON and reconstructs it only for height-dependent
checks. This retains every original seed and check. Two full-suite runs exhausted Node memory before this test-cache
change; further full-suite retries were stopped. Narrow checks and the round-5 ground/door matrix passed separately.
The complete suite must be rerun by the integrator before treating this branch as fully accepted.

### Round 5 acceptance record (partial)

Evidence is in `/tmp/w-ground-shots/`, including town/hill/5 aerial and climbing walk, village/hill/1 church-front
house door, and city/plain/5 street. The probe presses W and checks that the camera moves on the shared ground. An
additional disposable preview combines this branch with house branch `task/1791462969-2d8f69`; its captures are in
`/tmp/w-ground-shots/integrated/`. That branch was read into a scratch preview only, not merged or changed here.

Not complete: curved rows can have gaps left by safe rectangle rejection; some paving joins still show grass; the
full suite has not passed after its cache fix. Front/rear wall and prop clearances are tested across every tier/site
for seeds 1 to 5. The matrix does not prove all actual fitted doors against neighbouring fitted footprints. Terrain
blends use the stated 35-degree working formula, but no exhaustive bank-gradient acceptance test was added. Barn and
exact-width visual acceptance depends on the parallel house/style branch. No kits, styles, layout or live service
were changed. No push or deploy.