BREP_kernel 0.13.2

use super::*;

/// Cross-section of the removed (convex) or added (concave) material in
/// the plane perpendicular to the edge: corner at the edge, support
/// tangency points at r/tan(θ/2) along each face, and the rolling-ball
/// arc (fillet) or its chord (chamfer) between them.
fn cross_section_profile(
    cross: &EdgeCross,
    radius: f64,
    chamfer: bool,
) -> Result<Vec<NurbsCurve>, KernelRefusal> {
    let corner = cross.start;
    let cos_theta = cross.into_first.dot(cross.into_second).clamp(-1.0, 1.0);
    let theta = cos_theta.acos();
    if theta <= 1e-6 || theta >= std::f64::consts::PI - 1e-6 {
        return Err(KernelRefusal::input(
            KernelStage::Classify,
            "dihedral_degenerate",
            "fillet: dihedral angle too degenerate",
        ));
    }
    let tangent_offset = radius / (theta * 0.5).tan();
    let first_tangency = corner.add(cross.into_first.scale(tangent_offset));
    let second_tangency = corner.add(cross.into_second.scale(tangent_offset));
    let line = |from: Vec3, to: Vec3| {
        make_line(from, to).or_refuse(KernelStage::Fragment, "profile_line")
    };
    let mut profile = vec![line(corner, first_tangency)?];
    if chamfer {
        profile.push(line(first_tangency, second_tangency)?);
    } else {
        // Ball center: along the corner bisector at distance r/sin(θ/2);
        // the arc runs from the first tangency to the second, curving
        // toward the corner.
        let bisector = cross
            .into_first
            .add(cross.into_second)
            .normalized()
            .or_refuse(KernelStage::Fragment, "profile_bisector")?;
        let center = corner.add(bisector.scale(radius / (theta * 0.5).sin()));
        let x_axis = first_tangency.sub(center).scale(1.0 / radius);
        let sweep = std::f64::consts::PI - theta;
        // y axis chosen so the arc sweeps from the first tangency to the
        // second inside the corner wedge.
        let y_axis_raw = second_tangency.sub(center).scale(1.0 / radius);
        let y_axis = y_axis_raw
            .sub(x_axis.scale(y_axis_raw.dot(x_axis)))
            .normalized()
            .or_refuse(KernelStage::Fragment, "profile_arc_axis")?;
        profile.push(
            make_arc(center, x_axis, y_axis, radius, 0.0, sweep)
                .or_refuse(KernelStage::Fragment, "profile_arc")?,
        );
    }
    profile.push(line(second_tangency, corner)?);
    Ok(profile)
}

/// The FULL ROUND of a circular edge (lane F row 4): a convex rim whose ball radius
/// equals the distance from the rim to its axis along one support, so that support's
/// tangency lands ON the revolve axis and the blend wall is a sphere capping the
/// rod's end. The ordinary profile (corner, tangency, arc, tangency) then pinches to
/// a point at the pole — the cap line and the arc meet tangentially on the axis —
/// and its revolution is not a manifold solid (Euler 1, expected 2). This profile
/// grows the cutter into the air past the pinched support instead: it runs from a
/// point one radius beyond the corner down the other support to its tangency, along
/// the arc to the pole, up the axis and back out, so the revolved cutter is the end
/// slab minus the ball, with the ball's pole on the axis. The arc stays the second
/// curve (the blend wall, `build_exact_tool`). `None` when no tangency is on the
/// axis: that edge takes `cross_section_profile`.
fn full_round_profile(
    cross: &EdgeCross,
    radius: f64,
    chamfer: bool,
) -> Result<Option<Vec<NurbsCurve>>, KernelRefusal> {
    let EdgePath::Circular { center, axis, .. } = &cross.path else {
        return Ok(None);
    };
    if chamfer || !cross.convex {
        return Ok(None);
    }
    let corner = cross.start;
    let theta = cross.into_first.dot(cross.into_second).clamp(-1.0, 1.0).acos();
    if theta <= 1e-6 || theta >= std::f64::consts::PI - 1e-6 {
        return Ok(None);
    }
    let tangent_offset = radius / (theta * 0.5).tan();
    let radial = |point: Vec3| {
        let offset = point.sub(*center);
        offset.sub(axis.scale(offset.dot(*axis))).length()
    };
    let rim_radius = radial(corner);
    let on_axis = |point: Vec3| radial(point) <= 1e-9 * rim_radius.max(1.0);
    let first_tangency = corner.add(cross.into_first.scale(tangent_offset));
    let second_tangency = corner.add(cross.into_second.scale(tangent_offset));
    // `pole` is the tangency on the axis, `wall` the other support's.
    let (pole, wall, into_wall) = if on_axis(first_tangency) {
        (first_tangency, second_tangency, cross.into_second)
    } else if on_axis(second_tangency) {
        (second_tangency, first_tangency, cross.into_first)
    } else {
        return Ok(None);
    };
    let bisector = cross
        .into_first
        .add(cross.into_second)
        .normalized()
        .or_refuse(KernelStage::Fragment, "full_round_bisector")?;
    let ball = corner.add(bisector.scale(radius / (theta * 0.5).sin()));
    // Away from the material across the pinched support: back along the
    // wall support's inward direction, by one radius.
    let lift = into_wall.scale(-radius);
    let corner_up = corner.add(lift);
    let pole_up = pole.add(lift);
    let line = |from: Vec3, to: Vec3| {
        make_line(from, to).or_refuse(KernelStage::Fragment, "full_round_line")
    };
    let x_axis = wall.sub(ball).scale(1.0 / radius);
    let toward_pole = pole.sub(ball).scale(1.0 / radius);
    let y_axis = toward_pole
        .sub(x_axis.scale(toward_pole.dot(x_axis)))
        .normalized()
        .or_refuse(KernelStage::Fragment, "full_round_arc_axis")?;
    let arc = make_arc(ball, x_axis, y_axis, radius, 0.0, std::f64::consts::PI - theta)
        .or_refuse(KernelStage::Fragment, "full_round_arc")?;
    Ok(Some(vec![
        line(corner_up, wall)?,
        arc,
        line(pole, pole_up)?,
        line(pole_up, corner_up)?,
    ]))
}

/// Asymmetric chamfer cross-section (Golovanov §6.11): the removed triangular
/// sliver has EXPLICIT per-face setbacks — the standard CAD "d1 × d2"
/// convention, `d1` along face 1 (`into_first`) and `d2` along face 2
/// (`into_second`).  Curve order matches `cross_section_profile`: the corner
/// leg on face 1, the chamfer chord (blend wall, index 1), then the face-2 leg
/// back to the corner.
pub(super) fn chamfer_cross_section_offsets(
    cross: &EdgeCross,
    d1: f64,
    d2: f64,
) -> Result<Vec<NurbsCurve>, KernelRefusal> {
    let o = cross.start;
    let p1 = o.add(cross.into_first.scale(d1));
    let p2 = o.add(cross.into_second.scale(d2));
    let line = |from: Vec3, to: Vec3| {
        make_line(from, to).or_refuse(KernelStage::Fragment, "chamfer_profile_line")
    };
    Ok(vec![line(o, p1)?, line(p1, p2)?, line(p2, o)?])
}

/// Given setback `d1` on face 1 and the angle α between the chamfer face and
/// face 1, CONSTRUCT the face-2 setback `d2` in the cross-section plane
/// (§6.11 distance-angle chamfer).  We do not assume a closed form: an
/// orthonormal 2D basis `(e1, e2)` is built in the cross-section plane, the
/// chamfer chord ray leaving `P1 = d1·e1` at angle α from face 1 (tilting
/// toward face 2) is intersected with the face-2 ray `t·into_second`, and
/// `d2 = t`.
pub(super) fn chamfer_angle_second_distance(
    cross: &EdgeCross,
    d1: f64,
    angle_rad: f64,
) -> Result<f64, KernelRefusal> {
    let e1 = cross.into_first;
    let cos_theta = cross.into_first.dot(cross.into_second).clamp(-1.0, 1.0);
    let theta = cos_theta.acos();
    if theta <= 1e-6 || theta >= std::f64::consts::PI - 1e-6 {
        return Err(KernelRefusal::input(
            KernelStage::Classify,
            "angle_dihedral_degenerate",
            "chamfer_edge_angle: dihedral angle too degenerate",
        ));
    }
    if !(angle_rad > 1e-9) || angle_rad >= theta - 1e-9 {
        return Err(KernelRefusal::input(
            KernelStage::Collect,
            "chamfer_angle",
            format!(
                "chamfer_edge_angle: angle {angle_rad} must lie in (0, dihedral θ={theta})"
            ),
        ));
    }
    // Orthonormal basis of the cross-section plane: e1 = into_first, e2 the
    // normalized in-plane perpendicular pointing toward face 2.
    let e2 = cross
        .into_second
        .sub(e1.scale(cross.into_second.dot(e1)))
        .normalized()
        .or_refuse(KernelStage::Classify, "chamfer_basis")?;
    // Project face 2 into (e1, e2): (cosθ, sinθ), sinθ > 0 by construction.
    let f2x = cross.into_second.dot(e1);
    let f2y = cross.into_second.dot(e2);
    // P1 = (d1, 0).  The chamfer chord ray leaves P1 making angle α with face 1
    // and tilting toward face 2, so its 2D direction is (−cosα, sinα).  Intersect
    // P1 + s·(−cosα, sinα) = t·(f2x, f2y), t ≥ 0 (the face-2 ray) ⇒ d2 = t.
    let (ca, sa) = (angle_rad.cos(), angle_rad.sin());
    // [ ca   f2x ] [s]   [d1]      (from  d1 − s·cosα = t·f2x)
    // [ sa  −f2y ] [t] = [ 0]      (from  s·sinα      = t·f2y)
    let det = ca * (-f2y) - f2x * sa;
    // Both remaining refusals sit BEHIND the angle check above, which
    // bounds α strictly inside (0, θ): a parallel ray or a non-positive
    // setback is the construction contradicting its own precondition.
    if det.abs() < 1e-12 {
        return Err(KernelRefusal::internal(
            KernelStage::Classify,
            "chamfer_ray_parallel",
            "chamfer_edge_angle: chamfer ray is parallel to face 2",
        ));
    }
    // Cramer's rule for t (the face-2 setback d2).
    let t = (ca * 0.0 - sa * d1) / det;
    if !(t > 0.0) || !t.is_finite() {
        return Err(KernelRefusal::internal(
            KernelStage::Classify,
            "chamfer_setback",
            format!(
                "chamfer_edge_angle: constructed a non-positive setback d2={t}"
            ),
        ));
    }
    Ok(t)
}

fn tool_boolean_setup(convex: bool) -> (BooleanOperation, BooleanOptions) {
    let operation = if convex {
        BooleanOperation::Subtract
    } else {
        BooleanOperation::Union
    };
    // The tool's side walls lie ON the mating faces (cosurface); the
    // post-boolean same-surface merge currently mishandles the resulting
    // ring topology, so the blend boolean runs without it — callers can
    // merge coplanar faces afterwards if they wish.
    let options = BooleanOptions {
        merge_coplanar_faces: false,
        ..BooleanOptions::default()
    };
    (operation, options)
}

pub(super) fn apply_tool(
    solid: &BrepSolid,
    tool: &BrepSolid,
    convex: bool,
) -> Result<BrepSolid, KernelRefusal> {
    let (operation, options) = tool_boolean_setup(convex);
    boolean_operation(solid, tool, operation, &options)
}

/// Assemble the blend boolean with the EXACT arrangement only — no
/// Simulation-of-Simplicity fallback.
///
/// `boolean_operation` rescues an arrangement degeneracy by rigidly
/// TRANSLATING the second operand (here: the cutter) by a fraction of the model
/// scale and accepting the perturbed result once a point-classification oracle
/// and a 1%-slack volume bound agree.  Those gates are far too coarse to notice
/// that the blend wall has moved off its supports: the cutter is translated
/// bodily, so the fillet surface is no longer tangent to either mating face and
/// the removed sliver is wrong by ~1% of itself.  A blend has an exact
/// construction available (see the overshoot ladder in
/// `fillet_or_chamfer_exact`), so it must exhaust that ladder before it is
/// allowed to settle for a perturbed cutter.
pub(super) fn apply_tool_exact(
    solid: &BrepSolid,
    tool: &BrepSolid,
    convex: bool,
) -> Result<BrepSolid, KernelRefusal> {
    let (operation, options) = tool_boolean_setup(convex);
    Ok(crate::boolean_operation_with_diagnostics(solid, tool, operation, &options)?.value)
}

/// Which construction gets the first turn on one edge.
///
/// The public single-edge entries construct the blend by the march (the
/// rolling ball, the fitted rows, direct surgery) and fall back to the cutter
/// only where the march refuses.  The GROUP's sequential composition keeps
/// the cutter first: its corner closures (`round_convex_corner` and the
/// mixed-convexity lanes) reconstruct the corner from the cutter's output
/// and read its topology, so until the stripe network covers those corners
/// the composition they sit on must stay the one they were written against.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(super) enum Lane {
    GeneralFirst,
    CutterFirst,
}

pub(super) fn fillet_or_chamfer(
    solid: &BrepSolid,
    edge_id: u64,
    radius: f64,
    chamfer: bool,
    name: Option<&str>,
    ends: ToolEnds,
    lane: Lane,
) -> Result<BrepSolid, KernelRefusal> {
    // Fuse-first operand heal (Lever A) BEFORE the §6.9 surgery, mirroring the
    // output heal below: snap the input's near-coincident / off-plane vertices
    // to exact and re-anchor incident edges, so amplified solver/intersection
    // noise cannot break the blend boolean.  Edge identity (ids) is preserved,
    // so `edge_id` still resolves; a clean input is left byte-identical.
    let mut healed = solid.clone();
    let policy = crate::KernelTolerances::for_solid(&healed, 1e-7);
    crate::heal::heal_operands(&mut healed, &policy)?;
    let mut result = fillet_or_chamfer_inner(&healed, edge_id, radius, chamfer, name, ends, lane)?;
    // Heal the §6.9 surgery so re-trimmed edges meet their corner vertices
    // exactly (the boolean-backed exact path is already committed; this is a
    // no-op there and on any clean blend).
    heal_edge_vertex_gaps(&mut result, radius)?;
    // A trim the §6.9 surgery ran outside a planar carrier's chart is clamped
    // onto the chart's boundary by the pcurve builder, which leaves a wrong
    // region on a body `validate()` passes; widen the carrier to hold it.
    crate::blend::fit_planar_charts_to_trims(&healed, &mut result)?;
    // A blend with no corner closure after it is finished here. A cutter-first
    // composition's cutter keeps its standing scaffold tagged until the group
    // has closed its corners, which read that topology (`settle_cutter_scaffold`).
    if lane == Lane::GeneralFirst {
        result = settle_cutter_scaffold(result);
    }
    Ok(result)
}

/// Is this march refusal about the SHAPE rather than the lane?
///
/// A wall that folds through itself is not something another construction
/// answers: the cutter's tool surface is the same envelope with the same fold,
/// and the edge-preserving fallback builds a blend the rolling ball never made.
/// Reported as-is, so the caller reads the geometry instead of whichever later
/// rung complained last.
///
/// A marched seam or connector whose fit left its carriers is the same kind of
/// refusal for the same reason.  It does not say "not this lane": it says the
/// curve the corner was closed with is not the curve the march solved for,
/// read against the march's own witnesses, and no later rung re-asks that
/// question.  The lane beneath it answers a DIFFERENT question and answers it
/// wrong without saying so -- on the notched cap's stuck connector the cutter
/// composition reads 1724.506048919, +1.81e-2 against the closed form, and it
/// validates.  A refusal that falls through to a validating wrong solid is not
/// a refusal.
///
/// So is a blend that stops within a sliver of its face's width and cannot be
/// snapped onto the far edge without opening the shell
/// (`blend::CONSUMED_SNAP_UNSOUND`): the size is the question, and a tool solid
/// cut a sliver short of an edge answers it with a sliver no lane keeps.
///
/// So is a trim that left its planar carrier's chart
/// (`blend::PLANAR_CHART_EDGE_OFF_PLANE`, `blend::PLANAR_CHART_WIDEN_UNSOUND`):
/// the clamped body another lane would answer with is the defect itself.
pub(super) fn is_terminal_blend_refusal(refusal: &KernelRefusal) -> bool {
    crate::blend::is_wall_fold(refusal)
        || crate::blend::is_marched_fit_off_carriers(refusal)
        || crate::blend::is_consumed_snap(refusal)
        || crate::blend::is_planar_chart_refusal(refusal)
        || crate::blend::is_tangential_transverse_end(refusal)
}

fn fillet_or_chamfer_inner(
    solid: &BrepSolid,
    edge_id: u64,
    radius: f64,
    chamfer: bool,
    name: Option<&str>,
    ends: ToolEnds,
    lane: Lane,
) -> Result<BrepSolid, KernelRefusal> {
    // A lone straight chamfer whose rails run on past the edge's ends is cut
    // through to the faces those ends meet (`BREP_CHAMFER_THROUGH_END_FACES`,
    // default on; `=0` restores); it declines to the lanes below on anything else.
    // A pad below rounding (`tool_ends_to_original_extent` of an untrimmed
    // edge reads 1.8e-15 at its end) is no pad.
    let flush = ends.start.abs() <= 1e-9 * (1.0 + radius) && ends.end.abs() <= 1e-9 * (1.0 + radius);
    if chamfer && flush && lane == Lane::GeneralFirst && chamfer_through_end_faces_on() {
        let through = analyze_edge(solid, edge_id, radius).ok().and_then(|cross| {
            let profile = match full_round_profile(&cross, radius, true).ok()? {
                Some(profile) => profile,
                None => cross_section_profile(&cross, radius, true).ok()?,
            };
            chamfer_through_end_faces(solid, edge_id, &cross, &profile, name)
        });
        if let Some(result) = through {
            return Ok(result);
        }
    }
    // The general §4.9 march with direct §6.9 surgery is the PRIMARY lane:
    // it constructs the blend from the rolling ball and re-trims the mates,
    // with no tool solid to run past the edge.  A straight edge between two
    // planes comes out as the exact cylinder patch (`exact_extrusion_rows`),
    // a circular rim on straight-meridian carriers as the exact revolution
    // (`exact_closed_revolution_rows`), so nothing the cutter produced
    // exactly is lost.  The cutter remains only as the fallback for what the
    // march still refuses; a pad on its ends (`ends`) is a group-build
    // instruction that only the cutter understands.
    let closed = solid
        .edges
        .iter()
        .find(|edge| edge.id == edge_id)
        .map(|edge| edge.start_vertex_id == edge.end_vertex_id)
        .unwrap_or(false);
    // `BREP_CUTTER_FIRST=1` restores the pre-network order for A/B
    // comparison; the general lane is otherwise first.
    // The three lane notes below are not refusals of the shape: they say the
    // march was not asked, and only ever reach a caller inside the ladder's
    // combined text ("first attempt: …").  Classed as the deferral they are.
    let lane_note = |what: &'static str, message: &str| {
        KernelRefusal::unsupported(KernelStage::Classify, what, message)
    };
    // A concave fill that runs past its support face into air is built only
    // by the clipped cutter: the general lanes would build the pad unclipped,
    // overhanging the part (lane F row 5).
    let clip_probe = crate::blend::BlendTimer::start("timing.cutter.clip_probe_ms");
    let clipped_fill = !chamfer && ends == ToolEnds::default() && concave_clip_face(solid, edge_id, radius).is_some();
    clip_probe.stop();
    let general_first = crate::blend::BlendTimer::start("timing.cutter.general_first_ms");
    let general = if clipped_fill {
        Err(lane_note("clipped_fill", "a concave fill past its support face is clipped by the cutter"))
    } else if ends != ToolEnds::default() {
        Err(lane_note("padded_cutter", "a padded cutter was requested"))
    } else if lane == Lane::CutterFirst {
        Err(lane_note(
            "cutter_first",
            "the cutter has the first turn in this composition",
        ))
    } else if std::env::var("BREP_CUTTER_FIRST").is_ok() {
        Err(lane_note("cutter_first_env", "BREP_CUTTER_FIRST set"))
    } else if closed {
        crate::blend::blend_closed_edge(solid, edge_id, radius, chamfer, name)
    } else {
        // An open edge may be one tangent-continuous arc of a CLOSED smooth
        // chain (e.g. a cyl×cyl saddle split into arcs by the two carriers'
        // seams) — blend the whole rim as one unit (§6.9.5).  An OPEN tangent
        // chain is NOT walked: the network treats the edge as one stripe and
        // caps it where it runs into an unselected tangent neighbour.
        crate::blend::blend_smooth_chain_if_closed(solid, edge_id, radius, chamfer, name)
            .or_else(|error| {
                if is_terminal_blend_refusal(&error) {
                    return Err(error);
                }
                let names = [name.map(str::to_string)];
                crate::blend::blend_star_network(solid, &[edge_id], radius, chamfer, &names, &|_| None)
            })
            .or_else(|error| {
                if is_terminal_blend_refusal(&error) {
                    return Err(error);
                }
                crate::blend::blend_open_edge(solid, edge_id, radius, chamfer, name)
            })
    };
    // A general-lane result is accepted only when it is BOTH a valid solid and
    // a trimmed one: `check_blend_interference` catches the blend wall left
    // running through a third face, which `validate` cannot see.  Either way
    // the ladder carries on to the cutter, whose boolean does split the
    // crossing faces and drop the fragments in the void.
    let entry = if chamfer { "chamfer" } else { "fillet" };
    general_first.stop();
    let general_error = match general {
        Ok(result) if result.validate().is_empty() => {
            let interference = crate::blend::BlendTimer::start("timing.cutter.general_first.interference_ms");
            let checked = check_blend_interference(solid, &result, &[edge_id], entry).and_then(|()| check_blend_wall_loops(&result, entry));
            interference.stop();
            match checked {
                Ok(()) => return Ok(result),
                Err(untrimmed) => untrimmed,
            }
        }
        Ok(_) => KernelRefusal::internal(
            KernelStage::Validate,
            "general_invalid",
            "the general blend assembled an invalid solid",
        ),
        Err(error) => error,
    };
    // The rolling ball does not FIT: TERMINAL, like the mixed-convexity corner
    // (`fillet/edges.rs`).  The march refused because the tangency system has
    // no solution at this radius — the local wall is thinner than the ball —
    // and a tool solid does not answer that question, it only removes whatever
    // its own surface encloses.  Reporting the geometric refusal beats leading
    // the user with the cutter's unrelated complaint about the edge's curve.
    if crate::blend::is_ball_off_carrier(&general_error) {
        return Err(general_error);
    }
    // The wall the rolling ball sweeps FOLDS THROUGH ITSELF: terminal for the
    // same reason, and a step further.  The march converged — every station is
    // on the true centre curve — but the curve turns tighter there than the
    // ball is wide, so the envelope's own section sweeps back through itself
    // and no lane in the kernel trims that.  The cutter builds the identical
    // self-intersecting surface, and its boolean then hides the defect inside a
    // solid that validates; the fold is only visible to the tessellation-level
    // scan (`brep/soundness.rs`).  Reporting the geometry beats shipping it.
    if is_terminal_blend_refusal(&general_error) {
        return Err(general_error);
    }
    let exact_timer = crate::blend::BlendTimer::start("timing.cutter.exact_ms");
    let exact = fillet_or_chamfer_exact(solid, edge_id, radius, chamfer, name, ends, lane);
    exact_timer.stop();
    match exact {
        Ok(result) => Ok(result),
        Err(exact_error) => {
            let _general_last = crate::blend::BlendTimer::start("timing.cutter.general_last_ms");
            // The exact special cases (straight×planar extrude, circular×
            // straight-meridian rotational revolve) cover a subset; every
            // other edge goes through the general §4.9 tangency march with
            // direct §6.9 surgery.
            let general = if closed {
                // BREP lane L: begin lcount201_knot_aware_last_rung_20261016
                // The last rung: a support pcurve off the floor is terminal for
                // the whole fillet here, so the closed rim gets ONE knot-aware
                // retry; a retry that also fails keeps the first refusal.
                crate::blend::blend_closed_edge(solid, edge_id, radius, chamfer, name).or_else(|first| {
                    if crate::blend::is_pcurve_floor_refusal(&first) {
                        crate::blend::blend_closed_edge_knot_aware(solid, edge_id, radius, chamfer, name).map_err(|_| first)
                    } else {
                        Err(first)
                    }
                })
                // BREP lane L: end lcount201_knot_aware_last_rung_20261016
            } else {
                let rung = crate::blend::BlendTimer::start("timing.cutter.general_last.smooth_chain_ms");
                let chain = crate::blend::blend_smooth_chain(solid, edge_id, radius, chamfer, name);
                let chain_ms = rung.stop();
                if let Err(error) = &chain {
                    if std::env::var("BREP_DEBUG_NETWORK").is_ok() {
                        eprintln!("last rung, smooth chain of edge {edge_id} refused after {chain_ms:.1} ms: {error}");
                    }
                }
                chain
                    .or_else(|error| {
                        if is_terminal_blend_refusal(&error) {
                            return Err(error);
                        }
                        let rung = crate::blend::BlendTimer::start("timing.cutter.general_last.open_edge_ms");
                        let open = crate::blend::blend_open_edge(solid, edge_id, radius, chamfer, name);
                        let open_ms = rung.stop();
                        if let Err(error) = &open {
                            if std::env::var("BREP_DEBUG_NETWORK").is_ok() {
                                eprintln!("last rung, open march of edge {edge_id} refused after {open_ms:.1} ms: {error}");
                            }
                        }
                        open
                    })
                    .or_else(|error| {
                        if is_terminal_blend_refusal(&error) {
                            return Err(error);
                        }
                        let _rung = crate::blend::BlendTimer::start("timing.cutter.general_last.star_network_ms");
                        // The one-edge network, which the general-first lane
                        // runs BEFORE the open-edge march and this rung never
                        // ran: the two differ at a free end whose mates run
                        // tangent into the vertex (a POLE — the seam between
                        // two rounds where both meet a third face flush).
                        // The network reads that end (`pole_end`), stops its
                        // march on the vertex and closes the end by that
                        // point; the open-edge march overshoots past it,
                        // where the two offset carriers coincide and the
                        // station Newton is singular.  The 2026-10-13 star
                        // boss: F3 selects the four F2 corner seams beside
                        // mixed-convexity star corners, so the group is a
                        // cutter composition, and its first seam refused
                        // here while the same seam filleted alone built.
                        // Tried LAST so a composition the open-edge march
                        // already answers keeps that answer; the march's own
                        // refusal is what is reported when the network
                        // declines too.
                        let names = [name.map(str::to_string)];
                        match crate::blend::blend_star_network(
                            solid,
                            &[edge_id],
                            radius,
                            chamfer,
                            &names,
                            &|_| None,
                        ) {
                            Ok(result) if result.validate().is_empty() => Ok(result),
                            Ok(_) => Err(error),
                            Err(network_error) => {
                                if is_terminal_blend_refusal(&network_error) {
                                    return Err(network_error);
                                }
                                Err(error)
                            }
                        }
                    })
            };
            // Last rung of the ladder, and the same contract: an untrimmed
            // blend is a failure here too.  Nothing is left to fall through
            // to, so this one reaches the caller as a named refusal rather
            // than as a self-intersecting solid.
            general
                .and_then(|result| {
                    let rung = crate::blend::BlendTimer::start("timing.cutter.general_last.interference_ms");
                    let checked = check_blend_interference(solid, &result, &[edge_id], entry).and_then(|()| check_blend_wall_loops(&result, entry)).map(|()| result);
                    rung.stop();
                    checked
                })
                .map_err(|error| {
                    // Reachable with a fold only in the cutter-first
                    // compositions, where the first attempt never marched: the
                    // refusal is still the shape's, so it is reported alone
                    // rather than wrapped in the cutter's complaint.
                    if is_terminal_blend_refusal(&error) {
                        return error;
                    }
                    // The last rung's own class survives the wrap.
                    error.with_message(|error| {
                        format!(
                            "exact cutter failed: {exact_error}; general blend also failed: {error} \
                             (first attempt: {general_error})"
                        )
                    })
                })
        }
    }
}

/// How far the cutter must run PAST each end of the edge it is built on,
/// measured as arc length along the edge path.  Non-zero only when a
/// neighbouring blend has already TRIMMED this edge back from a shared corner
/// (see `tool_ends_to_original_extent`); a lone blend keeps both ends flush.
#[derive(Clone, Copy, Default, Debug, PartialEq)]
pub(super) struct ToolEnds {
    start: f64,
    end: f64,
}

impl ToolEnds {
    /// The two pads as bit patterns: an exact key for a memo of cutters
    /// built with these ends (the sequential composition's prefix memo in
    /// `fillet/edges.rs`).
    pub(super) fn key_bits(&self) -> [u64; 2] {
        [self.start.to_bits(), self.end.to_bits()]
    }
}

/// Build the fillet/chamfer cutter for one edge.  `overshoot` extends a
/// STRAIGHT edge's extruded tool by that much PAST each edge endpoint, so the
/// tool's end caps clear the adjacent end faces instead of sitting coincident
/// on them.  This is what lets the boolean cut the end faces TRANSVERSALLY
/// (one clean end-arc each) at a degenerate terminus — e.g. the two ends of a
/// partial-revolve's axis-junction edge, where each adjacent end face is a
/// planar sector that pinches to a POLE exactly on the edge endpoint: with a
/// coincident end cap the subtract emits duplicate/zero-length edges at the
/// pole (non-integral genus), whereas a small overshoot removes only air past
/// the pole and leaves a valid solid.  `overshoot` is 0 for the common case.
///
/// `ends` extends the SAME tool asymmetrically, one end at a time: it is how
/// far this edge was trimmed back from a shared corner by an earlier blend in
/// the same group, so the channel runs THROUGH the corner instead of stopping
/// at a flush cap inside the material.
fn build_exact_tool(
    cross: &EdgeCross,
    profile: &[NurbsCurve],
    overshoot: f64,
    ends: ToolEnds,
    name: Option<&str>,
) -> Result<BrepSolid, KernelRefusal> {
    let start_pad = overshoot + ends.start.max(0.0);
    let end_pad = overshoot + ends.end.max(0.0);
    let mut tool = match &cross.path {
        EdgePath::Straight { direction, length } => {
            let shifted: Vec<NurbsCurve> = if start_pad > 0.0 {
                profile
                    .iter()
                    .map(|curve| {
                        let mut shifted = curve.clone();
                        for cp in shifted.control_points.iter_mut() {
                            // Homogeneous control points store (P·w, w); translate
                            // the point P by −start_pad·direction ⇒ subtract
                            // start_pad·direction·w from the (x,y,z) components.
                            let delta = direction.scale(start_pad * cp.w);
                            cp.x -= delta.x;
                            cp.y -= delta.y;
                            cp.z -= delta.z;
                        }
                        shifted
                    })
                    .collect()
            } else {
                profile.to_vec()
            };
            extrude_profile_brep(&shifted, *direction, *length + start_pad + end_pad)?
        }
        EdgePath::Circular {
            center,
            axis,
            sweep,
        } => {
            // The revolved counterpart: arc-length pads become sweep angles at
            // the edge's own radius, and the profile rotates back by the start
            // pad so the tool still begins where the cutter must start.
            let path_radius = {
                let radial = cross.start.sub(*center);
                radial.sub(axis.scale(radial.dot(*axis))).length()
            };
            let (start_angle, end_angle) = if path_radius > 1e-12 {
                (start_pad / path_radius, end_pad / path_radius)
            } else {
                (0.0, 0.0)
            };
            let total = (*sweep + start_angle + end_angle).min(std::f64::consts::TAU);
            let rotated: Vec<NurbsCurve> = if start_angle > 0.0 {
                profile
                    .iter()
                    .map(|curve| rotate_curve_about_axis(curve, *center, *axis, -start_angle))
                    .collect::<Result<_, _>>()?
            } else {
                profile.to_vec()
            };
            revolve_profile_brep(&rotated, *center, *axis, total)
                .or_refuse(KernelStage::Fragment, "revolve_profile")?
        }
    };
    // Side faces are emitted in input-curve order; the blend wall is the
    // second profile curve.  Every OTHER cutter face — the two side walls
    // lying on the mates and the end caps — is scaffolding: it exists to close
    // the tool solid and must not appear on the blended solid.  It is tagged
    // so a survivor can be recognised in the boolean's output
    // (`count_cutter_scaffold`) and settled (`settle_cutter_scaffold`); the
    // tag never reaches a caller.
    let mut side_index = 0usize;
    for shell in &mut tool.shells {
        for face in &mut shell.faces {
            if side_index == 1 {
                if let Some(name) = name {
                    if face.name.is_none() {
                        face.name = Some(name.to_string());
                    }
                }
            } else {
                face.name = Some(scaffold_tag(name));
            }
            side_index += 1;
        }
    }
    Ok(tool)
}

/// Clip a concave edge's fill tool by the prism of its support face's outline
/// (lane F row 5): where the fill's contact runs past the face's outer boundary
/// into air, the blend is the fill cut back to the side planes the face is
/// bounded by — the outline, extruded along the face's normal
/// (`concave_clip_outline` admits only walls parallel to it). A hole loop of
/// the face (a through-hole the fill runs over, lCount_415) is cut out of the
/// clipped fill by its own prism, so the fill neither bridges the hole nor
/// plugs it. Each prism reaches `depth` below the face and the fill's whole
/// height above it; its faces are scaffold like the tool's own, so where they
/// survive on the walls they settle into them.
fn clip_fill_by_face_outline(
    solid: &BrepSolid,
    tool: &BrepSolid,
    face_id: u64,
    edge_id: u64,
    height: f64,
    name: Option<&str>,
) -> Result<BrepSolid, KernelRefusal> {
    let unclippable = |what: &'static str| {
        KernelRefusal::unsupported(KernelStage::Fragment, what, "the fill's clip outline cannot be built")
    };
    let face = solid
        .shells
        .iter()
        .flat_map(|shell| &shell.faces)
        .find(|face| face.id == face_id)
        .ok_or_else(|| unclippable("clip_face"))?;
    let angular = crate::KernelTolerances::for_solid(solid, 1e-7).angular;
    let loops = concave_clip_outline(solid, face, edge_id, angular).ok_or_else(|| unclippable("clip_outline"))?;
    let first_edge = face.loops[loops[0]].coedges.first().ok_or_else(|| unclippable("clip_loop"))?.edge_id;
    let first = solid.edges.iter().find(|edge| edge.id == first_edge).ok_or_else(|| unclippable("clip_edge"))?;
    let (_, normal) = face_plane_normal(face, first.curve.evaluate(first.t0).or_refuse(KernelStage::Fragment, "clip_anchor")?)?;
    let depth = height;
    let prism_of = |loop_record: &crate::topology::LoopRecord| -> Result<BrepSolid, KernelRefusal> {
        let mut profile = Vec::with_capacity(loop_record.coedges.len() + 1);
        for coedge in &loop_record.coedges {
            let border = solid.edges.iter().find(|edge| edge.id == coedge.edge_id).ok_or_else(|| unclippable("clip_edge"))?;
            let curve = crate::step::edge_subcurve(border).or_refuse(KernelStage::Fragment, "clip_subcurve")?;
            let mut curve = if coedge.forward {
                curve
            } else {
                curve.reversed().or_refuse(KernelStage::Fragment, "clip_reverse")?
            };
            // Homogeneous control points store (P·w, w): move P by −depth·normal.
            for cp in curve.control_points.iter_mut() {
                let delta = normal.scale(-depth * cp.w);
                cp.x += delta.x;
                cp.y += delta.y;
                cp.z += delta.z;
            }
            profile.push(curve);
        }
        // A loop of one closed edge (a round hole) is two halves to the extrude.
        if profile.len() == 1 {
            let [t0, t1] = profile[0].domain().or_refuse(KernelStage::Fragment, "clip_domain")?;
            let (head, tail) = profile[0].split(0.5 * (t0 + t1)).or_refuse(KernelStage::Fragment, "clip_split")?;
            profile = vec![head, tail];
        }
        let mut prism = extrude_profile_brep(&profile, normal, depth + 2.0 * height)?;
        for shell in &mut prism.shells {
            for face in &mut shell.faces {
                face.name = Some(scaffold_tag(name));
            }
        }
        Ok(prism)
    };
    let options = BooleanOptions {
        merge_coplanar_faces: false,
        ..BooleanOptions::default()
    };
    let outer = prism_of(&face.loops[loops[0]])?;
    let mut clipped = crate::boolean_operation_with_diagnostics(tool, &outer, BooleanOperation::Intersect, &options)?.value;
    for &hole in &loops[1..] {
        let prism = prism_of(&face.loops[hole])?;
        let tolerance = crate::KernelTolerances::for_solid(solid, 1e-7).model;
        if !crate::recentre::solid_bounds(&clipped).intersects(crate::recentre::solid_bounds(&prism), tolerance) {
            continue;
        }
        clipped = crate::boolean_operation_with_diagnostics(&clipped, &prism, BooleanOperation::Subtract, &options)?.value;
    }
    Ok(clipped)
}

/// Prefix of the name stamped on every cutter face except the blend wall while
/// the blend boolean runs.  A control character leads it so no authored or
/// derived face name can collide with it.
pub(super) const CUTTER_SCAFFOLD_NAME: &str = "\u{1}blend-cutter-scaffold:";

/// The scaffold tag of a cutter whose wall is named `wall`: the prefix, the
/// wall's name and a closing control character, so the wall survives the
/// boolean's `_n` fragment suffix, which lands after it.
pub(super) fn scaffold_tag(wall: Option<&str>) -> String {
    format!("{CUTTER_SCAFFOLD_NAME}{}\u{1}", wall.unwrap_or(""))
}

/// The wall name a scaffold tag carries, or `None` for a face that is not
/// scaffold.
fn scaffold_wall(name: Option<&str>) -> Option<&str> {
    let rest = name?.strip_prefix(CUTTER_SCAFFOLD_NAME)?;
    Some(rest.split('\u{1}').next().unwrap_or(""))
}

/// How many faces of a blend boolean's result carry the scaffold tag — the
/// cutter faces the boolean left standing on the blended solid.  Read only on
/// the general-first lane, whose operand never carries a tag (every earlier
/// blend on that lane settled its own), so every one counted is this cutter's.
///
/// Zero is the shape of a complete blend: the result's boundary is the
/// original solid's faces plus the blend wall, nothing else.  A survivor is a
/// bulkhead — the cutter's end cap (or a side wall) standing INSIDE the
/// material because the cutter stopped where the material did not — or an end
/// cap lying in the plane of the face the blend ends on.
fn count_cutter_scaffold(solid: &BrepSolid) -> usize {
    solid
        .shells
        .iter()
        .flat_map(|shell| &shell.faces)
        .filter(|face| scaffold_wall(face.name.as_deref()).is_some())
        .count()
}

/// Settle the cutter faces a blend left standing, by whose material each one is.
///
/// A survivor that rides the same carrier as a face it shares an edge with
/// is that face's material: the cutter's end cap lying in the plane of the face
/// a concave blend ends on (the fill's end, bounded by the arc and the two
/// straight legs to the sharp corner the blend replaced) or a side wall on its
/// mate. It merges into that face — the boolean's own same-carrier merge at the
/// blend boolean's model tolerance, which moves no boundary and so no volume —
/// and the two edges its corner vertices split along that face's boundary are
/// joined again, so the blend and a solid that never had the corner agree on
/// F/E/V. A survivor on no neighbour's carrier is a face the blend made, a cap
/// of its own, and is named `{wall}:CAP` after the wall of the edge it came
/// from, as the stripe network names its caps; with no wall name (the legacy
/// unnamed call) it stays unnamed.
///
/// A merge the checks refuse leaves every survivor in place, named as a cap.
pub(super) fn settle_cutter_scaffold(solid: BrepSolid) -> BrepSolid {
    let tagged: rustc_hash::FxHashSet<u64> = solid
        .shells
        .iter()
        .flat_map(|shell| &shell.faces)
        .filter(|face| scaffold_wall(face.name.as_deref()).is_some())
        .map(|face| face.id)
        .collect();
    if tagged.is_empty() {
        return solid;
    }
    let tolerance = crate::KernelTolerances::for_solid(&solid, BooleanOptions::default().tolerance).model;
    let corners: rustc_hash::FxHashSet<u64> = solid
        .shells
        .iter()
        .flat_map(|shell| &shell.faces)
        .filter(|face| tagged.contains(&face.id))
        .flat_map(|face| &face.loops)
        .flat_map(|loop_record| &loop_record.coedges)
        .filter_map(|coedge| solid.edges.iter().find(|edge| edge.id == coedge.edge_id))
        .flat_map(|edge| [edge.start_vertex_id, edge.end_vertex_id])
        .collect();
    let mut settled = match crate::face_merge::absorb_faces_into_carriers(&solid, tolerance, &tagged) {
        Ok(absorbed) => {
            match crate::coalesce::merge_curve_continuation_edges_at(&absorbed, tolerance, &corners) {
                Ok(joined) if joined.validate().is_empty() => joined,
                _ => absorbed,
            }
        }
        Err(_) => solid,
    };
    for shell in &mut settled.shells {
        for face in &mut shell.faces {
            if let Some(wall) = scaffold_wall(face.name.as_deref()) {
                face.name = (!wall.is_empty()).then(|| format!("{wall}:CAP"));
            }
        }
    }
    settled
}

/// Rigid rotation of a curve's control points about `axis` through `center`
/// (Rodrigues on the euclidean points; weights are unchanged).
fn rotate_curve_about_axis(
    curve: &NurbsCurve,
    center: Vec3,
    axis: Vec3,
    angle: f64,
) -> Result<NurbsCurve, KernelRefusal> {
    let (cosine, sine) = (angle.cos(), angle.sin());
    NurbsCurve::new(
        curve.degree,
        curve.knots.clone(),
        curve
            .control_points
            .iter()
            .map(|cp| {
                let point = Vec3::new(cp.x / cp.w, cp.y / cp.w, cp.z / cp.w);
                let vector = point.sub(center);
                let rotated = center
                    .add(vector.scale(cosine))
                    .add(axis.cross(vector).scale(sine))
                    .add(axis.scale(axis.dot(vector) * (1.0 - cosine)));
                crate::Vec4::from_point(rotated, cp.w)
            })
            .collect(),
    )
    .or_refuse(KernelStage::Fragment, "rotate_curve")
}

/// How far the cutter for `edge_id` must run PAST the edge's CURRENT ends to
/// cover the extent that edge had on the ORIGINAL solid.
///
/// A group blend applies its per-edge cutters in sequence, and every cutter
/// TRIMS the edges that touch it: at a shared corner the next edge in the
/// chain starts (or ends) a tangency setback short of where it did before.  A
/// flush cutter built on the trimmed edge therefore stops INSIDE the material
/// and leaves a wedge of it standing at the corner, capped by the cutter's own
/// end plane — the "one corner is not getting made" artefact.  The removal
/// volumes of adjacent blends are supposed to UNION through the corner (that
/// is what makes the miter), so each cutter is extended back to the corner the
/// edge had before its neighbours were blended.
///
/// `blocked` lists corner points that must keep the flush cutter: the STAR
/// corners (>=3 selected edges at one vertex) are closed afterwards by the
/// corner-rounding surgery, which is built against exactly the sequential
/// geometry a flush cutter leaves.
///
/// Returns zero pads when the edge is untrimmed, when its geometry is not the
/// straight/circular path the exact cutter is built on, or when the original
/// endpoints do not lie on the current edge's carrier (an edge that a boolean
/// SPLIT rather than trimmed) — in every one of those cases the historical
/// flush cutter is what gets built.
pub(super) fn tool_ends_to_original_extent(
    solid: &BrepSolid,
    edge_id: u64,
    radius: f64,
    original: (Vec3, Vec3),
    blocked: &[Vec3],
) -> ToolEnds {
    let zero = ToolEnds::default();
    let Ok(cross) = analyze_edge(solid, edge_id, radius) else {
        return zero;
    };
    let Some(edge) = solid.edges.iter().find(|edge| edge.id == edge_id) else {
        return zero;
    };
    if edge.start_vertex_id == edge.end_vertex_id {
        // Closed edge (a full circle): no ends to extend.
        return zero;
    }
    let (Ok(current_start), Ok(current_end)) =
        (edge.curve.evaluate(edge.t0), edge.curve.evaluate(edge.t1))
    else {
        return zero;
    };
    // Arc-length station of a point along the edge path, measured from the
    // current start (negative before it, > length past the current end), plus
    // its distance off the carrier.
    let station = |point: Vec3| -> Option<(f64, f64)> {
        match &cross.path {
            EdgePath::Straight { direction, .. } => {
                let offset = point.sub(current_start);
                let along = offset.dot(*direction);
                Some((along, offset.sub(direction.scale(along)).length()))
            }
            EdgePath::Circular { center, axis, .. } => {
                let radial = |p: Vec3| {
                    let v = p.sub(*center);
                    v.sub(axis.scale(v.dot(*axis)))
                };
                let from = radial(current_start);
                let to = radial(point);
                let path_radius = from.length();
                if path_radius <= 1e-12 {
                    return None;
                }
                let mut angle = from.cross(to).dot(*axis).atan2(from.dot(to));
                // The edge sweeps in +axis; a station just before the start
                // reads as a small NEGATIVE angle rather than nearly a turn.
                if angle > std::f64::consts::PI {
                    angle -= std::f64::consts::TAU;
                }
                let off_axis =
                    (point.sub(*center).dot(*axis)) - (current_start.sub(*center).dot(*axis));
                let off_circle = (to.length() - path_radius).hypot(off_axis);
                Some((angle * path_radius, off_circle))
            }
        }
    };
    let length = match &cross.path {
        EdgePath::Straight { length, .. } => *length,
        EdgePath::Circular { .. } => match station(current_end) {
            Some((along, _)) if along > 0.0 => along,
            _ => return zero,
        },
    };
    if !(length > 0.0) {
        return zero;
    }
    let tolerance = 1e-6 * (1.0 + length);
    let (Some((a, a_off)), Some((b, b_off))) = (station(original.0), station(original.1)) else {
        return zero;
    };
    if a_off > tolerance || b_off > tolerance {
        return zero;
    }
    let ((low, low_point), (high, high_point)) = if a <= b {
        ((a, original.0), (b, original.1))
    } else {
        ((b, original.1), (a, original.0))
    };
    // The original extent must CONTAIN the current one: anything else means
    // the point resolved to a different edge (a split), not a trimmed end.
    if low > tolerance || high < length - tolerance {
        return zero;
    }
    let is_blocked = |point: Vec3| {
        blocked
            .iter()
            .any(|corner| corner.sub(point).length() < 1e-6)
    };
    ToolEnds {
        start: if is_blocked(low_point) {
            0.0
        } else {
            (-low).max(0.0)
        },
        end: if is_blocked(high_point) {
            0.0
        } else {
            (high - length).max(0.0)
        },
    }
}

/// `BREP_CHAMFER_THROUGH_END_FACES` (default on; `=0` restores): a lone
/// chamfer of a straight edge runs on to the faces its ends meet.
///
/// A chamfer made after its neighbour (brep-bench `chamfer/box-top-asymmetric`,
/// `chamfer/octahedron-all-edges-mitered`) is on an edge the neighbour already
/// trimmed: the edge ends on the neighbour's slanted chamfer face, while the
/// chamfer's own rails, the lines at its setbacks on the two faces, run on along
/// those faces until they meet it. A cutter as long as the edge stops short of
/// that and leaves a wedge of material capped by its own end plane, and the
/// march caps the stripe at the same place.
pub(super) fn chamfer_through_end_faces_on() -> bool {
    switch!("BREP_CHAMFER_THROUGH_END_FACES", true)
}


/// How far one rail of a straight edge's chamfer runs on past each end of the
/// edge before it leaves the planar face it lies on: `(past the start, past
/// the end)`, each negative where the rail leaves the face short of that end
/// (the face was cut back there by an earlier chamfer the edge's end meets).
///
/// `rail` is the rail's point in the cross-section at the edge's start and
/// `direction` the edge's; the rail is `rail + s·direction` for `s` in
/// `[0, length]` along the edge. The crossings of that line with the face's
/// boundary (every loop, each edge sampled) bound the stretch of it inside the
/// face that holds the edge's middle. `None` when neither of `faces` is a plane
/// through the rail, or the line does not leave the face on both sides.
fn rail_overrun(
    solid: &BrepSolid,
    faces: &[&FaceRecord],
    rail: Vec3,
    direction: Vec3,
    length: f64,
    scale: f64,
) -> Option<(f64, f64)> {
    let face = faces.iter().find(|face| match face.surface.analytic() {
        Some(crate::AnalyticSurface::Plane { origin, u_dir, v_dir, .. }) => u_dir
            .cross(*v_dir)
            .normalized()
            .is_ok_and(|normal| rail.sub(*origin).dot(normal).abs() <= 1e-7 * scale),
        _ => false,
    })?;
    let Some(crate::AnalyticSurface::Plane { u_dir, v_dir, .. }) = face.surface.analytic() else {
        return None;
    };
    // The in-plane direction square to the edge: a boundary point's offset
    // from the rail line along it, and its station along the edge.
    let across = u_dir.cross(*v_dir).cross(direction).normalized().ok()?;
    let mut stations = Vec::new();
    for coedge in face.loops.iter().flat_map(|loop_record| &loop_record.coedges) {
        let edge = solid.edges.iter().find(|edge| edge.id == coedge.edge_id)?;
        if edge.degenerate {
            continue;
        }
        const SAMPLES: usize = 32;
        let mut previous: Option<(f64, f64)> = None;
        for index in 0..=SAMPLES {
            let t = edge.t0 + (edge.t1 - edge.t0) * index as f64 / SAMPLES as f64;
            let point = edge.curve.evaluate(t).ok()?.sub(rail);
            // A boundary vertex ON the rail line (a corner the rail passes
            // through) reads ±1e-16 off it: snapped, it is a crossing.
            let off = point.dot(across);
            let here = (if off.abs() <= 1e-9 * scale { 0.0 } else { off }, point.dot(direction));
            if let Some((off_a, along_a)) = previous {
                let (off_b, along_b) = here;
                if off_a == 0.0 && off_b == 0.0 {
                    stations.extend([along_a, along_b]);
                } else if (off_a <= 0.0 && off_b >= 0.0) || (off_a >= 0.0 && off_b <= 0.0) {
                    let s = off_a / (off_a - off_b);
                    stations.push(along_a + (along_b - along_a) * s);
                }
            }
            previous = Some(here);
        }
    }
    let middle = 0.5 * length;
    let low = stations.iter().copied().filter(|&s| s < middle).fold(f64::NEG_INFINITY, f64::max);
    let high = stations.iter().copied().filter(|&s| s > middle).fold(f64::INFINITY, f64::min);
    if !low.is_finite() || !high.is_finite() {
        return None;
    }
    Some((-low, high - length))
}

/// The lone straight chamfer cut through to the faces its ends meet
/// (`chamfer_through_end_faces_on`): the cutter of `profile` padded at each end
/// past where either rail leaves its face, by a quarter, one and then four times
/// the larger setback more, until its end caps clear the solid. At the last
/// chamfer of a mitered corner the edge starts where the rails have already
/// left their faces, and the wedge still holds material behind that start.
///
/// Answers only when the padding is needed (a rail runs on past an end of the
/// edge, or leaves its face short of it) and the cut is complete: the result validates and NOTHING of the
/// cutter but its wall stands on it. Where the material really continues past
/// an end (a concave corner, a face that runs on around it), the padded cutter
/// leaves its scaffold standing, and the caller's own construction answers.
pub(super) fn chamfer_through_end_faces(
    solid: &BrepSolid,
    edge_id: u64,
    cross: &EdgeCross,
    profile: &[NurbsCurve],
    name: Option<&str>,
) -> Option<BrepSolid> {
    if !chamfer_through_end_faces_on() || !cross.convex {
        return None;
    }
    let EdgePath::Straight { direction, length } = &cross.path else {
        return None;
    };
    let wall = profile.get(1)?;
    let [w0, w1] = wall.domain().ok()?;
    let rails = [wall.evaluate(w0).ok()?, wall.evaluate(w1).ok()?];
    let setback = rails.iter().map(|rail| rail.sub(cross.start).length()).fold(0.0, f64::max);
    let scale = 1.0 + length + setback;
    let (edge, faces) = super::analyze::edge_and_faces(solid, edge_id).ok()?;
    // An edge SPLIT by a vertex (a boolean operand's vertex on it) continues
    // past that end as another edge between the same two faces: the rails run
    // on along the continuation, and the padded cutter would chamfer the whole
    // line where one piece was asked for. Such an end is not a corner; decline.
    let borders = |face: &FaceRecord, other: u64| {
        face.loops.iter().flat_map(|loop_record| &loop_record.coedges).any(|coedge| coedge.edge_id == other)
    };
    let ends_at = [edge.start_vertex_id, edge.end_vertex_id];
    let split = solid.edges.iter().any(|other| {
        other.id != edge_id
            && !other.degenerate
            && (ends_at.contains(&other.start_vertex_id) || ends_at.contains(&other.end_vertex_id))
            && faces.iter().all(|face| borders(face, other.id))
    });
    if split {
        return None;
    }
    // Per end, the furthest a rail runs on past it, and whether either rail
    // does not end there (runs on, or leaves its face short of it): a square
    // end face, where the flush cutter is right, has both rails end with the
    // edge.
    let tolerance = 1e-9 * scale;
    let mut ends = ToolEnds::default();
    let mut needed = [false, false];
    for rail in rails {
        let (start, end) = rail_overrun(solid, &faces, rail, *direction, *length, scale)?;
        ends.start = ends.start.max(start);
        ends.end = ends.end.max(end);
        needed[0] |= start.abs() > tolerance;
        needed[1] |= end.abs() > tolerance;
    }
    if needed == [false, false] {
        return None;
    }
    for margin in [0.25, 1.0, 4.0].map(|share| share * setback) {
        let padded = ToolEnds {
            start: if needed[0] { ends.start + margin } else { 0.0 },
            end: if needed[1] { ends.end + margin } else { 0.0 },
        };
        let tool = build_exact_tool(cross, profile, 0.0, padded, name).ok()?;
        let Ok(result) = apply_tool_exact(solid, &tool, cross.convex) else {
            continue;
        };
        if count_cutter_scaffold(&result) == 0 && result.validate().is_empty() {
            return Some(result);
        }
    }
    None
}

fn fillet_or_chamfer_exact(
    solid: &BrepSolid,
    edge_id: u64,
    radius: f64,
    chamfer: bool,
    name: Option<&str>,
    ends: ToolEnds,
    lane: Lane,
) -> Result<BrepSolid, KernelRefusal> {
    let cross = analyze_edge(solid, edge_id, radius)?;
    let clip = if chamfer || ends != ToolEnds::default() {
        None
    } else {
        concave_clip_face(solid, edge_id, radius)
    };
    let profile = match full_round_profile(&cross, radius, chamfer)? {
        Some(profile) => profile,
        None => cross_section_profile(&cross, radius, chamfer)?,
    };
    // Straight edges: try a flush tool first (the workhorse box/prism case,
    // where the end caps land coincident on transverse end faces and the
    // boolean handles them), then retry with a small overshoot if that
    // subtract cannot assemble a valid solid — the overshoot rescues
    // degenerate termini (revolve axis-junction poles) without disturbing the
    // flush cases.  Circular edges are closed loops with no free ends.
    let overshoots: &[f64] = match &cross.path {
        EdgePath::Straight { .. } => &[0.0, radius],
        EdgePath::Circular { .. } => &[0.0],
    };
    // A LONE blend (the single-edge lane, no group pad on its ends) must run
    // THROUGH whatever bounds the material at its ends: where the flush cutter
    // assembles but leaves its own end cap standing on the result, the
    // material continued past the end face — the slab's top face met a
    // tangent blend a hair before the rail's tangency setback (2026-09-06
    // report: an r = 10.5 round on a 1.5 mm rim whose flat top ends at z = 10
    // and rolls into an r = 10 blend) — and the flush cut is a bulkhead
    // inside the part, not a blend.  The overshoot cutter reaches past that
    // end and is accepted when NOTHING of it but the wall survives: the
    // result is then bounded by the original faces and the blend surface
    // alone, which is the definition of a complete blend.  If the overshoot
    // leaves scaffold standing too, the material really does continue and
    // the flush cut (which at least stops at the end face) is kept, exactly
    // as before.  A group's sequential composition keeps the flush cut
    // unconditionally: its corner closures are built against the bulkhead
    // the next cutter in the chain removes.
    let prefer_through = lane == Lane::GeneralFirst && ends == ToolEnds::default();
    // Walk the ladder TWICE.  The first pass assembles each cutter with the
    // exact arrangement only, so a flush tool that hits a terminus degeneracy
    // falls through to the overshoot tool — whose end caps cut the pole faces
    // transversally — instead of being rescued by a bodily TRANSLATED cutter
    // (the Simulation-of-Simplicity lane inside `boolean_operation`), which
    // would leave the blend wall off its supports.  Only when no rung of the
    // ladder assembles exactly do we allow that perturbed rescue, so every
    // selection that used to succeed still does.
    // Every rung of the ladder below writes this before it is read: the
    // overshoot list is never empty.  The empty seed carries no text.
    let mut last_error = KernelRefusal::internal(KernelStage::Fragment, "cutter", String::new());
    let mut capped: Option<BrepSolid> = None;
    for exact_only in [true, false] {
        for (attempt, &overshoot) in overshoots.iter().enumerate() {
            let tool = build_exact_tool(&cross, &profile, overshoot, ends, name)?;
            let tool = match clip {
                Some(face) => clip_fill_by_face_outline(solid, &tool, face, edge_id, 2.0 * radius, name)?,
                None => tool,
            };
            let assembled = if exact_only {
                apply_tool_exact(solid, &tool, cross.convex)
            } else {
                apply_tool(solid, &tool, cross.convex)
            };
            match assembled {
                Ok(result) => {
                    let survivors = count_cutter_scaffold(&result);
                    if !prefer_through {
                        return Ok(result);
                    }
                    // The through cut is taken only as a VALID solid; a flush
                    // cut that assembled with a bulkhead is otherwise kept.
                    if survivors == 0 && (capped.is_none() || result.validate().is_empty()) {
                        return Ok(result);
                    }
                    if capped.is_none() {
                        capped = Some(result);
                    }
                    // A bulkhead standing on the result is the cut contradicting
                    // what a complete blend is (the header above): a check that
                    // tripped, never a refusal of the input.
                    last_error = KernelRefusal::internal(
                        KernelStage::Validate,
                        "cutter_scaffold",
                        format!(
                            "the cutter left {survivors} of its own faces standing on the result \
                             (overshoot {overshoot})"
                        ),
                    );
                }
                Err(error) => {
                    last_error = if exact_only && attempt == 0 {
                        error
                    } else {
                        // The retry's own class survives; the earlier rung's
                        // text is kept in front of it.
                        error.with_message(|error| {
                            format!("{last_error}; overshoot retry also failed: {error}")
                        })
                    };
                }
            }
        }
        // An exactly assembled cut, bulkhead and all, beats a perturbed one.
        if let Some(result) = capped.take() {
            return Ok(result);
        }
    }
    Err(last_error)
}