@woosh/meep-engine 3.56.0 → 3.58.0

package/src/generation/foliage/FOLIAGE_DESIGN.md

@@ -7,7 +7,7 @@ This document specifies a production-grade, State-of-the-Art (SotA) procedural t
 ### Core Design Tenets
 1. **Turn-Key Top Layer, Layered Override API Underneath**:
    - **Top Layer (1-line turn-key)**: `generate_tree({ preset: TreePreset.Oak, seed: 42 })` or `place_tree(scene_context, dataset, { preset: "pine", position: [10, 0, -5] })` produces a complete, multi-LOD, wind-rigged, PBR-materialized tree asset (`TreeAsset` / `SceneBundle` / `Prefab`) with zero external asset files required.
-   - **Mid Layer (Species & Generator Descriptors)**: Declarative `TreeSpeciesConfig`, `BranchLevelConfig`, `CrownConfig`, `FoliageConfig`, `BarkMaterialConfig`, `FoliageMaterialConfig`, and `TreeWindConfig` with `AnimationCurve` profiles and full JSON serialization.
+   - **Mid Layer (Species & Generator Descriptors)**: Declarative `TreeSpeciesConfig`, a branch generator graph (`BranchGeneratorConfig` nodes joined by `BranchSpawnRule` edges, foliage placed by `FoliageSpawnRule`s), `CrownConfig`, `FoliageConfig`, `BarkMaterialConfig`, `FoliageMaterialConfig`, and `TreeWindConfig` with `AnimationCurve` profiles and full JSON serialization.
    - **Low Layer (Pure Pipeline Passes)**: Composable, allocation-conscious pure functions operating on `Graph` skeletons, `Transform64` node frames, Hermite spine buffers, `PointHashGrid3` crown fields, and `Geometry` / `Attribute` buffers.
 2. **Zero Duplicate Adjacent Infrastructure**:
    - **Coordinate System**: Strictly Meep's right-handed **Y-up** convention (`Vector3.up = (0, 1, 0)`, ground plane `X-Z`).
@@ -106,23 +106,58 @@ Evaluating any point or derivative at local parameter $u \in [0, 1]$ along edge
 - `spline3_hermite_derivative(u, p0x, p1x, m0x, m1x)` (for $x, y, z$)
 
 ### 4.2 Hybrid Parametric + Space-Colonization Growth Algorithm
-For each recursion level $l \in \{0, \dots, L_{\max}\}$:
+Branches are grown breadth-first from the trunk (`species.branches[0]`). Every `species.branch_rules` edge
+`source -> target` (always `source < target`, so the graph is acyclic) spawns branches of generator `target` along
+each branch of generator `source`; one generator may spawn several kinds of children (boughs, roots, stubs, sprouts,
+inter-whorl branches) and several generators may spawn the same kind (fan-in). Branching depth $l$ counts lateral
+hops from the trunk; split forks keep their parent's depth and generator.
 1. **Crown Envelope & Space Colonization Field**:
    - The crown volume is defined by a configurable `CrownEnvelopeType` (`Conical`, `Spherical`, `Hemispherical`, `Cylindrical`, `TaperedCylindrical`, `Flame`, `InverseConical`, `TendFlame`, `Weeping`, or custom `AnimationCurve` profile) centered at $(0, H_{\text{crown}}, 0)$.
    - When `space_colonization_weight > 0`, $N_{\text{attract}}$ attraction points are sampled deterministically inside the crown envelope using `seededRandom` and indexed in a `PointHashGrid3` with cell size equal to the attraction radius $d_i$.
 2. **Branch Spawn & Phyllotactic Budding**:
-   - Along each parent branch of level $l - 1$, child branches are spawned above `bare_length_ratio` $t_{\text{bare}} \in [0, 1)$ according to the level's `PhyllotaxisMode` (`SpiralGolden` $137.507764^\circ$, `AlternateDistichous` $180^\circ$, `OppositeDecussate` $180^\circ + 90^\circ$ flip, `Opposite` $180^\circ$, `Whorled` $360^\circ / M$).
-   - Child branch length $L_l(t_p)$ is modulated by the parent's `length_profile: AnimationCurve` and the crown envelope $S_{\text{env}}(h_{\text{norm}})$.
+   - Along each parent branch, each outgoing rule spawns its children inside `[attach_min, attach_max]` according to the rule's `PhyllotaxisMode` (`SpiralGolden` $137.507764^\circ$, `AlternateDistichous` $180^\circ$, `OppositeDecussate` $180^\circ + 90^\circ$ flip, `Opposite` $180^\circ$, `Whorled` $360^\circ / M$, `FlareLobes` on the crests of the parent's basal buttress lobes).
+   - Child branch length $L_l(t_p)$ is modulated by the rule's `length_profile: AnimationCurve` and, for rules with `crown_envelope`, the crown envelope $S_{\text{env}}(h_{\text{norm}})$. Children of a rule without `crown_envelope` (roots, trunk sprouts) are neither shrunk by the envelope nor kept inside it.
+   - Self-pruning: below a crown rule's `attach_min` the rule once grew children too, at the same nodes continued down the stem; they died in the crown's shade. Each keeps `(1 - self_pruning) - age` of its length as a dead stub (age 0 just below the living children, 1 at the stem base; size at death `(1 - age)` of today's), and once that no longer clears the bark it is grown over and becomes a bark scar (knot).
+   - Generators with `root` grow structural surface roots: they descend onto the ground plane $y = 0$ and creep along it, add no pipe-model area to their stem, and never receive a wind joint.
    - Initial child heading $\mathbf{T}_c(0)$ diverges from parent tangent $\mathbf{T}_p(t_p)$ by insertion angle $\alpha_{\text{insert}}(t_p)$ around the azimuth $\phi_k$ in the parent's RMF plane $(\mathbf{R}_p, \mathbf{S}_p)$.
    - The child's initial RMF normal $\mathbf{R}_c(0)$ is aligned with the adaxial (upper crotch) projection of $\mathbf{T}_p$:
      $$\mathbf{R}_c(0) = \text{normalize}\big(\mathbf{T}_p - (\mathbf{T}_p \cdot \mathbf{T}_c(0))\mathbf{T}_c(0)\big)$$
      guaranteeing that $\theta = 0$ on the child's cross-section always lies at the top of the branch collar.
+   - **Dorsiventral parents** (`BranchGeneratorConfig.plagiotropism` $p > 0$, lateral generators only):
+     - **The plane.** A plagiotropic parent bears its buds in the plane of its tangent $\mathbf{T}_p$ and the horizontal
+       $\mathbf{H} = \mathbf{T}_p \times \mathbf{e}_y$ across it. The plane's normal is
+       $\mathbf{N} = \mathbf{H} \times \mathbf{T}_p$, which points up.
+     - **Ventral knockout.** No bud is emitted into the downward cone of half-angle $p\,\pi/2$.
+       - A bud whose own heading points into the cone does not break. That test is about where the bud sits on the
+         bough.
+       - Nor may fanning, or a turn for clearance, carry a bud's emitted heading into the cone. Each such candidate is
+         rejected, and a bud with none left does not break.
+       - Contact projection of a child's first segment can still deflect it in afterwards.
+     - **Fanning.** The surviving buds' radial direction loses $p\,|\mathbf{H}|$ of its component along $\mathbf{N}$,
+       fanning them into the plane. A vertical parent has no such plane, and its children are not fanned.
+     - **Which species.** Plagiotropism follows the species' architectural model (Hallé, Oldeman & Tomlinson's architectural models, as listed by Pfisterer (2000, *Mitt. Biol. Bundesanst.* 370) and Millet, Bouchard & Édelin (1999, *Écoscience* 6: 187–203)):
+       - **Massart's model** (*Picea*, *Abies*): tiers of plagiotropic branches. The spruce preset sets it.
+       - **Rauh's model** (*Pinus*, *Acer*, *Quercus*, *Betula*): branches orthotropic and built like the trunk. Those
+         presets set none.
+       - **Troll's model** (*Fagus*, *Tilia*, *Ulmus*): every axis plagiotropic. Not among the presets.
+       - The knockout is the least sourced part: laterals of a plagiotropic branch lie in its horizontal plane, but no
+         *Picea*-specific source was found for the fate of its ventral buds. On spruce it barely acts, since the buds are
+         already distichous.
+     - **Replaces.** This replaces an undocumented emission rule keyed on the *child's* gravitropism, which biased every
+       lateral's buds upward and off its underside.
+       - **Pads:** its effect was small (oak 0.750 with it, 0.789 without).
+       - **Headings:** its effect was not. Without it, oak has 3.8% of twigs more than 30° below the horizontal against
+         1.4% (mean heading y 0.327 against 0.398), and birch 1.2% against 0.6%.
+       - **No basis:** Rauh-model branches are orthotropic and branch radially, and the positional bias reported for
+         some of them is slight hypotony (lower-side laterals favoured; Millet et al. 1999), not an upward one.
 3. **Stepped Spine Integration with Tropisms, Gnarl, & Splits**:
    - As segment $k \to k+1$ advances by $\Delta s = L_l / N_{\text{seg}}$:
      - **Intrinsic curvature**: Pitch rotation around $\mathbf{S}_k$ by $\Delta \theta_{\text{curve}}(t_k)$ and helical twist around $\mathbf{T}_k$.
      - **Gravitropism (Y-up)**: Bending toward $-\mathbf{e}_y = (0, -1, 0)$ (or $+\mathbf{e}_y$ for negative gravitropism), weighted by mechanical tip compliance $\text{lerp}(0.2, 1.0, t^\gamma)$.
      - **Phototropism**: Steering toward $\text{normalize}(\alpha_{\text{sky}}\mathbf{e}_y + (1-\alpha_{\text{sky}})\mathbf{d}_{\text{radial}})$ to seek sky light and escape interior crown self-shading.
      - **Curl / Simplex Gnarl**: 3D divergence-free `curl_noise_3d` (or `sdnoise3_array`) projected perpendicular to $\mathbf{T}_k$.
+     - **Plagiotropism**: a lateral shoot with `plagiotropism` $p$ is steered by $-p\,T_{k,y}\,\mathbf{e}_y$ towards the horizontal. The apical `tip_upcurl` still turns its tip up, so conifer boughs keep their upturned ends.
+     - **Straightness**: `straightness` $\lambda$ adds $\lambda(\mathbf{T}_0 - \mathbf{T}_k)$, a pull back towards the heading the branch was given, so strong gnarl does not carry a branch out of its sector. $\mathbf{T}_0$ is the bud's heading. For the fork that continues a split it becomes the heading the split deflected it to, as the other forks aim along their own. It resists every deviation from that heading, droop included.
      - **Space Colonization Pull**: Queries `PointHashGrid3.forEachNear` around $\mathbf{p}_k$, pulling $\mathbf{T}_{k+1}$ toward unclaimed attraction points within radius $d_i$ and marking attraction points within kill radius $d_k$ as consumed.
      - **Sympodial / Dichotomous Forking (`split_probability`, `split_angle`, `split_Spread`)**: At segment $k$, a stem can bifurcate or trifurcate into $M \in \{2, 3\}$ daughter branches that diverge symmetrically in azimuth and pitch.
      - **RMF Transport**: Advances $(\mathbf{R}_k, \mathbf{S}_k) \to (\mathbf{R}_{k+1}, \mathbf{S}_{k+1})$ via Wang et al. (2008) **Double Reflection** with fallback to `tube_frame_transport`.
@@ -130,6 +165,40 @@ For each recursion level $l \in \{0, \dots, L_{\max}\}$:
    - After all branch levels are generated in `skeleton.graph`, a bottom-up post-order pass accumulates cross-sectional area using the Da Vinci / Murray Pipe Model law:
      $$R_{\text{pipe}}(v) = \left( R_{\text{tip}}^\alpha + \sum_{e=(v \to u)} R_{\text{pipe}}(u)^\alpha \right)^{1/\alpha}, \quad \alpha \in [2.0, 2.8]$$
    - The final radius at node $v$ blends the artist-controlled parametric taper curve (`radius_profile: AnimationCurve`) with the physical pipe model via `pipe_model_weight` $\in [0, 1]$.
+5. **Annual Shoot Layer** (`skeleton/tree_skeleton_grow_shoots.js`, `skeleton/shoot_systems_simulate.js`; see
+   `CROWN_FILLING_BRIEF_2026_10_26.md` and `SELF_ORGANIZING_FRAMEWORK_BRIEF_2026_10_26.md`):
+   - **Input.** Each `species.shoot_rules` entry (`ShootSystemRule`, its bud zones `ShootBudZone`) grows the
+     shoot system on every living branch of its `source` generator, after the pipe-model pass. A lateral is a branch
+     of the rule's `target` for its mother's order (short shoots `short_target`), one level below its carrier.
+   - **Time.** The framework is as old as it took to grow at `shoot_growth.leader_growth`; each carrier carries its
+     annual units over its length. The tree grows `max` of that and `shoot_growth.age` seasons. A carrier that
+     stopped growing before then grows on from its tip as an axis of its own order and generator, written onto it, so a
+     tree grown from a seed leader (the pine) is one stem from the ground up. The stem's units are
+     `shoot_growth.leader_unit(height)` (Kellomäki & Kurttio 1991, Eq. 6), not its unit before.
+   - **Each season, tree-wide**, under a voxel light field (`ShootLightField`: leaf area, Beer-Lambert from a standard
+     overcast sky) rebuilt round the crown as it grows:
+     - **Vigour.** The light each axis's tip receives flows down to its carrier and back up, shared at each node with
+       apical control `shoot_growth.apical_control` (Borchert-Honda, as Palubicki et al. 2009); a new unit's mean
+       length is scaled by its axis's vigour relative to the most vigorous. At 0.5 every vigour is 1.
+     - **Extension.** Every living axis grows a terminal unit. Its course turns by phototropism (towards where the
+       light field grows brighter), gravitropism, and a lateral's plagiotropism and straightness; zigzag kinks the unit
+       off the course, not the course. Short shoots survive as their light allows.
+     - **Buds.** Last season's units burst their zones' buds (and this season's, sylleptically). A bud breaks where
+       there is room, else turns by the golden angle round its node.
+     - **Shedding.** A new shoot survives at `net_yield(Q, gross) / gross`, `gross` the yield of the unit it grew on:
+       in full light every shoot is kept, and only shade sheds. A shed axis takes everything on it.
+     - **Wood.** The wood thickens with what it carries (`ShootGirth`): Table 7 (`d = 0.27 + 0.13 age + 0.02 l` cm)
+       for a unit of its age, the pipe model at the species' exponent, and 1 / 0.82 of a lateral where it joins.
+   - **Avoidance** (`ShootFrameworkHash`, `ShootWoodHash`). No unit grows into the ground, through framework wood, or
+     through older shoot wood it does not join: a mother either side of where it grew and over its crotch, a
+     grandmother at its mother's base, a carrier's extension and the carrier's laterals by its tip, and siblings'
+     first units within the collar they share (out of the mother's wood, at least half way). A shoot whose line
+     thicker (or as thick and older) wood has grown into dies; so does a lateral whose tip the wood its mother grew
+     since has closed over, and a carrier its parent has grown over, with its twigs. Graph branches buried by the
+     thickening are dead.
+   - **Leaves pay.** A lateral of a generator that bears no leaves (no foliage rule) does not grow.
+   - **The record.** Every carrier and twig records where each of its annual units starts
+     (`TreeSkeleton.branch_unit_start_t`), for the foliage pass (§6.1).
 
 ---
 
@@ -150,9 +219,15 @@ For any lateral branch ($l \ge 1$) attached to a parent branch of radius $R_p$ a
    - At $u = 0$, the vertex normal is set to the parent cylinder's outward radial normal $\mathbf{n}_{\text{parent}}$ at the contact point.
    - Across $u \in [0, 1]$, the vertex normal is interpolated via spherical/normalized linear blend between $\mathbf{n}_{\text{parent}}$ and the child's analytic tapered tube normal $\mathbf{n}_{\text{child}}$.
 
-### 5.3 Watertight Adaptive Radial & Longitudinal Tessellation
-- Ring radial vertex count $M_i$ adapts to local radius $R(t_i)$ and target LOD scale:
-  $$M_i = \text{clamp}\!\left( \lceil 2\pi R(t_i) / \epsilon_{\text{radial}} \rceil, \, M_{\min}, \, M_{\max} \right)$$
+### 5.3 Watertight Tessellation at a Geometric Error
+- Each LOD draws the bark to its error $\epsilon$ (`TreeLODConfig.error`, m): a branch is drawn while its wood is at
+  least $\epsilon$ thick and its parent is drawn, and its spine ends where it thins to $\epsilon$.
+- Rings stand where the surface needs them: candidates at every node, every segment's middle and every collar and knot
+  centre are measured all round (spine, radius, lobes, flutes, ovalization, collar bosses, knots, the weld's flare; bark
+  relief is the normal map's), and Douglas-Peucker (`polyline_simplify_by_error`) keeps those the rings either side
+  would miss by more than $\epsilon / 2$.
+- Each kept ring has the fewest sides $M_i$ whose polygon misses none of its measured points, nor its shape at any
+  chord's middle, by more than $\epsilon / 2$; for round wood of radius $R$ that is $R (1 - \cos(\pi / M_i)) \le \epsilon / 2$.
 - Whenever $M_{i+1} < M_i$ between consecutive rings $i$ and $i+1$, a **manifold zippering strip** advances around $\theta \in [0, 2\pi]$ on whichever ring has the smaller next normalized angle $j / M$, emitting $M_i + M_{i+1}$ triangles with **zero T-junctions** and preserving UV seam duplication at $\theta = 0$ and $\theta = 2\pi$.
 - Branch tips are closed with either a tapered apex fan (when $R_{\text{tip}} \le \epsilon$) or a rounded cap.
 
@@ -167,17 +242,94 @@ For any lateral branch ($l \ge 1$) attached to a parent branch of radius $R_p$ a
 
 ### 6.1 Phyllotactic Attachment Generator
 Generates `FoliageAttachment` transforms along carrier branches of levels $l \in [l_{\text{min}}, L_{\max}]$:
-- Supports `SpiralGolden` ($137.507764^\circ$), `AlternateDistichous` ($180^\circ$), `Tristichous` ($120^\circ$), `Opposite` ($2\times 180^\circ$), `OppositeDecussate` ($2\times 180^\circ$ with $90^\circ$ alternation), and `Whorled` ($M$ organs per node), plus terminal rosette clustering at branch tips ($t \to 1$).
+- Supports `SpiralGolden` ($137.507764^\circ$), `AlternateDistichous` ($180^\circ$), `Tristichous` ($120^\circ$), `Opposite` ($2\times 180^\circ$), `OppositeDecussate` ($2\times 180^\circ$ with $90^\circ$ alternation), and `Whorled` ($M$ organs per node), with nodes spaced evenly over the carrier's leafy span.
+- **Card density is derived, not authored** (`skeleton/foliage_card_density.js`):
+  - **The sleeve.** A card leaves the shoot at insertion angle $\alpha$ and reaches $L$, so the shoot wears a foliage
+    sleeve of radius $R = L \sin\alpha$.
+  - **One leaf per line of sight.** The carrier holds just enough leaf that a line of sight through that sleeve meets
+    one leaf on average. By Cauchy's formula the sleeve's mean projected area is a quarter of its surface ($2\pi R$ per
+    metre), and a flat leaf's is half its area. So the leaf area is $\pi R$ per metre, and
+    $$n = \frac{\pi \sin\alpha \,(1 - v_a)}{S \, s \, \phi \, P}\ \text{cards per metre}.$$
+    The terms:
+    - $S$ is the side of the species' square card, the size its tile draws its leaf at (`foliage_tile_layout`, §6.3),
+      and $s$ the card scale on that shoot.
+    - $\phi$ is the atlas's measured leaf coverage (`FoliageAtlasCutout.coverage`).
+    - $P$ is the number of planes a card stands up (2 for `CrossCard`, 3 for `TriStarCluster`).
+    - $v_a$ is where the tile's leaf attaches (`FoliageTileLayout.anchor_v`): the card's length spans the tile from
+      there.
+  - **Leafy span.** It starts at the rule's `attach_min`, honoured up to 0.92 (`foliage_leafy_span_start`), for the
+    cards and the sail alike.
+  - **Rounding.** The expected count is rounded with a golden-ratio dither per (branch, rule), so it is exact on
+    average.
+  - **Annual units replace the rule.** A branch that records its annual units (`TreeSkeleton.branch_unit_start_t`,
+    written by the annual shoot layer, §4.2) carries, on each unit, its leaves (`leaves_per_unit + leaves_per_metre L`,
+    times `leaf_survival` at the unit's age; a short shoot `leaves_per_short_shoot` at its tip), in place of the
+    density rule (`foliage_unit_card_spans`).
+    - **A card a leaf.** Each leaf is a card at its own node along the unit, leaving the shoot at the rule's insertion
+      angle and turned by its phyllotaxis. A needle-shoot card draws a stretch of shoot with its needles instead, as
+      many as the shoot bears there, and lies along it.
+    - **Maturity.** Each card draws its own maturity from its branch.
+    - **Wind.** The joint mechanics load the same card on that unit.
+  - **Wind.** The joint mechanics take the same $\pi R$ per metre as the foliage's sail. The wind rig and the cards
+    agree within 0–3.5% on every preset (size variance and length floors).
+- **Abscission and wilt** (`skeleton/foliage_senescence.js`):
+  - **Each tile's onset.** The pigment model ages each atlas tile at its own pace: a tile of maturity $\mu$ is at stage
+    $\sigma_k = \sigma(0.80 + 0.36|\mu - 0.35|) + 0.12\sigma^2$ (`foliage_variant_senescence`), and retains
+    $1 - \sigma_k(1.36 - \text{shielding})$ of its chlorophyll. Its exposed lamina is bare once $\sigma_k = 1/1.36$.
+    `foliage_variant_abscission_onset` solves that for the tree's senescence, $\sigma_0(\mu)$: 0.66 for mature tiles,
+    0.73 for juvenile ones and 0.82 at $\mu = 0.35$. No leaf falls or dries before its own tile's onset.
+  - **Each card's threshold.** After that, exposure orders the fall. A card's threshold
+    $\theta \in [\sigma_0(\mu), 1]$ comes from the mean of its sun exposure ($0.62\,\rho_{\text{shell}} + 0.38\,h_{\text{norm}}$)
+    and its position along its shoot. Outer and apical leaves fall first, and the crown is bare at $\sigma = 1$.
+  - **Dryness.** Between its onset and its fall the card dries: $d = (\sigma - \sigma_0)/(\theta - \sigma_0)$.
+    - The mesh builder takes a folding card (`FoldedVCard`, `RibbedFrond`, `CutoutHull`) towards a leaf with no turgor:
+      the fold closes towards $\pi/2$, the arch goes to 0, and the droop goes to 1. `CrossCard` and `TriStarCluster`
+      have no fold and do not wilt.
+    - A card just before its fall is nearly shut, a valid sliver.
+  - **Wind.** The joint mechanics shed the same leaves from their sail. They judge the expected leaf (no jitter) at each
+    segment's middle.
 - **Heliotropic & Gravitropic Orientation**:
   - Reorients each leaf/frond basis $(\mathbf{F}, \mathbf{U}, \mathbf{W})$ so its adaxial normal $\mathbf{U}$ tilts toward the sky + canopy-outward light vector (`phototropism` $\in [0, 1]$) while its forward tip $\mathbf{F}$ droops under `gravitropism` $\in [-1, 1]$, with seeded angular jitter to prevent specular aliasing.
 
 ### 6.2 Foliage Topologies
 Supports 5 production real-time foliage card/mesh archetypes:
-1. **`FoldedVCard` (Default Broadleaf Cluster)**: $2 \times 2$ or $2 \times 3$ grid with transverse V-fold angle $\beta_{\text{fold}}$, longitudinal midrib arch $h_{\text{arch}} \sin(\pi v)$, and tip camber $-h_{\text{camber}} v^2$. Never appears razor-flat at grazing view angles.
-2. **`CrossCard` (Conifer Needle Tuft / Dense Shrub Cluster)**: Two orthogonal intersecting V-cards rotated by $90^\circ$ around the petiole axis $\mathbf{F}$.
-3. **`TriStarCluster` (Volumetric Bush / Pine Shoot)**: Three cards arranged at $60^\circ$ star angles with radial offset.
+1. **`FoldedVCard`**: $2 \times 2$ or $2 \times 3$ grid with transverse V-fold angle $\beta_{\text{fold}}$, longitudinal midrib arch $h_{\text{arch}} \sin(\pi v)$, and tip camber $-h_{\text{camber}} v^2$. Never appears razor-flat at grazing view angles.
+2. **`CrossCard` (needle shoot)**: Two orthogonal intersecting V-cards rotated by $90^\circ$ around the shoot axis $\mathbf{F}$; each plane draws the needles in its sector round the shoot (§6.3).
+3. **`TriStarCluster` (needle shoot)**: Three cards arranged at $60^\circ$ star angles, each drawing its sector's needles.
 4. **`RibbedFrond` (Palms, Ferns, Cycads, Weeping Boughs)**: Multi-segment curved Cubic Hermite frond spine with RMF transport, longitudinal V-fold variation, and width profile $W(t) = W_{\max} \sin(\pi t^{p_w})$.
-5. **`OctagonalCutoutHull` (Tight Alpha-Bound Card)**: 6-vertex diamond/hexagonal hull trimming empty corner texels to cut alpha-test quad overdraw by ~35%.
+5. **`CutoutHull` (Fitted Alpha-Bound Card, the broadleaves' leaf)**: the convex hull of everything its atlas tile
+   draws, reduced to 6 vertices and fanned around a midrib vertex.
+   - **Shape.** Each half turns about the midrib by `fold_angle`, and the card arches and droops along its length like
+     a frond spine.
+   - **Fitting.** `make_foliage_material` fits the hulls while it synthesizes the atlas (`FoliageAtlasCutout`):
+     - Each covered texel row contributes the outer corners of its first and last texel that has any alpha.
+     - `convex_hull_monotone_2d` hulls those points.
+     - `convex_hull_fixed_count_2d_relaxation` reduces the hull to 6 vertices inside the tile, inset by half a texel
+       (its `bounds`), so no corner reaches the atlas neighbour.
+     - When no edge can be removed without leaving the tile, the unbounded fit is clipped to the tile
+       (`polygon2_clip_axis_halfplane`) and relaxed again.
+     - If that stalls too, the hull is the silhouette's bounding box as a hexagon. It is looser, but it holds every drawn
+       texel. Clamping the unbounded fit's corners instead would cut the leaf.
+   - **Result.** A willow's lanceolate leaf is cut far tighter than a hazel's broad one (`foliage_atlas_cutout.spec`).
+   - **Custom material.** With a caller's own material, the cards cover whole tiles.
+
+### 6.3 Leaf Architecture and the Atlas Tile
+Every tile draws the species' own leaf at its true size (`material/leaf_geometry.js`, `material/foliage_tile.js`;
+`LEAF_ARCHITECTURE_BRIEF_2026_10_26.md`):
+- **The leaf, as floras describe it** (`LeafArchitecture`, in the terms of Ellis et al. 2009, *Manual of Leaf
+  Architecture*): blade length and length/width ratio, where it is widest, apex and base angles and shapes, pinnate or
+  palmate lobes with their sinus depth, teeth a centimetre and their depth and order, secondary veins and their
+  angle, petiole length; a compound leaf's leaflets and rachis. Each preset cites its flora.
+- **The outline** is a monotone cubic Hermite envelope through the base, the base angle's point a quarter of the way up,
+  the widest point, the apex angle's point and the apex; rounded ends are arcs, acuminate ones concave. A pinnately
+  lobed blade is a body out to the sinus floors plus a rounded lobe along each secondary vein; a palmate one is a lobe
+  per primary vein over a body; teeth are offset along the outline's normal. All contours wind the same way, so
+  `polygon2_rasterize_coverage` fills their union by the nonzero rule with exact coverage across each row.
+- **The tile** draws the mature leaf filling it within a 2% margin, attached at the bottom middle; younger leaves are
+  smaller. The card is that tile at that scale: its size is the leaf's. The resolution draws the leaf's finest feature
+  (a tooth, a sinus) four texels across and its stems two, so they survive the alpha test.
+- **Needle shoots** draw a stretch of shoot as long as a needle, its needles shared among the card's planes, each
+  plane showing those in its sector round the shoot, foreshortened by their azimuth.
 
 ---
 
@@ -187,6 +339,11 @@ Supports 5 production real-time foliage card/mesh archetypes:
 - **Per-Vertex Canopy AO (`StandardAttributes.Color`)**:
   - Combines macro crown ellipsoid depth $AO_{\text{crown}}(\mathbf{v}) \in [AO_{\text{core}}, 1.0]$ with local hierarchy depth $AO_{\text{local}}(v) \in [0.7, 1.0]$ (darkening inner branch crotches and petiole bases while brightening outer sun-exposed tips).
   - Multiplied with optional per-cluster hue/value jitter in `StandardAttributes.Color` (`vec3<f32>`), which `StandardShadeMaterial` automatically multiplies with `texture_albedo` in the G-buffer pass.
+  - **Tint headroom.** Vertex colours are encoded as `unorm8`, so on their own they can only darken. Each card's tint
+    (`FoliageAttachmentSet.tints`) is free to exceed 1. The builder writes `tint / tint_scale`, where `tint_scale` is
+    the largest tint channel, and the foliage material's `diffuse_color` (the shader's `albedo_color`) carries
+    `tint_scale` back. The product is exactly `albedo · tint · AO`. Across the presets `tint_scale` is about 1.1, and
+    about half of all tint channels exceed 1.
 - **Spherized / Puffed Foliage Normals (`StandardAttributes.Normal`)**:
   - Blends the geometric card normal $\mathbf{n}_{\text{card}}$ with the canopy-outward normal $\text{normalize}(\mathbf{v} - \mathbf{C}_{\text{crown}})$ by `normal_puffiness` $\in [0, 0.85]$ before running `geometry.ensureTangents()`, giving leaf clusters soft volumetric canopy lighting.
 
@@ -212,21 +369,47 @@ Meep's visibility-buffer renderer (`Shade`) deforms `MeshletGeometry` on the GPU
 When the caller does not pass custom `bark_material` or `foliage_material`, the system synthesizes studio-quality procedural PBR textures using `Sampler2D` $\to$ `ShadeImage.fromSampler2D` $\to$ `ShadeTexture.from`:
 1. **`make_bark_material(config)`**:
    - Generates tileable (`TextureWrapType.Repeat`) bark **Albedo** (fissured ridges, lenticels/stripes for birch, warm heartwood/moss undertones), **Tangent-Space Normal Map** (derived analytically from height gradients), and **ORM Map** (`R`: fissure occlusion, `G`: micro-roughness, `B`: 0 metalness) on a `StandardShadeMaterial` (`TransparencyMode.Opaque`, `ShadeDrawSide.Front`).
-2. **`make_foliage_material(config)`**:
-   - Generates a botanical twig/leaf or conifer-needle cluster **Albedo + Alpha Cutout** texture (serrated/lobed/ovate/palmate/needle silhouettes, midrib & lateral venation, premultiplied RGBA compatible with Shade's `albedo_unpremultiply` and hashed alpha test), **Tangent-Space Normal Map** (vein relief), and **ORM Map** on a `StandardShadeMaterial` (`TransparencyMode.AlphaTested`, `ShadeDrawSide.Double`, `transmission_factor: 0.25`).
-
-### 7.4 Multi-LOD Chain with Area-Compensated Foliage Decimation
-Generates a configurable $N$-level LOD chain (default 4 levels: `LOD0`, `LOD1`, `LOD2`, `LOD3`):
-- **Branch Hierarchy & Ring Reduction**:
-  - `LOD0`: All branch levels, full radial segments ($M_0 = 16 \to 4$), $100\%$ foliage cards ($2 \times 3$ folded V-cards).
-  - `LOD1`: Prunes finest sub-twigs below radius threshold, reduces radial segments by $0.65\times$, retains $55\%$ foliage cards ($2 \times 2$ V-cards).
-  - `LOD2`: Retains trunk + primary/secondary boughs, reduces radial segments by $0.4\times$, retains $28\%$ foliage cards (single-fold cards).
-  - `LOD3`: Coarse structural trunk/boughs + $12\%$ large cross-cluster canopy cards.
-- **Golden-Ratio Stratified Decimation & Area Compensation**:
-  - Foliage attachments are filtered deterministically via Golden Ratio low-discrepancy rank $h_i = (i \cdot \varphi^{-1}) \bmod 1 < k_{\text{keep}}$, ensuring uniform thinning across every branch.
-  - Surviving cards are scaled around their petiole pivot by:
-    $$s_{\text{comp}}(k_{\text{keep}}) = k_{\text{keep}}^{-\eta}, \quad \eta = 0.42$$
-    preserving apparent optical density and crown silhouette across all LOD transitions.
+2. **`make_foliage_material(species)`**:
+   - Generates the species' leaf (or needle shoot) **Albedo + Alpha Cutout** texture from its `LeafArchitecture` (§6.3: outline coverage, midvein and secondary veins, petiole, premultiplied RGBA compatible with Shade's `albedo_unpremultiply` and hashed alpha test), **Tangent-Space Normal Map** (camber, vein relief, bullation), and **ORM Map** on a `StandardShadeMaterial` (`TransparencyMode.AlphaTested`, `ShadeDrawSide.Double`, `transmission_factor: 0`).
+
+### 7.4 Multi-LOD Chain
+Each LOD (default 3) is the tree drawn to a geometric error $\epsilon_k$, in metres (`LOD_REWORK_BRIEF_2026_10_27.md`):
+- **Bark** (§5.3): wood at least $\epsilon_k$ thick, its rings and sides as few as keep the surface within it.
+- **Cluster cards for what the wood leaves out.** Each cut is one card (`tree_clusters`, `tree_cluster_cards`): an
+  undrawn branch on drawn wood with everything it carries, or a drawn branch's undrawn tip; a leaf on drawn wood joins
+  its branch's nearest cut. The card lies in the plane what it draws spreads in: its leaves' cards and its twigs' bands,
+  each by its area (the least-spread axis is its normal), facing away from the crown's centre. Where its leaves attach
+  is not enough: a palm's attach along a rachis arching in a vertical plane while they spread to either side. Its depth is not held to the error, as
+  SpeedTree's cluster cards' is not; holding every leaf within the error of a plane needs 12-16 cm before LOD0 fits.
+- **A few tiles for every cut** (`tree_cluster_representatives`): the fewest cuts whose tiles draw every cut of every
+  LOD with its leaves magnified no further than the tree's own leaves vary (the 10th to 90th percentile of their
+  sizes), within the tree's texture ceiling. A cut draws its representative on its own plane, as large as it draws
+  (its leaves' and twigs' area: sized by its extent instead, the shrub's crown lost .12 of its density), hanging where it
+  hangs, turned to run out its way. All of a tree's LODs share the one atlas.
+- **The texel is the leaf's**: the leaf material's own (`FoliageTileLayout.texel`), coarsened by halves only while the
+  cover does not fit the texture ceiling, never past what still tells the leaf from another
+  (`FoliageTileLayout.legible_texel`: its outline's finest feature, teeth aside, four texels across, a needle two
+  across its width); a coarser LOD's representative at the error of the LOD before it, where that one is drawn to a
+  pixel. Tied to the LOD's error, LOD0's leaves were six texels long.
+- **The bake** (`tree_cluster_bake`): each representative's tile is drawn orthographically from the leaves and twigs
+  the tree grew, at its texel, 4x4 samples a texel, back to front in linear light. Every leaf is first pressed
+  onto its card, turned about where it attaches until it lies in the card's plane, so a card shows the leaf area the
+  tree grew whichever way the leaves face; projecting them instead loses half a leaf turned 60 degrees away. Twigs
+  are bands their length by their diameter. Albedo, normal (in the card's frame) and ORM tiles pack into one atlas per
+  LOD (`MaxRectanglesPacker`), each card a 6-vertex hull fitted to its tile's alpha
+  (`foliage_atlas_cutout_fit_alpha`), fanned, 6 triangles. Canopy AO is in the tiles, not the vertices.
+- **The rig per LOD** (`tree_lod_plan`): the joint walk (`tree_skeleton_assign_skin_joints`, §7.2) runs over the
+  wood the LOD draws, no further out than its bark, at a tolerance of `max(deflection_tolerance, eps_k)`: a sway
+  smaller than the shape's error cannot be seen. A coarser LOD places joints only where the finer has one, so a switch
+  keeps the joints both share. A card is skinned as the bark point it hangs from
+  (`interpolate_ring_skin_weights4`); its flutter grows with distance from that point. Each LOD's builders bind its
+  rig (`tree_skeleton_bind_skin_joints`) before meshing.
+- **Each LOD's error from its ceiling** (`tree_lod_plan`): the finest, a half-octave apart from
+  `TREE_LOD_ERROR_FINEST` (1 cm), at which the tree's triangles and its rig's joints per m^2 of what it grew
+  (`tree_grown_side_area`) fit `TREE_RENDER_COST_CEILING` at that LOD, and never finer than the LOD before. The atlas is
+  held to the ceiling's texture bytes per m^2.
+- **The leaves as grown** (`tree_mesh_build_foliage`, every leaf a card) are the reference the bakes draw from and the
+  measures hold the LODs to; no LOD draws them.
 
 ---
 
@@ -239,10 +422,13 @@ src/generation/foliage/
   config/
     CrownEnvelopeType.js
     PhyllotaxisMode.js
-    FoliageCardType.js
+    FoliageCardType.js
     FoliageBarkType.js
     TreePreset.js
-    BranchLevelConfig.js
+    BranchGeneratorConfig.js
+    BranchSpawnRule.js
+    FoliageSpawnRule.js
+    ShootSystemRule.js
     CrownConfig.js
     FoliageConfig.js
     BarkMaterialConfig.js
@@ -258,22 +444,43 @@ src/generation/foliage/
     spine_frame_double_reflection.js (+ .spec.js)
     tree_skeleton_grow.js (+ .spec.js)
     tree_skeleton_compute_pipe_radii.js (+ .spec.js)
+    shoot_demography.js (+ .spec.js)
+    tree_skeleton_grow_shoots.js (+ .spec.js)
     tree_skeleton_assign_skin_joints.js (+ .spec.js)
+    tree_skeleton_bind_skin_joints.js
+    tree_skeleton_grow_growth_modifiers.spec.js
+    foliage_card_density.js
+    foliage_senescence.js
   mesh/
     branch_collar_project.js (+ .spec.js)
     branch_ring_triangulate.js (+ .spec.js)
     tree_mesh_build_bark.js (+ .spec.js)
-    foliage_collect_attachments.js (+ .spec.js)
-    tree_mesh_build_foliage.js (+ .spec.js)
+    foliage_collect_attachments.js (+ .spec.js, _density.spec.js)
+    foliage_seasons.spec.js
+    tree_mesh_build_foliage.js (+ .spec.js, _cutout.spec.js)
     tree_mesh_apply_canopy_ao.js (+ .spec.js)
+    tree_clusters.js (+ .spec.js)
+    tree_cluster_cards.js (+ .spec.js)
+    tree_mesh_build_clusters.js
+    tree_cluster_representatives.js (+ .spec.js)
   material/
     make_bark_material.js (+ .spec.js)
     make_foliage_material.js (+ .spec.js)
+    compute_foliage_variant_atlas_layout.js
+    foliage_leaf_silhouette.js
+    FoliageAtlasCutout.js
+    foliage_atlas_cutout.js (+ .spec.js)
+    tree_cluster_bake.js (+ .spec.js)
+    tree_cluster_press.js
+    tree_cluster_tiles.js
+    tree_cluster_atlas_pack.js
+    foliage_material_from_samplers.js
   animation/
     build_tree_wind_rig.js (+ .spec.js)
   asset/
     TreeLODAsset.js
     TreeAsset.js
+    tree_lod_plan.js (+ .spec.js)
     generate_tree.js (+ .spec.js)
     place_tree.js (+ .spec.js)
 ```

package/src/generation/foliage/LEAF_ARCHITECTURE_BRIEF_2026_10_26.md

@@ -0,0 +1,158 @@
+# Leaf Architecture
+
+## Problem
+
+The oak's cards did not look like oak leaves (Alex, 2026-10-26: "What the fuck is that?"). Two causes, both hacks:
+
+- **The leaf outline was code, not botany.** `foliage_leaf_silhouette.js` switched on a string, `"lobed"` (a ±28% sine
+  ripple, "oak-like"), `"serrated"` (a sawtooth), `"palmate"` (a cosine), each with hand-picked constants. The oak's
+  `"lobed"` blade was widest near its base, with shallow wavy edges: a Christmas tree.
+- **A whole shoot was painted flat into one texture.** The `"rosette"` arrangement drew 11 leaves from one point,
+  fanned over ±83°, each three-quarters as wide as long. They merged into one blob with 11 tips. A `TriStarCluster`
+  stood three of those on crossing planes, which is the star in the screenshot. Meanwhile the simulation grows the
+  real shoots, so the tile duplicated the shoot geometry and contradicted it.
+
+Fixing the oak's outline alone would have kept both hacks.
+
+## Principle
+
+- **A leaf is data, described as floras describe it.** Ellis et al. (2009), *Manual of Leaf Architecture*, gives the
+  vocabulary; each preset cites its flora.
+- **A card is one leaf, on its shoot.** Each leaf is a card at its own node, leaving the shoot at the rule's insertion
+  angle and turned by its phyllotaxis.
+- **Needles stay shoot cards.** Pine bears 1,560 needles per metre and spruce 2,450 (sourced in the presets). A card
+  per needle is out of reach, and the needle shoot is the unit those papers measure.
+
+## Design
+
+- **`LeafArchitecture`** (`FoliageMaterialConfig.leaf`):
+  - blade length, length/width ratio, where it is widest;
+  - apex and base angle and shape (`LeafApexShape`, `LeafBaseShape`; the angles measured as Ellis et al. define them,
+    a quarter of the blade's length from the tip or the base);
+  - lobation (`LeafLobation`), lobes, sinus depth, palmate spread and lateral lobe length;
+  - teeth per cm, tooth depth and order;
+  - secondary veins and their angle;
+  - petiole length;
+  - a compound leaf's leaflets and rachis.
+- **`leaf_geometry`** turns that into outline contours, veins and stems in metres:
+  - **Envelope:** a monotone cubic Hermite (Fritsch-Carlson) through the base, the base angle's point, the widest point,
+    the apex angle's point and the apex. The shapes set the end slopes. A rounded end is an elliptic arc; an acuminate
+    one is shallow, so the margin is concave near the tip.
+  - **Pinnate lobes:** the blade reaches only to the sinus floor, `1 - sinus_depth` of the outline's width. Each lateral
+    lobe is a rounded blade of its own along its secondary vein (so it leans by the vein's angle), out to the outline.
+    The veins leave the midvein evenly spaced.
+  - **Palmate lobes:** a blade per primary lobe, radiating across `lobe_spread`, over a body to the sinus floors.
+  - **Base lobes:** cordate and lobate bases are a cubic Bezier from the petiole sinus round the basal lobe, solved to
+    reach exactly `base_lobe_depth` below the petiole.
+  - **Teeth:** offset along the outline's normal, spaced along the untoothed margin, with a second order a third the
+    size.
+  - **Union:** every contour winds the same way, so the union of lobes, leaflets and petiole is filled by the nonzero
+    rule (`polygon2_rasterize_coverage`, exact across each row, 4 samples down it).
+- **`foliage_tile_layout`** (one place for every consumer):
+  - The mature leaf fills the tile within a 2% margin, attached at the bottom middle. Every tile draws at that scale,
+    so the card's size in metres is the leaf's (`card_size`).
+  - **Resolution:** the finest feature (a tooth, a sinus) is drawn 4 texels across. The narrowest stem is drawn 2
+    texels across, so wherever it falls it covers a whole texel and survives the alpha test.
+  - **Needle shoots:** a stretch of shoot as long as a needle, with the needles the shoot bears there
+    (`leaves_per_metre`), shared among the card's planes. Each plane draws the needles in its sector round the shoot,
+    foreshortened by their azimuth.
+- **`foliage_tile_raster`:**
+  - Coverage, veins stamped near each segment, distance to the margin and to the midvein by chamfer, camber,
+    bullation, and the petiole.
+  - The pigment, senescence and normal code of `make_foliage_material` is unchanged. It now skips the texels the leaf
+    leaves empty, which keep the dilated fill.
+- **Cards:**
+  - **Broadleaves:** a card per leaf. A short shoot's `leaves_per_short_shoot` sit at its tip. The presets draw
+    `CutoutHull` cards.
+  - **Needle cards** lie along the shoot.
+  - **Density path:** branches not grown by annual units keep it, on the layout's card size and anchor.
+
+## Sources per species
+
+| preset | leaf | sources | estimated, not found |
+| :--- | :--- | :--- | :--- |
+| oak (*Quercus robur*) | mean blade 10.6 and 12.0 cm; L/W 1.8, 1.64; width 0.81-0.85 of max at 0.5 L, 0.47-0.50 at 0.9 L; petiole 7.4-8.0% of blade | Boratyński et al. 2008, *Silva Fennica* 42: 115-124, Table 4. Fitted: widest at 0.675, apex angle 1.2, base 0.8 rad (both widths within 0.01) | auricle size, secondary angle |
+| | obovate; apex broadly rounded; sinuses 1/3-7/8 to midrib; entire; 5-7 secondaries | FNA vol. 3 | |
+| | 5-7 lobes a side | Flora of China | |
+| | up to 5 pairs; auricles usually strong | BSBI Plant Crib | |
+| birch (*Betula pendula*) | 3-7 × 2.5-5 cm, ovate-rhombic, acuminate, cuneate, doubly serrate | FNA | apex and base angles, teeth (1.3 a cm, 1.5 mm), widest point |
+| | 6-8 lateral veins; petiole 2-3 cm | FoC | |
+| | 2 leaves a short shoot | Maillette 1982 | |
+| willow (*Salix babylonica*) | 90-160 × 5-20 mm, L/W 5.5-10.5, acuminate, cuneate, serrulate; petiole 7-9 mm | FNA vol. 7 | angles, teeth (5 a cm, 0.3 mm), veins |
+| maple (*Acer rubrum*) | 6.8 cm, 39 cm² | Wilson 1966 | lobe outline, lateral lobe length 0.85, teeth (3 a cm, 1.5 mm) |
+| | 3 lobes; lateral axes 73-86° apart; midlobe 46-56% of blade; petiole 60-114% of blade; 2 leaf pairs a short shoot | Critchfield 1971 | |
+| | doubly serrate | Gleason & Cronquist | |
+| | base truncate to cordate | Trees and Shrubs Online | |
+| shrub (*Corylus avellana*) | 5-12 × 4-12 cm, abruptly acuminate, narrowly cordate, doubly serrate, ≤ 8 vein pairs | FNA | angles, base lobe depth, teeth (0.7 a cm, 2.5 mm) |
+| | petiole 6-12 mm | Trees and Shrubs Online | |
+| | 8 cm gives the 41 cm² of a sun leaf | Catoni et al. 2015 | |
+| pine, spruce needles | 52 mm [Niinemets & Lukjanova 2003]; spruce's 18 mm was already chosen | | widths 1.6 and 1 mm; needle angle 0.6 rad |
+| palm, fern | no species named: the old frond's sizes are kept | | everything |
+
+The botanical data was gathered by a research subagent from efloras.org (FNA, FoC), BSBI, VicFlora, Go Botany, Trees
+and Shrubs Online, SEINet and the papers above. Its quotes and URLs are in the session's scratchpad (`leaf/`).
+floranorthamerica.org refused access, and HAL (Kremer et al. 2002) is behind a bot check.
+
+## Measured
+
+*Seed 1337 unless noted; the "before" figures are from 49845ff00.*
+
+**Atlas, from the drawn tiles:**
+
+| preset | resolution | card | coverage | one leaf |
+| :--- | ---: | ---: | ---: | ---: |
+| oak | 128 | 12.7 cm | 0.208 | 33 cm² |
+| birch | 256 | 7.8 cm | 0.174 | 10.6 cm² |
+| willow | 512 | 13.9 cm | 0.073 | 14 cm² |
+| maple | 512 | 13.2 cm | 0.213 | 37 cm² |
+| shrub | 128 | 9.3 cm | 0.522 | 45 cm² |
+| pine | 256 | 9.8 cm (81 needles) | | |
+| spruce | 256 | 3.4 cm (44 needles) | | |
+| palm | 128 | | | |
+| fern | 128 | | | |
+
+Leaf areas against the sources:
+- maple: 37 cm² against Wilson's 39;
+- hazel: 45 cm² against Catoni's 41;
+- birch: 10.6 cm² against about 11 from FNA's sizes.
+
+**Cost:** cards, LOD0 triangles, and `generate_tree` time with the LOD0 meshes.
+
+| preset | cards | foliage tris | bark tris | generate + LOD0 |
+| :--- | ---: | ---: | ---: | ---: |
+| oak | 25,622 | 153,732 | 81,587 | 0.77 + 0.06 s |
+| pine | 3,554 | 21,324 | 39,817 | 0.71 + 0.03 s |
+| birch | 63,909 | 383,454 | 454,735 | 1.73 + 0.56 s |
+| willow | 113,001 | 678,006 | 410,091 | 1.81 + 0.46 s |
+| maple | 13,008 | 78,048 | 37,774 | 1.16 + 0.05 s |
+| spruce | 176,311 | 705,244 | 1,085,114 | 3.12 + 1.23 s |
+| shrub | 16,976 | 101,856 | 62,817 | 0.52 + 0.05 s |
+
+**Crowns,** measured with `foliage_measure_leaf_area` and `tree_crown_opacity`; "before" is 49845ff00:
+
+| preset | leaf m² (before) | crown LAI | side density | side transparency | below density | below transparency |
+| :--- | ---: | ---: | ---: | ---: | ---: | ---: |
+| oak | 89.4 (90.9) | 3.11 | 0.50 | 0.42 | 0.58 | 0.27 |
+| pine | 15.7 (35.0) | 0.74 | 0.34 | 0.64 | 0.35 | 0.62 |
+| birch | 70.4 (64.5) | 6.77 | 0.56 | 0.33 | 0.75 | 0.12 |
+| willow | 232.6 (136.3) | 6.43 | 0.75 | 0.18 | 0.74 | 0.19 |
+| maple | 50.7 (36.3) | 1.97 | 0.41 | 0.42 | 0.42 | 0.32 |
+| spruce | 78.4 (117.8) | 3.03 | 0.33 | 0.31 | 0.42 | 0.29 |
+| shrub | 62.5 (57.8) | 4.52 | 0.63 | 0.22 | 0.64 | 0.16 |
+
+- **Pine and spruce lost leaf area** because their old tiles overdrew. Every plane of a card drew all of its needles,
+  three times over on pine, and wider than the needles are. Now each needle is drawn once at its width.
+- **Willow gained,** its lanceolate leaves replacing a frond drawing. Its transparency, 0.18, is near FIA's 15%.
+
+## Open (measured, not argued)
+
+- **Card counts rose where a card used to hold several leaves:** birch 5×, willow 9×, oak 11×. Pine and spruce rose
+  2.4×, because a needle card now covers one needle length of shoot, not 2.4. That stretch is chosen, not sourced.
+- **Estimates:** the angles, tooth sizes and widest points the floras do not give are marked in each preset.
+- **Palm and fern** name no species, so their leaves are not sourced.
+- **Wind sail:**
+  - `TreeWindConfig.elastic_modulus` is fitted to the oak, whose leaf area moved by 2% (90.9 to 89.4 m²); it was not
+    refit.
+  - Pine's and spruce's sails fell with their leaf area (to 0.45 and 0.67), so they will sway less. That sway is not
+    measured.
+- **Transparency:** every crown but willow's is still far above FIA's 15% transparency.