@woosh/meep-engine 3.57.0 → 3.59.0

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

@@ -1,301 +1,14 @@
-import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_user_data_intersects_capsule } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_capsule.js";
-import { PointHashGrid3 } from "../../../core/geom/3d/hash-grid/PointHashGrid3.js";
-import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
-import { GOLDEN_RATIO } from "../../../core/math/GOLDEN_RATIO.js";
-import { PI2 } from "../../../core/math/PI2.js";
-import { clamp } from "../../../core/math/clamp.js";
-import { lerp } from "../../../core/math/lerp.js";
-import { curl_noise_3d } from "../../../core/math/noise/curl_noise_3d.js";
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
-import { PhyllotaxisMode, phyllotaxis_sample_angle } from "../config/PhyllotaxisMode.js";
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 import { TreeSkeleton } from "./TreeSkeleton.js";
-import { assert } from "../../../core/assert.js";
-import { flare_lobe_phase_offset } from "./flare_lobe_phase_offset.js";
-import { crown_envelope_evaluate, crown_envelope_sdf } from "./crown_envelope_evaluate.js";
-import { spine_frame_double_reflection } from "./spine_frame_double_reflection.js";
-import { tree_skeleton_compute_pipe_radii } from "./tree_skeleton_compute_pipe_radii.js";
+import { tree_skeleton_fit_crown_frame } from "./tree_skeleton_fit_crown_frame.js";
+import { tree_skeleton_grow_framework } from "./tree_skeleton_grow_framework.js";
 import { tree_skeleton_grow_shoots } from "./tree_skeleton_grow_shoots.js";
 
-const GOLDEN_ANGLE = PI2 / (GOLDEN_RATIO * GOLDEN_RATIO); // ~2.399963229728653 rad (137.50776 deg)
-
-/**
- * Canonical order of a generator's outgoing rules: by target, then by content, so the order rules are listed in
- * never changes the tree.
- * @param {import("../config/BranchSpawnRule.js").BranchSpawnRule} a
- * @param {import("../config/BranchSpawnRule.js").BranchSpawnRule} b
- * @returns {number}
- */
-function compare_rule_target(a, b) {
-    return (a.target - b.target) || (a.hash() - b.hash());
-}
-
-/**
- * Node position `u` of child `c` of a rule laying out `planned` children over its attachment interval, `u` in
- * [0, 1) for `c` in [0, planned). The same layout continued to `c < 0` gives `u < 0`: where the rule's earlier
- * children grew, below its interval.
- *
- * @param {import("../config/BranchSpawnRule.js").BranchSpawnRule} rule
- * @param {number} c
- * @param {number} planned
- * @param {boolean} on_trunk whorls compress toward the apex of a trunk (self-similar conical internodes)
- * @returns {number}
- */
-function rule_node_u(rule, c, planned, on_trunk) {
-    switch (rule.phyllotaxis_mode) {
-        case PhyllotaxisMode.Opposite:
-        case PhyllotaxisMode.OppositeDecussate: {
-            const pair_count = Math.max(1, Math.ceil(planned / 2));
-            return pair_count > 1 ? ((c >> 1) + 0.35) / (pair_count - 0.55) : 0.5;
-        }
-        case PhyllotaxisMode.Whorled: {
-            const w_size = Math.max(1, rule.whorl_count | 0);
-            const whorl_total = Math.max(1, Math.ceil(planned / w_size));
-            const u_lin = whorl_total > 1 ? (Math.floor(c / w_size) + 0.35) / (whorl_total - 0.55) : 0.5;
-            // p > 1 => du/dt decreases as u -> 1; u_lin < 1 for every c < planned
-            return on_trunk ? 1.0 - Math.pow(1.0 - u_lin, 1.42) : u_lin;
-        }
-        default:
-            return planned > 1 ? (c + 0.35) / (planned - 0.55) : 0.5;
-    }
-}
-
-/**
- * Azimuth of child `c` of a rule relative to its family's base azimuth, for any integer `c` (also `c < 0`).
- * `FlareLobes` is placed by the caller.
- *
- * @param {import("../config/BranchSpawnRule.js").BranchSpawnRule} rule
- * @param {number} c
- * @returns {number}
- */
-function rule_node_phi(rule, c) {
-    return phyllotaxis_sample_angle(rule.phyllotaxis_mode, c, rule.whorl_count);
-}
-
-const SCRATCH_CURL = [0, 0, 0];
-const SCRATCH_RMF = new Float64Array(6);
-const SCRATCH_POS = new Float32Array(3);
-const SCRATCH_TAN = new Float32Array(3);
-const SCRATCH_P0 = new Float32Array(3);
-const SCRATCH_T0 = new Float32Array(3);
-const SCRATCH_R0 = new Float32Array(3);
-const SCRATCH_M_PREV = new Float32Array(3);
-const SCRATCH_M_NEXT = new Float32Array(3);
-const SCRATCH_GUIDE_P0 = new Float32Array(3);
-const SCRATCH_GUIDE_P1 = new Float32Array(3);
-const SCRATCH_GUIDE_T = new Float32Array(3);
-
-/**
- * Evaluates the trunk guide curve position `out_pos` and unit tangent `out_tan` at normalized
- * parameter `t_norm` in [0, 1]. Defaults to the vertical upward plumb line `(0, t_norm * trunk_len, 0)`
- * when `trunk_guide` is null or omitted.
- *
- * @param {Float32Array|number[]} out_pos
- * @param {Float32Array|number[]} out_tan
- * @param {Array<ArrayLike<number>>|Function|null|undefined} trunk_guide
- * @param {number} t_norm
- * @param {number} trunk_len
- */
-function evaluate_trunk_guide(out_pos, out_tan, trunk_guide, t_norm, trunk_len) {
-    const t = clamp(t_norm, 0.0, 1.0);
-    if (!trunk_guide) {
-        out_pos[0] = 0.0;
-        out_pos[1] = t * trunk_len;
-        out_pos[2] = 0.0;
-        out_tan[0] = 0.0;
-        out_tan[1] = 1.0;
-        out_tan[2] = 0.0;
-        return;
-    }
-
-    const sample_pt = (u, dst) => {
-        if (typeof trunk_guide === "function") {
-            trunk_guide(u, dst);
-            return;
-        }
-        if (Array.isArray(trunk_guide) && trunk_guide.length >= 2) {
-            const n = trunk_guide.length - 1;
-            const su = clamp(u, 0.0, 1.0) * n;
-            const idx = Math.min(n - 1, Math.floor(su));
-            const frac = su - idx;
-            const a = trunk_guide[idx];
-            const b = trunk_guide[idx + 1];
-            dst[0] = lerp(a[0] ?? 0.0, b[0] ?? 0.0, frac);
-            dst[1] = lerp(a[1] ?? 0.0, b[1] ?? 0.0, frac);
-            dst[2] = lerp(a[2] ?? 0.0, b[2] ?? 0.0, frac);
-            return;
-        }
-        dst[0] = 0.0;
-        dst[1] = u * trunk_len;
-        dst[2] = 0.0;
-    };
-
-    sample_pt(t, out_pos);
-    const eps = 0.01;
-    const t_a = Math.max(0.0, t - eps);
-    const t_b = Math.min(1.0, t + eps);
-    const pa = [0, 0, 0];
-    const pb = [0, 0, 0];
-    sample_pt(t_a, pa);
-    sample_pt(t_b, pb);
-    let tx = pb[0] - pa[0];
-    let ty = pb[1] - pa[1];
-    let tz = pb[2] - pa[2];
-    const tl = Math.hypot(tx, ty, tz);
-    if (tl > 1e-8) {
-        out_tan[0] = tx / tl;
-        out_tan[1] = ty / tl;
-        out_tan[2] = tz / tl;
-    } else {
-        out_tan[0] = 0.0;
-        out_tan[1] = 1.0;
-        out_tan[2] = 0.0;
-    }
-}
-
-/**
- * Rotates unit vector `(vx, vy, vz)` around unit axis `(ax, ay, az)` by `angle` radians (Rodrigues' formula).
- * @param {number[]|Float64Array} out
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} angle
- */
-function rotate_around_axis(out, vx, vy, vz, ax, ay, az, angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    const dot = vx * ax + vy * ay + vz * az;
-    const omc = 1.0 - c;
-
-    const cx = ay * vz - az * vy;
-    const cy = az * vx - ax * vz;
-    const cz = ax * vy - ay * vx;
-
-    let rx = vx * c + cx * s + ax * dot * omc;
-    let ry = vy * c + cy * s + ay * dot * omc;
-    let rz = vz * c + cz * s + az * dot * omc;
-
-    const len = Math.sqrt(rx * rx + ry * ry + rz * rz);
-    if (len > 1e-12) {
-        const inv = 1.0 / len;
-        rx *= inv;
-        ry *= inv;
-        rz *= inv;
-    }
-    out[0] = rx;
-    out[1] = ry;
-    out[2] = rz;
-}
-
-/**
- * Determines the non-exempt sub-segment parameter intervals `[s_min, 1]` on candidate segment A
- * and `[t_min, 1]` on existing segment B for branch-branch capsule collision testing.
- * Returns `false` if the segment pair is topologically exempt (e.g. direct parent-child base collar).
- *
- * @param {number} bA
- * @param {number} parent_bA
- * @param {number} attach_seg_A
- * @param {boolean} is_split_A
- * @param {number} local_idx_A
- * @param {number} bB
- * @param {number} parent_bB
- * @param {number} attach_seg_B
- * @param {boolean} is_split_B
- * @param {number} local_idx_B
- * @param {Float64Array|number[]} out_bounds `[s_min, t_min]`
- * @returns {boolean}
- */
-function resolve_subsegment_bounds(
-    bA, parent_bA, attach_seg_A, is_split_A, local_idx_A,
-    bB, parent_bB, attach_seg_B, is_split_B, local_idx_B,
-    out_bounds
-) {
-    if (bA === bB) return false;
-
-    // 1. A is a direct child of B
-    if (parent_bA === bB) {
-        if (is_split_A) {
-            if (local_idx_A === 0 && local_idx_B === attach_seg_A) return false;
-            if (local_idx_A === 0 && local_idx_B === attach_seg_A + 1) {
-                out_bounds[0] = 0.55;
-                out_bounds[1] = 0.55;
-                return true;
-            }
-            if (local_idx_A === 1 && (local_idx_B === attach_seg_A || local_idx_B === attach_seg_A + 1)) {
-                out_bounds[0] = 0.45;
-                out_bounds[1] = 0.45;
-                return true;
-            }
-        } else {
-            if (local_idx_A === 0 && Math.abs(local_idx_B - attach_seg_A) <= 1) return false;
-            if (local_idx_A === 1 && Math.abs(local_idx_B - attach_seg_A) <= 1) {
-                if (bA < 0 || local_idx_B === attach_seg_A) return false;
-                out_bounds[0] = 0.35;
-                out_bounds[1] = 0.0;
-                return true;
-            }
-        }
-    }
-
-    // 2. B is a direct child of A
-    if (parent_bB === bA) {
-        if (is_split_B) {
-            if (local_idx_B === 0 && local_idx_A === attach_seg_B) return false;
-            if (local_idx_B === 0 && local_idx_A === attach_seg_B + 1) {
-                out_bounds[0] = 0.55;
-                out_bounds[1] = 0.55;
-                return true;
-            }
-            if (local_idx_B === 1 && (local_idx_A === attach_seg_B || local_idx_A === attach_seg_B + 1)) {
-                out_bounds[0] = 0.45;
-                out_bounds[1] = 0.45;
-                return true;
-            }
-        } else {
-            if (local_idx_B <= 1 && Math.abs(local_idx_A - attach_seg_B) <= 1) return false;
-        }
-    }
-
-    // 3. A and B are siblings sharing the same parent branch
-    if (parent_bA >= 0 && parent_bA === parent_bB) {
-        if (local_idx_A === 0 && local_idx_B === 0) {
-            out_bounds[0] = 0.50;
-            out_bounds[1] = 0.50;
-            return true;
-        }
-        if (local_idx_A === 0 && local_idx_B === 1 && Math.abs(attach_seg_A - attach_seg_B) <= 1) {
-            out_bounds[0] = 0.25;
-            out_bounds[1] = 0.0;
-            return true;
-        }
-        if (local_idx_A === 1 && local_idx_B === 0 && Math.abs(attach_seg_A - attach_seg_B) <= 1) {
-            out_bounds[0] = 0.0;
-            out_bounds[1] = 0.25;
-            return true;
-        }
-    }
-
-    out_bounds[0] = 0.0;
-    out_bounds[1] = 0.0;
-    return true;
-}
-
 /**
- * Generates a directed botanical `TreeSkeleton` from a `TreeSpeciesConfig`, combining:
- * - A branch generator graph: `species.branches[0]` grows the trunk, and every `species.branch_rules` edge
- *   spawns branches of its `target` generator along each branch of its `source` generator
- * - Parametric Cubic Hermite spine generation (`BranchGeneratorConfig`, `AnimationCurve` profiles)
- * - Botanical phyllotaxis (`SpiralGolden`, `AlternateDistichous`, `Tristichous`, `Opposite`, `OppositeDecussate`, `Whorled`, `FlareLobes`)
- * - Structural surface roots (`BranchGeneratorConfig.root`) that creep along the ground plane `y = 0`
- * - Gravitropism (toward `-Y`), phototropism (toward `+Y` and outward crown exterior), and 3D `curl_noise_3d` gnarl
- * - Dichotomous / sympodial trunk & bough splitting
- * - Space colonization crown competition via `PointHashGrid3`
- * - Rotation-Minimizing Frames (`spine_frame_double_reflection`)
- * - Pipe Model cross-section radius accumulation (`tree_skeleton_compute_pipe_radii`)
+ * Grows a whole tree botanically (`TreeGrowth.Botanical`): its framework from the generator graph
+ * (`tree_skeleton_grow_framework`), then the shoot systems of its `shoot_rules`, year by year on that framework, its
+ * girth final (`tree_skeleton_grow_shoots`), and fits the crown frame to them as the framework did to its carriers
+ * (`tree_skeleton_fit_crown_frame`).
  *
  * @param {TreeSpeciesConfig|Object} [config]
  * @param {TreeSkeleton} [out]
@@ -303,1746 +16,8 @@ function resolve_subsegment_bounds(
  */
 export function tree_skeleton_grow(config = new TreeSpeciesConfig(), out = new TreeSkeleton()) {
     const species = config && config.isTreeSpeciesConfig ? config : TreeSpeciesConfig.from(config);
-    out.clear();
-
-    const rng = seededRandom(species.seed | 0);
-    // Seed-derived 3D noise offset so unseeded Simplex/Curl fields are unique and deterministic per seed
-    const noise_ox = (rng() - 0.5) * 1000.0;
-    const noise_oy = (rng() - 0.5) * 1000.0;
-    const noise_oz = (rng() - 0.5) * 1000.0;
-
-    const crown = species.crown;
-    const crown_cy = crown.base_height + crown.height * 0.5;
-    out.crown_center[0] = 0.0;
-    out.crown_center[1] = crown_cy;
-    out.crown_center[2] = 0.0;
-
-    out.crown_radii[0] = Math.max(0.25, crown.radius);
-    out.crown_radii[1] = Math.max(0.25, crown.height * 0.5);
-    out.crown_radii[2] = Math.max(0.25, crown.radius);
-
-    // Build Space Colonization attraction point cloud + PointHashGrid3 once
-    const use_space_col = crown.space_colonization_weight > 0.0 && crown.attraction_point_count > 0;
-    const attr_count = use_space_col ? (crown.attraction_point_count | 0) : 0;
-    const attr_positions = new Float32Array(attr_count * 3);
-    const attr_alive = new Uint8Array(attr_count);
-    let attr_grid = null;
-
-    if (use_space_col) {
-        let placed = 0;
-        let attempts = 0;
-        const max_attempts = attr_count * 12;
-        while (placed < attr_count && attempts < max_attempts) {
-            attempts++;
-            const u_h = rng();
-            const env_r = crown.radius * crown_envelope_evaluate(crown.envelope_type, u_h);
-            const rx = (rng() * 2.0 - 1.0) * env_r;
-            const rz = (rng() * 2.0 - 1.0) * env_r;
-            if (rx * rx + rz * rz <= env_r * env_r) {
-                const ry = crown.base_height + u_h * crown.height;
-                attr_positions[placed * 3] = rx;
-                attr_positions[placed * 3 + 1] = ry;
-                attr_positions[placed * 3 + 2] = rz;
-                attr_alive[placed] = 1;
-                placed++;
-            }
-        }
-        while (placed < attr_count) {
-            const theta = rng() * PI2;
-            const u_h = rng();
-            const r = Math.sqrt(rng()) * crown.radius * crown_envelope_evaluate(crown.envelope_type, u_h);
-            attr_positions[placed * 3] = Math.cos(theta) * r;
-            attr_positions[placed * 3 + 1] = crown.base_height + u_h * crown.height;
-            attr_positions[placed * 3 + 2] = Math.sin(theta) * r;
-            attr_alive[placed] = 1;
-            placed++;
-        }
-
-        attr_grid = new PointHashGrid3();
-        attr_grid.build(attr_positions, attr_count, Math.max(0.25, crown.attraction_radius));
-    }
-
-    const r_influence_sq = crown.attraction_radius * crown.attraction_radius;
-    const r_kill_sq = crown.kill_radius * crown.kill_radius;
-
-    // Queue of branches to grow in level-order (guarantees parent branches & vertices precede children)
-    const queue = [];
-
-    const lvl0 = species.branches[0];
-    if (!lvl0) {
-        return out;
-    }
-
-    // Outgoing rules of every generator in canonical order, so the order rules are listed in does not change the tree
-    const outgoing_rules = species.branches.map(() => []);
-    for (let r = 0; r < species.branch_rules.length; r++) {
-        const rule = species.branch_rules[r];
-        assert.ok(rule.source >= 0 && rule.source < rule.target && rule.target < species.branches.length,
-            'branch rule must satisfy 0 <= source < target < branches.length');
-        outgoing_rules[rule.source].push(rule);
-    }
-    for (let g = 0; g < outgoing_rules.length; g++) {
-        outgoing_rules[g].sort(compare_rule_target);
-    }
-
-    const trunk_len = Math.max(0.2, lvl0.length * (1.0 + (rng() * 2.0 - 1.0) * lvl0.length_variance));
-    const trunk_base_r = Math.max(0.01, trunk_len * lvl0.radius_ratio);
-
-    evaluate_trunk_guide(SCRATCH_GUIDE_P0, SCRATCH_GUIDE_T, species.trunk_guide, 0.0, trunk_len);
-
-    // Apply subtle initial basal trunk lean around the guide tangent
-    const max_lean = lvl0.excurrent ? 0.025 : 0.06;
-    const lean_ang = clamp((lvl0.basal_lean ?? 0.02) * (0.75 + 0.5 * rng()), 0.0, max_lean);
-    const lean_az = rng() * PI2;
-    const init_tx = clamp(SCRATCH_GUIDE_T[0] + Math.sin(lean_ang) * Math.cos(lean_az), -0.95, 0.95);
-    const init_ty = Math.max(0.2, SCRATCH_GUIDE_T[1] * Math.cos(lean_ang));
-    const init_tz = clamp(SCRATCH_GUIDE_T[2] + Math.sin(lean_ang) * Math.sin(lean_az), -0.95, 0.95);
-    const init_t_len = Math.hypot(init_tx, init_ty, init_tz) || 1.0;
-    const norm_tx = init_tx / init_t_len;
-    const norm_ty = init_ty / init_t_len;
-    const norm_tz = init_tz / init_t_len;
-
-    // Orthonormal initial R perpendicular to norm_T
-    let init_rx = 1.0 - norm_tx * norm_tx;
-    let init_ry = -norm_ty * norm_tx;
-    let init_rz = -norm_tz * norm_tx;
-    const init_r_len = Math.hypot(init_rx, init_ry, init_rz) || 1.0;
-    init_rx /= init_r_len;
-    init_ry /= init_r_len;
-    init_rz /= init_r_len;
-
-    queue.push({
-        level: 0,
-        generator: 0,
-        in_crown: true,
-        parent_branch_id: -1,
-        parent_edge_id: -1,
-        parent_attach_seg_idx: -1,
-        parent_attach_t: 0.0,
-        start_vertex: -1,
-        px: SCRATCH_GUIDE_P0[0],
-        py: SCRATCH_GUIDE_P0[1],
-        pz: SCRATCH_GUIDE_P0[2],
-        tx: norm_tx,
-        ty: norm_ty,
-        tz: norm_tz,
-        rx: init_rx,
-        ry: init_ry,
-        rz: init_rz,
-        emerge_drx: init_rx,
-        emerge_dry: init_ry,
-        emerge_drz: init_rz,
-        length: trunk_len,
-        full_branch_length: trunk_len,
-        base_radius: trunk_base_r,
-        start_seg: 0,
-        total_segs: Math.max(1, lvl0.segments),
-        shape_segs: Math.max(1, lvl0.segments),
-        initial_arc_s: 0.0,
-        has_split: false,
-        is_split_fork: false,
-        cum_t0: 0.0,
-        cum_t1: 1.0
-    });
-
-    const rot_scratch = [0, 0, 0];
-
-    // Scope-local BVH and per-segment metadata for branch-branch spatial avoidance & collision prevention
-    const bvh = new BVH();
-    const bvh_hits = new Uint32Array(256);
-    const query_capsule = new Float32Array(7);
-    const sub_bounds = new Float64Array(2);
-    const closest_st = new Float64Array(2);
-
-    const seg_branch_id = [];
-    const seg_local_idx = [];
-    const seg_p0x = [], seg_p0y = [], seg_p0z = [], seg_r0 = [];
-    const seg_p1x = [], seg_p1y = [], seg_p1z = [], seg_r1 = [];
-    const seg_bvh_leaf = [];
-
-    const branch_parent_seg_idx = [];
-    const branch_is_split_fork = [];
-
-    /**
-     * Evaluates the minimum signed surface-to-surface clearance between a candidate segment A
-     * and all non-exempt existing segments in `bvh`.
-     */
-    const evaluate_candidate_clearance = (
-        bA, parent_bA, attach_seg_A, is_split_A, local_idx_A,
-        a0x, a0y, a0z, rA0,
-        a1x, a1y, a1z, rA1,
-        extra_margin
-    ) => {
-        if (bvh.size === 0) return 10.0;
-        const max_rA = Math.max(rA0, rA1);
-        query_capsule[0] = a0x;
-        query_capsule[1] = a0y;
-        query_capsule[2] = a0z;
-        query_capsule[3] = a1x;
-        query_capsule[4] = a1y;
-        query_capsule[5] = a1z;
-        query_capsule[6] = max_rA * 1.15 + extra_margin + 0.04;
-
-        const hit_count = bvh_query_user_data_intersects_capsule(bvh_hits, 0, bvh, query_capsule);
-        let min_clear = 10.0;
-
-        for (let h = 0; h < hit_count; h++) {
-            const eB = bvh_hits[h];
-            const bB = seg_branch_id[eB];
-            const local_idx_B = seg_local_idx[eB];
-            const parent_bB = out.branch_parent[bB];
-            const attach_seg_B = branch_parent_seg_idx[bB];
-            const is_split_B = branch_is_split_fork[bB];
-
-            if (!resolve_subsegment_bounds(
-                bA, parent_bA, attach_seg_A, is_split_A, local_idx_A,
-                bB, parent_bB, attach_seg_B, is_split_B, local_idx_B,
-                sub_bounds
-            )) {
-                continue;
-            }
-
-            const s_min = sub_bounds[0];
-            const t_min = sub_bounds[1];
-            const sa0x = a0x + (a1x - a0x) * s_min;
-            const sa0y = a0y + (a1y - a0y) * s_min;
-            const sa0z = a0z + (a1z - a0z) * s_min;
-
-            const b0x = seg_p0x[eB], b0y = seg_p0y[eB], b0z = seg_p0z[eB];
-            const b1x = seg_p1x[eB], b1y = seg_p1y[eB], b1z = seg_p1z[eB];
-            const sb0x = b0x + (b1x - b0x) * t_min;
-            const sb0y = b0y + (b1y - b0y) * t_min;
-            const sb0z = b0z + (b1z - b0z) * t_min;
-
-            line3_compute_segment_segment_closest_points(
-                closest_st,
-                sa0x, sa0y, sa0z, a1x, a1y, a1z,
-                sb0x, sb0y, sb0z, b1x, b1y, b1z
-            );
-
-            const s_f = s_min + (1.0 - s_min) * closest_st[0];
-            const t_f = t_min + (1.0 - t_min) * closest_st[1];
-
-            const qAx = a0x + (a1x - a0x) * s_f;
-            const qAy = a0y + (a1y - a0y) * s_f;
-            const qAz = a0z + (a1z - a0z) * s_f;
-            const qBx = b0x + (b1x - b0x) * t_f;
-            const qBy = b0y + (b1y - b0y) * t_f;
-            const qBz = b0z + (b1z - b0z) * t_f;
-
-            const dist = Math.hypot(qAx - qBx, qAy - qBy, qAz - qBz);
-            const rA = rA0 + (rA1 - rA0) * s_f;
-            const rB = seg_r0[eB] + (seg_r1[eB] - seg_r0[eB]) * t_f;
-            const r_req = (rA + rB) * 1.08 + extra_margin;
-            const clear = dist - r_req;
-            if (clear < min_clear) {
-                min_clear = clear;
-            }
-        }
-        return min_clear;
-    };
-
-    for (let q_idx = 0; q_idx < queue.length; q_idx++) {
-        const job = queue[q_idx];
-        const level = job.level;
-        const generator = job.generator;
-        const lvl_cfg = species.branches[generator];
-
-        const phase_hash = rng();
-        const N_seg = job.total_segs;
-        // Shape is a function of position along the whole branch: envelopes take the genealogical t (cum_t0..cum_t1)
-        // and per-step amounts the whole branch's segmentation, so a dead stub bends as the base of its branch did
-        const N_shape = job.shape_segs;
-        const remaining_segs = N_seg - job.start_seg;
-        if (remaining_segs <= 0) continue;
-
-        const step_len = job.length / N_seg;
-        const prof_p0 = lvl_cfg.radius_profile.evaluate(0.0);
-        const prof_p1 = lvl_cfg.radius_profile.evaluate(1.0);
-        const prof_span = prof_p0 - prof_p1;
-
-        let cur_px = job.px;
-        let cur_py = job.py;
-        let cur_pz = job.pz;
-        let cur_tx = job.tx;
-        let cur_ty = job.ty;
-        let cur_tz = job.tz;
-        let cur_rx = job.rx;
-        let cur_ry = job.ry;
-        let cur_rz = job.rz;
-        let cur_arc_s = job.initial_arc_s;
-
-        // Compute binormal S = T x R
-        let cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
-        let cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
-        let cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
-
-        let prev_v = job.start_vertex;
-        let branch_id = -1;
-
-        if (prev_v < 0) {
-            const t0 = job.start_seg / N_seg;
-            const u_prof0 = prof_span > 1e-4
-                ? clamp((prof_p0 - lvl_cfg.radius_profile.evaluate(t0)) / prof_span, 0.0, 1.0)
-                : t0;
-            const min_r0_frac = level === 0 ? 0.08 : 0.15;
-            const r0 = Math.max(0.002, job.base_radius * Math.max(1.0 - lvl_cfg.taper * u_prof0, min_r0_frac));
-
-            branch_id = out.add_branch(
-                0,
-                level,
-                generator,
-                job.parent_branch_id,
-                job.parent_edge_id,
-                job.parent_attach_t,
-                job.length,
-                r0,
-                phase_hash
-            );
-            prev_v = out.add_node(
-                cur_px, cur_py, cur_pz,
-                cur_tx, cur_ty, cur_tz,
-                cur_rx, cur_ry, cur_rz,
-                r0,
-                branch_id,
-                level,
-                job.parent_branch_id,
-                t0,
-                cur_arc_s,
-                phase_hash
-            );
-            if (job.attach_parent_vertex !== undefined && job.attach_parent_vertex >= 0) {
-                out.connect_nodes(job.attach_parent_vertex, prev_v);
-            }
-            out.branch_root_vertex[branch_id] = prev_v;
-            out.branch_tip_vertex[branch_id] = prev_v;
-        } else {
-            const prev_r = out.node_read_radius(prev_v);
-            branch_id = out.add_branch(
-                prev_v,
-                level,
-                generator,
-                job.parent_branch_id,
-                job.parent_edge_id,
-                job.parent_attach_t,
-                job.length,
-                prev_r,
-                phase_hash
-            );
-        }
-
-        branch_parent_seg_idx[branch_id] = job.parent_attach_seg_idx ?? -1;
-        branch_is_split_fork[branch_id] = Boolean(job.is_split_fork);
-        out.branch_dead[branch_id] = job.dead ? 1 : 0;
-
-        const branch_edges = [];
-        const branch_edge_t0 = [];
-        const branch_edge_t1 = [];
-        const branch_vertices = [prev_v];
-
-        // Pre-schedule the phyllotactic child attachments of every outgoing rule so the parent spine kinks
-        // sympodially at lateral emissions
-        const len_fraction_est = level >= 1
-            ? clamp(Math.pow(job.length / Math.max(0.2, lvl_cfg.length), 0.85), 0.0, 1.0)
-            : 1.0;
-        const can_bear_children = !job.dead && job.base_radius >= 0.006 && (level === 0 || job.length >= 0.55);
-        const span_fraction_est = job.child_span_fraction ?? Math.max(0.25, (N_seg - job.start_seg) / Math.max(1, N_seg));
-        const effective_span = span_fraction_est * len_fraction_est;
-        const t_start_est = job.start_seg / N_seg;
-        const raw_base_phi = rng() * PI2;
-        const scheduled_children = [];
-        let has_children = false;
-
-        const rules = outgoing_rules[generator];
-        for (let r = 0; r < rules.length; r++) {
-            const rule = rules[r];
-            if (rule.count <= 0 || !can_bear_children) continue;
-            has_children = true;
-
-            const planned_child_count = effective_span < 0.99
-                ? Math.max(1, Math.round(rule.count * effective_span))
-                : rule.count;
-            const t_lo = Math.max(clamp(rule.attach_min, 0.0, 0.92), t_start_est);
-            const t_hi = Math.min(0.968, rule.attach_max);
-            const t_cap = Math.min(0.98, rule.attach_max);
-            if (t_hi <= t_lo + 1e-3) continue;
-
-            // Each rule turns its family by the golden angle, so families sharing a stretch of the parent interleave
-            let base_phi = raw_base_phi + r * GOLDEN_ANGLE;
-            if (
-                level >= 1
-                && (rule.phyllotaxis_mode === PhyllotaxisMode.AlternateDistichous
-                    || rule.phyllotaxis_mode === PhyllotaxisMode.Opposite)
-            ) {
-                // Align distichous / opposite lateral branching plane with the horizontal plane perpendicular to T
-                const horiz_phi = Math.atan2(-cur_ry, cur_sy);
-                base_phi = horiz_phi + (raw_base_phi < Math.PI ? 0.0 : Math.PI) + ((raw_base_phi % Math.PI) / Math.PI - 0.5) * 0.28;
-            }
-
-            for (let c = 0; c < planned_child_count; c++) {
-                const u_c = rule_node_u(rule, c, planned_child_count, level === 0);
-                const t_att = clamp(
-                    lerp(t_lo, t_hi, clamp(u_c, 0.0, 1.0)) + (rng() - 0.5) * ((t_hi - t_lo) * 0.25 / planned_child_count),
-                    t_lo,
-                    t_cap
-                );
-
-                let phi_c = base_phi + rule_node_phi(rule, c);
-                if (rule.phyllotaxis_mode === PhyllotaxisMode.FlareLobes) {
-                    // On a crest of this branch's basal flare lobes, in the same frame the bark mesher shapes them in
-                    const lobes = Math.max(1, lvl_cfg.flare_lobes | 0);
-                    const arc_est = job.initial_arc_s + t_att * job.length;
-                    phi_c = ((c % lobes) * PI2) / lobes - flare_lobe_phase_offset(arc_est, phase_hash);
-                }
-                phi_c += (rng() * 2.0 - 1.0) * rule.azimuth_jitter;
-                scheduled_children.push({ t_attach: t_att, phi: phi_c, rule, age: 0.0, retained: 1.0 });
-            }
-
-            // Self-pruning: below t_lo this crown rule once bore children too, at the same nodes, which died as the
-            // crown rose above them and were shed. Age runs from 0 just below the living children to 1 at the stem's
-            // base; a branch that died earlier died smaller, (1 - age) of its size today. It keeps
-            // (1 - self_pruning) - age of its length as a dead stub, and once that no longer clears the bark it has
-            // been grown over, leaving a scar.
-            if (rule.crown_envelope && !job.is_split_fork && planned_child_count > 1) {
-                const persistence = 1.0 - species.branches[rule.target].self_pruning;
-                let t_node = t_lo;
-                for (let c = -1; ; c--) {
-                    const t_dead = lerp(t_lo, t_hi, rule_node_u(rule, c, planned_child_count, level === 0));
-                    // past the stem's base, or a layout of a single node (one pair, one whorl) that has no 'below'
-                    if (t_dead <= 0.0 || t_dead > t_node) break;
-                    t_node = t_dead;
-                    const age = (t_lo - t_dead) / t_lo;
-                    const phi_c = base_phi + rule_node_phi(rule, c) + (rng() * 2.0 - 1.0) * rule.azimuth_jitter;
-                    scheduled_children.push({ t_attach: t_dead, phi: phi_c, rule, age, retained: persistence - age });
-                }
-            }
-        }
-
-        const k_symp = lvl_cfg.nodal_kink_strength ?? 0.45;
-        const zig_base = lvl_cfg.internode_zigzag ?? 0.06;
-        const tip_up = lvl_cfg.tip_upcurl ?? 0.18;
-
-        // Horizontal emergence direction of this branch for outward radial consistency near the trunk centerline
-        const emerge_horiz_len = Math.hypot(job.tx, job.tz);
-        const emerge_hx = emerge_horiz_len > 1e-4 ? job.tx / emerge_horiz_len : cur_rx;
-        const emerge_hz = emerge_horiz_len > 1e-4 ? job.tz / emerge_horiz_len : cur_rz;
-
-        // heading that straightness pulls back towards: the bud's, re-aimed by a split for the fork that continues
-        let aim_x = job.tx;
-        let aim_y = job.ty;
-        let aim_z = job.tz;
-
-        for (let s = job.start_seg + 1; s <= N_seg; s++) {
-            const t_prev = (s - 1) / N_seg;
-            const t_curr = s / N_seg;
-            const t_shape = lerp(job.cum_t0, job.cum_t1, t_curr);
-
-            // 1. Intrinsic S-curve pitch curvature (zero-mean higher harmonic on trunk so trunk weaves rather than leaning)
-            let s_wave = level === 0
-                ? (lvl_cfg.curvature * Math.sin(PI2 * 1.5 * t_shape + phase_hash * PI2))
-                : (lvl_cfg.curve_back !== 0.0
-                    ? (lvl_cfg.curvature * Math.cos(Math.PI * t_shape) + lvl_cfg.curve_back * Math.sin(PI2 * t_shape))
-                    : lvl_cfg.curvature);
-            // Attenuate negative (inward-toward-parent) pitch curvature on steep upper-crown insertions
-            // so upper lateral branches never curve backward across the parent stem axis.
-            if (level >= 1 && s_wave < 0.0 && job.parent_attach_t > 0.60) {
-                s_wave *= clamp(1.0 - (job.parent_attach_t - 0.60) * 2.2, 0.15, 1.0);
-            }
-            const d_pitch = s_wave / Math.max(2, N_shape * 0.65);
-
-            if (Math.abs(d_pitch) > 1e-6) {
-                rotate_around_axis(rot_scratch, cur_tx, cur_ty, cur_tz, cur_sx, cur_sy, cur_sz, d_pitch);
-                cur_tx = rot_scratch[0];
-                cur_ty = rot_scratch[1];
-                cur_tz = rot_scratch[2];
-                rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, cur_sx, cur_sy, cur_sz, d_pitch);
-                cur_rx = rot_scratch[0];
-                cur_ry = rot_scratch[1];
-                cur_rz = rot_scratch[2];
-            }
-
-            // 2. Helical spiral twist around T
-            if (Math.abs(lvl_cfg.spiral_twist) > 1e-6) {
-                const d_twist = lvl_cfg.spiral_twist / N_shape;
-                rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, cur_tx, cur_ty, cur_tz, d_twist);
-                cur_rx = rot_scratch[0];
-                cur_ry = rot_scratch[1];
-                cur_rz = rot_scratch[2];
-                cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
-                cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
-                cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
-            }
-
-            // 2b. Sympodial Nodal Kinking at scheduled lateral child emissions + Internodal Zig-Zag
-            let kink_rx = 0.0;
-            let kink_ry = 0.0;
-            let kink_rz = 0.0;
-
-            if (k_symp > 0.0) {
-                for (let c = 0; c < scheduled_children.length; c++) {
-                    const sc = scheduled_children[c];
-                    if (sc.rule.parent_kink > 0.0 && sc.t_attach >= t_prev && sc.t_attach <= t_curr) {
-                        // Recoil away from child branch emission azimuth phi
-                        const c_phi = Math.cos(sc.phi);
-                        const s_phi = Math.sin(sc.phi);
-                        const em_x = c_phi * cur_rx + s_phi * cur_sx;
-                        const em_y = c_phi * cur_ry + s_phi * cur_sy;
-                        const em_z = c_phi * cur_rz + s_phi * cur_sz;
-                        const apical_boost = sc.t_attach > 0.85 ? 1.35 : 1.0;
-                        const recoil = k_symp * sc.rule.parent_kink * (level === 0 ? 0.34 : 0.48) * apical_boost * (0.75 + 0.5 * rng());
-                        kink_rx -= em_x * recoil;
-                        kink_ry -= em_y * recoil;
-                        kink_rz -= em_z * recoil;
-                    }
-                }
-            }
-
-            if (zig_base > 0.0) {
-                const z_sign = (s & 1) === 0 ? 1.0 : -1.0;
-                const z_phi = phase_hash * PI2 + s * 0.85;
-                const zx = Math.cos(z_phi) * cur_rx + Math.sin(z_phi) * cur_sx;
-                const zy = Math.cos(z_phi) * cur_ry + Math.sin(z_phi) * cur_sy;
-                const zz = Math.cos(z_phi) * cur_rz + Math.sin(z_phi) * cur_sz;
-                const z_amp = zig_base * z_sign * (0.7 + 0.6 * rng());
-                kink_rx += zx * z_amp;
-                kink_ry += zy * z_amp;
-                kink_rz += zz * z_amp;
-            }
-
-            const kink_mag = Math.hypot(kink_rx, kink_ry, kink_rz);
-            if (kink_mag > 1e-5) {
-                const kx = kink_rx / kink_mag;
-                const ky = kink_ry / kink_mag;
-                const kz = kink_rz / kink_mag;
-                // Bend axis = T x K
-                let bx = cur_ty * kz - cur_tz * ky;
-                let by = cur_tz * kx - cur_tx * kz;
-                let bz = cur_tx * ky - cur_ty * kx;
-                const b_len = Math.hypot(bx, by, bz);
-                if (b_len > 1e-6) {
-                    bx /= b_len;
-                    by /= b_len;
-                    bz /= b_len;
-                    const clamped_kink = Math.min(0.42, kink_mag);
-                    rotate_around_axis(rot_scratch, cur_tx, cur_ty, cur_tz, bx, by, bz, clamped_kink);
-                    cur_tx = rot_scratch[0];
-                    cur_ty = rot_scratch[1];
-                    cur_tz = rot_scratch[2];
-                    rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, bx, by, bz, clamped_kink);
-                    cur_rx = rot_scratch[0];
-                    cur_ry = rot_scratch[1];
-                    cur_rz = rot_scratch[2];
-                    cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
-                    cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
-                    cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
-                }
-            }
-
-            // 3. Biomechanical Tropism steering (Gravitropic sag + Terminal Phototropic Up-Curl + Outward spread)
-            let steer_x = 0.0;
-            let steer_y = 0.0;
-            let steer_z = 0.0;
-
-            if (level === 0 && branch_id === 0) {
-                // Orthotropic upward striving & plumb-line righting reflex along guide curve (default vertical +Y)
-                evaluate_trunk_guide(SCRATCH_GUIDE_P0, SCRATCH_GUIDE_T, species.trunk_guide, t_prev, job.length);
-                evaluate_trunk_guide(SCRATCH_GUIDE_P1, SCRATCH_GUIDE_T, species.trunk_guide, t_curr, job.length);
-                const gtx = SCRATCH_GUIDE_T[0];
-                const gty = SCRATCH_GUIDE_T[1];
-                const gtz = SCRATCH_GUIDE_T[2];
-
-                const is_conifer = lvl_cfg.excurrent;
-                const apical_relax = (!is_conifer && (t_shape > 0.80 || job.has_split)) ? 0.55 : 1.0;
-                const righting = (1.65 + Math.max(0.0, -lvl_cfg.gravitropism) * 2.5 + Math.max(0.0, lvl_cfg.phototropism)) * apical_relax;
-                steer_x += gtx * righting;
-                steer_y += gty * righting;
-                steer_z += gtz * righting;
-
-                // Plumb-line centering force pulling lateral drift back toward the guide curve
-                const dx_g = cur_px - SCRATCH_GUIDE_P0[0];
-                const dy_g = cur_py - SCRATCH_GUIDE_P0[1];
-                const dz_g = cur_pz - SCRATCH_GUIDE_P0[2];
-                const dot_g = dx_g * gtx + dy_g * gty + dz_g * gtz;
-                const lat_x = dx_g - dot_g * gtx;
-                const lat_y = dy_g - dot_g * gty;
-                const lat_z = dz_g - dot_g * gtz;
-                const plumb_k = ((is_conifer ? 5.2 : 3.4) * apical_relax) / Math.max(1.0, job.length);
-                steer_x -= lat_x * plumb_k * N_seg * 0.5;
-                steer_y -= lat_y * plumb_k * N_seg * 0.5;
-                steer_z -= lat_z * plumb_k * N_seg * 0.5;
-            } else if (level === 0 && branch_id > 0) {
-                // Secondary bifurcated trunk leader (fork): ascend skyward while preserving fork divergence
-                steer_x += emerge_hx * 0.35;
-                steer_y += 1.25 + Math.max(0.0, lvl_cfg.phototropism);
-                steer_z += emerge_hz * 0.35;
-            } else {
-                if (lvl_cfg.gravitropism !== 0.0 || tip_up !== 0.0) {
-                    // Continuous blend from cantilever mid-branch sag arch (sin(pi * t^0.75)) to
-                    // pendulous weeping cascade (0.65 + 0.95 * t) based on gravitropism vs. tip_upcurl
-                    const w_pendulous = level >= 2
-                        ? clamp((lvl_cfg.gravitropism - 0.35 - 0.5 * Math.max(0.0, tip_up)) / 0.45, 0.0, 1.0)
-                        : 0.0;
-                    const arch_grav_env = Math.sin(Math.PI * Math.pow(t_shape, 0.75));
-                    const weep_grav_env = 0.65 + 0.95 * t_shape;
-                    const grav_env = lerp(arch_grav_env, weep_grav_env, w_pendulous);
-                    const apical_grav_atten = level === 1 && job.parent_attach_t > 0.75 && w_pendulous < 0.1
-                        ? clamp(1.0 - (job.parent_attach_t - 0.75) * 3.2, 0.15, 1.0)
-                        : 1.0;
-                    const up_env = t_shape * t_shape * (1.0 + 0.5 * Math.max(0.0, -cur_ty));
-                    steer_y += -lvl_cfg.gravitropism * grav_env * apical_grav_atten + tip_up * up_env;
-                }
-
-                if (lvl_cfg.phototropism !== 0.0) {
-                    const sky_mix = crown.sky_phototropism_mix;
-                    const horiz_r = Math.sqrt(cur_px * cur_px + cur_pz * cur_pz);
-                    let out_x = 0.0;
-                    let out_z = 0.0;
-                    if (horiz_r > 0.52) {
-                        out_x = cur_px / horiz_r;
-                        out_z = cur_pz / horiz_r;
-                    } else if (horiz_r > 1e-4) {
-                        const w_rad = horiz_r / 0.52;
-                        const bx = lerp(emerge_hx, cur_px / horiz_r, w_rad);
-                        const bz = lerp(emerge_hz, cur_pz / horiz_r, w_rad);
-                        const bl = Math.hypot(bx, bz) || 1.0;
-                        out_x = bx / bl;
-                        out_z = bz / bl;
-                    } else {
-                        out_x = emerge_hx;
-                        out_z = emerge_hz;
-                    }
-
-                    steer_x += lvl_cfg.phototropism * (1.0 - sky_mix) * out_x;
-                    steer_y += lvl_cfg.phototropism * sky_mix;
-                    steer_z += lvl_cfg.phototropism * (1.0 - sky_mix) * out_z;
-                }
-            }
-
-            // 4. 2-Octave 3D Curl Noise gnarl scaled properly by sqrt(6 / N_seg)
-            if (lvl_cfg.gnarl_strength > 0.0) {
-                const freq = lvl_cfg.gnarl_frequency;
-                curl_noise_3d(
-                    SCRATCH_CURL,
-                    cur_px * freq + noise_ox + level * 17.3,
-                    cur_py * freq + noise_oy + level * 31.7,
-                    cur_pz * freq + noise_oz + level * 47.1
-                );
-                const c1x = SCRATCH_CURL[0], c1y = SCRATCH_CURL[1], c1z = SCRATCH_CURL[2];
-                curl_noise_3d(
-                    SCRATCH_CURL,
-                    cur_px * freq * 2.15 + noise_ox + 53.1 + phase_hash * 29.3,
-                    cur_py * freq * 2.15 + noise_oy + 79.3,
-                    cur_pz * freq * 2.15 + noise_oz + 113.7
-                );
-                const cx_tot = 0.68 * c1x + 0.32 * SCRATCH_CURL[0];
-                const cy_tot = 0.68 * c1y + 0.32 * SCRATCH_CURL[1];
-                const cz_tot = 0.68 * c1z + 0.32 * SCRATCH_CURL[2];
-
-                const gnarl_scale = lvl_cfg.gnarl_strength * Math.sqrt(6.0 / Math.max(2, N_shape));
-                // Project curl vector perpendicular to T so it steers direction cleanly
-                const dot_ct = cx_tot * cur_tx + cy_tot * cur_ty + cz_tot * cur_tz;
-                steer_x += (cx_tot - dot_ct * cur_tx) * gnarl_scale * 2.2;
-                steer_y += (cy_tot - dot_ct * cur_ty) * gnarl_scale * 1.6;
-                steer_z += (cz_tot - dot_ct * cur_tz) * gnarl_scale * 2.2;
-            }
-
-            // 4b. A plagiotropic shoot is pulled towards the horizontal; straightness pulls back towards the bud's heading
-            if (level >= 1 && lvl_cfg.plagiotropism > 0.0) {
-                steer_y -= lvl_cfg.plagiotropism * cur_ty;
-            }
-            if (lvl_cfg.straightness > 0.0 && !(level === 0 && branch_id === 0)) {
-                steer_x += lvl_cfg.straightness * (aim_x - cur_tx);
-                steer_y += lvl_cfg.straightness * (aim_y - cur_ty);
-                steer_z += lvl_cfg.straightness * (aim_z - cur_tz);
-            }
-
-            // 5. Space colonization attraction steering (for branches in crown, level >= 1)
-            if (use_space_col && level >= 1 && job.in_crown && attr_grid !== null) {
-                let attr_vx = 0.0;
-                let attr_vy = 0.0;
-                let attr_vz = 0.0;
-                let attr_hits = 0;
-
-                attr_grid.forEachNear(cur_px, cur_py, cur_pz, (idx) => {
-                    if (attr_alive[idx] === 0) return;
-                    const ax = attr_positions[idx * 3] - cur_px;
-                    const ay = attr_positions[idx * 3 + 1] - cur_py;
-                    const az = attr_positions[idx * 3 + 2] - cur_pz;
-                    const d2 = ax * ax + ay * ay + az * az;
-                    if (d2 <= r_kill_sq) {
-                        attr_alive[idx] = 0;
-                    } else if (d2 <= r_influence_sq && d2 > 1e-8) {
-                        const inv_d = 1.0 / Math.sqrt(d2);
-                        attr_vx += ax * inv_d;
-                        attr_vy += ay * inv_d;
-                        attr_vz += az * inv_d;
-                        attr_hits++;
-                    }
-                });
-
-                if (attr_hits > 0) {
-                    const attr_len = Math.sqrt(attr_vx * attr_vx + attr_vy * attr_vy + attr_vz * attr_vz);
-                    if (attr_len > 1e-6) {
-                        const w_sc = crown.space_colonization_weight / attr_len;
-                        steer_x += attr_vx * w_sc;
-                        steer_y += attr_vy * w_sc;
-                        steer_z += attr_vz * w_sc;
-                    }
-                }
-            }
-
-            // 6. Crown envelope soft containment for lateral branches (level >= 1)
-            let seg_len = step_len;
-            if (level >= 1 && job.in_crown && crown.prune_ratio > 0.0) {
-                const probe_x = cur_px + cur_tx * step_len;
-                const probe_y = cur_py + cur_ty * step_len;
-                const probe_z = cur_pz + cur_tz * step_len;
-                const sdf = crown_envelope_sdf(probe_x, probe_y, probe_z, crown);
-                if (sdf > 0.0) {
-                    // Steer radially inward toward trunk axis (only pulling vertically if outside vertical crown span)
-                    const crown_top_y = crown.base_height + crown.height;
-                    const to_cx = -probe_x;
-                    const to_cy = probe_y > crown_top_y
-                        ? crown_top_y - probe_y
-                        : (probe_y < crown.base_height ? crown.base_height - probe_y : 0.0);
-                    const to_cz = -probe_z;
-                    const to_c_len = Math.sqrt(to_cx * to_cx + to_cy * to_cy + to_cz * to_cz);
-                    if (to_c_len > 1e-5) {
-                        const pull = crown.prune_ratio * 0.45 / to_c_len;
-                        steer_x += to_cx * pull;
-                        steer_y += to_cy * pull;
-                        steer_z += to_cz * pull;
-                    }
-                    seg_len *= Math.max(0.35, 1.0 - crown.prune_ratio * 0.5);
-                }
-            }
-
-            // Compute target radius r_curr for this segment before BVH collision checks
-            const t_spine = t_shape;
-            const u_prof = prof_span > 1e-4
-                ? clamp((prof_p0 - lvl_cfg.radius_profile.evaluate(t_spine)) / prof_span, 0.0, 1.0)
-                : t_spine;
-            const min_tip_frac = level === 0 ? 0.12 : (has_children ? 0.14 : 0.24);
-            const apical_shoot_taper = level === 0
-                ? (t_spine > 0.65 ? lerp(1.0, 0.11, Math.pow((t_spine - 0.65) / 0.35, 1.45)) : 1.0)
-                : (has_children && t_curr > 0.80 ? lerp(1.0, 0.62, Math.pow((t_curr - 0.80) / 0.20, 1.35)) : 1.0);
-            const r_curr = Math.max(
-                level === 0 ? 0.0015 : 0.002,
-                job.base_radius * Math.max(1.0 - lvl_cfg.taper * u_prof, min_tip_frac) * apical_shoot_taper
-            );
-            const r_prev = out.node_read_radius(prev_v);
-            const local_seg_idx = branch_edges.length;
-            const parent_bA = job.parent_branch_id;
-            const attach_seg_A = job.parent_attach_seg_idx ?? -1;
-            const is_split_A = Boolean(job.is_split_fork);
-
-            // 6b. Soft BVH Repulsion Field (steers growing shoot smoothly around nearby existing branches)
-            if ((level >= 1 || branch_id > 0) && bvh.size > 0) {
-                const look_len = seg_len * 1.55;
-                const look_x = cur_px + cur_tx * look_len;
-                const look_y = cur_py + cur_ty * look_len;
-                const look_z = cur_pz + cur_tz * look_len;
-                const soft_margin = Math.max(0.08, Math.min(0.24, seg_len * 0.65));
-
-                query_capsule[0] = cur_px;
-                query_capsule[1] = cur_py;
-                query_capsule[2] = cur_pz;
-                query_capsule[3] = look_x;
-                query_capsule[4] = look_y;
-                query_capsule[5] = look_z;
-                query_capsule[6] = Math.max(r_prev, r_curr) * 1.15 + soft_margin;
-
-                const hit_count = bvh_query_user_data_intersects_capsule(bvh_hits, 0, bvh, query_capsule);
-                for (let h = 0; h < hit_count; h++) {
-                    const eB = bvh_hits[h];
-                    const bB = seg_branch_id[eB];
-                    const local_idx_B = seg_local_idx[eB];
-                    if (!resolve_subsegment_bounds(
-                        branch_id, parent_bA, attach_seg_A, is_split_A, local_seg_idx,
-                        bB, out.branch_parent[bB], branch_parent_seg_idx[bB], branch_is_split_fork[bB], local_idx_B,
-                        sub_bounds
-                    )) {
-                        continue;
-                    }
-
-                    const s_min = sub_bounds[0];
-                    const t_min = sub_bounds[1];
-                    const sa0x = cur_px + (look_x - cur_px) * s_min;
-                    const sa0y = cur_py + (look_y - cur_py) * s_min;
-                    const sa0z = cur_pz + (look_z - cur_pz) * s_min;
-
-                    const b0x = seg_p0x[eB], b0y = seg_p0y[eB], b0z = seg_p0z[eB];
-                    const b1x = seg_p1x[eB], b1y = seg_p1y[eB], b1z = seg_p1z[eB];
-                    const sb0x = b0x + (b1x - b0x) * t_min;
-                    const sb0y = b0y + (b1y - b0y) * t_min;
-                    const sb0z = b0z + (b1z - b0z) * t_min;
-
-                    line3_compute_segment_segment_closest_points(
-                        closest_st,
-                        sa0x, sa0y, sa0z, look_x, look_y, look_z,
-                        sb0x, sb0y, sb0z, b1x, b1y, b1z
-                    );
-
-                    const s_f = s_min + (1.0 - s_min) * closest_st[0];
-                    const t_f = t_min + (1.0 - t_min) * closest_st[1];
-
-                    const qAx = cur_px + (look_x - cur_px) * s_f;
-                    const qAy = cur_py + (look_y - cur_py) * s_f;
-                    const qAz = cur_pz + (look_z - cur_pz) * s_f;
-                    const qBx = b0x + (b1x - b0x) * t_f;
-                    const qBy = b0y + (b1y - b0y) * t_f;
-                    const qBz = b0z + (b1z - b0z) * t_f;
-
-                    const dx = qAx - qBx;
-                    const dy = qAy - qBy;
-                    const dz = qAz - qBz;
-                    const dist = Math.hypot(dx, dy, dz);
-                    const rA = r_prev + (r_curr - r_prev) * Math.min(1.0, s_f);
-                    const rB = seg_r0[eB] + (seg_r1[eB] - seg_r0[eB]) * t_f;
-                    const r_req = (rA + rB) * 1.12 + 0.005;
-
-                    if (dist < r_req + soft_margin) {
-                        let nx = dist > 1e-5 ? dx / dist : cur_rx;
-                        let ny = dist > 1e-5 ? dy / dist : cur_ry;
-                        let nz = dist > 1e-5 ? dz / dist : cur_rz;
-                        // Project repulsion normal perpendicular to cur_T so it steers smoothly around the obstacle
-                        const dot_nt = nx * cur_tx + ny * cur_ty + nz * cur_tz;
-                        nx -= dot_nt * cur_tx;
-                        ny -= dot_nt * cur_ty;
-                        nz -= dot_nt * cur_tz;
-                        const n_len = Math.hypot(nx, ny, nz);
-                        if (n_len > 1e-5) {
-                            nx /= n_len;
-                            ny /= n_len;
-                            nz /= n_len;
-                            const u_prox = clamp(1.0 - Math.max(0.0, dist - r_req) / soft_margin, 0.0, 1.0);
-                            const rep_w = u_prox * u_prox * 2.8;
-                            steer_x += nx * rep_w;
-                            steer_y += ny * rep_w;
-                            steer_z += nz * rep_w;
-                        }
-                    }
-                }
-            }
-
-            // Apply steering to tangent and normalize
-            const steer_div = Math.max(2.0, Math.sqrt(N_shape) * 1.35);
-            let next_tx = cur_tx + steer_x / steer_div;
-            let next_ty = cur_ty + steer_y / steer_div;
-            let next_tz = cur_tz + steer_z / steer_div;
-            const t_len = Math.sqrt(next_tx * next_tx + next_ty * next_ty + next_tz * next_tz);
-            if (t_len > 1e-12) {
-                next_tx /= t_len;
-                next_ty /= t_len;
-                next_tz /= t_len;
-            } else {
-                next_tx = cur_tx;
-                next_ty = cur_ty;
-                next_tz = cur_tz;
-            }
-
-            let next_px = cur_px + 0.5 * (cur_tx + next_tx) * seg_len;
-            let next_py = cur_py + 0.5 * (cur_ty + next_ty) * seg_len;
-            let next_pz = cur_pz + 0.5 * (cur_tz + next_tz) * seg_len;
-
-            // Orthotropic plumb-tube containment on trunk (level === 0):
-            // Preserves local 3D nodal kinks and serpentine sweep while guaranteeing the trunk never drifts sideways
-            if (level === 0 && branch_id === 0) {
-                const gx = SCRATCH_GUIDE_P1[0];
-                const gy = SCRATCH_GUIDE_P1[1];
-                const gz = SCRATCH_GUIDE_P1[2];
-                const gtx = SCRATCH_GUIDE_T[0];
-                const gty = SCRATCH_GUIDE_T[1];
-                const gtz = SCRATCH_GUIDE_T[2];
-
-                const dx = next_px - gx;
-                const dy = next_py - gy;
-                const dz = next_pz - gz;
-                const dot_g = dx * gtx + dy * gty + dz * gtz;
-                const off_x = dx - dot_g * gtx;
-                const off_y = dy - dot_g * gty;
-                const off_z = dz - dot_g * gtz;
-                const off_r = Math.hypot(off_x, off_y, off_z);
-
-                const is_conifer = lvl_cfg.excurrent;
-                const max_drift_frac = is_conifer ? 0.032 : (job.has_split ? 0.078 : 0.058);
-                // Envelope rises from 0 at root, peaks in mid-trunk (allowing 3D sweep/crookedness), and tapers near tip
-                const env = Math.sin(Math.PI * Math.min(0.92, t_curr * 0.88)) * (1.0 - 0.38 * t_curr * t_curr);
-                const max_r = job.length * max_drift_frac * Math.max(job.has_split ? 0.42 : 0.18, env);
-
-                if (off_r > max_r && off_r > 1e-6) {
-                    const scale_r = max_r / off_r;
-                    next_px = gx + dot_g * gtx + off_x * scale_r;
-                    next_py = gy + dot_g * gty + off_y * scale_r;
-                    next_pz = gz + dot_g * gtz + off_z * scale_r;
-
-                    let ch_x = next_px - cur_px;
-                    let ch_y = next_py - cur_py;
-                    let ch_z = next_pz - cur_pz;
-                    const ch_l = Math.hypot(ch_x, ch_y, ch_z);
-                    if (ch_l > 1e-6) {
-                        next_tx = ch_x / ch_l;
-                        next_ty = ch_y / ch_l;
-                        next_tz = ch_z / ch_l;
-                    }
-                }
-            }
-
-            // 6c. Monotonic Parent Collar Escape + Hard BVH Capsule Contact Projection & Self-Pruning
-            if ((level >= 1 || branch_id > 0) && bvh.size > 0) {
-                let was_projected = false;
-
-                // Ensure lateral child branch exits its parent attachment segment cleanly on local_seg_idx <= 1
-                if (job.parent_edge_id >= 0 && !is_split_A && local_seg_idx <= 1) {
-                    const eP = job.parent_edge_id;
-                    const p0x = seg_p0x[eP], p0y = seg_p0y[eP], p0z = seg_p0z[eP];
-                    const p1x = seg_p1x[eP], p1y = seg_p1y[eP], p1z = seg_p1z[eP];
-
-                    line3_compute_segment_segment_closest_points(
-                        closest_st,
-                        next_px, next_py, next_pz, next_px, next_py, next_pz,
-                        p0x, p0y, p0z, p1x, p1y, p1z
-                    );
-                    const t_p = closest_st[1];
-                    const qPx = p0x + (p1x - p0x) * t_p;
-                    const qPy = p0y + (p1y - p0y) * t_p;
-                    const qPz = p0z + (p1z - p0z) * t_p;
-                    const r_p = seg_r0[eP] + (seg_r1[eP] - seg_r0[eP]) * t_p;
-
-                    let rx_p = next_px - qPx;
-                    let ry_p = next_py - qPy;
-                    let rz_p = next_pz - qPz;
-                    const d_p = Math.hypot(rx_p, ry_p, rz_p);
-                    if (local_seg_idx === 0 && (r_p + r_curr) * 1.18 > seg_len) {
-                        seg_len = (r_p + r_curr) * 1.18;
-                    }
-                    const min_d_p = local_seg_idx === 0
-                        ? Math.min(seg_len * 0.88, (r_p + r_curr) * 1.05)
-                        : (r_p + r_curr) * 1.10 + 0.004;
-
-                    const em_drx = job.emerge_drx ?? cur_rx;
-                    const em_dry = job.emerge_dry ?? cur_ry;
-                    const em_drz = job.emerge_drz ?? cur_rz;
-                    const dot_em = rx_p * em_drx + ry_p * em_dry + rz_p * em_drz;
-
-                    if (d_p < min_d_p || dot_em < 0.0) {
-                        const ux_p = (d_p > 1e-5 && dot_em > 0.0) ? rx_p / d_p : em_drx;
-                        const uy_p = (d_p > 1e-5 && dot_em > 0.0) ? ry_p / d_p : em_dry;
-                        const uz_p = (d_p > 1e-5 && dot_em > 0.0) ? rz_p / d_p : em_drz;
-                        const push_d = Math.max(0.0, min_d_p - (dot_em > 0.0 ? d_p : -d_p));
-                        next_px += ux_p * push_d;
-                        next_py += uy_p * push_d;
-                        next_pz += uz_p * push_d;
-
-                        let ch_x = next_px - cur_px;
-                        let ch_y = next_py - cur_py;
-                        let ch_z = next_pz - cur_pz;
-                        const ch_l = Math.hypot(ch_x, ch_y, ch_z);
-                        if (ch_l > 1e-6) {
-                            next_tx = ch_x / ch_l;
-                            next_ty = ch_y / ch_l;
-                            next_tz = ch_z / ch_l;
-                            next_px = cur_px + next_tx * seg_len;
-                            next_py = cur_py + next_ty * seg_len;
-                            next_pz = cur_pz + next_tz * seg_len;
-                            was_projected = true;
-                        }
-                    }
-                }
-
-                // Iterative BVH capsule contact projection
-                for (let iter = 0; iter < 4; iter++) {
-                    query_capsule[0] = cur_px;
-                    query_capsule[1] = cur_py;
-                    query_capsule[2] = cur_pz;
-                    query_capsule[3] = next_px;
-                    query_capsule[4] = next_py;
-                    query_capsule[5] = next_pz;
-                    query_capsule[6] = Math.max(r_prev, r_curr) * 1.15 + 0.025;
-
-                    const hit_count = bvh_query_user_data_intersects_capsule(bvh_hits, 0, bvh, query_capsule);
-                    let moved = false;
-
-                    for (let h = 0; h < hit_count; h++) {
-                        const eB = bvh_hits[h];
-                        const bB = seg_branch_id[eB];
-                        const local_idx_B = seg_local_idx[eB];
-                        if (!resolve_subsegment_bounds(
-                            branch_id, parent_bA, attach_seg_A, is_split_A, local_seg_idx,
-                            bB, out.branch_parent[bB], branch_parent_seg_idx[bB], branch_is_split_fork[bB], local_idx_B,
-                            sub_bounds
-                        )) {
-                            continue;
-                        }
-
-                        const s_min = sub_bounds[0];
-                        const t_min = sub_bounds[1];
-                        const sa0x = cur_px + (next_px - cur_px) * s_min;
-                        const sa0y = cur_py + (next_py - cur_py) * s_min;
-                        const sa0z = cur_pz + (next_pz - cur_pz) * s_min;
-
-                        const b0x = seg_p0x[eB], b0y = seg_p0y[eB], b0z = seg_p0z[eB];
-                        const b1x = seg_p1x[eB], b1y = seg_p1y[eB], b1z = seg_p1z[eB];
-                        const sb0x = b0x + (b1x - b0x) * t_min;
-                        const sb0y = b0y + (b1y - b0y) * t_min;
-                        const sb0z = b0z + (b1z - b0z) * t_min;
-
-                        line3_compute_segment_segment_closest_points(
-                            closest_st,
-                            sa0x, sa0y, sa0z, next_px, next_py, next_pz,
-                            sb0x, sb0y, sb0z, b1x, b1y, b1z
-                        );
-
-                        const s_f = s_min + (1.0 - s_min) * closest_st[0];
-                        const t_f = t_min + (1.0 - t_min) * closest_st[1];
-                        if (local_seg_idx === 0 && s_f <= 0.05) continue;
-
-                        const qAx = cur_px + (next_px - cur_px) * s_f;
-                        const qAy = cur_py + (next_py - cur_py) * s_f;
-                        const qAz = cur_pz + (next_pz - cur_pz) * s_f;
-                        const qBx = b0x + (b1x - b0x) * t_f;
-                        const qBy = b0y + (b1y - b0y) * t_f;
-                        const qBz = b0z + (b1z - b0z) * t_f;
-
-                        const dx = qAx - qBx;
-                        const dy = qAy - qBy;
-                        const dz = qAz - qBz;
-                        const dist = Math.hypot(dx, dy, dz);
-                        const rA = r_prev + (r_curr - r_prev) * s_f;
-                        const rB = seg_r0[eB] + (seg_r1[eB] - seg_r0[eB]) * t_f;
-                        const r_req = (rA + rB) * 1.08 + 0.004;
-
-                        if (dist < r_req) {
-                            let nx = dist > 1e-5 ? dx / dist : cur_rx;
-                            let ny = dist > 1e-5 ? dy / dist : cur_ry;
-                            let nz = dist > 1e-5 ? dz / dist : cur_rz;
-                            const push = (r_req - dist + 0.004) / Math.max(0.35, s_f);
-                            next_px += nx * push;
-                            next_py += ny * push;
-                            next_pz += nz * push;
-
-                            let ch_x = next_px - cur_px;
-                            let ch_y = next_py - cur_py;
-                            let ch_z = next_pz - cur_pz;
-                            const ch_l = Math.hypot(ch_x, ch_y, ch_z);
-                            if (ch_l > 1e-6) {
-                                next_tx = ch_x / ch_l;
-                                next_ty = ch_y / ch_l;
-                                next_tz = ch_z / ch_l;
-                                next_px = cur_px + next_tx * seg_len;
-                                next_py = cur_py + next_ty * seg_len;
-                                next_pz = cur_pz + next_tz * seg_len;
-                                moved = true;
-                                was_projected = true;
-                            }
-                        }
-                    }
-                    if (!moved) break;
-                }
-
-                // If segment >= 1 still penetrates an existing branch or was forced into an unnatural sharp reversal,
-                // self-prune / arrest the branch at prev_v so it never spears through another bough.
-                if (local_seg_idx >= 1) {
-                    const final_clear = evaluate_candidate_clearance(
-                        branch_id, parent_bA, attach_seg_A, is_split_A, local_seg_idx,
-                        cur_px, cur_py, cur_pz, r_prev,
-                        next_px, next_py, next_pz, r_curr,
-                        -0.004
-                    );
-                    const turn_cos = cur_tx * next_tx + cur_ty * next_ty + cur_tz * next_tz;
-                    if (final_clear < 0.0 || (was_projected && turn_cos < 0.25)) {
-                        break;
-                    }
-                } else if (was_projected) {
-                    // Keep root node tangent aligned with projected first segment so base collar has zero S-hook
-                    cur_tx = next_tx;
-                    cur_ty = next_ty;
-                    cur_tz = next_tz;
-                    out.node_write_tangent(prev_v, cur_tx, cur_ty, cur_tz);
-                }
-            }
-
-            // Structural surface root: creep along the ground plane y = 0 while sinking into it, its centreline at
-            // r(t) - 2 r_base t: it leaves the stem fully exposed and its top drops by twice its base radius over
-            // its length, so it dissolves into the soil about halfway out and its tip is never seen. Applied after all
-            // steering and contact handling so nothing lifts it off or pushes it under; the first segment keeps
-            // the bud's heading so the root leaves the stem where it was planted (e.g. on a flare lobe crest).
-            if (lvl_cfg.root) {
-                let hx = local_seg_idx === 0 ? emerge_hx : next_px - cur_px;
-                let hz = local_seg_idx === 0 ? emerge_hz : next_pz - cur_pz;
-                let h_len = Math.hypot(hx, hz);
-                if (h_len < 1e-6) {
-                    hx = emerge_hx;
-                    hz = emerge_hz;
-                    h_len = Math.hypot(hx, hz) || 1.0;
-                }
-                hx /= h_len;
-                hz /= h_len;
-                const dy = clamp(r_curr - 2.0 * job.base_radius * t_curr - cur_py, -0.7 * seg_len, 0.7 * seg_len);
-                const h_step = Math.sqrt(seg_len * seg_len - dy * dy);
-                next_px = cur_px + hx * h_step;
-                next_py = cur_py + dy;
-                next_pz = cur_pz + hz * h_step;
-                // arrive following the sinking profile, whose slope along the root is -(2 + taper) r_base / length
-                const sink_slope = -(2.0 + lvl_cfg.taper) * job.base_radius / Math.max(1e-3, job.length);
-                const t_norm_len = Math.hypot(1.0, sink_slope);
-                next_tx = hx / t_norm_len;
-                next_ty = sink_slope / t_norm_len;
-                next_tz = hz / t_norm_len;
-                if (local_seg_idx === 0) {
-                    // the root node leaves along its first chord, as a projected collar escape would
-                    cur_tx = (next_px - cur_px) / seg_len;
-                    cur_ty = (next_py - cur_py) / seg_len;
-                    cur_tz = (next_pz - cur_pz) / seg_len;
-                    out.node_write_tangent(prev_v, cur_tx, cur_ty, cur_tz);
-                }
-            }
-
-            // Transport RMF via Wang et al. Double Reflection
-            spine_frame_double_reflection(
-                SCRATCH_RMF, 0,
-                cur_px, cur_py, cur_pz,
-                cur_tx, cur_ty, cur_tz,
-                cur_rx, cur_ry, cur_rz,
-                next_px, next_py, next_pz,
-                next_tx, next_ty, next_tz
-            );
-            let next_rx = SCRATCH_RMF[0];
-            let next_ry = SCRATCH_RMF[1];
-            let next_rz = SCRATCH_RMF[2];
-            cur_sx = SCRATCH_RMF[3];
-            cur_sy = SCRATCH_RMF[4];
-            cur_sz = SCRATCH_RMF[5];
-
-            cur_arc_s += seg_len;
-
-            const curr_v = out.add_node(
-                next_px, next_py, next_pz,
-                next_tx, next_ty, next_tz,
-                next_rx, next_ry, next_rz,
-                r_curr,
-                branch_id,
-                level,
-                job.parent_branch_id,
-                t_curr,
-                cur_arc_s,
-                phase_hash
-            );
-
-            const edge_id = out.add_segment(
-                prev_v,
-                curr_v,
-                cur_tx * seg_len,
-                cur_ty * seg_len,
-                cur_tz * seg_len,
-                next_tx * seg_len,
-                next_ty * seg_len,
-                next_tz * seg_len,
-                seg_len,
-                t_prev === 0.0 ? job.parent_attach_t : t_prev
-            );
-
-            // Register segment in scope-local BVH
-            const bvh_pad = Math.max(r_prev, r_curr) * 1.25 + 0.008;
-            const bvh_leaf = bvh.allocate_node();
-            bvh.node_set_user_data(bvh_leaf, edge_id);
-            bvh.node_set_aabb_primitive(
-                bvh_leaf,
-                Math.min(cur_px, next_px) - bvh_pad,
-                Math.min(cur_py, next_py) - bvh_pad,
-                Math.min(cur_pz, next_pz) - bvh_pad,
-                Math.max(cur_px, next_px) + bvh_pad,
-                Math.max(cur_py, next_py) + bvh_pad,
-                Math.max(cur_pz, next_pz) + bvh_pad
-            );
-            bvh.insert_leaf(bvh_leaf);
-
-            seg_branch_id[edge_id] = branch_id;
-            seg_local_idx[edge_id] = local_seg_idx;
-            seg_p0x[edge_id] = cur_px;
-            seg_p0y[edge_id] = cur_py;
-            seg_p0z[edge_id] = cur_pz;
-            seg_r0[edge_id] = r_prev;
-            seg_p1x[edge_id] = next_px;
-            seg_p1y[edge_id] = next_py;
-            seg_p1z[edge_id] = next_pz;
-            seg_r1[edge_id] = r_curr;
-            seg_bvh_leaf[edge_id] = bvh_leaf;
-
-            branch_edges.push(edge_id);
-            branch_edge_t0.push(t_prev);
-            branch_edge_t1.push(t_curr);
-            branch_vertices.push(curr_v);
-
-            out.branch_tip_vertex[branch_id] = curr_v;
-            out.branch_length[branch_id] = cur_arc_s - job.initial_arc_s;
-
-            // Check for dichotomous / sympodial splitting at interior segments (only when stem is structurally thick enough)
-            const min_split_seg = level === 0
-                ? Math.max(2, Math.floor(N_seg * 0.5))
-                : Math.max(1, Math.floor(N_seg * 0.25));
-            if (
-                !job.has_split
-                && !job.dead
-                && lvl_cfg.split_probability > 0.0
-                && r_curr >= 0.012
-                && s >= min_split_seg
-                && s <= Math.floor(N_seg * 0.75)
-                && rng() < lvl_cfg.split_probability
-            ) {
-                job.has_split = true;
-                const fork_count = Math.max(2, lvl_cfg.split_count | 0);
-                const split_ang = lvl_cfg.split_angle;
-                let base_az = rng() * PI2;
-
-                // Preserve pre-split orthonormal triad (T, R, S) before deflecting fork 0
-                const pre_tx = next_tx, pre_ty = next_ty, pre_tz = next_tz;
-                const pre_rx = next_rx, pre_ry = next_ry, pre_rz = next_rz;
-                const pre_sx = cur_sx, pre_sy = cur_sy, pre_sz = cur_sz;
-
-                // On lateral branches (level >= 1), align the split bend axis toward local vertical (+Y)
-                // so the two daughter forks spread horizontally in the canopy rather than pitching into neighbor boughs.
-                if (level >= 1) {
-                    const up_az = Math.atan2(pre_sy, pre_ry);
-                    const side_sign = base_az < Math.PI ? 1.0 : -1.0;
-                    base_az = up_az + (side_sign < 0.0 ? Math.PI : 0.0) + ((base_az % Math.PI) / Math.PI - 0.5) * 0.45;
-                }
-
-                // Current branch deflects as fork 0: rotate both T and R around bend_axis so R remains orthogonal to T
-                const fork0_deflect = level === 0 ? split_ang * 0.22 : split_ang * 0.5;
-                const bend_axis_x = Math.cos(base_az) * pre_rx + Math.sin(base_az) * pre_sx;
-                const bend_axis_y = Math.cos(base_az) * pre_ry + Math.sin(base_az) * pre_sy;
-                const bend_axis_z = Math.cos(base_az) * pre_rz + Math.sin(base_az) * pre_sz;
-                rotate_around_axis(
-                    rot_scratch,
-                    pre_tx, pre_ty, pre_tz,
-                    bend_axis_x, bend_axis_y, bend_axis_z,
-                    fork0_deflect
-                );
-                next_tx = rot_scratch[0];
-                next_ty = rot_scratch[1];
-                next_tz = rot_scratch[2];
-                // fork 0 is aimed where it was deflected to, as the other forks are aimed along their own headings
-                aim_x = next_tx;
-                aim_y = next_ty;
-                aim_z = next_tz;
-
-                rotate_around_axis(
-                    rot_scratch,
-                    pre_rx, pre_ry, pre_rz,
-                    bend_axis_x, bend_axis_y, bend_axis_z,
-                    fork0_deflect
-                );
-                next_rx = rot_scratch[0];
-                next_ry = rot_scratch[1];
-                next_rz = rot_scratch[2];
-
-                cur_sx = next_ty * next_rz - next_tz * next_ry;
-                cur_sy = next_tz * next_rx - next_tx * next_rz;
-                cur_sz = next_tx * next_ry - next_ty * next_rx;
-
-                // Spawn fork 1..fork_count-1 as continuation branches with their own root vertex connected to curr_v
-                const rem_segs = Math.max(1, N_seg - s);
-                const rem_fraction = Math.max(0.15, rem_segs / Math.max(1, N_seg));
-                const fork_cum_t0 = lerp(job.cum_t0 ?? 0.0, job.cum_t1 ?? 1.0, t_curr);
-                const fork_cum_t1 = job.cum_t1 ?? 1.0;
-                const fork_len = Math.max(0.15, job.length * rem_fraction);
-                const fork_r0 = r_curr * 0.78;
-                const fork_step = fork_len / rem_segs;
-
-                for (let f = 1; f < fork_count; f++) {
-                    const f_az = base_az + (f * PI2) / fork_count;
-                    const fax = Math.cos(f_az) * pre_rx + Math.sin(f_az) * pre_sx;
-                    const fay = Math.cos(f_az) * pre_ry + Math.sin(f_az) * pre_sy;
-                    const faz = Math.cos(f_az) * pre_rz + Math.sin(f_az) * pre_sz;
-
-                    const f_tan = [0, 0, 0];
-                    rotate_around_axis(f_tan, pre_tx, pre_ty, pre_tz, fax, fay, faz, split_ang * 0.65);
-
-                    // Verify fork emergence clearance against BVH (and prevent inward-toward-trunk forks on lateral boughs)
-                    if (level >= 1) {
-                        const r_horiz_here = Math.hypot(next_px, next_pz);
-                        if (r_horiz_here > 0.35 && (next_px * f_tan[0] + next_pz * f_tan[2]) < -0.10 * r_horiz_here) {
-                            continue;
-                        }
-                        const f_clear = evaluate_candidate_clearance(
-                            -1, branch_id, local_seg_idx, true, 0,
-                            next_px, next_py, next_pz, fork_r0,
-                            next_px + f_tan[0] * fork_step,
-                            next_py + f_tan[1] * fork_step,
-                            next_pz + f_tan[2] * fork_step,
-                            fork_r0 * 0.85,
-                            0.002
-                        );
-                        if (f_clear < -0.002) {
-                            continue;
-                        }
-                    }
-
-                    const f_r = [0, 0, 0];
-                    rotate_around_axis(f_r, pre_rx, pre_ry, pre_rz, fax, fay, faz, split_ang * 0.65);
-
-                    queue.push({
-                        level,
-                        generator,
-                        in_crown: job.in_crown,
-                        parent_branch_id: branch_id,
-                        parent_edge_id: edge_id,
-                        parent_attach_seg_idx: local_seg_idx,
-                        parent_attach_t: t_curr,
-                        attach_parent_vertex: curr_v,
-                        start_vertex: -1,
-                        px: next_px,
-                        py: next_py,
-                        pz: next_pz,
-                        tx: f_tan[0],
-                        ty: f_tan[1],
-                        tz: f_tan[2],
-                        rx: f_r[0],
-                        ry: f_r[1],
-                        rz: f_r[2],
-                        emerge_drx: fax,
-                        emerge_dry: fay,
-                        emerge_drz: faz,
-                        length: fork_len,
-                        full_branch_length: job.full_branch_length ?? job.length,
-                        base_radius: fork_r0,
-                        start_seg: 0,
-                        total_segs: rem_segs,
-                        shape_segs: rem_segs,
-                        initial_arc_s: cur_arc_s,
-                        has_split: true,
-                        is_split_fork: true,
-                        child_span_fraction: rem_fraction,
-                        cum_t0: fork_cum_t0,
-                        cum_t1: fork_cum_t1
-                    });
-                }
-            }
-
-            cur_px = next_px;
-            cur_py = next_py;
-            cur_pz = next_pz;
-            cur_tx = next_tx;
-            cur_ty = next_ty;
-            cur_tz = next_tz;
-            cur_rx = next_rx;
-            cur_ry = next_ry;
-            cur_rz = next_rz;
-            prev_v = curr_v;
-        }
-
-        // If the branch was self-pruned early on contact (actual_segs < remaining_segs), renormalize
-        // t_norm and taper radii across the surviving vertices [0..actual_segs] so its tip terminates cleanly at t_norm = 1.0
-        const actual_segs = branch_edges.length;
-        if (actual_segs > 0 && actual_segs < remaining_segs) {
-            const s_param = /** @type {Float32Array} */ (out.attr_node_spine_param.data);
-            for (let i = 0; i < actual_segs; i++) {
-                const tn0 = i / actual_segs;
-                const tn1 = (i + 1) / actual_segs;
-                branch_edge_t0[i] = tn0;
-                branch_edge_t1[i] = tn1;
-
-                const v_curr = branch_vertices[i + 1];
-                s_param[v_curr * 3] = tn1;
-
-                const u_p = prof_span > 1e-4
-                    ? clamp((prof_p0 - lvl_cfg.radius_profile.evaluate(lerp(job.cum_t0, job.cum_t1, tn1))) / prof_span, 0.0, 1.0)
-                    : tn1;
-                const min_tf = has_children ? 0.14 : 0.24;
-                const ap_taper = has_children && tn1 > 0.80
-                    ? lerp(1.0, 0.62, Math.pow((tn1 - 0.80) / 0.20, 1.35))
-                    : 1.0;
-                const r_new = Math.max(
-                    0.002,
-                    job.base_radius * Math.max(1.0 - lvl_cfg.taper * u_p, min_tf) * ap_taper
-                );
-                out.node_write_radius(v_curr, r_new);
-
-                const e_curr = branch_edges[i];
-                seg_r1[e_curr] = r_new;
-                if (i + 1 < actual_segs) {
-                    seg_r0[branch_edges[i + 1]] = r_new;
-                }
-            }
-        }
-
-        // Smooth or preserve crisp interior Hermite tangents across consecutive edges of this branch
-        // (preserving branch_edges[0]'s m0 so continuation forks keep their exact fork departure tangent)
-        if (branch_edges.length >= 2) {
-            const kink_sharp = clamp(lvl_cfg.kink_sharpness ?? 0.5, 0.0, 0.92);
-            for (let k = 1; k < branch_edges.length; k++) {
-                const e_prev = branch_edges[k - 1];
-                const e_next = branch_edges[k];
-                const v_mid = branch_vertices[k];
-                const l_prev = Math.max(1e-5, out.segment_length(e_prev));
-                const l_next = Math.max(1e-5, out.segment_length(e_next));
-
-                out.segment_read_m1(SCRATCH_M_PREV, 0, e_prev);
-                out.segment_read_m0(SCRATCH_M_NEXT, 0, e_next);
-
-                const t_in_x = SCRATCH_M_PREV[0] / l_prev;
-                const t_in_y = SCRATCH_M_PREV[1] / l_prev;
-                const t_in_z = SCRATCH_M_PREV[2] / l_prev;
-                const t_out_x = SCRATCH_M_NEXT[0] / l_next;
-                const t_out_y = SCRATCH_M_NEXT[1] / l_next;
-                const t_out_z = SCRATCH_M_NEXT[2] / l_next;
-
-                let tx = t_in_x + t_out_x;
-                let ty = t_in_y + t_out_y;
-                let tz = t_in_z + t_out_z;
-                const t_len = Math.sqrt(tx * tx + ty * ty + tz * tz);
-                if (t_len > 1e-12) {
-                    tx /= t_len;
-                    ty /= t_len;
-                    tz /= t_len;
-
-                    out.node_write_tangent(v_mid, tx, ty, tz);
-
-                    // Blend between smooth C1 average tangent and crisp sympodial kink tangents
-                    let m1x = lerp(tx, t_in_x, kink_sharp);
-                    let m1y = lerp(ty, t_in_y, kink_sharp);
-                    let m1z = lerp(tz, t_in_z, kink_sharp);
-                    const m1_l = Math.sqrt(m1x * m1x + m1y * m1y + m1z * m1z);
-                    if (m1_l > 1e-12) { m1x /= m1_l; m1y /= m1_l; m1z /= m1_l; }
-
-                    let m0x = lerp(tx, t_out_x, kink_sharp);
-                    let m0y = lerp(ty, t_out_y, kink_sharp);
-                    let m0z = lerp(tz, t_out_z, kink_sharp);
-                    const m0_l = Math.sqrt(m0x * m0x + m0y * m0y + m0z * m0z);
-                    if (m0_l > 1e-12) { m0x /= m0_l; m0y /= m0_l; m0z /= m0_l; }
-
-                    out.segment_write_m1(e_prev, m1x * l_prev, m1y * l_prev, m1z * l_prev);
-                    out.segment_write_m0(e_next, m0x * l_next, m0y * l_next, m0z * l_next);
-                }
-            }
-        }
-
-        // Spawn lateral child branches at level + 1 using pre-scheduled attachments
-        const next_level = level + 1;
-        if (scheduled_children.length > 0 && branch_edges.length > 0) {
-            const t_max = branch_edge_t1[branch_edge_t1.length - 1];
-            const PHI_CANDIDATES = [0.0, 0.36, -0.36, 0.72, -0.72, 1.08, -1.08, 1.48, -1.48];
-
-            for (let c = 0; c < scheduled_children.length; c++) {
-                const sc = scheduled_children[c];
-                const rule = sc.rule;
-                const next_cfg = species.branches[rule.target];
-                if (sc.t_attach > t_max * 1.02) continue;
-                const t_attach = clamp(sc.t_attach, branch_edge_t0[0], t_max * 0.985);
-                const base_phi_c = sc.phi;
-
-                // Find parent edge containing t_attach
-                let seg_idx = 0;
-                for (let i = 0; i < branch_edges.length; i++) {
-                    if (t_attach >= branch_edge_t0[i] && t_attach <= branch_edge_t1[i]) {
-                        seg_idx = i;
-                        break;
-                    }
-                }
-
-                const parent_e = branch_edges[seg_idx];
-                const t0_e = branch_edge_t0[seg_idx];
-                const t1_e = branch_edge_t1[seg_idx];
-                const local_u = clamp((t_attach - t0_e) / Math.max(1e-5, t1_e - t0_e), 0.0, 1.0);
-
-                out.evaluate_segment_position(SCRATCH_POS, 0, parent_e, local_u);
-                out.evaluate_segment_tangent(SCRATCH_TAN, 0, parent_e, local_u);
-
-                const p_v0 = branch_vertices[seg_idx];
-                const p_v1 = branch_vertices[seg_idx + 1];
-                const r_p0 = out.node_read_radius(p_v0);
-                const r_p1 = out.node_read_radius(p_v1);
-                const parent_r_at_attach = lerp(r_p0, r_p1, local_u);
-                if (parent_r_at_attach < 0.004) continue;
-
-                // Transport parent RMF R vector from p_v0 along parent_e to SCRATCH_POS at local_u
-                out.node_read_position(SCRATCH_P0, 0, p_v0);
-                out.node_read_tangent(SCRATCH_T0, 0, p_v0);
-                out.node_read_frame_r(SCRATCH_R0, 0, p_v0);
-                const p_rx = SCRATCH_R0[0];
-                const p_ry = SCRATCH_R0[1];
-                const p_rz = SCRATCH_R0[2];
-
-                spine_frame_double_reflection(
-                    SCRATCH_RMF, 0,
-                    SCRATCH_P0[0], SCRATCH_P0[1], SCRATCH_P0[2],
-                    SCRATCH_T0[0], SCRATCH_T0[1], SCRATCH_T0[2],
-                    p_rx, p_ry, p_rz,
-                    SCRATCH_POS[0], SCRATCH_POS[1], SCRATCH_POS[2],
-                    SCRATCH_TAN[0], SCRATCH_TAN[1], SCRATCH_TAN[2]
-                );
-                const prx = SCRATCH_RMF[0], pry = SCRATCH_RMF[1], prz = SCRATCH_RMF[2];
-                const psx = SCRATCH_RMF[3], psy = SCRATCH_RMF[4], psz = SCRATCH_RMF[5];
-
-                // Genealogical position along the full parent axis (accounts for continuation forks)
-                const t_genealogical = lerp(job.cum_t0 ?? 0.0, job.cum_t1 ?? 1.0, t_attach);
-
-                // Insertion polar angle alpha from parent tangent T_p toward D_rad
-                const alpha_scale = rule.insertion_angle_profile.evaluate(t_genealogical);
-                const alpha = clamp(
-                    rule.insertion_angle * alpha_scale + (rng() * 2.0 - 1.0) * rule.insertion_angle_variation,
-                    0.1,
-                    Math.PI * 0.85
-                );
-                const cos_a = Math.cos(alpha);
-                const sin_a = Math.sin(alpha);
-                const var_scale = 1.0 + (rng() * 2.0 - 1.0) * next_cfg.length_variance;
-
-                // A plagiotropic parent is dorsiventral: its buds lie in the plane of its tangent T_p and the horizontal
-                // H = T_p x Y across it, whose normal N = H x T_p points up. A vertical parent has no such plane.
-                const tpx = SCRATCH_TAN[0], tpy = SCRATCH_TAN[1], tpz = SCRATCH_TAN[2];
-                const horizontality = Math.hypot(tpx, tpz);
-                const plagio = level >= 1 ? lvl_cfg.plagiotropism : 0.0;
-                const w_plagio = horizontality > 1e-3 ? plagio * horizontality : 0.0;
-                const dv_nx = horizontality > 1e-3 ? (-tpx * tpy) / horizontality : 0.0;
-                const dv_ny = horizontality;
-                const dv_nz = horizontality > 1e-3 ? (-tpy * tpz) / horizontality : 0.0;
-
-                // Helper to compute radial normal D_rad and child tangent T_c for a given azimuth phi_cand
-                const compute_child_basis = (phi_cand, out_dr, out_ct) => {
-                    const cp = Math.cos(phi_cand);
-                    const sp = Math.sin(phi_cand);
-                    let dx_r = cp * prx + sp * psx;
-                    let dy_r = cp * pry + sp * psy;
-                    let dz_r = cp * prz + sp * psz;
-
-                    if (w_plagio > 1e-3) {
-                        // fan into the dorsiventral plane: take off w of the radial's component along N
-                        const along_n = (dx_r * dv_nx + dy_r * dv_ny + dz_r * dv_nz) * w_plagio;
-                        dx_r -= along_n * dv_nx;
-                        dy_r -= along_n * dv_ny;
-                        dz_r -= along_n * dv_nz;
-                        const d_len = Math.sqrt(dx_r * dx_r + dy_r * dy_r + dz_r * dz_r);
-                        if (d_len > 1e-6) {
-                            dx_r /= d_len;
-                            dy_r /= d_len;
-                            dz_r /= d_len;
-                        } else {
-                            // a bud straight above (below) a fully dorsiventral shoot: to the side, along H
-                            dx_r = -tpz / horizontality;
-                            dy_r = 0.0;
-                            dz_r = tpx / horizontality;
-                        }
-                    }
-                    out_dr[0] = dx_r;
-                    out_dr[1] = dy_r;
-                    out_dr[2] = dz_r;
-
-                    let tx_c = cos_a * SCRATCH_TAN[0] + sin_a * dx_r;
-                    let ty_c = cos_a * SCRATCH_TAN[1] + sin_a * dy_r;
-                    let tz_c = cos_a * SCRATCH_TAN[2] + sin_a * dz_r;
-                    const ct_l = Math.sqrt(tx_c * tx_c + ty_c * ty_c + tz_c * tz_c) || 1.0;
-                    out_ct[0] = tx_c / ct_l;
-                    out_ct[1] = ty_c / ct_l;
-                    out_ct[2] = tz_c / ct_l;
-                };
-
-                // Ventral knockout: on a dorsiventral parent a bud whose own heading points into the downward cone of
-                // half-angle plagiotropism * pi / 2 does not break
-                const ventral_cos = Math.cos(plagio * Math.PI * 0.5);
-                if (plagio > 0.0) {
-                    const bud_y = cos_a * tpy + sin_a * (Math.cos(base_phi_c) * pry + Math.sin(base_phi_c) * psy);
-                    if (-bud_y > ventral_cos) {
-                        continue;
-                    }
-                }
-
-                const cand_dr = [0, 0, 0];
-                const cand_ct = [0, 0, 0];
-                compute_child_basis(base_phi_c, cand_dr, cand_ct);
-
-                // 1. Raw configured child branch length modulated by length_profile at t_genealogical and crown envelope
-                const prof_scale = Math.max(0.12, rule.length_profile.evaluate(t_genealogical));
-                const est_mid_y = SCRATCH_POS[1] + Math.max(0.0, cand_ct[1]) * next_cfg.length * prof_scale * 0.35;
-                const h_norm = clamp((est_mid_y - crown.base_height) / Math.max(0.1, crown.height), 0.0, 1.0);
-                // a dead branch grew before today's crown took its shape
-                const dead = sc.age > 0.0;
-                const env_scale = !rule.crown_envelope || dead
-                    ? 1.0
-                    : (level === 0
-                        ? crown_envelope_evaluate(crown.envelope_type, h_norm)
-                        : lerp(1.0, crown_envelope_evaluate(crown.envelope_type, h_norm), 0.5));
-                const raw_child_len = Math.max(0.12, next_cfg.length * prof_scale * env_scale * var_scale);
-
-                // 2. Continuous Gravity-Orientation & Allometric Slenderness Coupling (Cantilever vs. Pendulous Tension)
-                const rho_design = Math.max(0.012, next_cfg.radius_ratio);
-                const s_design = 1.0 / (2.0 * rho_design);
-                const g_trop = next_cfg.gravitropism ?? 0.0;
-                const u_curl = next_cfg.tip_upcurl ?? 0.0;
-                const t_eff_y = clamp(cand_ct[1] - 0.85 * g_trop + 0.35 * u_curl, -1.0, 1.0);
-
-                // Cantilever load (horizontal bending / upward compression) vs. pendulous tensile compliance
-                const k_cantilever = Math.sqrt(Math.max(0.0, 1.0 - t_eff_y * t_eff_y)) + 0.65 * Math.max(0.0, t_eff_y);
-                const tau_tension = clamp(g_trop, 0.0, 1.0) * Math.max(0.0, -t_eff_y);
-
-                // 3. Parent-relative distal conical envelope (prevents distal shoots or split forks from outgrowing their parent)
-                const actual_parent_len = Math.max(0.15, out.branch_length[branch_id]);
-                const parent_full_len = Math.max(actual_parent_len, job.full_branch_length ?? actual_parent_len);
-                const distal_tip_ratio = lerp(0.32, 0.55, tau_tension);
-                const cone_max_len = level === 0
-                    ? parent_full_len * lerp(0.85, 0.32, Math.pow(t_genealogical, 1.6))
-                    : Math.min(
-                        actual_parent_len * lerp(0.90, 1.05, tau_tension),
-                        parent_full_len * lerp(0.85, distal_tip_ratio, Math.pow(t_genealogical, 1.25))
-                    );
-                const desired_len = Math.max(0.12, Math.min(raw_child_len, cone_max_len));
-
-                const nom_len = Math.max(0.15, next_cfg.length);
-                const r_design = (nom_len * rho_design * Math.pow(desired_len / nom_len, 0.75)) / (1.0 + 0.65 * tau_tension);
-                // children on the flare crests sit side by side around the stem: N of them fit at most R sin(pi / N) thick
-                const side_by_side_r = rule.phyllotaxis_mode === PhyllotaxisMode.FlareLobes
-                    ? parent_r_at_attach * Math.sin(Math.PI / Math.max(2, lvl_cfg.flare_lobes | 0))
-                    : Infinity;
-                const child_base_r = Math.min(
-                    parent_r_at_attach * 0.78,
-                    side_by_side_r,
-                    Math.max(0.0035, r_design)
-                );
-
-                const gamma = lerp(0.82, 0.65, tau_tension);
-                const allometric_len = child_base_r < r_design
-                    ? desired_len * Math.pow(child_base_r / Math.max(1e-5, r_design), gamma)
-                    : desired_len;
-                const s_max = s_design * (1.35 + 0.65 * tau_tension) / (0.65 + 0.35 * k_cantilever);
-                const full_len = clamp(Math.min(allometric_len, 2.0 * child_base_r * s_max), 0.12, desired_len);
-                // a dead branch is what is left of it: its base part, if that still clears the bark; otherwise it has
-                // been grown over and the stem carries its scar
-                const child_len = full_len * sc.retained;
-                if (dead && child_len <= parent_r_at_attach) {
-                    out.add_scar(branch_id, t_attach, cand_ct[0], cand_ct[1], cand_ct[2], child_base_r * (1.0 - sc.age));
-                    continue;
-                }
-                const child_segs = Math.max(1, Math.ceil(next_cfg.segments * sc.retained));
-                const child_step = child_len / child_segs;
-
-                // 4. Pre-Spawn BVH Bud Clearance Probing (selects open canopy azimuth or inhibits blocked bud)
-                let best_drx = cand_dr[0], best_dry = cand_dr[1], best_drz = cand_dr[2];
-                let best_ctx = cand_ct[0], best_cty = cand_ct[1], best_ctz = cand_ct[2];
-                let best_clear = -Infinity;
-                const r_horiz_attach = Math.hypot(SCRATCH_POS[0], SCRATCH_POS[2]);
-
-                for (let k = 0; k < PHI_CANDIDATES.length; k++) {
-                    if (k > 0) {
-                        compute_child_basis(base_phi_c + PHI_CANDIDATES[k], cand_dr, cand_ct);
-                    }
-                    // nor may fanning or a turn for clearance carry it into the cone: a bud with no heading left
-                    // outside it does not break
-                    if (plagio > 0.0 && -cand_ct[1] > ventral_cos) continue;
-                    // Prevent lateral shoots on boughs from pointing backward into the trunk core
-                    if (level >= 1 && r_horiz_attach > 0.30) {
-                        const radial_dot = (SCRATCH_POS[0] * cand_ct[0] + SCRATCH_POS[2] * cand_ct[2]) / r_horiz_attach;
-                        if (radial_dot < -0.15) continue;
-                    }
-
-                    const p1_x = SCRATCH_POS[0] + cand_ct[0] * child_step;
-                    const p1_y = SCRATCH_POS[1] + cand_ct[1] * child_step;
-                    const p1_z = SCRATCH_POS[2] + cand_ct[2] * child_step;
-
-                    const clear0 = evaluate_candidate_clearance(
-                        -1, branch_id, seg_idx, false, 0,
-                        SCRATCH_POS[0], SCRATCH_POS[1], SCRATCH_POS[2], child_base_r,
-                        p1_x, p1_y, p1_z, child_base_r * 0.88,
-                        0.002
-                    );
-
-                    const p2_x = p1_x + cand_ct[0] * child_step;
-                    const p2_y = p1_y + cand_ct[1] * child_step;
-                    const p2_z = p1_z + cand_ct[2] * child_step;
-                    const clear1 = child_segs >= 2
-                        ? evaluate_candidate_clearance(
-                            -1, branch_id, seg_idx, false, 1,
-                            p1_x, p1_y, p1_z, child_base_r * 0.88,
-                            p2_x, p2_y, p2_z, child_base_r * 0.75,
-                            0.002
-                        )
-                        : clear0;
-
-                    const min_c = Math.min(clear0, clear1);
-                    if (min_c > best_clear) {
-                        best_clear = min_c;
-                        best_drx = cand_dr[0];
-                        best_dry = cand_dr[1];
-                        best_drz = cand_dr[2];
-                        best_ctx = cand_ct[0];
-                        best_cty = cand_ct[1];
-                        best_ctz = cand_ct[2];
-                    }
-                    if (min_c >= 0.004) {
-                        break;
-                    }
-                }
-
-                // Botanical bud inhibition: if all candidate directions are blocked by existing branches, suppress bud
-                if (best_clear < -0.004) {
-                    continue;
-                }
-
-                const drx = best_drx, dry = best_dry, drz = best_drz;
-                const ctx = best_ctx, cty = best_cty, ctz = best_ctz;
-
-                // Initial RMF radial vector for child branch:
-                // R_c = cos(alpha) * D_rad - sin(alpha) * T_p is exact unit length and orthogonal
-                // to T_c = cos(alpha) * T_p + sin(alpha) * D_rad for all alpha in [0, pi],
-                // avoiding any singularity at alpha = pi/2.
-                let crx = cos_a * drx - sin_a * SCRATCH_TAN[0];
-                let cry = cos_a * dry - sin_a * SCRATCH_TAN[1];
-                let crz = cos_a * drz - sin_a * SCRATCH_TAN[2];
-                const cr_dot = crx * ctx + cry * cty + crz * ctz;
-                crx -= cr_dot * ctx;
-                cry -= cr_dot * cty;
-                crz -= cr_dot * ctz;
-                const cr_len = Math.sqrt(crx * crx + cry * cry + crz * crz);
-                if (cr_len > 1e-12) {
-                    crx /= cr_len;
-                    cry /= cr_len;
-                    crz /= cr_len;
-                }
-
-                queue.push({
-                    level: next_level,
-                    generator: rule.target,
-                    in_crown: rule.crown_envelope && !dead,
-                    dead,
-                    parent_branch_id: branch_id,
-                    parent_edge_id: parent_e,
-                    parent_attach_seg_idx: seg_idx,
-                    parent_attach_t: t_attach,
-                    attach_parent_vertex: p_v0,
-                    start_vertex: -1,
-                    px: SCRATCH_POS[0],
-                    py: SCRATCH_POS[1],
-                    pz: SCRATCH_POS[2],
-                    tx: ctx,
-                    ty: cty,
-                    tz: ctz,
-                    rx: crx,
-                    ry: cry,
-                    rz: crz,
-                    emerge_drx: drx,
-                    emerge_dry: dry,
-                    emerge_drz: drz,
-                    length: child_len,
-                    full_branch_length: child_len,
-                    base_radius: child_base_r * (1.0 - sc.age),
-                    start_seg: 0,
-                    total_segs: child_segs,
-                    shape_segs: Math.max(1, next_cfg.segments),
-                    initial_arc_s: 0.0,
-                    has_split: false,
-                    is_split_fork: false,
-                    cum_t0: 0.0,
-                    cum_t1: sc.retained
-                });
-            }
-        }
-    }
-
-    // Bottom-up Pipe Model radius calculation & blending
-    tree_skeleton_compute_pipe_radii(out, species);
-
-    // The peripheral twig systems, grown year by year on the finished framework, its girth final
+    tree_skeleton_grow_framework(species, out);
     tree_skeleton_grow_shoots(out, species);
-
+    tree_skeleton_fit_crown_frame(out, species);
     return out;
 }