@woosh/meep-engine 3.57.0 → 3.59.0

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

@@ -0,0 +1,2050 @@
+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 { tree_skeleton_fit_crown_frame } from "./tree_skeleton_fit_crown_frame.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";
+
+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;
+}
+
+/**
+ * Grows a tree's framework from its generator graph (`TreeGrowth.Graph`): a directed `TreeSkeleton` from a
+ * `TreeSpeciesConfig`, without the shoot systems of its `shoot_rules` (`tree_skeleton_grow` grows those on it), 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`)
+ *
+ * @param {TreeSpeciesConfig|Object} [config]
+ * @param {TreeSkeleton} [out]
+ * @returns {TreeSkeleton}
+ */
+export function tree_skeleton_grow_framework(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);
+    }
+
+    // a seed leader is a shoot a few centimetres long
+    const trunk_len = Math.max(1e-3, 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 crown is where the shoot systems grow
+    tree_skeleton_fit_crown_frame(out, species);
+
+    return out;
+}