ogeom_fillet/

chamfer.rs

//! Chamfers: the bevel that replaces an edge.
//!
//! A chamfer along a straight edge between two planar faces is a wedge
//! subtracted, and the wedge's own faces lie *exactly* on the solid's
//! (coplanar, materials aligned), which is the boolean's same-domain case.
//!
//! Three spellings, one construction. The symmetric chamfer cuts the same
//! distance along both faces; the distance-distance form cuts a named
//! distance along a named face and another along its neighbour; the
//! distance-angle form cuts a distance along the named face and leaves it at
//! an angle, with the second distance derived where that bevel meets the
//! other face. All three end in the same wedge subtraction.
//!
//! Two seats per spelling. A straight edge between planes takes the
//! triangular prism above; the circular rim where a coaxial cylinder or cone
//! meets a perpendicular planar cap takes a revolved wedge whose bevel is a
//! *cone*, its leg on a cone's wall running along the slant:
//! the same flanks the rim fillet builds, with the quarter-tube exchanged
//! for the slant, and the same melt taking the legs away.

use crate::chamfer_sphere::{SphereSeat, sphere_bevel, sphere_seat};
use crate::support::{
    Blamed, RevolvedSeat, Seat, apply_wedge, edge_curve, planar_face, planar_seat, revolved_flanks,
    revolved_seat,
};
use ogeom_algo::{Built, make_revolution_band};
use ogeom_core::{OgeomResult, Tolerances, ogeom_bail};
use ogeom_geom::{ConeSurface, Curve, SurfaceGeometry};
use ogeom_math::{Cone, Direction, Frame};
use ogeom_topo::{Model, Shape};

/// Bevel a straight edge of a solid, cutting `distance` back along each of
/// its two faces.
///
/// The edge must be straight, convex, and shared by exactly two planar faces;
/// the distances are equal (the symmetric chamfer). The result is the boolean
/// difference with a wedge whose legs run along the two faces, so the
/// history reads as a cut: the two faces are modified into their trimmed
/// pieces, the edge's neighbourhood gains the bevel face.
///
/// A seam (an edge between two faces of one shell on one surface facing
/// one way, as a boolean leaves where it joined two flats) is no edge of
/// the part's form, and naming one names nothing: the solid comes back as
/// it is. See [`chamfer_edges_with`].
///
/// What `solid` shares with other shapes is copied before it is
/// worked on ([`ogeom_algo::on_own_nodes`]), which leaves them as they are.
///
/// # Errors
///
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) if the edge is
/// not straight, not convex, not shared by exactly two planar faces of
/// `solid`, or `distance` is not a usable length.
pub fn chamfer_edge(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    distance: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    ogeom_algo::on_own_nodes(
        model,
        solid,
        std::slice::from_ref(edge),
        |model, solid, parts| chamfer_edge_own(model, solid, &parts[0], distance, tol),
    )
}

/// [`chamfer_edge`] on a shape every node below which is its own.
fn chamfer_edge_own(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    distance: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    if crate::engine::is_seam(model, solid, edge, tol)? {
        return Ok(unchanged(solid));
    }
    let specs = [(edge.clone(), Chamfer::Symmetric(distance))];
    if let Some(built) = engine_chamfer(model, solid, &specs, tol)? {
        return Ok(built);
    }
    wedge_for(model, solid, edge, &specs[0].1, tol)?.apply(model, solid, edge, tol)
}

/// Bevel a straight edge, cutting `on_face` back along `face` and `on_other`
/// along the edge's other face.
///
/// The asymmetric chamfer: `face` names which side the first distance applies
/// to, and must be one of the two faces meeting at the edge.
///
/// What `solid` shares with other shapes is copied before it is
/// worked on ([`ogeom_algo::on_own_nodes`]), which leaves them as they are.
///
/// # Errors
///
/// As [`chamfer_edge`], and additionally if `face` is not one of the edge's
/// two faces.
pub fn chamfer_edge_distances(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    face: &Shape,
    on_face: f64,
    on_other: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    ogeom_algo::on_own_nodes(
        model,
        solid,
        &[edge.clone(), face.clone()],
        |model, solid, parts| {
            chamfer_edge_distances_own(model, solid, &parts[0], &parts[1], on_face, on_other, tol)
        },
    )
}

/// [`chamfer_edge_distances`] on a shape every node below which is its own.
fn chamfer_edge_distances_own(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    face: &Shape,
    on_face: f64,
    on_other: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    let spec = Chamfer::Distances {
        face: face.clone(),
        on_face,
        on_other,
    };
    if crate::engine::is_seam(model, solid, edge, tol)? {
        return Ok(unchanged(solid));
    }
    let specs = [(edge.clone(), spec)];
    if let Some(built) = engine_chamfer(model, solid, &specs, tol)? {
        return Ok(built);
    }
    wedge_for(model, solid, edge, &specs[0].1, tol)?.apply(model, solid, edge, tol)
}

/// Bevel a straight edge, cutting `distance` back along `face` and leaving it
/// at `angle` radians from that face.
///
/// The distance-angle chamfer: the second distance is where the bevel,
/// departing the named face at the given angle, meets the other face. An
/// angle of `π/4` on a square edge reproduces the symmetric chamfer.
///
/// What `solid` shares with other shapes is copied before it is
/// worked on ([`ogeom_algo::on_own_nodes`]), which leaves them as they are.
///
/// # Errors
///
/// As [`chamfer_edge_distances`], and additionally if the bevel at that angle
/// never reaches the other face.
pub fn chamfer_edge_angle(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    face: &Shape,
    distance: f64,
    angle: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    ogeom_algo::on_own_nodes(
        model,
        solid,
        &[edge.clone(), face.clone()],
        |model, solid, parts| {
            chamfer_edge_angle_own(model, solid, &parts[0], &parts[1], distance, angle, tol)
        },
    )
}

/// [`chamfer_edge_angle`] on a shape every node below which is its own.
fn chamfer_edge_angle_own(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    face: &Shape,
    distance: f64,
    angle: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    let spec = Chamfer::Angle {
        face: face.clone(),
        distance,
        angle,
    };
    if crate::engine::is_seam(model, solid, edge, tol)? {
        return Ok(unchanged(solid));
    }
    let specs = [(edge.clone(), spec)];
    if let Some(built) = engine_chamfer(model, solid, &specs, tol)? {
        return Ok(built);
    }
    wedge_for(model, solid, edge, &specs[0].1, tol)?.apply(model, solid, edge, tol)
}

/// The shapes chamfer specs name: each edge, then the face its chamfer
/// runs along where it names one.
fn chamfer_parts(specs: &[(Shape, Chamfer)]) -> Vec<Shape> {
    let mut parts = Vec::with_capacity(specs.len() * 2);
    for (edge, spec) in specs {
        parts.push(edge.clone());
        match spec {
            Chamfer::Symmetric(_) => {}
            Chamfer::Distances { face, .. } | Chamfer::Angle { face, .. } => {
                parts.push(face.clone());
            }
        }
    }
    parts
}

/// The specs again, naming `parts` in the order [`chamfer_parts`] lists
/// them.
fn chamfer_specs(specs: &[(Shape, Chamfer)], parts: &[Shape]) -> Vec<(Shape, Chamfer)> {
    let mut parts = parts.iter().cloned();
    let mut next = |was: &Shape| parts.next().unwrap_or_else(|| was.clone());
    specs
        .iter()
        .map(|(edge, spec)| {
            let edge = next(edge);
            let spec = match spec {
                Chamfer::Symmetric(d) => Chamfer::Symmetric(*d),
                Chamfer::Distances {
                    face,
                    on_face,
                    on_other,
                } => Chamfer::Distances {
                    face: next(face),
                    on_face: *on_face,
                    on_other: *on_other,
                },
                Chamfer::Angle {
                    face,
                    distance,
                    angle,
                } => Chamfer::Angle {
                    face: next(face),
                    distance: *distance,
                    angle: *angle,
                },
            };
            (edge, spec)
        })
        .collect()
}

/// One edge's chamfer, in any of the three spellings.
#[derive(Debug, Clone)]
pub enum Chamfer {
    /// The same distance back along both faces, as [`chamfer_edge`].
    Symmetric(f64),
    /// `on_face` along `face` and `on_other` along the other face, as
    /// [`chamfer_edge_distances`].
    Distances {
        /// The face the first distance runs along.
        face: Shape,
        /// The distance along `face`.
        on_face: f64,
        /// The distance along the edge's other face.
        on_other: f64,
    },
    /// `distance` along `face`, leaving it at `angle` radians, as
    /// [`chamfer_edge_angle`].
    Angle {
        /// The face the distance runs along.
        face: Shape,
        /// The distance along `face`.
        distance: f64,
        /// The bevel's angle from `face`, in radians.
        angle: f64,
    },
}

/// Bevel several edges of a solid as one operation, each by `distance`.
///
/// As [`chamfer_edges_with`] with the symmetric chamfer on every edge.
///
/// # Errors
///
/// As [`chamfer_edges_with`].
pub fn chamfer_edges(
    model: &mut Model,
    solid: &Shape,
    edges: &[Shape],
    distance: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    let specs: Vec<(Shape, Chamfer)> = edges
        .iter()
        .map(|e| (e.clone(), Chamfer::Symmetric(distance)))
        .collect();
    chamfer_edges_with(model, solid, &specs, tol)
}

/// Bevel several edges of a solid as one operation, each with its own
/// chamfer.
///
/// The whole request is read on the solid as it stands before the call, so
/// the result is the same for every order of `specs`. Where two bevels meet
/// at a vertex they mitre along the line their planes share, with neither a
/// step nor a cap, at a face's reflex corner as at a convex one. Where three
/// or more meet, the vertex is closed by the facet through the points where
/// their contact lines cross on the faces round it
/// ([`ChamferCorner::Facet`](crate::ChamferCorner::Facet)); the mitre of
/// their planes is [`chamfer_edges_cornered`](crate::chamfer_edges_cornered)
/// with [`ChamferCorner::Point`](crate::ChamferCorner::Point).
///
/// A solid bounded by planes is chamfered by the blend engine in one pass:
/// every face set back from its bevelled edges, every bevel the plane
/// between its two setback lines, every vertex of three bevels its facet. A
/// request past what its faces hold (a face its setbacks consume), and any
/// other solid, are chamfered by wedges built on the solid as given and
/// applied together, mitred where bevels meet.
///
/// A seam is no edge of the part's form: an edge between two faces of one
/// shell lying on one surface facing one way
/// ([`ogeom_heal::same_domain`]), as a boolean leaves where it joined two
/// flats, the surface running on across it and the material on one side.
/// Mainstream CAD merges such faces after the boolean, so the edge cannot
/// be picked; here a spec naming one names nothing and is passed over, and
/// a request naming nothing but seams returns the solid as it is. A solid
/// holding seams is read by the blend engine with them dissolved, as
/// [`ogeom_heal::unify_same_domain`] and [`ogeom_heal::merge_edges`] merge
/// them: the faces on one plane come out one face, the pieces of an edge
/// split along its length one bevel, and the history tells of the solid
/// as given (each face modified into the face holding it, each seam and
/// each vertex the seams left inside an edge deleted). Coplanar faces
/// facing opposite ways, the material changing side across the edge
/// between them, meet at a real edge.
///
/// What `solid` shares with other shapes is copied before it is
/// worked on ([`ogeom_algo::on_own_nodes`]), which leaves them as they are.
///
/// # Errors
///
/// As [`chamfer_edge`], [`chamfer_edge_distances`] and
/// [`chamfer_edge_angle`] per edge, judged on the solid as it stands before
/// the call; and [`OgeomError::Construction`](ogeom_core::OgeomError::Construction)
/// if no edges are given.
pub fn chamfer_edges_with(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> OgeomResult<Built> {
    chamfer_edges_blamed(model, solid, specs, tol).map_err(|blamed| blamed.error)
}

/// [`chamfer_edges_with`], its refusal naming the specs it concerns.
///
/// A solid bounded by planes goes through the blend engine
/// ([`crate::engine`]): one pass by setbacks, each vertex of three bevels
/// closed by a facet. Any other solid is chamfered by wedges, mitred.
pub(crate) fn chamfer_edges_blamed(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> Result<Built, Blamed> {
    if specs.is_empty() {
        return Err(
            ogeom_core::ogeom_err!(Construction, "a chain of no edges bevels nothing").into(),
        );
    }
    let (specs, index) = without_seams(model, solid, specs, tol)?;
    if specs.is_empty() {
        return Ok(unchanged(solid));
    }
    if let Some(built) = engine_chamfer(model, solid, &specs, tol)? {
        return Ok(built);
    }
    chamfer_edges_mitred_blamed(model, solid, &specs, tol).map_err(|mut blamed| {
        for i in &mut blamed.edges {
            *i = index[*i];
        }
        blamed
    })
}

/// Chamfer specs, each edge with its chamfer.
pub(crate) type Specs = Vec<(Shape, Chamfer)>;

/// `specs` without those naming a seam of `solid` (an edge between two
/// faces on one surface facing one way, no edge of the part's form), with
/// the index in `specs` of each kept.
pub(crate) fn without_seams(
    model: &Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> OgeomResult<(Specs, Vec<usize>)> {
    let mut kept = Vec::with_capacity(specs.len());
    let mut index = Vec::with_capacity(specs.len());
    for (i, spec) in specs.iter().enumerate() {
        if !crate::engine::is_seam(model, solid, &spec.0, tol)? {
            kept.push(spec.clone());
            index.push(i);
        }
    }
    Ok((kept, index))
}

/// `solid` as given: what a request naming nothing but seams makes.
pub(crate) fn unchanged(solid: &Shape) -> Built {
    let mut built = Built::from_nothing(solid.clone());
    built.history.modify(solid, solid.clone());
    built
}

/// The chamfer of `specs` by the blend engine, or `None` where the solid
/// or a spec lies outside its classes. A solid holding seams is chamfered
/// with them dissolved, as [`ogeom_heal::unify_same_domain`] merges them;
/// no spec may name a seam.
pub(crate) fn engine_chamfer(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> OgeomResult<Option<Built>> {
    use crate::engine::Dissolved;
    match crate::engine::dissolve(model, solid, tol)? {
        Dissolved::Plain => {
            let Some(request) = crate::engine::Request::from_chamfers(model, solid, specs, tol)?
            else {
                return Ok(None);
            };
            crate::engine::run(model, solid, &request, tol)
        }
        Dissolved::Outside => Ok(None),
        Dissolved::Into(seamless) => {
            let Some(specs) = seamless.specs(specs) else {
                return Ok(None);
            };
            let Some(request) =
                crate::engine::Request::from_chamfers(model, &seamless.solid, &specs, tol)?
            else {
                return Ok(None);
            };
            let Some(built) = crate::engine::run(model, &seamless.solid, &request, tol)? else {
                return Ok(None);
            };
            Ok(Some(Built::new(
                built.shape,
                seamless.carry(&built.history),
            )))
        }
    }
}

/// The chamfer of `specs` by wedges built on the solid as given and
/// applied together, mitred where bevels meet: three bevels at a convex
/// vertex meet at the point their planes share.
pub(crate) fn chamfer_edges_mitred(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> OgeomResult<Built> {
    chamfer_edges_mitred_blamed(model, solid, specs, tol).map_err(|blamed| blamed.error)
}

/// [`chamfer_edges_mitred`], its refusal naming the specs it concerns.
fn chamfer_edges_mitred_blamed(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> Result<Built, Blamed> {
    let mut blame = Vec::new();
    ogeom_algo::on_own_nodes(
        model,
        solid,
        &chamfer_parts(specs),
        |model, solid, parts| {
            chamfer_edges_with_own(model, solid, &chamfer_specs(specs, parts), tol).map_err(
                |blamed| {
                    blame = blamed.edges;
                    blamed.error
                },
            )
        },
    )
    .map_err(|error| Blamed {
        edges: blame,
        error,
    })
}

/// [`chamfer_edges_with`] on a shape every node below which is its own.
///
/// A wedge refused names its spec; one that does not apply names its
/// spec, then the specs before it whose edges share a vertex with its
/// edge, whose bevels it was applied after.
fn chamfer_edges_with_own(
    model: &mut Model,
    solid: &Shape,
    specs: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> Result<Built, Blamed> {
    if specs.is_empty() {
        return Err(
            ogeom_core::ogeom_err!(Construction, "a chain of no edges bevels nothing").into(),
        );
    }
    let mut wedges = Vec::with_capacity(specs.len());
    for (i, (edge, spec)) in specs.iter().enumerate() {
        wedges.push(
            wedge_for(model, solid, edge, spec, tol).map_err(|error| Blamed {
                edges: vec![i],
                error,
            })?,
        );
    }
    // A bevel on a marched seat is built against the solid as it stands
    // when its turn comes: its edge is found again there, between the faces
    // it lay between as asked.
    let marched = specs
        .iter()
        .any(|(edge, _)| matches!(seat_kind(model, edge, tol), Ok(SeatKind::Marched)));
    let given = if marched {
        let mut given = Vec::with_capacity(specs.len());
        for (edge, _) in specs {
            given.push(faces_holding(model, solid, edge)?);
        }
        given
    } else {
        Vec::new()
    };
    let mut built = Built::from_nothing(solid.clone());
    let mut rings: Vec<(usize, WholeRing)> = Vec::new();
    for (i, ((edge, _), wedge)) in specs.iter().zip(wedges).enumerate() {
        // The arcs a boolean split one sphere rim into each chamfer the
        // whole ring: the first cuts it, the others asking the same legs
        // are taken with it, and others asking other legs contradict it.
        if let Some(ring) = wedge.whole_ring {
            if let Some((j, first)) = rings.iter().find(|(_, r)| r.same_circle(&ring, tol)) {
                if first.same_legs(&ring, tol) {
                    continue;
                }
                return Err(Blamed {
                    edges: vec![i, *j],
                    error: ogeom_core::ogeom_err!(
                        Construction,
                        "two arcs of one sphere rim ask for different chamfers \
                         of its whole ring"
                    ),
                });
            }
            rings.push((i, ring));
        }
        let applied = match &wedge.marched {
            Some(spec) => marched_step(model, &built, edge, spec, &given[i], &specs[..i], tol),
            None => wedge.apply(model, &built.shape, edge, tol),
        };
        let step = match applied {
            Ok(step) => step,
            Err(error) => {
                let mut edges = vec![i];
                let ends = |e: &Shape| -> OgeomResult<Vec<ogeom_topo::TShapeId>> {
                    Ok(ogeom_algo::edge_vertices(model, e)?
                        .map(|(a, b)| vec![a.node(), b.node()])
                        .unwrap_or_default())
                };
                let own = ends(edge)?;
                for (j, (other, _)) in specs[..i].iter().enumerate() {
                    if ends(other)?.iter().any(|v| own.contains(v)) {
                        edges.push(j);
                    }
                }
                return Err(Blamed { edges, error });
            }
        };
        built = Built {
            shape: step.shape.clone(),
            history: built.history.then(&step.history),
        };
    }
    Ok(built)
}

/// The seat of a rim's bevel: a revolved seat, its wall a cylinder or a
/// cone, or a sphere centred on the rim's axis.
enum RimSeat {
    Revolved(RevolvedSeat),
    Sphere(SphereSeat),
}

fn rim_seat(
    model: &Model,
    solid: &Shape,
    edge: &Shape,
    rim: &ogeom_geom::CircleCurve,
    tol: Tolerances,
) -> OgeomResult<RimSeat> {
    match revolved_seat(model, solid, edge, rim, tol) {
        Ok(seat) => Ok(RimSeat::Revolved(seat)),
        Err(refused) => match sphere_seat(model, solid, edge, rim, tol)? {
            Some(seat) => Ok(RimSeat::Sphere(seat)),
            None => Err(refused),
        },
    }
}

/// How far along the axis a leg of `on_wall` down the wall's ruling
/// reaches: the leg itself on a cylinder, its run along the slant on a
/// cone.
fn wall_depth(seat: &RevolvedSeat, on_wall: f64) -> f64 {
    if seat.slope == 0.0 {
        on_wall
    } else {
        on_wall / seat.slope.hypot(1.0)
    }
}

/// The angle at the rim between the cap's leg and the wall's, in the
/// rim's section: square on a cylinder, and on a cone the cone's lean
/// from it, obtuse where the wall leans out under the cap.
fn rim_corner(seat: &RevolvedSeat) -> f64 {
    // In the section, the cap's leg runs `-sigma tau` radially and the
    // wall's runs `(-slope tau, -tau)`, both from the rim.
    (seat.sigma * seat.slope / seat.slope.hypot(1.0)).acos()
}

/// The wedge one chamfer cuts, built on `solid` as it stands.
fn wedge_for(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    spec: &Chamfer,
    tol: Tolerances,
) -> OgeomResult<Wedge> {
    match legs(model, solid, edge, spec, tol)? {
        Legs::Straight(seat, distances) => bevel(model, &seat, distances, tol),
        Legs::Rim(seat, on_wall, on_cap) => {
            revolved_bevel(model, solid, edge, &seat, on_wall, on_cap, tol)
        }
        Legs::Marched => Ok(Wedge {
            faces: Vec::new(),
            solid: None,
            additive: false,
            whole_ring: None,
            marched: Some(spec.clone()),
        }),
        Legs::Sphere(seat, on_wall, on_cap) => {
            // Each contact stays on its face at every station the walk
            // reads, or the wedge would cut past the face.
            let per = |face: &Shape| sphere_leg(&seat, face, on_wall, on_cap);
            if crate::fits::legs_largest(model, solid, edge, 1.0, per, tol)? < 1.0 {
                ogeom_bail!(
                    Construction,
                    "a chamfer on the rim between a plane and a sphere runs past \
                     one of its faces"
                );
            }
            let closed =
                ogeom_algo::edge_vertices(model, edge)?.is_some_and(|(a, b)| a.is_same(&b));
            let Curve::Circle(rim) = edge_curve(model, edge, tol)?.0 else {
                ogeom_bail!(Construction, "a sphere's rim is not a circle");
            };
            let whole = closed
                || crate::chamfer_sphere::rim_closes(model, solid, &seat, &rim.circle(), tol)?;
            // An arc that stops short of its circle is the section turned
            // through the arc's own sweep.
            let span = if whole {
                None
            } else {
                let frame =
                    Frame::new(seat.centre, Direction::new(seat.up, tol)?, seat.x_ref, tol)?;
                Some(arc_window(model, edge, &frame, tol)?)
            };
            Ok(Wedge {
                faces: sphere_bevel(model, &seat, on_wall, on_cap, span, tol)?,
                solid: None,
                additive: seat.tau < 0.0,
                whole_ring: whole.then_some(WholeRing {
                    centre: seat.centre,
                    radius: seat.radius,
                    up: seat.up,
                    on_wall,
                    on_cap,
                }),
                marched: None,
            })
        }
    }
}

/// How far a sphere seat's bevel runs along `face`: its leg on the wall or
/// the cap, nothing on any other face.
fn sphere_leg(seat: &SphereSeat, face: &Shape, on_wall: f64, on_cap: f64) -> f64 {
    if face.is_same(&seat.wall_face) {
        on_wall
    } else if face.is_same(&seat.cap_face) {
        on_cap
    } else {
        0.0
    }
}

/// The largest measure up to `up_to` at which a chamfer of `spec`'s
/// spelling on `edge` of `solid` is not refused for running past its
/// faces: for [`Chamfer::Symmetric`] the distance, for
/// [`Chamfer::Distances`] the largest common scale of its two distances,
/// and for [`Chamfer::Angle`] the distance along its face at its angle;
/// the measure `spec` itself names is not read. None where no measure
/// leaving both legs longer than the confusion distance fits.
///
/// Read from the seat, without building a wedge. On a straight edge
/// between planes, a convex bevel's leg runs at most as far as its face
/// reaches back from the edge, the bound [`chamfer_edges_with`] refuses
/// past, and the answer is exact against it; a concave one fuses and runs
/// past no face. On a rim, the cap's leg stops short of the axis, and
/// each leg's contact stays on its face at the stations
/// [`largest_fillet_radius`](crate::largest_fillet_radius) reads, a
/// confusion distance short.
///
/// # Errors
///
/// As [`chamfer_edges_with`] where the seat or spelling is refused at any
/// measure, and [`OgeomError::Construction`](ogeom_core::OgeomError::Construction)
/// if `up_to` is not a usable length; as
/// [`largest_fillet_radius`](crate::largest_fillet_radius) where a
/// contact's walk on a rim depends on the measure.
pub fn largest_chamfer_distance(
    model: &Model,
    solid: &Shape,
    edge: &Shape,
    spec: &Chamfer,
    up_to: f64,
    tol: Tolerances,
) -> OgeomResult<Option<f64>> {
    let conf = tol.confusion();
    if !up_to.is_finite() || up_to <= conf {
        ogeom_bail!(
            Construction,
            "a largest distance up to {up_to} asks for nothing"
        );
    }
    // The legs at a measure of one, which scale with it.
    let unit = match spec {
        Chamfer::Symmetric(_) => Chamfer::Symmetric(1.0),
        Chamfer::Distances {
            face,
            on_face,
            on_other,
        } => Chamfer::Distances {
            face: face.clone(),
            on_face: *on_face,
            on_other: *on_other,
        },
        Chamfer::Angle { face, angle, .. } => Chamfer::Angle {
            face: face.clone(),
            distance: 1.0,
            angle: *angle,
        },
    };
    let mut largest = up_to;
    let shortest = match legs(model, solid, edge, &unit, tol)? {
        Legs::Straight(seat, per) => {
            if seat.convex {
                for (i, leg) in per.into_iter().enumerate() {
                    if leg > 0.0 {
                        let along = seat.leg(i, tol)?;
                        let reach = crate::support::face_reach(
                            model,
                            &seat.faces[i],
                            seat.start,
                            along,
                            tol,
                        )?;
                        largest = largest.min(reach / leg);
                    }
                }
            }
            per[0].min(per[1])
        }
        Legs::Rim(seat, on_wall, on_cap) => {
            // The cap's leg ends at the radius `radius - sigma tau on_cap`,
            // which stays above the confusion distance.
            let inward = seat.sigma * seat.tau * on_cap;
            if inward > 0.0 {
                largest = largest.min((seat.radius - 2.0 * conf) / inward);
            }
            // A cone's wall leg ends at the radius the wall has a depth
            // down, which narrows toward the apex with the measure.
            let narrowing = seat.slope * seat.tau * wall_depth(&seat, on_wall);
            if narrowing > 0.0 {
                largest = largest.min((seat.radius - 2.0 * conf) / narrowing);
            }
            let per = |face: &Shape| {
                if face.is_same(&seat.wall_face) {
                    on_wall
                } else if face.is_same(&seat.cap_face) {
                    on_cap
                } else {
                    0.0
                }
            };
            largest = largest.min(crate::fits::legs_largest(
                model, solid, edge, largest, per, tol,
            )?);
            on_wall.min(on_cap)
        }
        Legs::Marched => ogeom_bail!(
            NotDone,
            "the largest distance of a chamfer on a marched seat is not read \
             from the seat"
        ),
        Legs::Sphere(seat, on_wall, on_cap) => {
            // The derived leg of an angle on a sphere's rim does not scale
            // with the measure: the wall's section is an arc.
            if matches!(spec, Chamfer::Angle { .. }) {
                ogeom_bail!(
                    NotDone,
                    "the largest distance of a chamfer at an angle on a sphere's \
                     rim is not read from the seat"
                );
            }
            let inward = seat.sigma * seat.tau * on_cap;
            if inward > 0.0 {
                largest = largest.min((seat.radius - 2.0 * conf) / inward);
            }
            largest = largest.min((seat.to_pole() - 2.0 * conf) / on_wall);
            let per = |face: &Shape| sphere_leg(&seat, face, on_wall, on_cap);
            largest = largest.min(crate::fits::legs_largest(
                model, solid, edge, largest, per, tol,
            )?);
            on_wall.min(on_cap)
        }
    };
    Ok((largest * shortest > conf).then_some(largest))
}

/// The seat a chamfer stands on and how far its legs run along each face.
pub(crate) enum Legs {
    /// A straight edge between planes, its legs along the seat's faces in
    /// order.
    Straight(Seat, [f64; 2]),
    /// A rim on a cylinder or a cone: its legs down the wall and in along the
    /// cap.
    Rim(RevolvedSeat, f64, f64),
    /// A rim on a sphere: its legs down the sphere's great circle and along
    /// the cap.
    Sphere(SphereSeat, f64, f64),
    /// A crease on a marched seat, its legs read station by station when
    /// the bevel is built.
    Marched,
}

/// Read one chamfer's seat and legs from `solid` as it stands.
pub(crate) fn legs(
    model: &Model,
    solid: &Shape,
    edge: &Shape,
    spec: &Chamfer,
    tol: Tolerances,
) -> OgeomResult<Legs> {
    match spec {
        Chamfer::Symmetric(distance) => match seat_kind(model, edge, tol)? {
            SeatKind::Straight => {
                let seat = planar_seat(model, solid, edge, tol)?;
                Ok(Legs::Straight(seat, [*distance, *distance]))
            }
            SeatKind::Marched => Ok(Legs::Marched),
            SeatKind::Rim(rim) => match rim_seat(model, solid, edge, &rim, tol)? {
                RimSeat::Revolved(seat) => Ok(Legs::Rim(seat, *distance, *distance)),
                RimSeat::Sphere(seat) => Ok(Legs::Sphere(seat, *distance, *distance)),
            },
        },
        Chamfer::Distances {
            face,
            on_face,
            on_other,
        } => match seat_kind(model, edge, tol)? {
            SeatKind::Straight => {
                let seat = planar_seat(model, solid, edge, tol)?;
                let i = seat_side(&seat, face)?;
                let mut distances = [0.0; 2];
                distances[i] = *on_face;
                distances[1 - i] = *on_other;
                Ok(Legs::Straight(seat, distances))
            }
            SeatKind::Marched => Ok(Legs::Marched),
            SeatKind::Rim(rim) => match rim_seat(model, solid, edge, &rim, tol)? {
                RimSeat::Revolved(seat) => {
                    let (on_wall, on_cap) =
                        revolved_side(&seat.wall_face, &seat.cap_face, face, *on_face, *on_other)?;
                    Ok(Legs::Rim(seat, on_wall, on_cap))
                }
                RimSeat::Sphere(seat) => {
                    let (on_wall, on_cap) =
                        revolved_side(&seat.wall_face, &seat.cap_face, face, *on_face, *on_other)?;
                    Ok(Legs::Sphere(seat, on_wall, on_cap))
                }
            },
        },
        Chamfer::Angle {
            face,
            distance,
            angle,
        } => {
            let (distance, angle) = (*distance, *angle);
            if !angle.is_finite() || angle <= tol.angular() {
                ogeom_bail!(
                    Construction,
                    "a chamfer at an angle of {angle} cuts nothing"
                );
            }
            match seat_kind(model, edge, tol)? {
                SeatKind::Straight => {
                    let seat = planar_seat(model, solid, edge, tol)?;
                    let i = seat_side(&seat, face)?;
                    // In the cross-section: from the contact on the named
                    // face, the bevel leaves at `angle` into the wedge's own
                    // side: the material on a convex edge, the open dihedral
                    // on a concave one. Where it crosses the other leg's ray
                    // is the derived distance; no crossing, no chamfer.
                    let sign = if seat.convex { 1.0 } else { -1.0 };
                    let a = seat.leg(i, tol)? * sign;
                    let b = seat.leg(1 - i, tol)? * sign;
                    let inward = -seat.normals[i] * sign;
                    let denominator = angle.sin().mul_add(b.dot(a), angle.cos() * b.dot(inward));
                    if denominator <= tol.angular() {
                        ogeom_bail!(
                            Construction,
                            "the bevel at that angle never meets the edge's other face"
                        );
                    }
                    let derived = distance * angle.sin() / denominator;
                    let mut distances = [0.0; 2];
                    distances[i] = distance;
                    distances[1 - i] = derived;
                    Ok(Legs::Straight(seat, distances))
                }
                SeatKind::Marched => Ok(Legs::Marched),
                SeatKind::Rim(rim) => {
                    // In the rim's section the legs make the triangle with
                    // the bevel: `angle` at the named face's contact and the
                    // corner's own angle at the rim. A cylinder's seat is
                    // square, the derived distance the plain tangent; past
                    // the two angles' sum of a half turn the bevel walks
                    // away from the other face instead of toward it.
                    let seat = match rim_seat(model, solid, edge, &rim, tol)? {
                        RimSeat::Revolved(seat) => seat,
                        RimSeat::Sphere(seat) => {
                            // On a sphere the section's wall is an arc: the
                            // other contact is where the line meets it.
                            let on_cap_face = if seat.cap_face.is_same(face) {
                                true
                            } else if seat.wall_face.is_same(face) {
                                false
                            } else {
                                ogeom_bail!(
                                    Construction,
                                    "the named face does not meet the edge being chamfered"
                                )
                            };
                            let (on_wall, on_cap) =
                                seat.angle_legs(on_cap_face, distance, angle, tol)?;
                            return Ok(Legs::Sphere(seat, on_wall, on_cap));
                        }
                    };
                    let corner = rim_corner(&seat);
                    let past = if seat.slope == 0.0 {
                        angle >= core::f64::consts::FRAC_PI_2 - tol.angular()
                    } else {
                        angle + corner >= core::f64::consts::PI - tol.angular()
                    };
                    if past {
                        ogeom_bail!(
                            Construction,
                            "the bevel at that angle never meets the edge's other face"
                        );
                    }
                    let derived = if seat.slope == 0.0 {
                        distance * angle.tan()
                    } else {
                        distance * angle.sin() / (angle + corner).sin()
                    };
                    let (on_wall, on_cap) =
                        revolved_side(&seat.wall_face, &seat.cap_face, face, distance, derived)?;
                    Ok(Legs::Rim(seat, on_wall, on_cap))
                }
            }
        }
    }
}

/// A chamfer's wedge, built and not yet applied: its faces, and whether it
/// fuses (a concave edge) or cuts (a convex one).
struct Wedge {
    faces: Vec<Shape>,
    /// The wedge already closed into a solid, where it was built as one.
    solid: Option<Shape>,
    additive: bool,
    /// The whole ring a sphere's rim chamfers from any of the arcs a
    /// boolean split it into.
    whole_ring: Option<WholeRing>,
    /// The spelling of a bevel on a marched seat, built against the solid
    /// as it stands when its turn in the request comes.
    marched: Option<Chamfer>,
}

/// A sphere rim's whole ring and the legs its bevel runs.
#[derive(Debug, Clone, Copy)]
struct WholeRing {
    centre: ogeom_math::Point,
    radius: f64,
    up: ogeom_math::Vector,
    on_wall: f64,
    on_cap: f64,
}

impl WholeRing {
    /// Whether `other` is a ring on the same circle and the same cap.
    fn same_circle(&self, other: &Self, tol: Tolerances) -> bool {
        self.centre.distance(other.centre) <= tol.confusion()
            && (self.radius - other.radius).abs() <= tol.confusion()
            && self.up.dot(other.up) >= 1.0 - tol.angular()
    }

    /// Whether `other`'s legs are this ring's.
    fn same_legs(&self, other: &Self, tol: Tolerances) -> bool {
        (self.on_wall - other.on_wall).abs() <= tol.confusion()
            && (self.on_cap - other.on_cap).abs() <= tol.confusion()
    }
}

impl Wedge {
    fn apply(
        self,
        model: &mut Model,
        solid: &Shape,
        edge: &Shape,
        tol: Tolerances,
    ) -> OgeomResult<Built> {
        let mut built = match self.solid {
            Some(wedge) => {
                let mut result = if self.additive {
                    ogeom_bool::fuse(model, solid, &wedge, tol)?
                } else {
                    ogeom_bool::cut(model, solid, &wedge, tol)?
                };
                result.history.delete(edge);
                result
            }
            None => apply_wedge(model, solid, Some(edge), &self.faces, self.additive, tol)?,
        };
        crate::support::credit_new_faces(model, solid, edge, &mut built)?;
        Ok(built)
    }
}

/// Which seat a chamfer is standing on, read from the edge's curve.
enum SeatKind {
    /// A straight edge between planes: the triangular-prism wedge.
    Straight,
    /// A circular rim: the revolved wedge with a conical bevel.
    Rim(ogeom_geom::CircleCurve),
    /// Any other crease: the marched seat, its bevel ruled.
    Marched,
}

fn seat_kind(model: &Model, edge: &Shape, tol: Tolerances) -> OgeomResult<SeatKind> {
    let (curve, _) = edge_curve(model, edge, tol)?;
    match curve {
        Curve::Line(_) => Ok(SeatKind::Straight),
        Curve::Circle(c) => Ok(SeatKind::Rim(c)),
        _ => Ok(SeatKind::Marched),
    }
}

/// Assign a named face's distance to the wall or the cap.
///
/// On the wall the distance runs axially down from the rim; on the cap it
/// runs radially in from it.
fn revolved_side(
    wall_face: &Shape,
    cap_face: &Shape,
    face: &Shape,
    on_face: f64,
    on_other: f64,
) -> OgeomResult<(f64, f64)> {
    if wall_face.is_same(face) {
        Ok((on_face, on_other))
    } else if cap_face.is_same(face) {
        Ok((on_other, on_face))
    } else {
        ogeom_bail!(
            Construction,
            "the named face does not meet the edge being chamfered"
        )
    }
}

/// The revolved wedge with the quarter-tube exchanged for a slant: legs
/// `on_wall` down the wall along its ruling and `on_cap` radially along the
/// cap, and the cone between the two tangency rings as the bevel.
fn revolved_bevel(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    seat: &RevolvedSeat,
    on_wall: f64,
    on_cap: f64,
    tol: Tolerances,
) -> OgeomResult<Wedge> {
    for distance in [on_wall, on_cap] {
        if !distance.is_finite() || distance <= tol.confusion() {
            ogeom_bail!(Construction, "a chamfer of {distance} cuts nothing");
        }
    }
    let cap_rho = seat.sigma.mul_add(-(seat.tau * on_cap), seat.radius);
    if cap_rho <= tol.confusion() {
        ogeom_bail!(
            Construction,
            "a chamfer of {on_cap} along the cap swallows the axis of a rim \
             of radius {}",
            seat.radius
        );
    }
    // A cone's wall leg runs its distance along the slant, a depth down
    // the axis, to the wall's radius there.
    let depth = wall_depth(seat, on_wall);
    let wall_rho = seat.radius_at(-seat.tau * depth);
    if wall_rho <= tol.confusion() {
        ogeom_bail!(
            Construction,
            "a chamfer of {on_wall} down the wall runs past the apex of its cone"
        );
    }
    if let Some((start, sweep)) = arc_span(model, edge, seat, tol)? {
        let legs = (depth, cap_rho, on_wall.max(on_cap));
        return sector_bevel(model, solid, edge, seat, legs, (start, sweep), tol);
    }
    let flanks = revolved_flanks(model, seat, depth, cap_rho, tol)?;

    // The bevel: the cone through both tangency rings (reference radius
    // `cap_rho` at the cap's level, the wall's radius a depth below), a
    // cylinder where the two radii agree. Unlike the fillet's quarter-tube,
    // whose away-from-the-tube normal tracks the wedge seat by seat, the
    // cone's natural normal always points away from the axis, and the
    // wedge sits on the axis side of the slant exactly when `sigma` and
    // `tau` agree.
    let bevel_band = {
        let slope = (cap_rho - wall_rho) / (seat.tau * depth);
        // The domain covers the band's two rows (the cap ring at zero and
        // the wall ring a depth away) with a margin that stays clear of the
        // apex, where the surface degenerates.
        let rows = (
            0.0_f64.min(-seat.tau * depth),
            0.0_f64.max(-seat.tau * depth),
        );
        let frame = seat.frame_at(seat.centre, tol)?;
        let surface: SurfaceGeometry = if slope.atan().abs() <= tol.angular() {
            let pad = 0.1 * depth;
            ogeom_geom::CylinderSurface::new(
                ogeom_math::Cylinder::new(frame, cap_rho, tol)?,
                (rows.0 - pad, rows.1 + pad),
            )?
            .into()
        } else {
            // Beside a cone's wall the bevel's apex can come near its
            // rows; the margin then stops halfway to it.
            let pad = if seat.slope == 0.0 {
                0.1 * depth
            } else {
                let apex = -cap_rho / slope;
                let clear = (apex - rows.0).abs().min((apex - rows.1).abs());
                (0.1 * depth).min(0.5 * clear)
            };
            let cone = Cone::new(frame, cap_rho, slope.atan(), tol)?;
            ConeSurface::new(cone, (rows.0 - pad, rows.1 + pad))?.into()
        };
        let band = make_revolution_band(model, &surface, &flanks.wall_ring, &flanks.cap_ring, tol)?;
        if seat.sigma * seat.tau > 0.0 {
            band.reversed()
        } else {
            band
        }
    };

    Ok(Wedge {
        faces: vec![flanks.wall_band, flanks.annulus, bevel_band],
        solid: None,
        additive: seat.additive(),
        whole_ring: None,
        marched: None,
    })
}

/// Where a rim that is only an arc of its circle starts, and how far it
/// turns, as angles about the seat's axis from its `x_ref`, turning
/// positively about `up`. `None` for a whole circle, or an arc of one whose
/// wall runs on round the rest of the turn.
fn arc_span(
    model: &Model,
    edge: &Shape,
    seat: &RevolvedSeat,
    tol: Tolerances,
) -> OgeomResult<Option<(f64, f64)>> {
    let (curve, range) = edge_curve(model, edge, tol)?;
    let closed = ogeom_algo::edge_vertices(model, edge)?.is_some_and(|(a, b)| a.is_same(&b));
    let Curve::Circle(arc) = &curve else {
        return Ok(None);
    };
    if closed || crate::support::runs_whole_turn(model, seat, arc, range, tol)? {
        return Ok(None);
    }
    let frame = seat.frame_at(seat.centre, tol)?;
    Ok(Some(arc_window(model, edge, &frame, tol)?))
}

/// Where an arc of a rim starts and how far it turns, as angles about
/// `frame`'s `z` from its `x`, whose origin is the rim's centre.
fn arc_window(
    model: &Model,
    edge: &Shape,
    frame: &Frame,
    tol: Tolerances,
) -> OgeomResult<(f64, f64)> {
    use ogeom_geom::Curve3d as _;
    let (curve, range) = edge_curve(model, edge, tol)?;
    let centre = frame.origin();
    let angle = |t: f64| -> OgeomResult<f64> {
        let d = curve.point_at(t, tol)? - centre;
        Ok(d.dot(frame.y().vector()).atan2(d.dot(frame.x().vector())))
    };
    let turn = core::f64::consts::TAU;
    let (a, b, m) = (
        angle(range.0)?,
        angle(range.1)?,
        angle(0.5 * (range.0 + range.1))?,
    );
    // The arc runs from `a` to `b` one way round or the other: the way
    // that passes through its middle.
    let forward = (b - a).rem_euclid(turn);
    let start = if (m - a).rem_euclid(turn) <= forward {
        a
    } else {
        b
    };
    let sweep = if start == a { forward } else { turn - forward };
    Ok((start, sweep))
}

/// The wedge of a chamfer along an arc of a rim: the bevel's cross-section,
/// the triangle between the rim and the two tangency rings, turned about the
/// rim's axis through the arc alone. Its ends are the triangles a straight
/// bevel meeting the arc at a tangent ends in, so the bevels of a chain of
/// lines and arcs abut exactly; a whole ring would cut the material on the
/// far side of the axis as well.
///
/// Where the arc ends on a planar face oblique to the crease there, the
/// section in the meridian through that end would stop short of the face
/// and leave the corner between them: the bevel runs on past the end until
/// its section has left the solid across that face, within four of its
/// longer leg, as a straight band's run-out is read, and is cut back to the
/// face's plane.
fn sector_bevel(
    model: &mut Model,
    solid: &Shape,
    edge: &Shape,
    seat: &RevolvedSeat,
    (depth, cap_rho, leg): (f64, f64, f64),
    (start, sweep): (f64, f64),
    tol: Tolerances,
) -> OgeomResult<Wedge> {
    let frame = seat.frame_at(seat.centre, tol)?;
    let radial_at =
        |theta: f64| frame.x().vector() * theta.cos() + frame.y().vector() * theta.sin();
    let section_at = |theta: f64| -> [ogeom_math::Point; 3] {
        let radial = radial_at(theta);
        let rim = seat.centre + radial * seat.radius;
        let wall = if seat.slope == 0.0 {
            rim - seat.up * (seat.tau * depth)
        } else {
            let height = -seat.tau * depth;
            seat.centre + seat.up * height + radial * seat.radius_at(height)
        };
        [rim, wall, seat.centre + radial * cap_rho]
    };
    let mut window = [start, start + sweep];
    let mut trims = Vec::new();
    let hosts = [&seat.cap_face, &seat.wall_face];
    for (slot, sign) in [(0_usize, -1.0), (1, 1.0)] {
        let end = window[slot];
        let at = seat.centre + radial_at(end) * seat.radius;
        let ahead = seat.up.cross(radial_at(end)) * sign;
        if !crate::marched::crease_terminates_at(model, solid, edge, hosts, at, tol)? {
            continue;
        }
        let Some(face) = crate::support::oblique_end_face(model, solid, at, ahead, tol)? else {
            continue;
        };
        let step = (leg / seat.radius) / 8.0;
        let reach = 4.0 * leg / seat.radius;
        let section = |t: f64| Ok(section_at(end + sign * t));
        if let Some(past) =
            crate::support::run_out_past(model, solid, face, step, reach, &section, tol)?
        {
            window[slot] = end + sign * past;
            trims.push(face);
        }
    }
    // A bevel that would close the turn running on keeps its ends.
    if window[1] - window[0] >= core::f64::consts::TAU - tol.angular() {
        window = [start, start + sweep];
        trims.clear();
    }
    let [rim, wall, cap] = section_at(window[0]);
    let across = seat.up.cross(radial_at(window[0]));
    let profile = crate::support::planar_face(model, &[rim, wall, cap], across, tol)?;
    let axis = ogeom_math::Axis::new(seat.centre, frame.z());
    let turn = window[1] - window[0];
    let mut wedge = ogeom_algo::make_revolution(model, &profile, axis, turn, tol)?.shape;
    let span = (seat.radius + leg) * 4.0;
    for plane in trims {
        wedge = crate::support::trimmed_wedge(model, &wedge, plane, span, tol)?;
    }
    Ok(Wedge {
        faces: Vec::new(),
        solid: Some(wedge),
        additive: seat.additive(),
        whole_ring: None,
        marched: None,
    })
}

/// Which side of the seat a named face is, by identity.
fn seat_side(seat: &Seat, face: &Shape) -> OgeomResult<usize> {
    if seat.faces[0].is_same(face) {
        Ok(0)
    } else if seat.faces[1].is_same(face) {
        Ok(1)
    } else {
        ogeom_bail!(
            Construction,
            "the named face does not meet the edge being chamfered"
        )
    }
}

/// The one construction under all three spellings: the wedge with legs
/// `distances[i]` along face `i`, subtracted.
fn bevel(
    model: &mut Model,
    seat: &Seat,
    distances: [f64; 2],
    tol: Tolerances,
) -> OgeomResult<Wedge> {
    for distance in distances {
        if !distance.is_finite() || distance <= tol.confusion() {
            ogeom_bail!(Construction, "a chamfer of {distance} cuts nothing");
        }
    }
    // On a concave edge every leg mirrors: the wedge sits in the open
    // dihedral, its legs walk the faces' planes into it, and its strips face
    // the material they will melt against with *opposed* orientation, which
    // is exactly what a fuse cancels.
    let sign = if seat.convex { 1.0 } else { -1.0 };
    let a = seat.leg(0, tol)? * sign;
    let b = seat.leg(1, tol)? * sign;
    // A setback runs back across each face; past the face's far side it
    // would cut through the face and on into whatever lies beyond it.
    if seat.convex {
        for (i, leg) in [a, b].into_iter().enumerate() {
            let reach = crate::support::face_reach(model, &seat.faces[i], seat.start, leg, tol)?;
            if distances[i] > reach + tol.confusion() {
                ogeom_bail!(
                    Construction,
                    "a chamfer of {} on the edge from {:?} to {:?} runs past its face, \
                     which reaches {reach} back from the edge",
                    distances[i],
                    seat.start,
                    seat.end
                );
            }
        }
    }

    let travel = seat.end - seat.start;
    let apex0 = seat.start;
    let apex1 = seat.end;
    let a0 = apex0 + a * distances[0];
    let b0 = apex0 + b * distances[1];
    let a1 = a0 + travel;
    let b1 = b0 + travel;

    // The bevel's outward normal: perpendicular to the cut line and the edge,
    // pointing from the apex toward the cut. For equal distances this is the
    // leg bisector exactly.
    let bevel_out = {
        let across = b0 - a0;
        let mut n = seat.along.cross(across);
        let m = n.magnitude();
        if m <= tol.confusion() {
            ogeom_bail!(Construction, "the chamfer's cut line has no direction");
        }
        n /= m;
        if n.dot(a0 - apex0) < 0.0 {
            n = -n;
        }
        n
    };

    // The wedge: a triangular prism whose apex line is the edge and whose
    // legs run the distances along each face. Built from five explicit planar
    // faces rather than swept, because a sweep's walls are extrusion
    // surfaces even when they are geometrically planes, and the boolean's
    // same-domain resolution (which is what makes the coplanar legs melt
    // into the solid's own faces) recognises coincidence between *planes*.
    let faces = [
        planar_face(model, &[apex0, a0, b0], -seat.along, tol)?,
        planar_face(model, &[apex1, a1, b1], seat.along, tol)?,
        planar_face(model, &[apex0, a0, a1, apex1], seat.normals[0] * sign, tol)?,
        planar_face(model, &[apex0, b0, b1, apex1], seat.normals[1] * sign, tol)?,
        planar_face(model, &[a0, b0, b1, a1], bevel_out, tol)?,
    ];
    Ok(Wedge {
        faces: faces.to_vec(),
        solid: None,
        additive: !seat.convex,
        whole_ring: None,
        marched: None,
    })
}

/// The faces of `solid` holding `edge`.
fn faces_holding(model: &Model, solid: &Shape, edge: &Shape) -> Result<Vec<Shape>, Blamed> {
    let mut found = Vec::new();
    for face in ogeom_topo::explore_unique(model, solid, ogeom_topo::ShapeType::Face)? {
        if ogeom_topo::explore_unique(model, &face, ogeom_topo::ShapeType::Edge)?
            .iter()
            .any(|e| e.is_same(edge))
        {
            found.push(face);
        }
    }
    Ok(found)
}

/// A bevel on a marched seat, applied to the solid the request's earlier
/// bevels (`earlier`) left (`so_far`, with their history): the edge found
/// again there between the faces `given` it lay between as asked, a face
/// the spelling names followed to what those bevels made of it, each piece
/// of the edge bevelled in turn.
///
/// A bevel runs on through a vertex where the crease carries on (an open
/// marched bevel runs out as the marched fillet does), so an edge an
/// earlier bevel of the same spelling meeting it at a vertex has taken
/// away is bevelled already; one an earlier bevel of another spelling has
/// taken is refused.
fn marched_step(
    model: &mut Model,
    so_far: &Built,
    edge: &Shape,
    spec: &Chamfer,
    given: &[Shape],
    earlier: &[(Shape, Chamfer)],
    tol: Tolerances,
) -> OgeomResult<Built> {
    let solid = &so_far.shape;
    let faces_now = ogeom_topo::explore_unique(model, solid, ogeom_topo::ShapeType::Face)?;
    let now = |named: &Shape| -> Shape {
        if faces_now.iter().any(|f| f.is_same(named)) {
            return named.clone();
        }
        so_far
            .history
            .modified(named)
            .iter()
            .find(|f| faces_now.iter().any(|g| g.is_same(f)))
            .cloned()
            .unwrap_or_else(|| named.clone())
    };
    let asked = spec;
    let spec = &match spec {
        Chamfer::Symmetric(d) => Chamfer::Symmetric(*d),
        Chamfer::Distances {
            face,
            on_face,
            on_other,
        } => Chamfer::Distances {
            face: now(face),
            on_face: *on_face,
            on_other: *on_other,
        },
        Chamfer::Angle {
            face,
            distance,
            angle,
        } => Chamfer::Angle {
            face: now(face),
            distance: *distance,
            angle: *angle,
        },
    };
    // An edge nothing of which is left is reported consumed.
    let pieces = match crate::fillet::refind_edges(model, solid, edge, given, tol) {
        Ok(pieces) => pieces,
        Err(ogeom_core::OgeomError::Construction(_)) => Vec::new(),
        Err(e) => return Err(e),
    };
    if pieces.is_empty() {
        let ends = |e: &Shape| -> OgeomResult<Vec<ogeom_topo::TShapeId>> {
            Ok(ogeom_algo::edge_vertices(model, e)?
                .map(|(a, b)| vec![a.node(), b.node()])
                .unwrap_or_default())
        };
        let own = ends(edge)?;
        for (other, theirs) in earlier {
            if same_spelling(theirs, asked, tol) && ends(other)?.iter().any(|v| own.contains(v)) {
                let mut done = Built::from_nothing(solid.clone());
                done.history.delete(edge);
                return Ok(done);
            }
        }
        ogeom_bail!(
            Construction,
            "a bevel on a marched seat whose edge an earlier bevel of the request, \
             of another spelling, took away is not built"
        );
    }
    let mut built = Built::from_nothing(solid.clone());
    for piece in pieces {
        let mut step =
            crate::chamfer_marched::marched_bevel(model, &built.shape, &piece, spec, given, tol)?;
        crate::support::credit_new_faces(model, &built.shape, &piece, &mut step)?;
        step.history.delete(edge);
        built = Built {
            shape: step.shape.clone(),
            history: built.history.then(&step.history),
        };
    }
    Ok(built)
}

/// Whether two spellings bevel alike: the same kind, the same measures, the
/// same face named.
fn same_spelling(a: &Chamfer, b: &Chamfer, tol: Tolerances) -> bool {
    let near = |x: f64, y: f64| (x - y).abs() <= tol.confusion();
    match (a, b) {
        (Chamfer::Symmetric(x), Chamfer::Symmetric(y)) => near(*x, *y),
        (
            Chamfer::Distances {
                face: fa,
                on_face: oa,
                on_other: ra,
            },
            Chamfer::Distances {
                face: fb,
                on_face: ob,
                on_other: rb,
            },
        ) => fa.is_same(fb) && near(*oa, *ob) && near(*ra, *rb),
        (
            Chamfer::Angle {
                face: fa,
                distance: da,
                angle: aa,
            },
            Chamfer::Angle {
                face: fb,
                distance: db,
                angle: ab,
            },
        ) => fa.is_same(fb) && near(*da, *db) && (aa - ab).abs() <= tol.angular(),
        _ => false,
    }
}