@woosh/meep-engine 3.56.0 → 3.58.0

package/src/generation/foliage/skeleton/shoot_systems_simulate.js

@@ -0,0 +1,1055 @@
+import { GOLDEN_RATIO } from "../../../core/math/GOLDEN_RATIO.js";
+import { PI2 } from "../../../core/math/PI2.js";
+import { clamp } from "../../../core/math/clamp.js";
+import { phyllotaxis_sample_angle } from "../config/PhyllotaxisMode.js";
+import { shoot_order_value } from "../config/ShootBudZone.js";
+import { foliage_atlas_cutout } from "../material/foliage_atlas_cutout.js";
+import { foliage_tile_layout } from "../material/foliage_tile.js";
+import { foliage_card_leaf_area } from "./foliage_card_density.js";
+import { foliage_unit_leaf_count } from "./foliage_unit_cards.js";
+import { ShootFrameworkHash } from "./ShootFrameworkHash.js";
+import { ShootGirth } from "./ShootGirth.js";
+import { ShootLightField } from "./ShootLightField.js";
+import { ShootWoodHash } from "./ShootWoodHash.js";
+import { shoot_expected_yield, shoot_sample_unit_length, shoot_survival } from "./shoot_demography.js";
+import { shoot_framework_buried, shoot_locate_on_chain, shoot_normalize3, shoot_perpendicular3, shoot_radius } from "./shoot_geometry.js";
+
+const GOLDEN_ANGLE = PI2 / (GOLDEN_RATIO * GOLDEN_RATIO);
+
+/**
+ * Room (m) the light field leaves around the wood and leaves for the shoots to grow into; a shoot past it sees open
+ * sky. The field is rebuilt round the crown when leaves come within half of it of the field's edge, so no leaf falls
+ * outside it. Chosen.
+ * @type {number}
+ */
+const LIGHT_FIELD_MARGIN = 2.0;
+
+/**
+ * Height (m) of the ground, the plane the surface roots creep on (`tree_skeleton_grow`): no shoot grows below it.
+ * @type {number}
+ */
+const GROUND = 0;
+
+const SCRATCH_P = new Float32Array(3);
+const SCRATCH_T = new Float32Array(3);
+const SCRATCH_R = new Float64Array(3);
+const SCRATCH_O = new Float64Array(3);
+const SCRATCH_H = new Float64Array(3);
+const SCRATCH_C = new Float64Array(3);
+const SCRATCH_A = new Float64Array(3);
+const SCRATCH_B = new Float64Array(3);
+const SCRATCH_BOX = new Float64Array(6);
+const SCRATCH_REACH = new Float64Array(1);
+
+/**
+ * @typedef {Object} ShootCarrier
+ * @property {import("../config/ShootSystemRule.js").ShootSystemRule} rule
+ * @property {number} carrier framework branch
+ * @property {number} length metres
+ * @property {number[]} nodes the carrier's chain
+ * @property {number[]} edges
+ * @property {number[]} units lengths (m) of its last annual units, oldest first, ending at its tip
+ * @property {Float64Array} starts arc length (m) from its base where each unit starts
+ * @property {Float64Array} points world position of each unit boundary, `(units + 1) * 3`, the last its tip
+ * @property {number} first_season season its oldest unit grew in
+ * @property {Float64Array} [carrier_area] pipe area of what grows on each unit, after the simulation
+ * @property {Float64Array} [carrier_demand] radius each unit needs where its laterals join, after the simulation
+ * @property {boolean} [dead] its parent's wood has grown over it, and it and its twigs died
+ */
+
+/**
+ * @typedef {Object} ShootAxis
+ * @property {number} system index of its carrier
+ * @property {number} parent mother axis, `-1` for the carrier
+ * @property {number} parent_unit unit of the mother it grew from, oldest first
+ * @property {number} u where along that unit, 0 base to 1 tip
+ * @property {number} node bud index on that unit, for the leaf spiral
+ * @property {number} order branching order, the carrier being `rule.carrier_order`
+ * @property {boolean} short a short shoot
+ * @property {number} generator its branch generator
+ * @property {number} phase random phase in [0, 1)
+ * @property {number[]} units lengths (m), oldest first
+ * @property {number[]} unit_seasons season each unit grew in
+ * @property {number[]} points world position of each unit boundary, `(units + 1) * 3`
+ * @property {number[]} radii radius (m) of the wood at each unit boundary, `units + 1`
+ * @property {number} anchor_edge carrier segment a first-order axis grows from, else -1
+ * @property {boolean} extends the carrier's own extension past its framework tip, written onto the carrier
+ */
+
+/**
+ * @typedef {ShootAxis & {alive: boolean, birth: number, heading: number[], aim: number[], taken: Array<number[]|null>, exempt_branch: number, exempt_family: number, stem: boolean, vigour: number, birth_radius: number}} ShootAxisState
+ */
+
+/**
+ * Grows the twig systems of every carrier together, season by season, in the light their leaves make for each other,
+ * for `seasons` seasons: the tree's age, so every unit of every carrier has had the time since it grew to grow its
+ * twigs.
+ *
+ * No shoot grows into the ground, through older framework wood, or through older shoot wood (`ShootWoodHash`) it does
+ * not join: any of them is a blocked bud.
+ *
+ * Each season:
+ * 1. **Light.** The leaves alive last season are put in a {@link ShootLightField}, and each shoot reads the relative
+ *    irradiance where it grows.
+ * 2. **Extension.** Every living long axis grows a terminal unit, `terminal_length + terminal_length_slope *` its last
+ *    unit long on average. The axis's course turns by the generator's phototropism (towards where the light field grows
+ *    brighter) and gravitropism, and a lateral's by its plagiotropism and straightness; the unit is kinked off that
+ *    course by the generator's zigzag.
+ * 3. **Short shoots** live on at `short_shoot_survival`, less in light too dim for a shoot to replace itself.
+ * 4. **Buds.** Last season's units burst their buds: by zone and mother order, a `long` share grow long shoots and a
+ *    `short` share short shoots. A `sylleptic` share of this season's units' buds grow at once.
+ * 5. **Shedding.** A new shoot in relative light `Q` survives at `p = net_yield(Q, yield) / yield`: the species'
+ *    net shoots per shoot at that light, over the gross new shoots its mother makes from the unit it grew on
+ *    (`shoot_expected_yield`). In full light that is 1: every shoot the buds grow is kept, and only shade sheds. Of a season's new shoots the
+ *    sum of their `p` survive, with a carried-over remainder so the count is exact on average. They are ranked by
+ *    `log p` plus the rank of oak's shedding: the highest orders, the youngest axes and the shortest shoots go first
+ *    (Buck-Sorlin & Bell 1998, Bot. J. Linn. Soc. 127: 371-391, p. 388). So the shaded go before the lit, and among
+ *    equally lit shoots an established axis outlasts a new lateral. A shed terminal sheds its whole axis with
+ *    everything on it, as oak sheds only at an axis's base (p. 388). So a branch in deep shade, whose terminals are
+ *    shed, dies.
+ *
+ * A carrier whose last annual unit grew before the last season grows on from its tip as an axis of its own order and
+ * generator, its extension: a tree older than its framework took to grow. The extension of the tree's first branch, the
+ * stem, grows each year by `ShootGrowthConfig.leader_unit` at the height its tip has reached, not by its unit before.
+ *
+ * Apical control shares the light out (`ShootGrowthConfig.apical_control`, {@link apical_vigour}): each season every
+ * new unit's mean length is scaled by its axis's vigour, and a new lateral's by its mother's. The stem keeps its
+ * height-driven leader.
+ *
+ * The wood thickens season by season with what it carries (`ShootGirth`): twigs, carriers, and the framework above
+ * them. A shoot whose path would run into framework wood as thick as it is that season is a blocked bud and does not
+ * grow; its mother's junction is the one exception. A blocked terminal leaves its axis without a unit that season. A
+ * shoot whose wood the framework, or its own girth, has grown into by the end of a season is engulfed and dies with
+ * everything on it.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {ShootCarrier[]} carriers
+ * @param {number} seasons
+ * @param {function():number} rng
+ * @returns {ShootAxis[]} the living axes, a mother before its laterals
+ */
+export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng) {
+    const growth = species.shoot_growth;
+    // everything in the skeleton now is framework
+    const framework_segments = skeleton.segment_count;
+    const girth = new ShootGirth(skeleton, carriers, skeleton.branch_count, species.crown.pipe_model_exponent);
+    let framework = new ShootFrameworkHash(skeleton, framework_segments);
+    const leaf_survival = species.foliage.leaf_survival;
+
+    // Leaf area of one leaf, as the cards draw it
+    const leafy = new Map();
+    for (const rule of species.foliage_rules) {
+        leafy.set(rule.source, rule.short_shoot);
+    }
+    let leaf_area_each = 0;
+    if (leafy.size > 0) {
+        const layout = foliage_tile_layout(species);
+        const coverage = foliage_atlas_cutout(species).mean_coverage();
+        leaf_area_each = foliage_card_leaf_area(layout, species.foliage.card_type, coverage, 1.0) / layout.leaves_per_card;
+    }
+
+    const bounds = framework_bounds(skeleton);
+    let field = make_light_field(bounds, growth.light_cell);
+
+    /** @type {ShootAxisState[]} */
+    const axes = [];
+    /** buds spent on sylleptic shoots per carrier unit, by zone */
+    const carrier_taken = carriers.map(c => new Array(c.units.length).fill(null));
+    // the shoots' own wood, every unit once it has grown
+    const wood = new ShootWoodHash(axes);
+    // the shoot a query is for: its mother (-1 for a carrier), the unit it grows from, its carrier, itself (-1 before it
+    // exists), its unit being tested and that unit's radius
+    let probe_parent = -1, probe_parent_unit = 0, probe_system = 0, probe_self = -1, probe_unit = 0;
+    // the probe unit's radii at its ends, and where along it the capsule tested starts
+    let probe_r0 = 0, probe_r1 = 0, probe_s0 = 0;
+    /**
+     * Whether unit `k` of lateral `child` (-1 for one not grown yet, at its junction) is in its crotch: it starts inside
+     * its mother's wood where it grew, however far her girth carries it: nearer the axis of her unit there, or of the
+     * one either side, than her radius. With `k` past the last unit, whether its tip is.
+     */
+    const in_crotch = (child, k) => {
+        if (child < 0 || k === 0) return true;
+        return wood_reach(child, k) < 0;
+    };
+    /**
+     * How far point `k` of lateral `child` lies outside its mother's wood where it grew, on her unit there or the one
+     * either side (negative inside), into `reach_distance` its distance from her axis.
+     */
+    let reach_distance = 0;
+    const wood_reach = (child, k) => {
+        const axis = axes[child];
+        const p = axis.points;
+        const q = k * 3;
+        let best = Infinity;
+        if (axis.parent >= 0) {
+            const mother = axes[axis.parent];
+            const m = mother.points;
+            for (let j = Math.max(0, axis.parent_unit - 1); j <= Math.min(mother.units.length - 1, axis.parent_unit + 1); j++) {
+                const a = j * 3;
+                const out = outside_wood(p, q, m[a], m[a + 1], m[a + 2], m[a + 3], m[a + 4], m[a + 5],
+                    ShootWoodHash.radius_at(mother, j, 0), ShootWoodHash.radius_at(mother, j, 1));
+                if (out < best) {
+                    best = out;
+                    reach_distance = SCRATCH_REACH[0];
+                }
+            }
+            return best;
+        }
+        const edges = carriers[axis.system].edges;
+        const at = edges.indexOf(axis.anchor_edge);
+        for (let j = Math.max(0, at - 1); j <= Math.min(edges.length - 1, at + 1); j++) {
+            const v0 = skeleton.segment_v0(edges[j]), v1 = skeleton.segment_v1(edges[j]);
+            skeleton.node_read_position(SCRATCH_P, 0, v0);
+            skeleton.node_read_position(SCRATCH_T, 0, v1);
+            const out = outside_wood(p, q, SCRATCH_P[0], SCRATCH_P[1], SCRATCH_P[2], SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2],
+                skeleton.node_read_radius(v0), skeleton.node_read_radius(v1));
+            if (out < best) {
+                best = out;
+                reach_distance = SCRATCH_REACH[0];
+            }
+        }
+        return best;
+    };
+    /**
+     * Whether unit `k` of axis `m` is one wood with the probe's unit where they join: the same axis; a mother, either
+     * side of where her lateral grew and anywhere over its crotch; a grandmother where it grew at its mother's base; a
+     * carrier's extension, which is the carrier, and the carrier's laterals by the tip it grew from. Shoots from the same
+     * node share only their collar, which the first unit's test leaves out ({@link collar_start}).
+     */
+    const joined = (m, k) => {
+        if (m === probe_self) return true;
+        const other = axes[m];
+        // the other is the probe's mother or grandmother
+        if (m === probe_parent) return Math.abs(k - probe_parent_unit) <= 1 || in_crotch(probe_self, probe_unit);
+        if (probe_parent >= 0 && probe_parent_unit <= 1 && axes[probe_parent].parent === m) {
+            return Math.abs(k - axes[probe_parent].parent_unit) <= 1;
+        }
+        // the probe is the other's mother or grandmother
+        if (probe_self >= 0 && other.parent === probe_self) return Math.abs(probe_unit - other.parent_unit) <= 1 || in_crotch(m, k);
+        if (probe_self >= 0 && other.parent >= 0 && other.parent_unit <= 1 && axes[other.parent].parent === probe_self) {
+            return Math.abs(probe_unit - axes[other.parent].parent_unit) <= 1;
+        }
+        // a carrier's extension and the carrier's laterals by its tip
+        if (probe_parent < 0 && other.parent < 0 && other.system === probe_system) {
+            if (other.extends) return k <= 1 && probe_parent_unit >= other.parent_unit - 1;
+            if (probe_self >= 0 && axes[probe_self].extends) return probe_unit <= 1 && other.parent_unit >= probe_parent_unit - 1;
+        }
+        return false;
+    };
+    /**
+     * Where along its first unit, `len` long, a lateral leaves the collar it shares with its siblings: out of its
+     * mother's wood, `mother_radius` thick, and at least half way.
+     * @param {number} len
+     * @param {number} mother_radius
+     * @returns {number}
+     */
+    const collar_start = (len, mother_radius) => Math.max(0.5, Math.min(1, mother_radius / Math.max(1e-9, len)));
+    /** Radius (m) of the wood lateral `axis` grew from, where it grew */
+    const junction_radius = (axis) => {
+        if (axis.parent >= 0) {
+            const mother = axes[axis.parent];
+            return Math.max(ShootWoodHash.radius_at(mother, axis.parent_unit, 0), ShootWoodHash.radius_at(mother, axis.parent_unit, 1));
+        }
+        const e = axis.anchor_edge;
+        return Math.max(skeleton.node_read_radius(skeleton.segment_v0(e)), skeleton.node_read_radius(skeleton.segment_v1(e)));
+    };
+    /** Whether axis `m` grew from the probe's node or the next: their first units share a collar */
+    const sibling = (m) => {
+        const other = axes[m];
+        return other.parent === probe_parent && (probe_parent >= 0 || other.system === probe_system)
+            && Math.abs(other.parent_unit - probe_parent_unit) <= 1;
+    };
+    /** Wood the probe's whole unit is tested against, and its siblings' first units only out of its collar */
+    const skip_joined = (m, k) => joined(m, k) || (k === 0 && sibling(m));
+    const skip_joined_out_of_collar = (m, k) => joined(m, k);
+    /**
+     * Wood has grown into the probe's unit, whose line it holds, if they are not joined and, where they meet, it is
+     * thicker than the probe, or as thick and older
+     */
+    const thinner = (m, r, s) => {
+        const at = probe_s0 + (1 - probe_s0) * s;
+        const own = probe_r0 + (probe_r1 - probe_r0) * at;
+        return r < own || (r === own && m > probe_self);
+    };
+    const skip_engulf = (m, k, r, s) => joined(m, k) || (k === 0 && sibling(m)) || thinner(m, r, s);
+    const skip_engulf_out_of_collar = (m, k, r, s) => joined(m, k) || thinner(m, r, s);
+
+    /** vigour per unit of light of each carrier's base, relative to the most vigorous shoot's */
+    const carrier_vigour = new Float64Array(carriers.length).fill(1);
+    let remainder = 0.5;
+
+    /**
+     * A new shoot's chance in `light`: the net shoots a shoot leaves, over the gross new shoots its mother makes, a unit
+     * of `mother_order` `mother_length` metres long; 1 in full light
+     */
+    const survival_at = (light, system, mother_order, mother_length) =>
+        shoot_survival(growth, light, shoot_expected_yield(carriers[system].rule, mother_order, mother_length));
+
+    /**
+     * Where a bud on unit `k` of a mother sits, and the mother's tangent there, into SCRATCH_P / SCRATCH_T.
+     * @returns {{edge: number, u: number}|null} the carrier segment, for a carrier's bud
+     */
+    const bud_site = (system, mother, k, u) => {
+        if (mother < 0) {
+            const c = carriers[system];
+            const located = shoot_locate_on_chain(skeleton, c.nodes, c.edges, (c.starts[k] + u * c.units[k]) / c.length);
+            skeleton.evaluate_segment_position(SCRATCH_P, 0, located.edge, located.u);
+            skeleton.evaluate_segment_tangent(SCRATCH_T, 0, located.edge, located.u);
+            shoot_normalize3(SCRATCH_T, SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2]);
+            return located;
+        }
+        const p = axes[mother].points;
+        const a = k * 3, b = (k + 1) * 3;
+        SCRATCH_P[0] = p[a] + (p[b] - p[a]) * u;
+        SCRATCH_P[1] = p[a + 1] + (p[b + 1] - p[a + 1]) * u;
+        SCRATCH_P[2] = p[a + 2] + (p[b + 2] - p[a + 2]) * u;
+        shoot_normalize3(SCRATCH_T, p[b] - p[a], p[b + 1] - p[a + 1], p[b + 2] - p[a + 2]);
+        return null;
+    };
+
+    /**
+     * A lateral from bud `node` at `u` on unit `k` of `mother` (`-1` for the carrier), or -1 when the bud cannot grow:
+     * its generator bears no leaves (no foliage rule), or no bud round its node clears a plagiotropic mother's ventral
+     * cone, the ground, and older wood.
+     */
+    const spawn = (system, mother, k, u, node, order, mean_length, short, season, candidates) => {
+        const c = carriers[system];
+        const rule = c.rule;
+        // a shoot pays for its offspring with its leaves: one of a generator that bears none yields nothing
+        const generator = short ? rule.short_target : shoot_order_value(rule.target, order - 1);
+        if (!leafy.has(generator)) return -1;
+        const located = bud_site(system, mother, k, u);
+        const px = SCRATCH_P[0], py = SCRATCH_P[1], pz = SCRATCH_P[2];
+        const mtx = SCRATCH_T[0], mty = SCRATCH_T[1], mtz = SCRATCH_T[2];
+        const mother_phase = mother < 0 ? skeleton.branch_phase_hash[c.carrier] : axes[mother].phase;
+        const mother_generator = mother < 0 ? rule.source : axes[mother].generator;
+        // a trunk is upright: it has no horizontal plane to fan its buds into, so no ventral knockout
+        const mother_trunk = mother < 0 ? skeleton.branch_parent[c.carrier] < 0 : axes[mother].stem;
+
+        // radial direction at the bud: a frame around the mother's tangent turned by the leaf spiral
+        shoot_perpendicular3(SCRATCH_R, mtx, mty, mtz);
+        const rx0 = SCRATCH_R[0], ry0 = SCRATCH_R[1], rz0 = SCRATCH_R[2];
+        const sx0 = mty * rz0 - mtz * ry0;
+        const sy0 = mtz * rx0 - mtx * rz0;
+        const sz0 = mtx * ry0 - mty * rx0;
+        const ins = shoot_order_value(rule.insertion_angle, order - 1) * (0.85 + 0.3 * rng());
+        const cos_i = Math.cos(ins), sin_i = Math.sin(ins);
+        const vigour = mother < 0 ? carrier_vigour[system] : axes[mother].vigour;
+        const len = short ? rule.short_shoot_growth : shoot_sample_unit_length(rng, mean_length * vigour, order, rule);
+        const radius = shoot_radius(len, 0);
+        const exempt_branch = mother < 0 ? c.carrier : -1;
+        const exempt_edge = located !== null ? located.edge : -1;
+        probe_parent = mother;
+        probe_parent_unit = k;
+        probe_system = system;
+        probe_self = -1;
+        probe_unit = 0;
+        const mother_radius = located !== null
+            ? Math.max(skeleton.node_read_radius(skeleton.segment_v0(located.edge)), skeleton.node_read_radius(skeleton.segment_v1(located.edge)))
+            : Math.max(ShootWoodHash.radius_at(axes[mother], k, 0), ShootWoodHash.radius_at(axes[mother], k, 1));
+        const collar = collar_start(len, mother_radius) * len;
+        // a bud breaks where there is room: not into a plagiotropic mother's downward cone (its ventral knockout), the
+        // ground, or wood that was there first, its own junction aside. Blocked, it turns by the golden angle round its
+        // node to where the next bud would be, or does not break
+        const plagio = mother_trunk ? 0 : species.branches[mother_generator].plagiotropism;
+        const ventral_cos = plagio > 0 ? Math.cos(plagio * Math.PI * 0.5) : Infinity;
+        let phi = phyllotaxis_sample_angle(rule.phyllotaxis_mode, node, 1, mother_phase * PI2) + (rng() - 0.5) * 0.4;
+        let cleared = false;
+        for (let attempt = 0; attempt < 5 && !cleared; attempt++, phi += GOLDEN_ANGLE) {
+            const drx = Math.cos(phi) * rx0 + Math.sin(phi) * sx0;
+            const dry = Math.cos(phi) * ry0 + Math.sin(phi) * sy0;
+            const drz = Math.cos(phi) * rz0 + Math.sin(phi) * sz0;
+            shoot_normalize3(SCRATCH_H, cos_i * mtx + sin_i * drx, cos_i * mty + sin_i * dry, cos_i * mtz + sin_i * drz);
+            if (-SCRATCH_H[1] > ventral_cos) continue;
+            SCRATCH_B[0] = px + SCRATCH_H[0] * len;
+            SCRATCH_B[1] = py + SCRATCH_H[1] * len;
+            SCRATCH_B[2] = pz + SCRATCH_H[2] * len;
+            SCRATCH_A[0] = px;
+            SCRATCH_A[1] = py;
+            SCRATCH_A[2] = pz;
+            if (SCRATCH_B[1] < GROUND || framework.hits(SCRATCH_A, SCRATCH_B, radius, exempt_branch, exempt_edge)) continue;
+            if (wood.hits(SCRATCH_A, SCRATCH_B, radius, 0, skip_joined) >= 0) continue;
+            SCRATCH_A[0] = px + SCRATCH_H[0] * collar;
+            SCRATCH_A[1] = py + SCRATCH_H[1] * collar;
+            SCRATCH_A[2] = pz + SCRATCH_H[2] * collar;
+            cleared = wood.hits(SCRATCH_A, SCRATCH_B, radius, 0, skip_joined_out_of_collar) < 0;
+        }
+        if (!cleared) return -1;
+
+        const light = field.irradiance_at(px, py, pz);
+        axes.push({
+            system, parent: mother, parent_unit: k, u, node, order, short,
+            generator,
+            phase: rng(),
+            units: [len],
+            unit_seasons: [season],
+            points: [px, py, pz, SCRATCH_B[0], SCRATCH_B[1], SCRATCH_B[2]],
+            radii: [],
+            anchor_edge: located !== null ? located.edge : -1,
+            extends: false,
+            exempt_branch,
+            exempt_family: -1,
+            stem: false,
+            vigour,
+            birth_radius: mother_radius,
+            heading: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+            aim: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+            taken: [null],
+            birth: season,
+            alive: true
+        });
+        const m = axes.length - 1;
+        if (!short) {
+            const p = survival_at(light, system, order - 1, mother < 0 ? c.units[k] : axes[mother].units[k]);
+            candidates.push({ axis: m, p, key: shed_rank(p, order, len, 0, rule, rng) });
+            axes[m].taken[0] = sylleptic(system, m, 0, len, order, season, candidates);
+        }
+        return m;
+    };
+
+    /** Buds of a unit grown this season that grow out at once; the buds they spent, by zone */
+    const sylleptic = (system, mother, k, unit_length, order, season, candidates) => {
+        const rule = carriers[system].rule;
+        if (order + 1 > rule.max_order) return null;
+        let taken = null;
+        let node = 0;
+        for (let z = 0; z < rule.zones.length; z++) {
+            const zone = rule.zones[z];
+            const n = zone.bud_count(unit_length, order);
+            const p = shoot_order_value(zone.sylleptic, order);
+            if (p > 0) {
+                const count = binomial(rng, n, p);
+                if (taken === null) taken = new Array(rule.zones.length).fill(0);
+                taken[z] = count;
+                const mean = lateral_mean(zone, order, unit_length);
+                for (let j = 0; j < count; j++) {
+                    const u = lerp_u(zone.u_max, zone.u_min, (j + rng()) / Math.max(1, count));
+                    spawn(system, mother, k, u, node + j, order + 1, mean, false, season, candidates);
+                }
+            }
+            node += n;
+        }
+        return taken;
+    };
+
+    /** Unit `k` of a mother, grown last season, bursts its buds */
+    const burst = (system, mother, k, unit_length, order, taken, season, candidates) => {
+        const rule = carriers[system].rule;
+        if (order + 1 > rule.max_order) return;
+        let node = 0;
+        for (let z = 0; z < rule.zones.length; z++) {
+            const zone = rule.zones[z];
+            const all = zone.bud_count(unit_length, order);
+            const n = all - (taken !== null ? taken[z] : 0);
+            const p_long = shoot_order_value(zone.long, order);
+            const p_short = shoot_order_value(zone.short, order);
+            let n_long = 0;
+            let n_short = 0;
+            if (p_short > 0) {
+                for (let i = 0; i < n; i++) {
+                    const r = rng();
+                    if (r < p_long) n_long++;
+                    else if (r < p_long + p_short) n_short++;
+                }
+            } else {
+                n_long = binomial(rng, n, p_long);
+            }
+            const mean = lateral_mean(zone, order, unit_length);
+            for (let j = 0; j < n_long; j++) {
+                spawn(system, mother, k, lerp_u(zone.u_max, zone.u_min, (j + rng()) / Math.max(1, n_long)), node + j, order + 1, mean, false, season, candidates);
+            }
+            for (let j = 0; j < n_short; j++) {
+                spawn(system, mother, k, lerp_u(zone.u_max, zone.u_min, (j + rng()) / Math.max(1, n_short)), node + n_long + j, order + 1, 0, true, season, candidates);
+            }
+            node += all;
+        }
+    };
+
+    for (let season = 0; season < seasons; season++) {
+        // 1. Light from last season's leaves
+        crown_frame(skeleton, carriers, axes);
+        if (season > 0) {
+            crown_bounds(bounds, carriers, axes);
+            if (!field_holds(field, bounds)) {
+                field = make_light_field(bounds, growth.light_cell);
+            }
+            field.clear();
+            deposit_leaves(field, species, carriers, axes, season - 1, leafy, leaf_area_each, leaf_survival);
+            field.solve(growth.leaf_clumping);
+        }
+
+        /** @type {Array<{axis: number, p: number, key: number}>} key: the shedding rank, the highest kept */
+        const candidates = [];
+
+        // a carrier whose last unit grew last season grows on from its tip from now
+        for (let s = 0; s < carriers.length; s++) {
+            const c = carriers[s];
+            if (!c.dead && season === c.first_season + c.units.length) {
+                axes.push(carrier_extension(skeleton, c, s, season));
+            }
+        }
+
+        // the light the shoots receive flows down and back up: each axis's vigour
+        apical_vigour(axes, carriers, field, growth.apical_control, carrier_vigour);
+
+        // 2. Every living long axis extends by a terminal unit, a candidate for shedding with its whole axis
+        const extended = [];
+        const count_before = axes.length;
+        for (let m = 0; m < count_before; m++) {
+            const axis = axes[m];
+            if (!axis.alive || axis.short || axis.birth >= season) continue;
+            const rule = carriers[axis.system].rule;
+            const cfg = species.branches[axis.generator];
+            const n = axis.units.length;
+            const pts = axis.points;
+            const tip = n * 3;
+            const light = field.irradiance_at(pts[tip], pts[tip + 1], pts[tip + 2]);
+            const c = carriers[axis.system];
+            field.gradient_at(SCRATCH_O, pts[tip], pts[tip + 1], pts[tip + 2]);
+            // the axis's course turns by its tropisms; a lateral's also towards the horizontal by its plagiotropism and back
+            // towards its bud's heading by its straightness, as the graph's spines do (a trunk takes neither). The
+            // internode's zigzag kinks this unit off the course, not the course
+            const zig = cfg.internode_zigzag;
+            const h = axis.heading;
+            const aim = axis.aim;
+            const plagio = axis.stem ? 0 : cfg.plagiotropism;
+            const straight = axis.stem ? 0 : cfg.straightness;
+            shoot_normalize3(
+                SCRATCH_C,
+                h[0] + cfg.phototropism * 0.5 * SCRATCH_O[0] + straight * 0.5 * (aim[0] - h[0]),
+                h[1] + cfg.phototropism * 0.5 * SCRATCH_O[1] - cfg.gravitropism * 0.5 - plagio * 0.5 * h[1] + straight * 0.5 * (aim[1] - h[1]),
+                h[2] + cfg.phototropism * 0.5 * SCRATCH_O[2] + straight * 0.5 * (aim[2] - h[2])
+            );
+            shoot_normalize3(
+                SCRATCH_H,
+                SCRATCH_C[0] + (rng() * 2 - 1) * zig,
+                SCRATCH_C[1] + (rng() * 2 - 1) * zig,
+                SCRATCH_C[2] + (rng() * 2 - 1) * zig
+            );
+            const prev = n > 0 ? axis.units[n - 1] : c.units[c.units.length - 1];
+            // the stem grows as fast as the tree's height lets it; every other axis by its unit before
+            const mean = axis.stem
+                ? growth.leader_unit(pts[tip + 1])
+                : axis.vigour * (shoot_order_value(rule.terminal_length, axis.order) + shoot_order_value(rule.terminal_length_slope, axis.order) * prev);
+            const len = shoot_sample_unit_length(rng, mean, axis.order, rule);
+            SCRATCH_A[0] = pts[tip];
+            SCRATCH_A[1] = pts[tip + 1];
+            SCRATCH_A[2] = pts[tip + 2];
+            SCRATCH_B[0] = pts[tip] + SCRATCH_H[0] * len;
+            SCRATCH_B[1] = pts[tip + 1] + SCRATCH_H[1] * len;
+            SCRATCH_B[2] = pts[tip + 2] + SCRATCH_H[2] * len;
+            if (SCRATCH_B[1] < GROUND || framework.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), axis.exempt_branch, axis.anchor_edge, axis.exempt_family)) continue;
+            probe_parent = axis.parent;
+            probe_parent_unit = axis.parent_unit;
+            probe_system = axis.system;
+            probe_self = m;
+            probe_unit = n;
+            if (wood.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), 0, skip_joined_out_of_collar) >= 0) continue;
+            axis.units.push(len);
+            axis.unit_seasons.push(season);
+            axis.taken.push(null);
+            pts.push(SCRATCH_B[0], SCRATCH_B[1], SCRATCH_B[2]);
+            h[0] = SCRATCH_C[0];
+            h[1] = SCRATCH_C[1];
+            h[2] = SCRATCH_C[2];
+            const p_ext = survival_at(light, axis.system, axis.order, prev);
+            candidates.push({ axis: m, p: p_ext, key: shed_rank(p_ext, axis.order, len, season - axis.birth, rule, rng) });
+            extended.push(m);
+        }
+
+        // 3. Short shoots live on, a year's growth each, or die
+        for (let m = 0; m < count_before; m++) {
+            const axis = axes[m];
+            if (!axis.alive || !axis.short || axis.birth >= season) continue;
+            const rule = carriers[axis.system].rule;
+            const pts = axis.points;
+            const tip = axis.units.length * 3;
+            const light = field.irradiance_at(pts[tip], pts[tip + 1], pts[tip + 2]);
+            // a shoot that cannot replace itself, below the compensation light, dies the more the darker
+            const mother_unit = axis.parent < 0 ? carriers[axis.system].units[axis.parent_unit] : axes[axis.parent].units[axis.parent_unit];
+            const gross = shoot_expected_yield(rule, axis.order - 1, mother_unit);
+            if (rng() < rule.short_shoot_survival * Math.min(1, growth.net_yield(light, gross))) {
+                const g = rule.short_shoot_growth;
+                axis.units.push(g);
+                axis.unit_seasons.push(season);
+                pts.push(pts[tip] + axis.heading[0] * g, pts[tip + 1] + axis.heading[1] * g, pts[tip + 2] + axis.heading[2] * g);
+            } else {
+                axis.alive = false;
+            }
+        }
+
+        // 4. Units grown last season burst their buds: on the carriers and on every living long axis
+        for (let s = 0; s < carriers.length; s++) {
+            const c = carriers[s];
+            const k = season - 1 - c.first_season;
+            if (!c.dead && k >= 0 && k < c.units.length) {
+                burst(s, -1, k, c.units[k], c.rule.carrier_order, carrier_taken[s][k], season, candidates);
+            }
+        }
+        for (let m = 0; m < count_before; m++) {
+            const axis = axes[m];
+            if (!axis.alive || axis.short || axis.birth >= season) continue;
+            const k = axis.unit_seasons.lastIndexOf(season - 1);
+            if (k >= 0) {
+                burst(axis.system, m, k, axis.units[k], axis.order, axis.taken[k], season, candidates);
+            }
+        }
+
+        // 5. This season's units branch at once where their buds are sylleptic: the carriers' and the extensions'
+        for (let s = 0; s < carriers.length; s++) {
+            const c = carriers[s];
+            const k = season - c.first_season;
+            if (!c.dead && k >= 0 && k < c.units.length) {
+                carrier_taken[s][k] = sylleptic(s, -1, k, c.units[k], c.rule.carrier_order, season, candidates);
+            }
+        }
+        for (let i = 0; i < extended.length; i++) {
+            const m = extended[i];
+            const axis = axes[m];
+            const k = axis.units.length - 1;
+            axis.taken[k] = sylleptic(axis.system, m, k, axis.units[k], axis.order, season, candidates);
+        }
+
+        // 6. Shedding: the best-lit share of this season's new shoots survives
+        let expected = remainder;
+        for (let i = 0; i < candidates.length; i++) expected += candidates[i].p;
+        const keep = Math.floor(expected);
+        remainder = expected - keep;
+        candidates.sort((a, b) => b.key - a.key);
+        for (let i = keep; i < candidates.length; i++) {
+            axes[candidates[i].axis].alive = false;
+        }
+        // a dead mother takes everything on it; mothers come first
+        cascade(axes);
+
+        // 7. The wood thickens with what it now carries, and what it has grown into dies: framework wood, or shoot wood
+        // thicker than it, or as thick and older. This season's units join the shoots' wood
+        girth.update(axes, season);
+        framework = new ShootFrameworkHash(skeleton, framework_segments);
+        // a carrier its parent's thickening wood has grown over dies, with its twigs
+        for (const c of carriers) {
+            if (!c.dead && shoot_framework_buried(skeleton, c.carrier)) c.dead = true;
+        }
+        for (let m = 0; m < axes.length; m++) {
+            const axis = axes[m];
+            if (!axis.alive || axis.short) continue;
+            for (let k = 0; k < axis.units.length; k++) {
+                if (axis.unit_seasons[k] === season) wood.add(m, k);
+            }
+        }
+        wood.refresh();
+        for (let m = 0; m < axes.length; m++) {
+            const axis = axes[m];
+            if (!axis.alive) continue;
+            if ((axis.parent >= 0 && !axes[axis.parent].alive) || carriers[axis.system].dead) {
+                axis.alive = false;
+                continue;
+            }
+            const pts = axis.points;
+            const r = axis.radii;
+            // a lateral whose tip the wood its mother grew since has closed over is buried (one that grew out of wood
+            // already there, as on a carrier the generator graph laid at its full girth, is not)
+            if (!axis.extends && !axis.short && wood_reach(m, axis.units.length) < 0 && reach_distance >= axis.birth_radius) {
+                axis.alive = false;
+                continue;
+            }
+            for (let k = 0; k < axis.units.length; k++) {
+                SCRATCH_A[0] = pts[k * 3];
+                SCRATCH_A[1] = pts[k * 3 + 1];
+                SCRATCH_A[2] = pts[k * 3 + 2];
+                SCRATCH_B[0] = pts[k * 3 + 3];
+                SCRATCH_B[1] = pts[k * 3 + 4];
+                SCRATCH_B[2] = pts[k * 3 + 5];
+                if (framework.hits(SCRATCH_A, SCRATCH_B, Math.max(r[k], r[k + 1]), axis.exempt_branch, axis.anchor_edge, axis.exempt_family)) {
+                    axis.alive = false;
+                    break;
+                }
+                if (axis.short) continue;
+                probe_parent = axis.parent;
+                probe_parent_unit = axis.parent_unit;
+                probe_system = axis.system;
+                probe_self = m;
+                probe_unit = k;
+                probe_r0 = r[k];
+                probe_r1 = r[k + 1];
+                probe_s0 = 0;
+                const thinnest = Math.min(r[k], r[k + 1]);
+                // grown into: the unit's line is inside the other wood, not merely its bark against it; a first unit's
+                // siblings only out of the collar they share
+                if (wood.hits(SCRATCH_A, SCRATCH_B, 0, thinnest, k === 0 ? skip_engulf : skip_engulf_out_of_collar) >= 0) {
+                    axis.alive = false;
+                    break;
+                }
+                if (k === 0 && !axis.extends) {
+                    probe_s0 = collar_start(axis.units[0], junction_radius(axis));
+                    SCRATCH_A[0] += (SCRATCH_B[0] - SCRATCH_A[0]) * probe_s0;
+                    SCRATCH_A[1] += (SCRATCH_B[1] - SCRATCH_A[1]) * probe_s0;
+                    SCRATCH_A[2] += (SCRATCH_B[2] - SCRATCH_A[2]) * probe_s0;
+                    if (wood.hits(SCRATCH_A, SCRATCH_B, 0, thinnest, skip_engulf_out_of_collar) >= 0) {
+                        axis.alive = false;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // The living axes, a mother before its laterals
+    const index = new Int32Array(axes.length).fill(-1);
+    /** @type {ShootAxis[]} */
+    const living = [];
+    for (let m = 0; m < axes.length; m++) {
+        const axis = axes[m];
+        // an extension blocked since it began has no unit
+        if (!axis.alive || axis.units.length === 0) continue;
+        index[m] = living.length;
+        living.push({
+            system: axis.system,
+            parent: axis.parent < 0 ? -1 : index[axis.parent],
+            parent_unit: axis.parent_unit,
+            u: axis.u,
+            node: axis.node,
+            order: axis.order,
+            short: axis.short,
+            generator: axis.generator,
+            phase: axis.phase,
+            units: axis.units,
+            unit_seasons: axis.unit_seasons,
+            points: axis.points,
+            radii: axis.radii,
+            anchor_edge: axis.anchor_edge,
+            extends: axis.extends
+        });
+    }
+    return living;
+}
+
+/**
+ * Borchert-Honda allocation of the light the shoots receive (Borchert & Honda 1984, as Palubicki et al. 2009, ACM
+ * Trans. Graph. 28(3): 58, use it). Each living axis receives the relative irradiance at its tip; summed down every
+ * subtree, each carrier's total flows back up from its base, and at each lateral, base first, the lateral takes
+ * `v (1 - λ) Q_l / (λ Q_rest + (1 - λ) Q_l)` of the flow `v`, `Q_l` its subtree's light and `Q_rest` the light of the
+ * axis beyond it. What reaches an axis's tip over its own light is its vigour, which is written relative to the most
+ * vigorous axis's into `axis.vigour`; a carrier's base receives its subtree's light, vigour 1 before that division.
+ * At `λ = 0.5` every vigour is 1.
+ *
+ * @param {ShootAxisState[]} axes
+ * @param {ShootCarrier[]} carriers
+ * @param {ShootLightField} field
+ * @param {number} lambda
+ * @param {Float64Array} carrier_vigour out
+ */
+function apical_vigour(axes, carriers, field, lambda, carrier_vigour) {
+    const n = axes.length;
+    const own = new Float64Array(n);
+    const sub = new Float64Array(n);
+    const flow = new Float64Array(n);
+    /** @type {Array<number[]|undefined>} */
+    const children = new Array(n);
+    const carrier_children = carriers.map(() => []);
+    for (let m = 0; m < n; m++) {
+        const axis = axes[m];
+        if (!axis.alive) continue;
+        const p = axis.points;
+        const t = axis.units.length * 3;
+        own[m] = field.irradiance_at(p[t], p[t + 1], p[t + 2]);
+        if (axis.parent < 0) {
+            carrier_children[axis.system].push(m);
+        } else if (axes[axis.parent].alive) {
+            (children[axis.parent] ??= []).push(m);
+        }
+    }
+    // laterals come after their mother: their light is summed into hers first
+    for (let m = n - 1; m >= 0; m--) {
+        if (!axes[m].alive) continue;
+        sub[m] += own[m];
+        const parent = axes[m].parent;
+        if (parent >= 0) sub[parent] += sub[m];
+    }
+    const by_site = (a, b) => (axes[a].parent_unit - axes[b].parent_unit) || (axes[a].u - axes[b].u);
+    // shares flow `v` entering an axis of own light `own_light` among its laterals, base first; returns what reaches its tip
+    const share = (v, own_light, kids) => {
+        kids.sort(by_site);
+        let rest = own_light;
+        for (let i = 0; i < kids.length; i++) rest += sub[kids[i]];
+        for (let i = 0; i < kids.length; i++) {
+            const c = kids[i];
+            const q = sub[c];
+            rest -= q;
+            const d = lambda * rest + (1 - lambda) * q;
+            const vc = d > 0 ? v * (1 - lambda) * q / d : 0;
+            flow[c] = vc;
+            v -= vc;
+        }
+        return v;
+    };
+    for (let s = 0; s < carriers.length; s++) {
+        const kids = carrier_children[s];
+        let total = 0;
+        for (let i = 0; i < kids.length; i++) total += sub[kids[i]];
+        share(total, 0, kids);
+    }
+    let most = 1;
+    for (let m = 0; m < n; m++) {
+        const axis = axes[m];
+        if (!axis.alive) continue;
+        const tip = share(flow[m], own[m], children[m] ?? []);
+        axis.vigour = own[m] > 0 ? tip / own[m] : 0;
+        if (axis.vigour > most) most = axis.vigour;
+    }
+    for (let m = 0; m < n; m++) {
+        if (axes[m].alive) axes[m].vigour /= most;
+    }
+    carrier_vigour.fill(1 / most);
+}
+
+/**
+ * Carrier `c`'s own extension from its tip from `season` on: an axis of the carrier's order and generator, heading
+ * along the carrier's tip, with no unit yet. It counts as grown a season before, so it extends with the living axes; it
+ * keeps clear of no wood of the carrier or of what the carrier carries in the framework.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {ShootCarrier} c
+ * @param {number} system
+ * @param {number} season
+ */
+function carrier_extension(skeleton, c, system, season) {
+    const last = c.units.length;
+    const edge = c.edges[c.edges.length - 1];
+    skeleton.evaluate_segment_tangent(SCRATCH_T, 0, edge, 1);
+    shoot_normalize3(SCRATCH_H, SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2]);
+    return {
+        system, parent: -1, parent_unit: last - 1, u: 1, node: 0,
+        order: c.rule.carrier_order,
+        short: false,
+        generator: c.rule.source,
+        phase: skeleton.branch_phase_hash[c.carrier],
+        units: [],
+        unit_seasons: [],
+        points: [c.points[last * 3], c.points[last * 3 + 1], c.points[last * 3 + 2]],
+        radii: [],
+        anchor_edge: edge,
+        extends: true,
+        exempt_branch: c.carrier,
+        exempt_family: c.carrier,
+        stem: skeleton.branch_parent[c.carrier] < 0,
+        vigour: 1,
+        birth_radius: 0,
+        heading: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+        aim: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+        taken: [],
+        birth: season - 1,
+        alive: true
+    };
+}
+
+/**
+ * Centres the skeleton's crown frame, which the foliage and the crown's shading read, on the carriers and the living
+ * axes, and spans it over them.
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {ShootCarrier[]} carriers
+ * @param {Array<{alive: boolean, points: number[]}>} axes
+ */
+function crown_frame(skeleton, carriers, axes) {
+    const box = SCRATCH_BOX;
+    box[0] = box[1] = box[2] = Infinity;
+    box[3] = box[4] = box[5] = -Infinity;
+    crown_bounds(box, carriers, axes);
+    for (let i = 0; i < 3; i++) {
+        skeleton.crown_center[i] = 0.5 * (box[i] + box[i + 3]);
+        skeleton.crown_radii[i] = Math.max(0.25, 0.5 * (box[i + 3] - box[i]));
+    }
+}
+
+/**
+ * How far point `q` of `p` lies outside the wood of the segment from `(x0, y0, z0)`, radius `r0`, to `(x1, y1, z1)`,
+ * radius `r1` (negative inside); its distance from the segment's axis into `SCRATCH_REACH[0]`.
+ * @returns {number}
+ */
+function outside_wood(p, q, x0, y0, z0, x1, y1, z1, r0, r1) {
+    const dx = x1 - x0, dy = y1 - y0, dz = z1 - z0;
+    const t = clamp(((p[q] - x0) * dx + (p[q + 1] - y0) * dy + (p[q + 2] - z0) * dz) / Math.max(1e-12, dx * dx + dy * dy + dz * dz), 0, 1);
+    const d = Math.hypot(p[q] - x0 - dx * t, p[q + 1] - y0 - dy * t, p[q + 2] - z0 - dz * t);
+    SCRATCH_REACH[0] = d;
+    return d - (r0 + (r1 - r0) * t);
+}
+
+/**
+ * Kills every axis whose mother has died; mothers come before their laterals.
+ * @param {Array<{parent: number, alive: boolean}>} axes
+ */
+function cascade(axes) {
+    for (let m = 0; m < axes.length; m++) {
+        const parent = axes[m].parent;
+        if (axes[m].alive && parent >= 0 && !axes[parent].alive) axes[m].alive = false;
+    }
+}
+
+/**
+ * The box `[min x, y, z, max x, y, z]` round the framework's nodes.
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @returns {Float64Array}
+ */
+function framework_bounds(skeleton) {
+    const box = Float64Array.of(Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity);
+    const p = new Float32Array(3);
+    for (let v = 0; v < skeleton.node_count; v++) {
+        skeleton.node_read_position(p, 0, v);
+        grow_box(box, p[0], p[1], p[2]);
+    }
+    return box;
+}
+
+/**
+ * Grows `box` round every carrier's units and every living axis.
+ * @param {Float64Array} box
+ * @param {ShootCarrier[]} carriers
+ * @param {Array<{alive: boolean, points: number[]}>} axes
+ */
+function crown_bounds(box, carriers, axes) {
+    for (const c of carriers) {
+        for (let i = 0; i < c.points.length; i += 3) grow_box(box, c.points[i], c.points[i + 1], c.points[i + 2]);
+    }
+    for (const axis of axes) {
+        if (!axis.alive) continue;
+        const p = axis.points;
+        for (let i = 0; i < p.length; i += 3) grow_box(box, p[i], p[i + 1], p[i + 2]);
+    }
+}
+
+/**
+ * @param {Float64Array} box
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function grow_box(box, x, y, z) {
+    box[0] = Math.min(box[0], x);
+    box[1] = Math.min(box[1], y);
+    box[2] = Math.min(box[2], z);
+    box[3] = Math.max(box[3], x);
+    box[4] = Math.max(box[4], y);
+    box[5] = Math.max(box[5], z);
+}
+
+/**
+ * Whether `field` still reaches half of {@link LIGHT_FIELD_MARGIN} past `box` all round.
+ * @param {ShootLightField} field
+ * @param {Float64Array} box
+ * @returns {boolean}
+ */
+function field_holds(field, box) {
+    const half = LIGHT_FIELD_MARGIN * 0.5;
+    const n = [field.nx, field.ny, field.nz];
+    for (let i = 0; i < 3; i++) {
+        if (box[i] - half < field.min[i] || box[i + 3] + half > field.min[i] + n[i] * field.cell) return false;
+    }
+    return true;
+}
+
+/**
+ * A light field over `box` and {@link LIGHT_FIELD_MARGIN} around it.
+ * @param {Float64Array} box
+ * @param {number} cell
+ * @returns {ShootLightField}
+ */
+function make_light_field(box, cell) {
+    const min = [box[0] - LIGHT_FIELD_MARGIN, box[1] - LIGHT_FIELD_MARGIN, box[2] - LIGHT_FIELD_MARGIN];
+    const max = [box[3] + LIGHT_FIELD_MARGIN, box[4] + LIGHT_FIELD_MARGIN, box[5] + LIGHT_FIELD_MARGIN];
+    return new ShootLightField(min, max, cell);
+}
+
+/**
+ * Puts the leaves alive in `season` into `field`: on each leaf-bearing unit young enough to keep them, the unit's leaves
+ * times the share of that age still alive, spread along it; a short shoot's at its tip. `leaf_area_each` is one leaf's
+ * area (m^2).
+ */
+function deposit_leaves(field, species, carriers, axes, season, leafy, leaf_area_each, leaf_survival) {
+    const L = leaf_survival.length;
+    for (let s = 0; s < carriers.length; s++) {
+        const c = carriers[s];
+        if (!leafy.has(c.rule.source)) continue;
+        for (let k = 0; k < c.units.length; k++) {
+            const age = season - (c.first_season + k);
+            if (age < 0 || age >= L) continue;
+            const area = foliage_unit_leaf_count(species, false, c.units[k]) * leaf_area_each * leaf_survival[age];
+            field.deposit_segment(c.points.subarray(k * 3, k * 3 + 3), c.points.subarray(k * 3 + 3, k * 3 + 6), area);
+        }
+    }
+    for (let m = 0; m < axes.length; m++) {
+        const axis = axes[m];
+        if (!axis.alive || !leafy.has(axis.generator)) continue;
+        const pts = axis.points;
+        if (axis.short) {
+            const tip = axis.units.length * 3;
+            field.deposit(pts[tip], pts[tip + 1], pts[tip + 2], foliage_unit_leaf_count(species, true, 0) * leaf_area_each);
+            continue;
+        }
+        for (let k = 0; k < axis.units.length; k++) {
+            const age = season - axis.unit_seasons[k];
+            if (age < 0 || age >= L) continue;
+            const area = foliage_unit_leaf_count(species, false, axis.units[k]) * leaf_area_each * leaf_survival[age];
+            SCRATCH_A[0] = pts[k * 3];
+            SCRATCH_A[1] = pts[k * 3 + 1];
+            SCRATCH_A[2] = pts[k * 3 + 2];
+            SCRATCH_B[0] = pts[k * 3 + 3];
+            SCRATCH_B[1] = pts[k * 3 + 4];
+            SCRATCH_B[2] = pts[k * 3 + 5];
+            field.deposit_segment(SCRATCH_A, SCRATCH_B, area);
+        }
+    }
+}
+
+/**
+ * Rank of a new shoot for surviving, the highest kept: the log of its chance in the light it has, plus oak's shedding
+ * rank, by which older axes, lower orders and longer units hold on, and the highest orders and short shoots are shed
+ * first [Buck-Sorlin & Bell 1998 p. 388]. The rank's weights are chosen.
+ *
+ * @param {number} p chance of surviving in its light
+ * @param {number} order
+ * @param {number} length metres
+ * @param {number} age seasons its axis has lived
+ * @param {import("../config/ShootSystemRule.js").ShootSystemRule} rule
+ * @param {function():number} rng
+ * @returns {number}
+ */
+function shed_rank(p, order, length, age, rule, rng) {
+    return Math.log(Math.max(1e-6, p)) + 1.5 * age - 0.5 * order + Math.log(length / shoot_order_value(rule.mean_unit_length, order)) + 0.5 * rng();
+}
+
+/**
+ * Mean length (m) of the first unit of a long lateral from `zone`, grown on a mother of `order` from a unit
+ * `unit_length` long.
+ * @param {import("../config/ShootBudZone.js").ShootBudZone} zone
+ * @param {number} order
+ * @param {number} unit_length
+ * @returns {number}
+ */
+function lateral_mean(zone, order, unit_length) {
+    return shoot_order_value(zone.length, order) + shoot_order_value(zone.length_slope, order) * unit_length;
+}
+
+/**
+ * @param {function():number} rng
+ * @param {number} n
+ * @param {number} p
+ * @returns {number}
+ */
+function binomial(rng, n, p) {
+    let k = 0;
+    for (let i = 0; i < n; i++) {
+        if (rng() < p) k++;
+    }
+    return k;
+}
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} t
+ * @returns {number}
+ */
+function lerp_u(a, b, t) {
+    return a + (b - a) * clamp(t, 0, 1);
+}