ogeom_bool/

lib.rs

//! Boolean operations.
//!
//! Fuse, common, cut, section and split are one algorithm (general fuse)
//! plus a selection predicate: every face of each solid is split by the
//! other solid's faces, the pieces are classified against the other solid,
//! and a filter keeps the pieces the operation wants.
//!
//! # One pipeline, any analytic face
//!
//! The pipeline runs on solids whose faces are any surface the intersectors
//! answer for (planes, cylinders, spheres, cones, tori), with the planar
//! case as nothing more than the case where every curve is a line. Sections
//! come from [`intersect_surfaces`](ogeom_intersect::intersect_surfaces), exact
//! with same-parameter pcurves where the projection has a closed form and
//! *marched and fitted to a stated tolerance* where it does not. Paves (the
//! points where sections meet boundary edges and each other) come from the
//! exact curve/curve intersection. Every face is then split in its own
//! parameter space by an arrangement of *strands*: polyline scaffolding, each
//! naming the exact sub-curve it stands for, so the combinatorics run on
//! polylines and the rebuilt result is exact curves, pcurves attached both
//! sides, sewn back into shared topology.
//!
//! Pieces are classified against the other solid by the exact ray classifier
//! and the filters select: fuse keeps what is outside, common what is inside,
//! cut flips the tool's contribution. Same-domain contact (a piece lying
//! *on* the other boundary) is resolved by whether the two solids' outward
//! normals agree there, where the contact's edges can be imaged in the
//! shared chart, and refused by name where they cannot. A tangential touch
//! splits nothing and is carried as the contact curve it is.
//!
//! # Sheets
//!
//! A sheet (a face, a shell or a compound of those) runs the same pipeline
//! with one side left out: its faces are split by the other argument's, and
//! the other argument's faces only cut. [`common`] and [`cut`] classify the
//! sheet's pieces against a solid or a half space and keep those inside or
//! outside it. [`split_sheet`] keeps every piece, unclassified. The kept
//! pieces are sewn into shells with no closure asked of them.

mod arrange;
mod aside;
mod ball_chart;
mod bins;
mod box_tree;
mod defeature;
mod half_space;
mod mesh_region;
mod seam_join;
mod seated;
mod section_face;
mod self_union;
mod sub_shapes;
#[cfg(feature = "test-hooks")]
#[doc(hidden)]
pub mod work;

pub use ball_chart::TOUCHING as POLE_TOUCHING;
pub use ball_chart::{POLE_MARGIN, Recharted, rechart_clear_of_poles};
pub use defeature::remove_faces;
pub use mesh_region::cut_by_mesh_region;
pub use section_face::section_face;
pub use self_union::self_union;

use ogeom_algo::{
    Built, Containment, History, is_shell_closed, make_edge_between, make_face_on, make_vertex,
    make_wire, sew_around, sew_around_within, shape_bounds,
};
use ogeom_core::{OgeomResult, Tolerances, ogeom_bail};
use ogeom_geom::Curve2d as _;
use ogeom_geom::Curve3d as _;
use ogeom_geom::Surface as _;
use ogeom_geom::{Curve, PlanarCurve, SurfaceGeometry, Transformable};
use ogeom_math::{Point, Point2};
use ogeom_topo::{
    EdgeRepr, Filter, Location, Model, NodeData, Shape, ShapeType, explore, explore_unique,
};

use arrange::{Strand, Traversal, assemble as arrange_pieces, inside_many, inside_rings};

/// Parameter-space chord for the polyline scaffolding.
const SCAFFOLD_CHORD: f64 = 1e-3;

/// How far a curved strand's chords may stand off its curve on a plane, and
/// a face outline's chords off its pcurves on any surface. A piece is
/// classified by a point inside its polyline outline, and a piece thinner
/// than its outline's chords bow (the cap annulus between two drums a
/// thousandth apart in radius) has that point outside the true piece. A
/// section's piece is kept on a face by its middle read against the face's
/// outline, and a piece standing nearer the rim than the rim's chords bow
/// (an arc between two crossings of a bowed seam) reads on the wrong side.
const STRAND_SAG: f64 = 1e-4;

/// Samples enough that a curve's chords stand within [`STRAND_SAG`] of it in
/// the chart: from `count`, raised as the measured sag at the chords'
/// middles asks, up to 512. With the count, the sag measured at it, or
/// infinity where the count was raised past the last measure.
fn sag_count(
    at: &dyn Fn(f64) -> OgeomResult<Point2>,
    lo: f64,
    hi: f64,
    mut count: usize,
) -> OgeomResult<(usize, f64)> {
    const MOST: usize = 512;
    let mut measured = f64::INFINITY;
    for _ in 0..3 {
        if count >= MOST {
            break;
        }
        let mut sag = 0.0_f64;
        #[allow(clippy::cast_precision_loss)]
        let step = (hi - lo) / count as f64;
        let mut previous = at(lo)?;
        for i in 1..=count {
            #[allow(clippy::cast_precision_loss)]
            let t = (i as f64).mul_add(step, lo);
            let here = at(t)?;
            let middle = at(t - step / 2.0)?;
            sag = sag.max(middle.distance(Point2::midpoint(previous, here)));
            previous = here;
        }
        if sag <= STRAND_SAG {
            measured = sag;
            break;
        }
        // Sag falls as the square of the step.
        #[allow(
            clippy::cast_possible_truncation,
            clippy::cast_sign_loss,
            clippy::cast_precision_loss
        )]
        let raised = ((count as f64) * (sag / STRAND_SAG).sqrt()).ceil() as usize;
        count = raised.clamp(count + 1, MOST);
    }
    Ok((count, measured))
}

/// [`sag_count`] for a circle, whose chords' sag is known: `r(1 - cos(θ/2))`
/// over a step of `θ`. `None` for any other curve.
fn circle_sag_count(pcurve: &PlanarCurve, lo: f64, hi: f64, count: usize) -> Option<usize> {
    const MOST: usize = 512;
    let PlanarCurve::Circle(circle) = pcurve else {
        return None;
    };
    let radius = circle.circle().radius();
    if radius <= STRAND_SAG {
        return Some(count);
    }
    let step = 2.0 * (1.0 - STRAND_SAG / radius).acos();
    #[allow(
        clippy::cast_possible_truncation,
        clippy::cast_sign_loss,
        clippy::cast_precision_loss
    )]
    let needed = ((hi - lo).abs() / step).ceil().min(MOST as f64) as usize;
    Some(count.max(needed))
}

/// How far the chords of a circle sampled in `count` equal steps over
/// `lo..hi` stand off it: `r(1 - cos(θ/2))` over a step of `θ`. `None` for
/// any other curve.
fn circle_sag(pcurve: &PlanarCurve, lo: f64, hi: f64, count: usize) -> Option<f64> {
    let PlanarCurve::Circle(circle) = pcurve else {
        return None;
    };
    #[allow(clippy::cast_precision_loss)]
    let step = (hi - lo).abs() / count.max(1) as f64;
    Some(circle.circle().radius() * (1.0 - (step / 2.0).cos()))
}

/// Parameter-space node snap for the arrangement.
const PARAM_SNAP: f64 = 1e-6;

/// The widest chart gap a seam column's end may stand from the face's
/// other edges and still meet them within their radii in space.
const SEAM_HAIR: f64 = 1e-3;

// --- gathering ---------------------------------------------------------------

/// An edge occurrence's identity: its node and where it is placed.
///
/// One node placed twice is two edges in space: a prism's far cap is its
/// near cap moved, the same nodes under a displacement. Paves shared by
/// node alone would split the near cap's edges wherever the far cap's were
/// crossed. The placement is folded in as its hash, which keeps the key a
/// plain value.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct EdgeKey {
    node: ogeom_topo::TShapeId,
    placement: u64,
}

impl EdgeKey {
    fn of(edge: &Shape) -> Self {
        use core::hash::{Hash as _, Hasher as _};
        // An edge where its node puts it, the usual case, needs no hash.
        if edge.location().is_identity() {
            return Self {
                node: edge.node(),
                placement: 0,
            };
        }
        let mut hasher = std::collections::hash_map::DefaultHasher::new();
        edge.location().hash(&mut hasher);
        Self {
            node: edge.node(),
            placement: hasher.finish(),
        }
    }

    /// The node's index, for the debug traces.
    fn index(self) -> u32 {
        self.node.index()
    }
}

/// What a boolean reads of one edge occurrence, the same for the faces on
/// either side of it.
struct Occurrence {
    key: EdgeKey,
    /// The edge's curve in world space, placement applied.
    curve: std::sync::Arc<Curve>,
    /// Each end where the curve puts it, with the tolerance of the vertex
    /// there, matched to the curve's ends by position: the edge's vertex
    /// order and its curve's direction need not agree once the edge is
    /// reversed in its wire.
    ends: [(Point, f64); 2],
    /// Each end's vertex where the vertex stands, which a file may put
    /// between the ends of the curves it closes, each within its radius;
    /// the curve's end where it has none.
    vertices: [Point; 2],
    /// The loosest tolerance either of its vertices states.
    ends_tolerance: f64,
    /// The box of seventeen points along the curve, the box of the chord
    /// midpoints between them, and twice the farthest a midpoint stands off
    /// its chord: how far the true curve may sag from the sampled polyline.
    sampled: (ogeom_math::Aabb, ogeom_math::Aabb, f64),
}

impl Occurrence {
    fn of(
        model: &Model,
        edge: &Shape,
        curve: Curve,
        range: (f64, f64),
        tol: Tolerances,
    ) -> OgeomResult<Self> {
        let vertices = model.children_of(edge)?;
        let ends_tolerance = vertices
            .iter()
            .filter_map(|v| model.node(v).and_then(|n| n.data().as_vertex()))
            .fold(0.0_f64, |acc, d| acc.max(d.tolerance.get()));
        let (a, b) = (curve.point_at(range.0, tol)?, curve.point_at(range.1, tol)?);
        let mut ends = [(a, tol.confusion()), (b, tol.confusion())];
        let mut at_vertex = [a, b];
        for v in &vertices {
            if let Some(d) = model.node(v).and_then(|n| n.data().as_vertex()) {
                let at = v.transform(model.datums())?.apply(d.point);
                let k = usize::from(at.distance(b) < at.distance(a));
                ends[k].1 = ends[k].1.max(d.tolerance.get());
                at_vertex[k] = at;
            }
        }
        let mut previous: Option<Point> = None;
        let (mut points, mut mids) = (ogeom_math::Aabb::EMPTY, ogeom_math::Aabb::EMPTY);
        let mut sag = 0.0_f64;
        for i in 0..=16 {
            #[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
            let t = range.0 + (range.1 - range.0) * f64::from(i) / 16.0;
            let p = curve.point_at(t, tol)?;
            if let Some(q) = previous {
                let step = (range.1 - range.0) / 32.0;
                let mid = curve.point_at(t - step, tol)?;
                sag = sag.max(mid.distance(Point::midpoint(q, p)) * 2.0);
                mids = mids.with_point(mid);
            }
            points = points.with_point(p);
            previous = Some(p);
        }
        Ok(Self {
            key: EdgeKey::of(edge),
            curve: std::sync::Arc::new(curve),
            ends,
            vertices: at_vertex,
            ends_tolerance,
            sampled: (points, mids, sag),
        })
    }
}

/// One boundary strand source: an edge as one face uses it, with the pcurve
/// that side of it.
struct BoundaryEdge {
    /// The edge occurrence's identity, for sharing paves across faces.
    node: EdgeKey,
    /// The curve in world space, shared by the faces the edge bounds.
    curve: std::sync::Arc<Curve>,
    /// The portion the edge covers, in the curve's parameter.
    crange: (f64, f64),
    /// The pcurve on this face's surface.
    pcurve: PlanarCurve,
    /// The portion of the pcurve, mapped proportionally from `crange`.
    prange: (f64, f64),
    /// The other side of a seam, where this edge is one.
    other_side: Option<(PlanarCurve, (f64, f64))>,
    /// The edge's two seam columns as its node states them, forward then
    /// reversed, kept where this face uses only one: on a surface several
    /// faces stand on, the edge between two of them is a seam of that
    /// surface, each face walking its own column.
    seam: Option<(PlanarCurve, PlanarCurve)>,
    /// The radius within which the edge honestly lies: a fitted rail can
    /// carry a few dozen microns of construction slop, and every filter that
    /// compares this edge's curve against exact geometry widens by it.
    tolerance: f64,
    /// How far the edge stands off this face: its curve from the face's
    /// own image of it, the pcurve on the surface, at most its tolerance.
    /// An edge's tolerance is one radius for both its faces, and it may be
    /// owed to one of them alone: a chord between a facet and the drum
    /// it was converted beside lies in the facet's plane and stands off
    /// the drum by its sag. On the facet the chord is exact, and what
    /// meets it there is read as exactly as the facet's other edges. A
    /// tolerance no face of the edge stands off by half of is owed to
    /// none, and is this too.
    standoff: f64,
    /// The radius the edge holds to on this face as measured: its stated
    /// tolerance, or the curve's distance from the face's own image of it
    /// where that is wider.
    residual: f64,
    /// Whether the face walks the edge along its curve (`true`) or back,
    /// keeping its material on the left about its outward normal; `None`
    /// where it walks it both ways, a seam.
    walked: Option<bool>,
    /// The edge as this face draws it, where it stands off the face by more
    /// than [`DRAWN_APART`]: the pcurve on the surface, over `prange`. A
    /// chord between a facet and the drum it was converted beside is drawn
    /// on the drum as the arc beneath it, and what meets the drum's trim
    /// meets that arc: a section running a hair outside the arc, read
    /// against the chord its sag away, runs along the edge it never
    /// reaches.
    image: Option<std::sync::Arc<Curve>>,
    /// The looser of the edge's two end vertices' own radii: the doubt an
    /// earlier junction recorded there, which the arrangement's node snap
    /// on this face must reach.
    ends_tolerance: f64,
    /// Each end vertex in space with its own recorded radius: a vertex that
    /// owns a span is a junction of this boolean too, and every strand end
    /// inside it names it.
    ends: [(Point, f64); 2],
    /// Each end's vertex where the vertex itself stands (see
    /// [`Occurrence::vertices`]).
    vertices: [Point; 2],
    /// A conservative box round the edge: its samples, grown by twice the
    /// sag measured between them and by its own radius.
    bound: ogeom_math::Aabb,
}

/// How far an edge must stand off a face before the face reads it as its
/// own image of it: a hundred confusions, past the rounding of any edge
/// whose curve and pcurve were made together.
const DRAWN_APART: f64 = 1e2;

/// How many of a loose edge's tolerances a crossing of it may stand along
/// it from the crossing the face across it finds: where the edge leans out
/// of the crossing face by less than a tenth of a radian, the two are not
/// told apart by the lean but by the touch, and held to this.
const LEAN_SPREAD: f64 = 10.0;

impl BoundaryEdge {
    /// The curve this face's boundary runs along, its range, and how far
    /// the face may stand off it: the image where there is one, exact on
    /// the face, or the edge's curve and its standoff.
    fn drawn(&self) -> (&Curve, (f64, f64), f64) {
        match &self.image {
            Some(image) => (image, ordered(self.prange), 0.0),
            None => (&self.curve, self.crange, self.standoff),
        }
    }

    /// A parameter of [`BoundaryEdge::drawn`] as the edge curve's: the
    /// image runs over the pcurve's range, mapped onto the curve's in
    /// proportion, as the face's strands draw it.
    fn onto_curve(&self, s: f64) -> f64 {
        if self.image.is_some() {
            rescale(s, self.prange, self.crange)
        } else {
            s
        }
    }

    /// A parameter of the edge curve as [`BoundaryEdge::drawn`]'s.
    fn onto_drawn(&self, t: f64) -> f64 {
        if self.image.is_some() {
            rescale(t, self.crange, self.prange)
        } else {
            t
        }
    }
}

/// A range low end first.
fn ordered(range: (f64, f64)) -> (f64, f64) {
    if range.0 <= range.1 {
        range
    } else {
        (range.1, range.0)
    }
}

/// A pole: an edge that bounds a face in parameter space and collapses to
/// a point in space.
///
/// A sphere's poles and a cone's apex have no curve to split, but they are
/// half the chart's boundary. Leave them out and the face's outline does
/// not close, and nothing can be arranged inside it.
struct PoleEdge {
    /// Where the pole sits in space.
    point: Point,
    /// The chart line the pole runs along.
    pcurve: PlanarCurve,
    prange: (f64, f64),
}

/// One face, gathered and vetted.
struct GFace {
    face: Shape,
    /// The surface in world space, placement applied.
    surface: SurfaceGeometry,
    /// A conservative world bound: the boundary edges' sampled extent plus
    /// the surface's own allowance: nothing for a plane, measured sampling
    /// slack for the ruled kinds whose rulings pin them to their boundary's
    /// hull, most of the diagonal for anything that can genuinely bulge, a
    /// dome past its equator. The poles join after. Gates the pair filter
    /// and refusals. `OGEOM_BOOL_AUDIT_BOUNDS` audits its conservatism.
    bound: ogeom_math::Aabb,
    /// What the pair tests read: [`GFace::bound`] cut down to the box the
    /// model keeps for the face, which stands off a dome by its tolerance
    /// where `bound` keeps most of its diagonal as allowance. The scales
    /// taken from a face's size still read `bound`.
    filter: ogeom_math::Aabb,
    /// The scale the marching chord derives from: deliberately *not* the
    /// filter box's diagonal, so the filter can tighten without silently
    /// tightening the marcher.
    chord_scale: f64,
    /// How far the face may stand off its surface, as it states: a face
    /// fitted to a mesh lies within its fit's deviation of it.
    tolerance: f64,
    edges: Vec<BoundaryEdge>,
    poles: Vec<PoleEdge>,
    /// The edges its rings walk out along and straight back ([`slits`]),
    /// left out of `edges`.
    slits: ogeom_core::FastSet<EdgeKey>,
    /// The face's boundary polylined in its chart within [`STRAND_SAG`],
    /// both seam columns, ends welded: the trim [`chart_point_within`]
    /// tests against. Built the first time a probe asks and kept, since the
    /// same face is asked about once per piece that might lie on it. `None`
    /// where a pcurve would not polyline.
    outline: std::sync::OnceLock<Option<Vec<Vec<Point2>>>>,
    /// [`GFace::outline`] with its lines' boxes, for asking whether many
    /// points lie inside it.
    outline_trim: std::sync::OnceLock<Option<arrange::Trim>>,
    /// The holes left out of the arrangement (see [`aside`]): each lies
    /// inside one piece, which takes it back.
    holes_aside: std::sync::Arc<[aside::Hole]>,
    /// The surface the face's node stands on, where the face is rebuilt on
    /// it: a face holding edges it shares with faces set aside, which keep
    /// their pcurves on it.
    own_surface: Option<ogeom_topo::SurfaceId>,
    /// The stored surface and the placement it stands at: faces with the
    /// same carrier stand on one surface in space.
    carrier: (ogeom_topo::SurfaceId, Location),
    /// The face's trim sampled coarsely for folding a chart image inside
    /// it: [`face_trim_lines`], kept for the face's every sub-edge.
    trim_lines: std::sync::OnceLock<Vec<Vec<Point2>>>,
}

impl GFace {
    fn trim_lines(&self, tol: Tolerances) -> &[Vec<Point2>] {
        self.trim_lines.get_or_init(|| face_trim_lines(self, tol))
    }

    fn outline_trim(&self, tol: Tolerances) -> Option<&arrange::Trim> {
        self.outline_trim
            .get_or_init(|| {
                self.outline(tol)
                    .map(|lines| arrange::Trim::new(lines.to_vec()))
            })
            .as_ref()
    }

    fn outline(&self, tol: Tolerances) -> Option<&[Vec<Point2>]> {
        self.outline
            .get_or_init(|| {
                let mut lines: Vec<Vec<Point2>> = Vec::new();
                for e in &self.edges {
                    lines.push(
                        pcurve_polyline_within_sag(
                            &e.pcurve,
                            e.prange,
                            e.crange,
                            e.crange,
                            &self.surface,
                            tol,
                        )
                        .ok()?,
                    );
                    // A seam bounds the chart twice (once per column), and
                    // a trim test that sees only one side reads half the
                    // band as outside.
                    if let Some((other, orange)) = &e.other_side {
                        lines.push(
                            pcurve_polyline_within_sag(
                                other,
                                *orange,
                                e.crange,
                                e.crange,
                                &self.surface,
                                tol,
                            )
                            .ok()?,
                        );
                    }
                }
                weld_outline_ends(&mut lines, self, tol);
                bridge_outline_gaps(&mut lines);
                Some(lines)
            })
            .as_deref()
    }
}

/// Whether `shape` is a solid, or a compound of solids and nothing else:
/// disjoint lumps (a fuse of parts that do not meet, a fillet's wedges
/// taken together) bound their material as one solid's shells do.
fn is_solid_or_lumps(model: &Model, shape: &Shape) -> OgeomResult<bool> {
    Ok(match model.kind_of(shape)? {
        ShapeType::Solid => true,
        ShapeType::Compound => {
            let parts = model.children_of(shape)?;
            !parts.is_empty()
                && parts
                    .iter()
                    .map(|part| model.kind_of(part))
                    .collect::<OgeomResult<Vec<_>>>()?
                    .iter()
                    .all(|kind| *kind == ShapeType::Solid)
        }
        _ => false,
    })
}

/// Whether `shape` is a sheet: a face, a shell, or a compound of faces and
/// shells, with no solid behind any of it.
fn is_sheet(model: &Model, shape: &Shape) -> OgeomResult<bool> {
    Ok(match model.kind_of(shape)? {
        ShapeType::Face | ShapeType::Shell => true,
        ShapeType::Compound => {
            let parts = model.children_of(shape)?;
            !parts.is_empty()
                && parts
                    .iter()
                    .map(|part| model.kind_of(part))
                    .collect::<OgeomResult<Vec<_>>>()?
                    .iter()
                    .all(|kind| matches!(kind, ShapeType::Face | ShapeType::Shell))
        }
        _ => false,
    })
}

/// Every edge of a sheet's faces given its exact pcurve on the face where it
/// has none: a face built on a bare boundary is split in its chart like any
/// other.
fn trim_sheet_edges(model: &mut Model, sheet: &Shape, tol: Tolerances) -> OgeomResult<()> {
    for face in explore_unique(model, sheet, ShapeType::Face)? {
        ogeom_algo::build::trimmed_where_bare(model, &face, tol)?;
    }
    Ok(())
}

/// An argument: a solid, or a sheet where the operation takes one.
struct GSolid {
    solid: Shape,
    faces: Vec<GFace>,
    /// The faces set aside, passed through untouched, each with its place
    /// among the solid's faces.
    aside: Vec<(Shape, usize)>,
    /// The edges the gathered faces share with the faces set aside, each
    /// as it stands: rebuilt as itself, so the faces set aside still meet
    /// the rebuilt ones along it.
    shared: ogeom_core::FastMap<EdgeKey, Shape>,
    /// The vertices of the shared edges, each where it stands: the strands
    /// ending there end on it.
    shared_vertices: Vec<(Point, Shape)>,
    /// Each face's place in the solid, where faces are set aside.
    order: ogeom_core::FastMap<ogeom_topo::SameKey, usize>,
    /// What joins the faces set aside to the rest.
    beside: std::sync::Arc<aside::Beside>,
    /// Whether the solid is one shell already found closed.
    closed: bool,
}

/// What the general fuse makes of its two arguments.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Operands {
    /// Two solids: each one's faces split by the other's and classified
    /// against it.
    Solids,
    /// A sheet and a solid: the sheet's faces split by the solid's and
    /// classified against it. The solid's faces only cut.
    SheetBySolid,
    /// Two sheets: the first one's faces split by the second's and left
    /// unclassified. The second one's faces only cut.
    SheetBySheet,
    /// A solid and itself: each face split by every face of the solid but
    /// itself and the faces it shares an edge or a corner with, and left
    /// unclassified. Only the first argument's pieces are made.
    Itself,
}

fn gather(
    model: &Model,
    solid: &Shape,
    sheet: bool,
    aside: Option<&aside::Aside>,
    tol: Tolerances,
) -> OgeomResult<GSolid> {
    let mut read_closed = false;
    if sheet {
        if !is_sheet(model, solid)? {
            ogeom_bail!(
                Construction,
                "a sheet argument is a face, a shell or a compound of those"
            );
        }
    } else {
        if !is_solid_or_lumps(model, solid)? {
            ogeom_bail!(Construction, "boolean arguments are solids");
        }
        let shells = explore_unique(model, solid, ShapeType::Shell)?;
        // A solid of one shell whose every edge its faces walk an even
        // number of times, as setting faces aside read it, is closed.
        read_closed =
            shells.len() == 1 && aside.is_some_and(|aside| !aside.is_empty() && aside.closed);
        for shell in shells {
            if !read_closed && !is_shell_closed(model, &shell)? {
                ogeom_bail!(Construction, "an open shell bounds no volume to operate on");
            }
        }
    }

    let mut faces = Vec::new();
    let mut shared = ogeom_core::FastMap::default();
    // Each edge occurrence read once for the faces on either side of it:
    // its world curve, its ends, and its sampled extent.
    let mut occurrences: ogeom_core::FastMap<(ogeom_topo::TShapeId, Location), Occurrence> =
        ogeom_core::FastMap::default();
    let aside = aside.filter(|aside| !aside.is_empty());
    for face in explore(model, solid, Filter::OfType(ShapeType::Face))? {
        if aside.is_some_and(|aside| {
            !aside
                .gathered
                .contains_key(&ogeom_topo::SameKey(face.clone()))
        }) {
            continue;
        }
        let Some(node) = model.node(&face) else {
            ogeom_bail!(Dangling, "face is not in this model");
        };
        let NodeData::Face(data) = node.data() else {
            ogeom_bail!(Construction, "face node holds no face data");
        };
        let Some(stored) = model.geometry().surface(data.surface) else {
            ogeom_bail!(Dangling, "face refers to a surface not in this model");
        };
        let placement = face.transform(model.datums())?;
        if (placement.scale_factor().abs() - 1.0).abs() > 1e-9 {
            ogeom_bail!(
                NotDone,
                "a scaled placement changes a surface's parameterization out \
                 from under its pcurves; bake the scale before a boolean"
            );
        }
        let surface = stored.transformed(&placement, tol)?;
        let surface_id = data.surface;
        let tolerance = data.tolerance.get();

        // A plane's holes clear of the other solid are left out: nothing
        // crosses them, and each goes back into the piece holding it.
        let holes_aside = aside
            .and_then(|aside| aside.holes.get(&ogeom_topo::SameKey(face.clone())))
            .cloned()
            .unwrap_or_else(|| std::sync::Arc::from(Vec::new()));
        let slits = slits(model, &face, &surface, surface_id, tol)?;
        // How the face walks each of its edges, senses composed: forward
        // along the curve, back, or both ways (a seam).
        let mut walks: ogeom_core::FastMap<EdgeKey, (bool, bool)> = ogeom_core::FastMap::default();
        for edge in explore(model, &face, Filter::OfType(ShapeType::Edge))? {
            let forward = edge.orientation() == ogeom_topo::Orientation::Forward;
            let walk = walks.entry(EdgeKey::of(&edge)).or_default();
            if forward {
                walk.0 = true;
            } else {
                walk.1 = true;
            }
        }
        let mut face_edges = if holes_aside.is_empty() {
            explore_unique(model, &face, ShapeType::Edge)?
        } else {
            let wires = model.children_of(&face)?;
            let mut left = vec![false; wires.len()];
            for hole in holes_aside.iter() {
                left[hole.at] = true;
            }
            let mut seen = ogeom_core::FastSet::default();
            let mut edges = Vec::new();
            for (wire, _) in wires.iter().zip(&left).filter(|(_, left)| !**left) {
                for edge in explore_unique(model, wire, ShapeType::Edge)? {
                    if seen.insert(ogeom_topo::SameKey(edge.clone())) {
                        edges.push(edge);
                    }
                }
            }
            edges
        };
        face_edges.retain(|edge| !slits.contains(&EdgeKey::of(edge)));
        let mut shares = false;

        let mut edges = Vec::new();
        let mut samples: Vec<(ogeom_math::Aabb, ogeom_math::Aabb, f64)> = Vec::new();
        let mut poles = Vec::new();
        let mut pole_keys = Vec::new();
        for edge in face_edges {
            if let Some(aside) = aside
                && aside.edges.contains(&EdgeKey::of(&edge))
            {
                shared.insert(
                    EdgeKey::of(&edge),
                    edge.oriented(ogeom_topo::Orientation::Forward),
                );
                shares = true;
            }
            let Some(edge_node) = model.node(&edge) else {
                ogeom_bail!(Dangling, "edge is not in this model");
            };
            let NodeData::Edge(edge_data) = edge_node.data() else {
                ogeom_bail!(Construction, "edge node holds no edge data");
            };
            let Some(EdgeRepr::Curve3d { curve, range, .. }) = edge_data.curve3d() else {
                // A degenerate edge (a sphere's pole, a cone's apex) has
                // no extent to split, but it *does* bound the chart, and a
                // chart whose top is missing bounds nothing.
                if let Some(EdgeRepr::PCurve {
                    curve: pc, range, ..
                }) = edge_data.pcurve_for(surface_id, edge.location())
                {
                    let Some(planar) = model.geometry().pcurve(*pc) else {
                        ogeom_bail!(Dangling, "pcurve is not in this model");
                    };
                    let at = explore_unique(model, &edge, ShapeType::Vertex)?;
                    let Some(point) = at
                        .first()
                        .and_then(|v| model.node(v))
                        .and_then(|n| n.data().as_vertex().map(|d| d.point))
                    else {
                        ogeom_bail!(Construction, "a pole with no vertex is nowhere");
                    };
                    let placed = edge.transform(model.datums())?.apply(point);
                    poles.push(PoleEdge {
                        point: placed,
                        pcurve: planar.clone(),
                        prange: *range,
                    });
                    pole_keys.push(EdgeKey::of(&edge));
                }
                continue;
            };
            let occurrence = match occurrences.entry((edge.node(), edge.location().clone())) {
                ogeom_core::collections::hash_map::Entry::Occupied(known) => known.into_mut(),
                ogeom_core::collections::hash_map::Entry::Vacant(slot) => {
                    let Some(geometry) = model.geometry().curve(*curve) else {
                        ogeom_bail!(Dangling, "curve is not in this model");
                    };
                    let placed = geometry.transformed(&edge.transform(model.datums())?, tol)?;
                    slot.insert(Occurrence::of(model, &edge, placed, *range, tol)?)
                }
            };
            let world = occurrence.curve.clone();
            samples.push(occurrence.sampled);
            let (pcurve, prange, other_side, seam) =
                match edge_data.pcurve_for(surface_id, edge.location()) {
                    Some(EdgeRepr::PCurve {
                        curve: pc, range, ..
                    }) => {
                        let Some(planar) = model.geometry().pcurve(*pc) else {
                            ogeom_bail!(Dangling, "pcurve is not in this model");
                        };
                        (planar.clone(), *range, None, None)
                    }
                    Some(EdgeRepr::Seam {
                        forward,
                        reversed,
                        range,
                        ..
                    }) => {
                        let (Some(f), Some(r)) = (
                            model.geometry().pcurve(*forward),
                            model.geometry().pcurve(*reversed),
                        ) else {
                            ogeom_bail!(Dangling, "seam pcurve is not in this model");
                        };
                        (
                            f.clone(),
                            *range,
                            Some((r.clone(), *range)),
                            Some((f.clone(), r.clone())),
                        )
                    }
                    _ => ogeom_bail!(
                        Construction,
                        "an edge with no pcurve on its face cannot be split in \
                         that face's parameter space"
                    ),
                };
            let edge_tolerance = edge_data.tolerance.get();
            let mut standoff = edge_tolerance;
            let mut residual = edge_tolerance;
            if edge_tolerance > tol.confusion() * 10.0 {
                let gap = |pc: &PlanarCurve, pr: (f64, f64)| {
                    ogeom_algo::pcurve_fit::lifted_gap(
                        (&world, *range),
                        (pc, pr),
                        &surface,
                        false,
                        tol,
                    )
                    .unwrap_or(edge_tolerance)
                };
                let mut measured = gap(&pcurve, prange);
                if let Some((other, orange)) = &other_side {
                    measured = measured.max(gap(other, *orange));
                }
                standoff = measured.min(edge_tolerance);
                residual = measured.max(edge_tolerance);
            }

            edges.push(BoundaryEdge {
                node: occurrence.key,
                curve: world,
                crange: *range,
                pcurve,
                prange,
                other_side,
                seam,
                tolerance: edge_tolerance,
                standoff,
                residual,
                walked: match walks.get(&occurrence.key) {
                    Some((true, false)) => Some(true),
                    Some((false, true)) => Some(false),
                    _ => None,
                },
                image: None,
                ends_tolerance: occurrence.ends_tolerance,
                ends: occurrence.ends,
                vertices: occurrence.vertices,
                bound: ogeom_math::Aabb::EMPTY,
            });
        }
        if edges.is_empty() {
            ogeom_bail!(Construction, "a face with no boundary bounds nothing");
        }

        if aside.is_none() || !(shares || !holes_aside.is_empty()) {
            fold_seamed_rings(
                model,
                &face,
                &surface,
                &mut edges,
                (&poles, &pole_keys),
                &slits,
                tol,
            )?;
        }
        // A seam edge bounds the chart twice *only when this face wraps*:
        // when its other boundary reaches both columns, as a full drum's
        // rims do. A face that merely sits against the meridian (a sphere
        // octant whose boundary happens to be the seam) uses one column,
        // and feeding the far copy into the arrangement leaves a strand
        // nothing connects to. The decision is made here, once, by chart
        // connectivity, and everything downstream (the arrangement, the
        // trim tests, the rebuild) inherits it.
        let seam_indices: Vec<usize> = edges
            .iter()
            .enumerate()
            .filter(|(_, e)| e.other_side.is_some())
            .map(|(i, _)| i)
            .collect();
        for i in seam_indices {
            // Each other end in the chart, with how far its edge may stand
            // off where it meets the next: its own radius, or its ends'.
            let mut pool: Vec<(Point2, f64)> = Vec::new();
            for (j, e) in edges.iter().enumerate() {
                if j == i {
                    continue;
                }
                let reach = e.tolerance.max(e.ends_tolerance);
                for t in [e.prange.0, e.prange.1] {
                    pool.push((e.pcurve.point_at(t, tol)?, reach));
                }
                if let Some((other, orange)) = &e.other_side {
                    for t in [orange.0, orange.1] {
                        pool.push((other.point_at(t, tol)?, reach));
                    }
                }
            }
            for p in &poles {
                for t in [p.prange.0, p.prange.1] {
                    pool.push((p.pcurve.point_at(t, tol)?, 0.0));
                }
            }
            let own = edges[i].tolerance.max(edges[i].ends_tolerance);
            // Two ends meet within PARAM_SNAP in the chart, or as far apart
            // across it as both their radii reach in space, twice over: a
            // loop's pcurve, sewn shut in space within its ends' radius, can
            // stop a hair short of the column it closes on. Read across the
            // chart, not in space, where the seam's two columns are one.
            let meets = |q: Point2, at: Point2, reach: f64| -> bool {
                let apart = q.distance(at);
                if apart <= PARAM_SNAP {
                    return true;
                }
                // A hair, not a turn: at a pole a column's whole width
                // costs nothing in space.
                if apart > SEAM_HAIR {
                    return false;
                }
                let middle = Point2::new(f64::midpoint(q.x, at.x), f64::midpoint(q.y, at.y));
                let Ok((du, dv)) = surface.d1_at(middle.x, middle.y, tol) else {
                    return false;
                };
                let across = (du.magnitude() * (q.x - at.x)).hypot(dv.magnitude() * (q.y - at.y));
                across <= 2.0 * (reach + own) + tol.confusion()
            };
            let connected = |pc: &PlanarCurve, range: (f64, f64)| -> OgeomResult<bool> {
                for t in [range.0, range.1] {
                    let at = pc.point_at(t, tol)?;
                    if !pool.iter().any(|&(q, reach)| meets(q, at, reach)) {
                        return Ok(false);
                    }
                }
                Ok(true)
            };
            let e = &edges[i];
            let primary_connects = connected(&e.pcurve, e.prange)?;
            let (other_pc, orange) = e
                .other_side
                .clone()
                .unwrap_or_else(|| (e.pcurve.clone(), e.prange));
            let other_connects = connected(&other_pc, orange)?;
            match (primary_connects, other_connects) {
                // Both columns meet the rest of the boundary: the face
                // wraps, and both belong.
                (true, true) => {}
                // One column is this face's. The far copy would dangle.
                (true, false) => edges[i].other_side = None,
                (false, true) => {
                    let e = &mut edges[i];
                    e.pcurve = other_pc;
                    e.prange = orange;
                    e.other_side = None;
                }
                // Neither connects: leave both, and the arrangement's own
                // refusal names the failure.
                (false, false) => {}
            }
        }
        // Every ring is folded onto one branch of its chart, a face rebuilt
        // on its own surface beside faces set aside too. Such a face keeps
        // the pcurves of the edges it shares with them as stated. Along a
        // direction the surface repeats in, a stated pcurve whole periods
        // from where the fold reads it names the same curve, as it did in
        // the face given. Along one the chart only closes in, the two lie on
        // different lines of the closure, and the fuse gathers every face
        // instead.
        let stated: Vec<Option<Point2>> = edges
            .iter()
            .map(|e| {
                aside
                    .is_some_and(|aside| aside.edges.contains(&e.node))
                    .then(|| {
                        e.pcurve
                            .point_at(f64::midpoint(e.prange.0, e.prange.1), tol)
                    })
                    .transpose()
            })
            .collect::<OgeomResult<_>>()?;
        fold_rings(
            model,
            &face,
            &surface,
            &mut edges,
            (&poles, &pole_keys),
            &slits,
            tol,
        )?;
        let repeats = [surface.is_periodic_u(), surface.is_periodic_v()];
        for (e, at) in edges.iter().zip(&stated) {
            let Some(at) = at else { continue };
            let now = e
                .pcurve
                .point_at(f64::midpoint(e.prange.0, e.prange.1), tol)?;
            if ((now.x - at.x).abs() > PARAM_SNAP && !repeats[0])
                || ((now.y - at.y).abs() > PARAM_SNAP && !repeats[1])
            {
                ogeom_bail!(
                    NotDone,
                    "a face sharing edges with faces set aside has its ring stated \
                     across its chart's join on one of them"
                );
            }
        }
        let moved = bring_trim_home(&surface, &mut edges, &mut poles, tol)?;
        close_pole_joints(
            model,
            &face,
            &surface,
            (&edges, &slits),
            &mut poles,
            &pole_keys,
            tol,
        )?;
        // Rebuilt around edges it shares with faces set aside, the face
        // stays on its own surface, where those edges' pcurves are, in the
        // chart they are stated in.
        let own_surface = if aside.is_some() && (shares || !holes_aside.is_empty()) {
            if moved {
                ogeom_bail!(
                    NotDone,
                    "a face sharing edges with faces set aside has its trim stated \
                     a period off its chart"
                );
            }
            Some(surface_id)
        } else {
            None
        };
        let mut bound = ogeom_math::Aabb::EMPTY;
        // For a plane or a ruled surface the box is trusted to the
        // boundary's own hull, so the boundary's sampling slack must be
        // measured: how far the true edge sags from the 16-chord polyline,
        // read at each chord's midpoint and doubled for the sag's asymmetry.
        // A disc's rim bows out between its samples by more than a
        // cylinder's cap pokes past a wall it all but meets.
        let ruled = matches!(
            &surface,
            SurfaceGeometry::Plane(_) | SurfaceGeometry::Cylinder(_) | SurfaceGeometry::Cone(_)
        );
        let mut slack = 0.0_f64;
        for (e, &(points, mids, sag)) in edges.iter_mut().zip(&samples) {
            if ruled {
                slack = slack.max(sag);
                bound = bound.union(&mids);
            }
            bound = bound.union(&points);
            e.bound = points
                .union(&mids)
                .expanded(sag + e.tolerance + tol.confusion() * 1e2);
        }
        // A plane never bulges past its boundary. A ruled surface (cylinder,
        // cone) cannot either: every surface point lies on a straight ruling
        // whose ends are on the boundary, so the face sits inside its
        // boundary's hull and only the boundary's own sampling slack is needed,
        // the plane's as much as the ruled surface's.
        // Anything else may genuinely bulge (a dome past its equator) and
        // keeps most of its own diagonal as allowance. The audit behind
        // OGEOM_BOOL_AUDIT_BOUNDS holds every arm to conservatism.
        let bulge = match &surface {
            SurfaceGeometry::Plane(_) | SurfaceGeometry::Cylinder(_) | SurfaceGeometry::Cone(_) => {
                slack
            }
            _ => bound.diagonal() * 0.75,
        };
        // The scale the marching chord is derived from, decoupled from the
        // filter box: the diagonal with a blanket three-quarter bulge for
        // every curved surface. The chord is a tolerance, not a bound, so
        // tightening the filter must not silently tighten the marcher,
        // which is what a single box feeding both does.
        let margin = tol.confusion() * 1e2;
        let chord_scale = match &surface {
            SurfaceGeometry::Plane(_) => bound.expanded(margin).diagonal(),
            _ => bound.expanded(bound.diagonal() * 0.75 + margin).diagonal(),
        };
        // A pole bounds the chart with no edge to sample: a cone drilled to
        // its apex reaches the apex, and a bound that omits it would let the
        // filter drop a pair the apex genuinely meets. It joins *after* the
        // bulge is taken from the boundary's own diagonal: the pole is an
        // exact point, and letting it stretch the diagonal would inflate a
        // dome's allowance by its own height over again.
        let mut bound = bound.expanded(bulge);
        for pole in &poles {
            bound = bound.with_point(pole.point);
        }
        let bound = bound.expanded(tol.confusion() * 1e2);
        let filter = kept_filter(model, &face, &surface, bound, tol);
        let carrier = (surface_id, face.location().clone());
        faces.push(GFace {
            poles,
            slits,
            face,
            surface,
            bound,
            filter,
            chord_scale,
            tolerance,
            edges,
            outline: std::sync::OnceLock::new(),
            outline_trim: std::sync::OnceLock::new(),
            trim_lines: std::sync::OnceLock::new(),
            holes_aside,
            own_surface,
            carrier,
        });
    }
    if faces.is_empty() {
        if sheet {
            ogeom_bail!(Construction, "a sheet with no faces has nothing to split");
        }
        ogeom_bail!(Construction, "a solid with no faces bounds nothing");
    }
    let mut shared_vertices = Vec::new();
    let mut seen = ogeom_core::FastSet::default();
    for edge in shared.values() {
        for vertex in model.children_of(edge)? {
            if !seen.insert(ogeom_topo::SameKey(vertex.clone())) {
                continue;
            }
            let Some(data) = model.node(&vertex).and_then(|n| n.data().as_vertex()) else {
                ogeom_bail!(Dangling, "vertex is not in this model");
            };
            let at = vertex.transform(model.datums())?.apply(data.point);
            shared_vertices.push((at, vertex.oriented(ogeom_topo::Orientation::Forward)));
        }
    }
    // An edge's tolerance is owed to the face whose image of it stands that
    // far off, and each other face reads the edge as it stands off that
    // face. One no face of it stands off by half as much (an edge stated
    // loose, a rail welded across a gap an earlier operation left) owes it
    // to none, and every face reads the edge to its tolerance.
    let mut owed: ogeom_core::FastMap<EdgeKey, f64> = ogeom_core::FastMap::default();
    for e in faces.iter().flat_map(|f: &GFace| f.edges.iter()) {
        let most = owed.entry(e.node).or_insert(0.0);
        *most = most.max(e.standoff);
    }
    for face in &mut faces {
        for e in &mut face.edges {
            if owed
                .get(&e.node)
                .is_some_and(|most| most * 2.0 < e.tolerance)
            {
                e.standoff = e.tolerance;
                continue;
            }
            // Standing off the face, the edge is drawn as the face draws it,
            // its pcurve read against its curve in proportion as the face's
            // strands draw it. Where the two are paced apart by more than
            // twice the edge's tolerance, the reach a loose edge's junction
            // takes, that reading would put the face's stops a pace off the
            // edge's splits, and the edge is read as it stands.
            // A periodic curve or pcurve (a circle, in space or in a chart)
            // is read through one window only, and parameters met along it
            // come back folded into its period: such an edge is left to its
            // curve.
            if e.standoff <= tol.confusion() * DRAWN_APART
                || e.other_side.is_some()
                || e.pcurve.is_periodic()
                || e.curve.is_periodic()
            {
                continue;
            }
            let paced = ogeom_algo::pcurve_fit::lifted_gap(
                (&e.curve, e.crange),
                (&e.pcurve, e.prange),
                &face.surface,
                true,
                tol,
            );
            if !paced.is_ok_and(|gap| gap <= e.tolerance * 2.0) {
                continue;
            }
            let (lo, hi) = ordered(e.prange);
            e.image = ogeom_geom::TrimmedCurve::new(
                Curve::OnSurface(Box::new(ogeom_geom::CurveOnSurface::new(
                    e.pcurve.clone(),
                    face.surface.clone(),
                ))),
                lo,
                hi,
                tol,
            )
            .ok()
            .map(|trimmed| std::sync::Arc::new(Curve::Trimmed(Box::new(trimmed))));
        }
    }
    Ok(GSolid {
        solid: solid.clone(),
        faces,
        aside: aside.map(|aside| aside.faces.clone()).unwrap_or_default(),
        shared,
        shared_vertices,
        order: aside
            .map(|aside| aside.gathered.clone())
            .unwrap_or_default(),
        beside: aside.map(|aside| aside.beside.clone()).unwrap_or_default(),
        closed: read_closed,
    })
}

/// `bound` cut down to the box the model keeps for `face`, widened by the
/// margin the box tests allow. The kept box is found exactly on the
/// elementary surfaces; on any other its interior extremes start from a
/// mesh, which may fall short of the surface by the mesh's chord, and that
/// chord is allowed for. A face whose box cannot be found keeps `bound`.
fn kept_filter(
    model: &Model,
    face: &Shape,
    surface: &SurfaceGeometry,
    bound: ogeom_math::Aabb,
    tol: Tolerances,
) -> ogeom_math::Aabb {
    let Ok(kept) = ogeom_algo::face_bounds(model, face) else {
        return bound;
    };
    let exact = matches!(
        surface,
        SurfaceGeometry::Plane(_)
            | SurfaceGeometry::Cylinder(_)
            | SurfaceGeometry::Cone(_)
            | SurfaceGeometry::Sphere(_)
            | SurfaceGeometry::Torus(_)
    );
    let mut margin = tol.confusion() * 1e2;
    if !exact {
        margin += ogeom_mesh::Deflection::default().chord;
    }
    let filter = bound.intersection(&kept.expanded(margin));
    if filter.is_empty() { bound } else { filter }
}

/// The slits of a face: edges a ring walks out along and straight back, the
/// face on both sides, ending at a vertex no other edge of the ring reaches.
///
/// Such an edge bounds no material. The arrangement reads each strand as a
/// stretch of a cycle between nodes, and a slit's tip is a node of one
/// strand only. Left out of the face's boundary, the ring closes round the
/// region the face covers, and the pieces of it are rebuilt without it.
///
/// A ring is peeled at a joint where it takes the same edge, of two
/// distinct vertices, once each way, and where the joint is an ordinary
/// point of the chart. Peeling one slit may leave the edge it hangs from
/// walked out and back, and that edge is peeled in turn.
///
/// A seam to a pole is walked the same way, out along one column and back
/// along the other: at the pole the whole chart row is one point, and the
/// face wraps round it between the two columns. A joint is such a pole
/// where the surface's rate along a row through it, read at the row's ends
/// and middle, times the chart's whole width that way, stays within the
/// joint vertex's radius. A ring is never peeled there.
fn slits(
    model: &Model,
    face: &Shape,
    surface: &SurfaceGeometry,
    surface_id: ogeom_topo::SurfaceId,
    tol: Tolerances,
) -> OgeomResult<ogeom_core::FastSet<EdgeKey>> {
    let mut slits = ogeom_core::FastSet::default();
    let ((u0, u1), (v0, v1)) = surface.domain();
    // Whether the joint where `edge` ends, as its ring walks it, is an
    // ordinary point of the chart, not on a row the surface collapses.
    let ordinary = |edge: &Shape| -> OgeomResult<bool> {
        let Some(data) = model.node(edge).and_then(|n| n.data().as_edge()) else {
            return Ok(false);
        };
        if !matches!(data.curve3d(), Some(EdgeRepr::Curve3d { .. })) {
            return Ok(false);
        }
        let Some((start, end)) = ogeom_algo::edge_vertices(model, edge)? else {
            return Ok(false);
        };
        if start.is_same(&end) {
            return Ok(false);
        }
        let Some(tip) = model.node(&end).and_then(|n| n.data().as_vertex()) else {
            return Ok(false);
        };
        let reach = tip.tolerance.get().max(tol.confusion());
        let (pcurve, range) = match data.pcurve_for(surface_id, edge.location()) {
            Some(EdgeRepr::PCurve { curve, range, .. }) => (curve, range),
            Some(EdgeRepr::Seam { forward, range, .. }) => (forward, range),
            _ => return Ok(false),
        };
        let Some(pcurve) = model.geometry().pcurve(*pcurve) else {
            return Ok(false);
        };
        let back = edge.orientation() == ogeom_topo::Orientation::Reversed;
        let at = pcurve.point_at(if back { range.0 } else { range.1 }, tol)?;
        for along_u in [true, false] {
            let (lo, hi) = if along_u { (u0, u1) } else { (v0, v1) };
            let width = hi - lo;
            let mut collapses = width.is_finite();
            for s in [0.0, 0.5, 1.0] {
                if !collapses {
                    break;
                }
                let q = if along_u {
                    Point2::new(lo + width * s, at.y)
                } else {
                    Point2::new(at.x, lo + width * s)
                };
                let Ok((du, dv)) = surface.d1_at(q.x, q.y, tol) else {
                    return Ok(false);
                };
                let rate = if along_u {
                    du.magnitude()
                } else {
                    dv.magnitude()
                };
                collapses = rate * width <= reach;
            }
            if collapses {
                return Ok(false);
            }
        }
        Ok(true)
    };
    let stored = face.oriented(ogeom_topo::Orientation::Forward);
    for wire in model.children_of(&stored)? {
        let mut ring = model.ordered_children_of(&wire)?;
        'peel: loop {
            let n = ring.len();
            for k in 0..n {
                let (out, back) = (&ring[k], &ring[(k + 1) % n]);
                if n < 2
                    || EdgeKey::of(out) != EdgeKey::of(back)
                    || out.orientation() == back.orientation()
                    || !ordinary(out)?
                {
                    continue;
                }
                slits.insert(EdgeKey::of(out));
                let (first, second) = (k.min((k + 1) % n), k.max((k + 1) % n));
                ring.remove(second);
                ring.remove(first);
                continue 'peel;
            }
            break;
        }
    }
    Ok(slits)
}

/// The rings of `face`, as it orients them, each without its slits.
fn rings_without(
    model: &Model,
    face: &Shape,
    slits: &ogeom_core::FastSet<EdgeKey>,
) -> OgeomResult<Vec<Vec<Shape>>> {
    model
        .children_of(face)?
        .iter()
        .map(|wire| {
            let mut ring = model.ordered_children_of(wire)?;
            ring.retain(|edge| !slits.contains(&EdgeKey::of(edge)));
            Ok(ring)
        })
        .collect()
}

/// Each of a face's rings walked in its chart, every edge's pcurve moved by
/// whole periods onto the branch that continues the ring, along each
/// direction the chart closes in, and each hole brought onto its outer
/// ring's branch.
///
/// Two faces sharing an edge share its pcurve, and on a periodic surface
/// it is stated on one branch: a quarter-round wall's straight edge on the
/// chart's closure may stand at `u = 0` while the arcs it meets end at
/// `u = 2 pi`. The ring is one closed curve on the surface, and in the
/// chart it jumps a period at one joint and back at another; the
/// arrangement reads two strands that end where nothing begins. The
/// mesher folds the same jumps back, edge by edge.
///
/// The walk starts on a ring's degenerate edge where it has one: a pole's
/// or an apex's chart line is the strand the arrangement draws there, and
/// is never moved, so the edges either side of it are carried onto its
/// branch, met in the chart, since every point of the line is the same
/// point of the surface. Failing that it starts on a seam the ring walks
/// once, a border with another face across the seam: read on the side the
/// ring walks it, it is never moved either, and the ring folded onto it
/// keeps that side alone. Elsewhere an edge is moved where its start stands
/// whole periods from the end walked to, unless the joint stands across a
/// degenerate row, and moved stands within both edges' radii of it on the
/// surface, measured through the middle of the chart segment between them.
/// A joint stands across a degenerate row where the surface's derivative
/// along the chart segment between its ends vanishes, not where the ends
/// merely lie close: a cylinder smaller than its edges' radii has ends a
/// period apart that close. A ring with no degenerate edge starts just
/// after a joint across an apex (two rulings meeting at one point stand
/// apart in the chart, and meet from any branch), and its first edge never
/// moves.
///
/// A ring is folded only where, folded, it closes where it began: one
/// winding round the surface keeps its jump. A ring walking a seam both
/// ways, or another edge twice, is left as stated, as is one walking a
/// seam once on a side it cannot tell. A hole whose chart extent lies
/// wholly beside its outer ring's is moved by the whole periods that put
/// it inside. On a chart that closes without repeating, a pcurve moves
/// only onto a stretch the chart covers.
fn fold_rings(
    model: &Model,
    face: &Shape,
    surface: &SurfaceGeometry,
    edges: &mut [BoundaryEdge],
    (poles, pole_keys): (&[PoleEdge], &[EdgeKey]),
    slits: &ogeom_core::FastSet<EdgeKey>,
    tol: Tolerances,
) -> OgeomResult<()> {
    /// One edge as a ring walks it: a boundary edge, which may move; a
    /// degenerate one, which anchors the ring; or a seam the ring walks
    /// once, on the side it walks (an index into the ring's seam sides),
    /// which anchors it too; and whether the walk runs against its pcurve.
    #[derive(Clone, Copy)]
    enum Step {
        Edge(usize, bool),
        Pole(usize, bool),
        Seam(usize, bool),
    }
    let ((ua, ub), (va, vb)) = surface.domain();
    let periods = [
        ((surface.is_periodic_u() || surface.is_closed_u(tol)) && ub > ua).then_some(ub - ua),
        ((surface.is_periodic_v() || surface.is_closed_v(tol)) && vb > va).then_some(vb - va),
    ];
    if periods.iter().all(Option::is_none) {
        return Ok(());
    }
    let periodic = [surface.is_periodic_u(), surface.is_periodic_v()];
    // On a chart that closes without repeating, a pcurve is moved only onto
    // a stretch the chart covers: an edge on the closure, from one of its
    // two lines to the other.
    let inside = |pc: &PlanarCurve, range: (f64, f64)| -> OgeomResult<bool> {
        for k in 0..=2 {
            let p = pc.point_at(range.0 + (range.1 - range.0) * f64::from(k) / 2.0, tol)?;
            if (!periodic[0] && (p.x < ua - PARAM_SNAP || p.x > ub + PARAM_SNAP))
                || (!periodic[1] && (p.y < va - PARAM_SNAP || p.y > vb + PARAM_SNAP))
            {
                return Ok(false);
            }
        }
        Ok(true)
    };
    // The whole periods that bring `from` nearest `to`, along each closing
    // direction.
    let whole = |to: Point2, from: Point2| -> ogeom_math::Vector2 {
        let mut shift = ogeom_math::Vector2::new(0.0, 0.0);
        if let Some(period) = periods[0] {
            shift.x = ((to.x - from.x) / period).round() * period;
        }
        if let Some(period) = periods[1] {
            shift.y = ((to.y - from.y) / period).round() * period;
        }
        shift
    };
    let mut index: ogeom_core::FastMap<EdgeKey, (usize, usize)> = ogeom_core::FastMap::default();
    for (i, e) in edges.iter().enumerate() {
        index.insert(e.node, (i, 0));
    }
    let wires = rings_without(model, face, slits)?;
    for edge in wires.iter().flatten() {
        if let Some(slot) = index.get_mut(&EdgeKey::of(edge)) {
            slot.1 += 1;
        }
    }
    // How far apart two chart points stand on the surface, read through
    // the middle of the segment between them.
    let apart = |a: Point2, b: Point2| -> Option<f64> {
        let mid = Point2::new(f64::midpoint(a.x, b.x), f64::midpoint(a.y, b.y));
        let (p, m, q) = (
            surface.point_at(a.x, a.y, tol).ok()?,
            surface.point_at(mid.x, mid.y, tol).ok()?,
            surface.point_at(b.x, b.y, tol).ok()?,
        );
        Some(p.distance(m).max(m.distance(q)))
    };
    // Each ring's boundary edges where it was walked: the rings a hole may
    // be brought home among.
    let mut walked: Vec<Option<Vec<usize>>> = Vec::with_capacity(wires.len());
    for ring in &wires {
        let mut walk = Vec::with_capacity(ring.len());
        let mut kept = false;
        // Each seam the ring walks once, a border with another face rather
        // than the face's own closure: the edge and the side walked.
        let mut sides: Vec<(usize, PlanarCurve, (f64, f64))> = Vec::new();
        for edge in ring {
            let back = edge.orientation() == ogeom_topo::Orientation::Reversed;
            let key = EdgeKey::of(edge);
            if let Some(&(i, uses)) = index.get(&key) {
                let e = &edges[i];
                if uses == 1 && e.seam.is_some() {
                    match walked_seam_side(e, back, tol)? {
                        Some((pcurve, range)) => {
                            walk.push(Step::Seam(sides.len(), back));
                            sides.push((i, pcurve, range));
                        }
                        None => kept = true,
                    }
                    continue;
                }
                kept |= uses > 1 || e.seam.is_some() || e.other_side.is_some();
                walk.push(Step::Edge(i, back));
            } else if let Some(j) = pole_keys.iter().position(|k| *k == key) {
                walk.push(Step::Pole(j, back));
            }
        }
        let moving: Vec<usize> = walk
            .iter()
            .filter_map(|s| match s {
                Step::Edge(i, _) => Some(*i),
                Step::Pole(..) | Step::Seam(..) => None,
            })
            .collect();
        if kept || moving.is_empty() {
            walked.push(None);
            continue;
        }
        // A ring of one edge has no joint to fold, and as a hole may still
        // stand on another branch from its outer ring.
        if walk.len() < 2 {
            walked.push(Some(moving));
            continue;
        }
        let ends_of = |step: Step| -> OgeomResult<(Point2, Point2)> {
            let (pc, range, back) = match step {
                Step::Edge(i, back) => (&edges[i].pcurve, edges[i].prange, back),
                Step::Pole(j, back) => (&poles[j].pcurve, poles[j].prange, back),
                Step::Seam(k, back) => (&sides[k].1, sides[k].2, back),
            };
            let (a, b) = (pc.point_at(range.0, tol)?, pc.point_at(range.1, tol)?);
            Ok(if back { (b, a) } else { (a, b) })
        };
        let radius = |step: Step| match step {
            Step::Edge(i, _) => edges[i].tolerance.max(edges[i].ends_tolerance),
            Step::Seam(k, _) => edges[sides[k].0]
                .tolerance
                .max(edges[sides[k].0].ends_tolerance),
            Step::Pole(..) => 0.0,
        };
        let is_pole = |step: Step| matches!(step, Step::Pole(..));
        // Whether a joint meets: on the surface, within both edges' radii,
        // or beside a degenerate edge, whose line stands for one point, in
        // the chart within the same reach. There the chart shrinks to
        // nothing along the line, and the arrangement welds a strand's end
        // there at its length in space, unscaled, no finer than its own
        // node snap: the fold carries an edge onto the pole's line only
        // where that weld then meets it.
        let meets = |a: Point2, b: Point2, step: Step, prev: Step, within: f64| -> bool {
            if is_pole(step) || is_pole(prev) {
                a.distance(b) <= within.max(PARAM_SNAP)
            } else {
                apart(a, b).is_some_and(|d| d <= within)
            }
        };
        // Whether a joint's two ends, apart in the chart, stand across a
        // degenerate row: the surface does not move along the chart segment
        // between them, its derivative along it vanishing at both ends and
        // in the middle, so that the whole gap moves it by under the
        // confusion distance. A small surface's ends a period apart lie
        // within the edges' radii without its derivative vanishing, and are
        // not such a joint.
        let across_a_degenerate_row = |a: Point2, b: Point2| -> bool {
            let gap = b - a;
            let length = gap.magnitude();
            if length <= PARAM_SNAP {
                return false;
            }
            let middle = Point2::new(f64::midpoint(a.x, b.x), f64::midpoint(a.y, b.y));
            [a, middle, b].iter().all(|p| {
                surface
                    .d1_at(p.x, p.y, tol)
                    .is_ok_and(|(du, dv)| (du * gap.x + dv * gap.y).magnitude() <= tol.confusion())
            })
        };
        let anchor = |step: &Step| matches!(step, Step::Pole(..) | Step::Seam(..));
        let start = if let Some(k) = walk.iter().position(|s| is_pole(*s)) {
            k
        } else if let Some(k) = walk.iter().position(anchor) {
            k
        } else {
            let mut start = 0;
            for k in 0..walk.len() {
                let (step, prev) = (walk[k], walk[(k + walk.len() - 1) % walk.len()]);
                let (end, from) = (ends_of(prev)?.1, ends_of(step)?.0);
                if across_a_degenerate_row(end, from) {
                    start = k;
                    break;
                }
            }
            start
        };
        walk.rotate_left(start);
        let (begin, mut last) = ends_of(walk[0])?;
        let mut moves: Vec<(usize, PlanarCurve)> = Vec::new();
        let mut broken = false;
        for k in 1..walk.len() {
            let (step, prev) = (walk[k], walk[k - 1]);
            let (from, to) = ends_of(step)?;
            let within = 2.0 * (radius(step) + radius(prev)) + tol.confusion();
            let Step::Edge(i, _) = step else {
                // A degenerate edge stays where it is stated, and a seam
                // walked once on the side walked: the ring must reach it
                // there.
                broken |= !meets(last, from, step, prev, within);
                last = to;
                continue;
            };
            let shift = whole(last, from);
            let moved = Point2::new(from.x + shift.x, from.y + shift.y);
            // A whole period between two ends is a jump of branch, unless
            // the joint stands across a degenerate row; beside a degenerate
            // edge it is read in the chart.
            let jumps = if is_pole(step) || is_pole(prev) {
                !meets(last, from, step, prev, within)
            } else {
                !across_a_degenerate_row(last, from)
            };
            let fold = (shift.x != 0.0 || shift.y != 0.0)
                && jumps
                && meets(last, moved, step, prev, within);
            last = to;
            if fold {
                let by = ogeom_math::Transform2::translation(shift);
                let pcurve = edges[i].pcurve.transformed(&by, tol)?;
                if inside(&pcurve, edges[i].prange)? {
                    moves.push((i, pcurve));
                    last = Point2::new(to.x + shift.x, to.y + shift.y);
                }
            }
        }
        // Folded, the ring closes where it began, or it winds round the
        // surface and stays as stated.
        let (first, closing) = (walk[0], walk[walk.len() - 1]);
        let within = 2.0 * (radius(first) + radius(closing)) + tol.confusion();
        if !broken && !moves.is_empty() && meets(last, begin, first, closing, within) {
            for (i, pcurve) in moves {
                edges[i].pcurve = pcurve;
            }
            // Read on the side walked, the seam bounds the folded ring on
            // that column alone.
            for (i, pcurve, range) in sides {
                edges[i].pcurve = pcurve;
                edges[i].prange = range;
                edges[i].other_side = None;
            }
        }
        walked.push((!walk.iter().any(anchor)).then_some(moving));
    }
    // A hole on another branch from its outer ring is brought onto it.
    let extent = |edges: &[BoundaryEdge], ring: &[usize]| -> OgeomResult<(Point2, Point2)> {
        let mut low = Point2::new(f64::INFINITY, f64::INFINITY);
        let mut high = Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);
        for &i in ring {
            let e = &edges[i];
            for k in 0..=4 {
                let t = e.prange.0 + (e.prange.1 - e.prange.0) * f64::from(k) / 4.0;
                let p = e.pcurve.point_at(t, tol)?;
                low = Point2::new(low.x.min(p.x), low.y.min(p.y));
                high = Point2::new(high.x.max(p.x), high.y.max(p.y));
            }
        }
        Ok((low, high))
    };
    let Some(outer) = wires.first() else {
        return Ok(());
    };
    let outer: Vec<usize> = outer
        .iter()
        .filter_map(|e| index.get(&EdgeKey::of(e)).map(|&(i, _)| i))
        .collect();
    if outer.is_empty() {
        return Ok(());
    }
    let (olow, ohigh) = extent(edges, &outer)?;
    for hole in walked.iter().skip(1).flatten() {
        let (low, high) = extent(edges, hole)?;
        let centre = Point2::new(f64::midpoint(low.x, high.x), f64::midpoint(low.y, high.y));
        let ocentre = Point2::new(
            f64::midpoint(olow.x, ohigh.x),
            f64::midpoint(olow.y, ohigh.y),
        );
        let shift = whole(ocentre, centre);
        let beside =
            |lo: f64, hi: f64, olo: f64, ohi: f64| hi < olo - PARAM_SNAP || lo > ohi + PARAM_SNAP;
        let within =
            |lo: f64, hi: f64, olo: f64, ohi: f64| lo >= olo - PARAM_SNAP && hi <= ohi + PARAM_SNAP;
        let along = |s: f64, lo: f64, hi: f64, olo: f64, ohi: f64| {
            s == 0.0 || (beside(lo, hi, olo, ohi) && within(lo + s, hi + s, olo, ohi))
        };
        if (shift.x == 0.0 && shift.y == 0.0)
            || !along(shift.x, low.x, high.x, olow.x, ohigh.x)
            || !along(shift.y, low.y, high.y, olow.y, ohigh.y)
        {
            continue;
        }
        let by = ogeom_math::Transform2::translation(shift);
        let mut moved = Vec::with_capacity(hole.len());
        for &i in hole {
            let pcurve = edges[i].pcurve.transformed(&by, tol)?;
            if !inside(&pcurve, edges[i].prange)? {
                moved.clear();
                break;
            }
            moved.push((i, pcurve));
        }
        for (i, pcurve) in moved {
            edges[i].pcurve = pcurve;
        }
    }
    Ok(())
}

/// Which side of a seam an occurrence walks: the one that keeps the face
/// on the ring's left, as every ring of a face stored forward keeps it. A
/// seam's two sides bound the window the face wraps, so the face lies
/// towards the other side, and the occurrence runs along the side from
/// which that lies on its left. `None` where the sides do not stand apart
/// across the occurrence's run.
fn walked_seam_side(
    e: &BoundaryEdge,
    back: bool,
    tol: Tolerances,
) -> OgeomResult<Option<(PlanarCurve, (f64, f64))>> {
    let Some((other, orange)) = &e.other_side else {
        return Ok(None);
    };
    let (a, b) = (
        e.pcurve.point_at(e.prange.0, tol)?,
        e.pcurve.point_at(e.prange.1, tol)?,
    );
    let run = if back { a - b } else { b - a };
    let mid = |pc: &PlanarCurve, r: (f64, f64)| pc.point_at(f64::midpoint(r.0, r.1), tol);
    let towards = mid(other, *orange)? - mid(&e.pcurve, e.prange)?;
    let left = run.x * towards.y - run.y * towards.x;
    Ok(if left > 0.0 {
        Some((e.pcurve.clone(), e.prange))
    } else if left < 0.0 {
        Some((other.clone(), *orange))
    } else {
        None
    })
}

/// A ring walking a seam both ways brought onto the seam's branch of a
/// closed chart: each seam occurrence on the side the ring walks (see
/// [`walked_seam_side`]), and every other edge moved by the whole periods
/// that make it start where the ring has reached. A file may state a rim
/// a period or more off the window its seam bounds; the arrangement
/// draws both seam columns and needs the rims between them.
///
/// The ring is moved only where, so walked, every joint meets and it
/// closes where it began, and every moved pcurve stays on a stretch the
/// chart covers. Consecutive occurrences of one seam meet across the
/// closure, a whole period apart, where the ring crosses the join. A ring
/// with any other edge walked twice is left as stated.
fn fold_seamed_rings(
    model: &Model,
    face: &Shape,
    surface: &SurfaceGeometry,
    edges: &mut [BoundaryEdge],
    (poles, pole_keys): (&[PoleEdge], &[EdgeKey]),
    slits: &ogeom_core::FastSet<EdgeKey>,
    tol: Tolerances,
) -> OgeomResult<()> {
    #[derive(Clone)]
    enum Step {
        Seam(usize, Point2, Point2),
        Edge(usize, Point2, Point2),
        Pole(Point2, Point2),
    }
    let ((ua, ub), (va, vb)) = surface.domain();
    let periods = [
        ((surface.is_periodic_u() || surface.is_closed_u(tol)) && ub > ua).then_some(ub - ua),
        ((surface.is_periodic_v() || surface.is_closed_v(tol)) && vb > va).then_some(vb - va),
    ];
    if periods.iter().all(Option::is_none) {
        return Ok(());
    }
    let periodic = [surface.is_periodic_u(), surface.is_periodic_v()];
    let whole = |to: Point2, from: Point2| -> ogeom_math::Vector2 {
        let mut shift = ogeom_math::Vector2::new(0.0, 0.0);
        if let Some(period) = periods[0] {
            shift.x = ((to.x - from.x) / period).round() * period;
        }
        if let Some(period) = periods[1] {
            shift.y = ((to.y - from.y) / period).round() * period;
        }
        shift
    };
    let inside = |pc: &PlanarCurve, range: (f64, f64)| -> OgeomResult<bool> {
        for k in 0..=2 {
            let p = pc.point_at(range.0 + (range.1 - range.0) * f64::from(k) / 2.0, tol)?;
            if (!periodic[0] && (p.x < ua - PARAM_SNAP || p.x > ub + PARAM_SNAP))
                || (!periodic[1] && (p.y < va - PARAM_SNAP || p.y > vb + PARAM_SNAP))
            {
                return Ok(false);
            }
        }
        Ok(true)
    };
    let apart = |a: Point2, b: Point2| -> Option<f64> {
        let mid = Point2::new(f64::midpoint(a.x, b.x), f64::midpoint(a.y, b.y));
        let (p, m, q) = (
            surface.point_at(a.x, a.y, tol).ok()?,
            surface.point_at(mid.x, mid.y, tol).ok()?,
            surface.point_at(b.x, b.y, tol).ok()?,
        );
        Some(p.distance(m).max(m.distance(q)))
    };
    // A seam's two sides stand one period apart across the direction its
    // chart closes in; a file may state the far side whole periods
    // further. On a chart that closes without repeating, only one of the
    // two copies a period from the near side lies in the window: the far
    // side is moved there, exactly, by whole periods.
    for e in edges.iter_mut() {
        let Some((other, orange)) = &e.other_side else {
            continue;
        };
        let mid = |pc: &PlanarCurve, r: (f64, f64)| pc.point_at(f64::midpoint(r.0, r.1), tol);
        let (near, far) = (mid(&e.pcurve, e.prange)?, mid(other, *orange)?);
        let mut shift = ogeom_math::Vector2::new(0.0, 0.0);
        for (axis, period) in periods.iter().enumerate() {
            let Some(period) = *period else { continue };
            if periodic[axis] {
                continue;
            }
            let (from, to, lo, hi) = if axis == 0 {
                (near.x, far.x, ua, ub)
            } else {
                (near.y, far.y, va, vb)
            };
            let turns = ((to - from) / period).round();
            if turns.abs() < 2.0 || ((to - from) - turns * period).abs() > PARAM_SNAP {
                continue;
            }
            let inside = |x: f64| x >= lo - PARAM_SNAP && x <= hi + PARAM_SNAP;
            let copies: Vec<f64> = [-1.0, 1.0]
                .into_iter()
                .filter(|s| inside(from + s * period))
                .collect();
            if let [s] = copies.as_slice() {
                let by = (from + s * period) - (from + turns * period);
                if axis == 0 {
                    shift.x = by;
                } else {
                    shift.y = by;
                }
            }
        }
        if shift.x != 0.0 || shift.y != 0.0 {
            let by = ogeom_math::Transform2::translation(shift);
            let moved = other.transformed(&by, tol)?;
            let range = *orange;
            e.other_side = Some((moved, range));
        }
    }
    let mut uses: ogeom_core::FastMap<EdgeKey, (usize, usize)> = ogeom_core::FastMap::default();
    for (i, e) in edges.iter().enumerate() {
        uses.insert(e.node, (i, 0));
    }
    let wires = rings_without(
        model,
        &face.oriented(ogeom_topo::Orientation::Forward),
        slits,
    )?;
    for edge in wires.iter().flatten() {
        if let Some(slot) = uses.get_mut(&EdgeKey::of(edge)) {
            slot.1 += 1;
        }
    }
    'rings: for ring in &wires {
        let mut walk: Vec<Step> = Vec::with_capacity(ring.len());
        for edge in ring {
            let back = edge.orientation() == ogeom_topo::Orientation::Reversed;
            let key = EdgeKey::of(edge);
            let ends = |pc: &PlanarCurve, r: (f64, f64)| -> OgeomResult<(Point2, Point2)> {
                let (a, b) = (pc.point_at(r.0, tol)?, pc.point_at(r.1, tol)?);
                Ok(if back { (b, a) } else { (a, b) })
            };
            if let Some(&(i, n)) = uses.get(&key) {
                let e = &edges[i];
                if e.other_side.is_some() && n == 2 {
                    let Some((side, range)) = walked_seam_side(e, back, tol)? else {
                        continue 'rings;
                    };
                    let (a, b) = ends(&side, range)?;
                    walk.push(Step::Seam(i, a, b));
                } else if n == 1 && e.other_side.is_none() && e.seam.is_none() {
                    let (a, b) = ends(&e.pcurve, e.prange)?;
                    walk.push(Step::Edge(i, a, b));
                } else {
                    continue 'rings;
                }
            } else if let Some(j) = pole_keys.iter().position(|k| *k == key) {
                let (a, b) = ends(&poles[j].pcurve, poles[j].prange)?;
                walk.push(Step::Pole(a, b));
            } else {
                continue 'rings;
            }
        }
        let Some(start) = walk.iter().position(|s| matches!(s, Step::Seam(..))) else {
            continue;
        };
        walk.rotate_left(start);
        let radius = |s: &Step| match s {
            Step::Seam(i, ..) | Step::Edge(i, ..) => {
                edges[*i].tolerance.max(edges[*i].ends_tolerance)
            }
            Step::Pole(..) => 0.0,
        };
        let meets = |a: Point2, b: Point2, step: &Step, prev: &Step| -> bool {
            if matches!(step, Step::Pole(..)) || matches!(prev, Step::Pole(..)) {
                a.distance(b) <= SEAM_HAIR
            } else {
                let within = 2.0 * (radius(step) + radius(prev)) + tol.confusion();
                a.distance(b) <= PARAM_SNAP || apart(a, b).is_some_and(|d| d <= within)
            }
        };
        let Step::Seam(_, begin, mut last) = walk[0] else {
            continue;
        };
        let mut moves: Vec<(usize, PlanarCurve)> = Vec::new();
        for k in 1..walk.len() {
            let (step, prev) = (&walk[k], &walk[k - 1]);
            match step {
                Step::Edge(i, from, to) => {
                    let shift = whole(last, *from);
                    let moved = Point2::new(from.x + shift.x, from.y + shift.y);
                    if !meets(last, moved, step, prev) {
                        continue 'rings;
                    }
                    if shift.x != 0.0 || shift.y != 0.0 {
                        let by = ogeom_math::Transform2::translation(shift);
                        let pcurve = edges[*i].pcurve.transformed(&by, tol)?;
                        if !inside(&pcurve, edges[*i].prange)? {
                            continue 'rings;
                        }
                        moves.push((*i, pcurve));
                    }
                    last = Point2::new(to.x + shift.x, to.y + shift.y);
                }
                Step::Seam(i, from, to) => {
                    let across = matches!(prev, Step::Seam(j, ..) if j == i) && {
                        let shift = whole(last, *from);
                        (shift.x != 0.0 || shift.y != 0.0)
                            && meets(
                                last,
                                Point2::new(from.x + shift.x, from.y + shift.y),
                                step,
                                prev,
                            )
                    };
                    if !across && !meets(last, *from, step, prev) {
                        continue 'rings;
                    }
                    last = *to;
                }
                Step::Pole(from, to) => {
                    if !meets(last, *from, step, prev) {
                        continue 'rings;
                    }
                    last = *to;
                }
            }
        }
        let closing = &walk[walk.len() - 1];
        let across = matches!((&walk[0], closing), (Step::Seam(i, ..), Step::Seam(j, ..)) if i == j)
            && {
                let shift = whole(last, begin);
                (shift.x != 0.0 || shift.y != 0.0)
                    && meets(
                        last,
                        Point2::new(begin.x + shift.x, begin.y + shift.y),
                        &walk[0],
                        closing,
                    )
            };
        if !across && !meets(last, begin, &walk[0], closing) {
            continue;
        }
        for (i, pcurve) in moves {
            edges[i].pcurve = pcurve;
        }
    }
    Ok(())
}

/// The stretches of a pole row a face's ring crosses with no edge there:
/// two edges meeting at a cone's apex or a sphere's pole stand apart in the
/// chart, at the columns they arrive along, and the row between them is
/// one point in space. Each such joint becomes a pole of the face, the
/// chart line from one edge's end to the next one's start, as a degenerate
/// edge there would state it.
///
/// A joint closes this way only where that line is the pole row the face
/// itself bounds:
/// - both ends lift to one point, within the joint vertex's radius;
/// - the row is that point: the surface's rate along it, read at its ends
///   and middle, times the chart's whole width that way, and its rate
///   across times the line's offset, stay within that radius;
/// - the line is shorter than the chart's period that way, and the face
///   lies on its left, as every ring of a face stored forward keeps it:
///   towards the middle of the face's own trim.
///
/// Any other joint is left for the arrangement to snap or refuse by name.
/// A ring that walks a seam both ways reads each occurrence on the side it
/// walks ([`walked_seam_side`]).
fn close_pole_joints(
    model: &Model,
    face: &Shape,
    surface: &SurfaceGeometry,
    (edges, slits): (&[BoundaryEdge], &ogeom_core::FastSet<EdgeKey>),
    poles: &mut Vec<PoleEdge>,
    pole_keys: &[EdgeKey],
    tol: Tolerances,
) -> OgeomResult<()> {
    let index: ogeom_core::FastMap<EdgeKey, usize> =
        edges.iter().enumerate().map(|(i, e)| (e.node, i)).collect();
    // The middle of the face's trim in the chart.
    let (mut low, mut high) = (
        Point2::new(f64::INFINITY, f64::INFINITY),
        Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
    );
    for e in edges {
        for k in 0..=4 {
            let p = e.pcurve.point_at(
                e.prange.0 + (e.prange.1 - e.prange.0) * f64::from(k) / 4.0,
                tol,
            )?;
            low = Point2::new(low.x.min(p.x), low.y.min(p.y));
            high = Point2::new(high.x.max(p.x), high.y.max(p.y));
        }
    }
    let centre = Point2::new(f64::midpoint(low.x, high.x), f64::midpoint(low.y, high.y));
    let ((u0, u1), (v0, v1)) = surface.domain();
    let closes = [
        surface.is_periodic_u() || surface.is_closed_u(tol),
        surface.is_periodic_v() || surface.is_closed_v(tol),
    ];
    for ring in rings_without(
        model,
        &face.oriented(ogeom_topo::Orientation::Forward),
        slits,
    )? {
        // Each occurrence's edge, whether the ring walks it backwards and,
        // for a seam the ring walks both ways, the side it walks; `None`
        // for a degenerate edge, which stands between its neighbours
        // already.
        type Walked = (usize, bool, Option<(PlanarCurve, (f64, f64))>);
        let mut walk: Vec<Option<Walked>> = Vec::with_capacity(ring.len());
        for edge in &ring {
            let key = EdgeKey::of(edge);
            if pole_keys.contains(&key) {
                walk.push(None);
                continue;
            }
            let Some(&i) = index.get(&key) else {
                walk.clear();
                break;
            };
            let back = edge.orientation() == ogeom_topo::Orientation::Reversed;
            let side = if edges[i].other_side.is_some() {
                let Some(side) = walked_seam_side(&edges[i], back, tol)? else {
                    walk.clear();
                    break;
                };
                Some(side)
            } else {
                None
            };
            walk.push(Some((i, back, side)));
        }
        let n = walk.len();
        for k in 0..n {
            let (Some((a, a_back, a_side)), Some((b, b_back, b_side))) =
                (&walk[k], &walk[(k + 1) % n])
            else {
                continue;
            };
            // The joint: where the ring leaves one edge and takes up the
            // next, in the chart and in space, with the joint vertex's
            // radius as each edge states it.
            let end = |i: usize,
                       back: bool,
                       side: &Option<(PlanarCurve, (f64, f64))>,
                       last: bool|
             -> OgeomResult<(Point2, (Point, f64))> {
                let e = &edges[i];
                let (pcurve, range) = side
                    .as_ref()
                    .map_or((&e.pcurve, e.prange), |(c, r)| (c, *r));
                let at_start = back == last;
                let t = if at_start { range.0 } else { range.1 };
                Ok((pcurve.point_at(t, tol)?, e.ends[usize::from(!at_start)]))
            };
            let ((from, (pa, ra)), (to, (pb, rb))) = (
                end(*a, *a_back, a_side, true)?,
                end(*b, *b_back, b_side, false)?,
            );
            if from.distance(to) <= PARAM_SNAP {
                continue;
            }
            let reach = ra.max(rb).max(tol.confusion());
            if pa.distance(pb) > reach {
                continue;
            }
            let along_u = (to.x - from.x).abs() >= (to.y - from.y).abs();
            let (length, offset, width, closing) = if along_u {
                (
                    (to.x - from.x).abs(),
                    (to.y - from.y).abs(),
                    (u1 - u0).abs(),
                    closes[0],
                )
            } else {
                (
                    (to.y - from.y).abs(),
                    (to.x - from.x).abs(),
                    (v1 - v0).abs(),
                    closes[1],
                )
            };
            if closing && length >= width - PARAM_SNAP {
                continue;
            }
            let mut collapses = true;
            for s in [0.0, 0.5, 1.0] {
                let q = Point2::new(from.x + (to.x - from.x) * s, from.y + (to.y - from.y) * s);
                let Ok((du, dv)) = surface.d1_at(q.x, q.y, tol) else {
                    collapses = false;
                    break;
                };
                let (rate, across) = if along_u {
                    (du.magnitude(), dv.magnitude())
                } else {
                    (dv.magnitude(), du.magnitude())
                };
                if !(rate * width <= reach && across * offset <= reach) {
                    collapses = false;
                    break;
                }
            }
            if !collapses {
                continue;
            }
            // The face on the line's left.
            let run = to - from;
            let middle = Point2::midpoint(from, to);
            let towards = centre - middle;
            if run.x * towards.y - run.y * towards.x <= 0.0 {
                continue;
            }
            let Ok(at) = surface.point_at(from.x, from.y, tol) else {
                continue;
            };
            let line = ogeom_geom::Line2d::segment(from, to, tol)?;
            let prange = ogeom_geom::Curve2d::domain(&line);
            poles.push(PoleEdge {
                point: at,
                pcurve: line.into(),
                prange,
            });
        }
    }
    Ok(())
}

/// A face's pcurves moved by whole periods, all alike, so the middle of
/// their extent lies in the chart's own window along each periodic
/// direction.
///
/// A periodic face's trim may sit any number of turns along its chart: a
/// partial drum's boundary can arrive two turns below zero. The paving and
/// the arrangement fold a section's image into the chart and try it at
/// most one period either side, and against a trim two turns off no try
/// lands inside it. Moved home, the trim straddles the window's edge at
/// most, which one period's try reaches. The face is the same face: every
/// pcurve moves by the same whole period. Whether they moved.
fn bring_trim_home(
    surface: &SurfaceGeometry,
    edges: &mut [BoundaryEdge],
    poles: &mut [PoleEdge],
    tol: Tolerances,
) -> OgeomResult<bool> {
    if !(surface.is_periodic_u() || surface.is_periodic_v()) {
        return Ok(false);
    }
    let mut low = Point2::new(f64::INFINITY, f64::INFINITY);
    let mut high = Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);
    let mut take = |pc: &PlanarCurve, range: (f64, f64)| -> OgeomResult<()> {
        for k in 0..=4 {
            let t = range.0 + (range.1 - range.0) * f64::from(k) / 4.0;
            let p = pc.point_at(t, tol)?;
            low = Point2::new(low.x.min(p.x), low.y.min(p.y));
            high = Point2::new(high.x.max(p.x), high.y.max(p.y));
        }
        Ok(())
    };
    for e in edges.iter() {
        take(&e.pcurve, e.prange)?;
        if let Some((other, range)) = &e.other_side {
            take(other, *range)?;
        }
    }
    for p in poles.iter() {
        take(&p.pcurve, p.prange)?;
    }
    let ((ua, ub), (va, vb)) = surface.domain();
    // A trim within a period of the window is reached already, and stays
    // where it was stated.
    let turns = |periodic: bool, lo: f64, hi: f64, start: f64, end: f64| -> f64 {
        let span = end - start;
        if !periodic
            || span <= 0.0
            || !lo.is_finite()
            || !hi.is_finite()
            || (lo >= start - span && hi <= end + span)
        {
            return 0.0;
        }
        -((f64::midpoint(lo, hi) - start) / span).floor() * span
    };
    let shift = ogeom_math::Vector2::new(
        turns(surface.is_periodic_u(), low.x, high.x, ua, ub),
        turns(surface.is_periodic_v(), low.y, high.y, va, vb),
    );
    if shift.x == 0.0 && shift.y == 0.0 {
        return Ok(false);
    }
    let moved = ogeom_math::Transform2::translation(shift);
    for e in edges.iter_mut() {
        e.pcurve = e.pcurve.transformed(&moved, tol)?;
        if let Some((other, _)) = &mut e.other_side {
            *other = other.transformed(&moved, tol)?;
        }
        if let Some((forward, reversed)) = &mut e.seam {
            *forward = forward.transformed(&moved, tol)?;
            *reversed = reversed.transformed(&moved, tol)?;
        }
    }
    for p in poles.iter_mut() {
        p.pcurve = p.pcurve.transformed(&moved, tol)?;
    }
    Ok(true)
}

/// A parameter brought onto the turn its edge actually covers.
///
/// A periodic curve's own domain and an edge's range over it need not agree
/// on which turn to count from: a sphere's seam runs its half meridian over
/// `[-π/2, π/2]`, while every crossing found on it comes back in `[0, 2π)`.
/// Left alone, a crossing on the negative half arrives a turn on, sits
/// outside the range, and is discarded, so the seam never splits where a
/// section genuinely meets it, and the arrangement finds the chain hanging.
fn onto_range(t: f64, curve: &Curve, range: (f64, f64), tol: Tolerances) -> f64 {
    if !curve.is_periodic() {
        return t;
    }
    let (a, b) = curve.domain();
    let period = b - a;
    if period <= 0.0 {
        return t;
    }
    for k in [0.0, -1.0, 1.0, -2.0, 2.0] {
        let shifted = period.mul_add(k, t);
        if shifted >= range.0 - tol.parametric() && shifted <= range.1 + tol.parametric() {
            return shifted;
        }
    }
    t
}

/// A stretch of an overlap on the first curve, and the second curve's
/// parameter at either end where the second curve's range ends it.
type OverlapPart = ((f64, f64), [Option<f64>; 2]);

/// The parts of an overlap that fall within the second curve's own bounded
/// range, stated in the *first* curve's parameter, in increasing order,
/// each with the second curve's parameter at either end where the range's
/// own end, not the overlap's, bounds it.
///
/// An overlap is between two curves. An edge covers only part of its curve.
/// The correspondence the overlap states is affine, so the edge's range
/// carries across as an interval, and on a periodic curve it carries across
/// up to whole turns. A full turn of the overlap meets an edge whose range
/// starts elsewhere on the circle in two stretches, one either side of the
/// edge's own start, and both are returned. Empty where the edge's own
/// stretch and the overlap do not meet.
fn overlap_within(
    overlap: &ogeom_intersect::Overlap,
    range: (f64, f64),
    curve: &Curve,
    tol: Tolerances,
) -> Vec<OverlapPart> {
    let ordered = |r: (f64, f64)| if r.0 <= r.1 { r } else { (r.1, r.0) };
    let span_a = overlap.on_a.1 - overlap.on_a.0;
    let span_b = overlap.on_b.1 - overlap.on_b.0;
    if span_b.abs() <= f64::MIN_POSITIVE {
        return Vec::new();
    }
    let to_a = |t: f64| overlap.on_a.0 + span_a * (t - overlap.on_b.0) / span_b;
    let (from_start, from_end) = (to_a(range.0), to_a(range.1));
    let ((wlo, elo), (whi, ehi)) = if from_start <= from_end {
        ((from_start, range.0), (from_end, range.1))
    } else {
        ((from_end, range.1), (from_start, range.0))
    };
    let (lo, hi) = ordered(overlap.on_a);
    let period = if curve.is_periodic() {
        let (a, b) = curve.domain();
        // The turn measured in the *first* curve's parameter, which is where
        // the intersection is being taken.
        (b - a) * (span_a / span_b).abs()
    } else {
        0.0
    };
    let turns: &[f64] = if period == 0.0 {
        &[0.0]
    } else {
        &[-2.0, -1.0, 0.0, 1.0, 2.0]
    };
    turns
        .iter()
        .map(|&k| {
            let (start, end) = (period.mul_add(k, wlo), period.mul_add(k, whi));
            (
                (lo.max(start), hi.min(end)),
                [(start > lo).then_some(elo), (end < hi).then_some(ehi)],
            )
        })
        .filter(|((a, b), _)| b - a > tol.parametric())
        .collect()
}

/// A parameter carried proportionally from one range to another.
fn rescale(t: f64, from: (f64, f64), to: (f64, f64)) -> f64 {
    let span = from.1 - from.0;
    if span.abs() <= f64::MIN_POSITIVE {
        return to.0;
    }
    to.0 + (to.1 - to.0) * (t - from.0) / span
}

/// Whether a curve is exact: a line or a conic, or a trim of one (an arc
/// stated as a stretch of its circle is as exact as its basis).
fn exact(c: &Curve) -> bool {
    match c {
        Curve::Line(_)
        | Curve::Circle(_)
        | Curve::Ellipse(_)
        | Curve::Hyperbola(_)
        | Curve::Parabola(_) => true,
        Curve::Trimmed(t) => exact(t.basis()),
        _ => false,
    }
}

/// How far `curve`, held to `tolerance`, may stand off the edge `e` and
/// still be read as running along it.
///
/// A fitted curve wobbles about the edge it runs along by far more than its
/// stated budget, and is measured loosely. Two exact curves are held to
/// their own tolerances, as an exact section is: an edge that parts from
/// another by a few microns over its length (a wall leaning off a pad's
/// side) runs beside it, not along it, and read as along it the strands
/// that meet it are left a few microns short.
fn measuring_width(curve: &Curve, tolerance: f64, e: &BoundaryEdge, tol: Tolerances) -> f64 {
    let floor = if exact(curve) && exact(&e.curve) {
        tol.confusion() * 10.0
    } else {
        tol.confusion() * 1e3
    };
    (tolerance.max(e.tolerance) * 2.0).max(floor)
}

/// Whether the distance `off` grows in proportion from where two curves
/// meet, at `meet` (a parameter and the distance there), out to `t`: the
/// two crossing at an angle there, not parting tangentially.
///
/// Growing as the k-th power from the meeting, the distance halfway out
/// stands at 2^-k of the distance at the end: past 2^-3/2, half way between
/// the crossing's 1/2 and the tangent parting's 1/4, the two cross.
fn grows_in_proportion(
    off: impl Fn(f64) -> OgeomResult<f64>,
    meet: (f64, f64),
    t: f64,
) -> OgeomResult<bool> {
    let rise = off(t)? - meet.1;
    let half = off(f64::midpoint(meet.0, t))? - meet.1;
    Ok(rise > 0.0 && half >= rise * core::f64::consts::FRAC_1_SQRT_2 / 2.0)
}

/// Whether `curve`, over `crange` and held to `tolerance`, crosses the edge
/// `e` at a shallow turn where the two meet at `on_a` on it, rather than
/// touching it.
///
/// Crossing at a turn whose sine is `s`, the two stand within the measuring
/// width `w` of each other for `w / s` either side of the crossing, and
/// past it their distance grows in proportion on both sides. Touching, it
/// grows as the square of the way from the touch, and a crossing found
/// along the touch is noise in the valley between them: from there the
/// distance grows on at most one side in proportion. Bending apart by `k`,
/// the difference of their curvature vectors, the two part by `k x² / 2`
/// over a way `x` besides the turn's `s x`, which over `w / s` stays below
/// half the width only where `s² > k w`: a shallower turn is not told from
/// a touch at the width, and reads as one.
fn crosses_shallowly(
    curve: &Curve,
    crange: (f64, f64),
    tolerance: f64,
    e: &BoundaryEdge,
    (on_a, on_b): (f64, f64),
    tol: Tolerances,
) -> OgeomResult<bool> {
    let bending =
        |c: &Curve, t: f64| -> OgeomResult<Option<(ogeom_math::Vector, ogeom_math::Vector)>> {
            let d = c.derivatives_at(t, 2, tol)?;
            let speed = d[1].magnitude();
            if speed <= tol.confusion() {
                return Ok(None);
            }
            let unit = d[1] / speed;
            let normal = d[2] - unit * unit.dot(d[2]);
            Ok(Some((d[1], normal / (speed * speed))))
        };
    let (Some((da, ka)), Some((db, kb))) = (bending(curve, on_a)?, bending(&e.curve, on_b)?) else {
        return Ok(false);
    };
    let (ma, mb) = (da.magnitude(), db.magnitude());
    let turn = da.cross(db).magnitude() / (ma * mb);
    let width = measuring_width(curve, tolerance, e, tol);
    if turn * turn <= (ka - kb).magnitude() * width {
        return Ok(false);
    }
    let step = width / turn / ma;
    let off = |t: f64| -> OgeomResult<f64> {
        distance_to_edge_curve(&e.curve, e.crange, curve.point_at(t, tol)?, tol)
    };
    let meet = (on_a, off(on_a)?);
    for t in [(on_a - step).max(crange.0), (on_a + step).min(crange.1)] {
        if (t - on_a).abs() <= tol.parametric() || !grows_in_proportion(off, meet, t)? {
            return Ok(false);
        }
    }
    Ok(true)
}

/// The stretches of `curve` over `crange` that lie along the edge `e`
/// within the pair's honesty, as overlaps with the edge's own parameters at
/// their ends: the measured twin of the intersector's closed-form
/// coincidence, for a fitted curve on an exact one.
///
/// With `parted`, the sum of the radii both curves hold to, a fitted
/// stretch ends where the two part by it (see below); without, where they
/// part by the measuring width.
fn measured_overlaps(
    curve: &Curve,
    crange: (f64, f64),
    tolerance: f64,
    e: &BoundaryEdge,
    parted: Option<f64>,
    tol: Tolerances,
) -> OgeomResult<Vec<ogeom_intersect::Overlap>> {
    const SAMPLES: usize = 48;
    let width = measuring_width(curve, tolerance, e, tol);
    let mut near: Vec<bool> = Vec::with_capacity(SAMPLES + 1);
    for i in 0..=SAMPLES {
        #[allow(clippy::cast_precision_loss)]
        let t = crange.0 + (crange.1 - crange.0) * (i as f64) / (SAMPLES as f64);
        let p = curve.point_at(t, tol)?;
        near.push(
            e.bound.expanded(width).contains(p)
                && distance_to_edge_curve(&e.curve, e.crange, p, tol)? <= width,
        );
    }
    let mut out = Vec::new();
    let mut i = 0;
    while i <= SAMPLES {
        if !near[i] {
            i += 1;
            continue;
        }
        let start = i;
        while i < SAMPLES && near[i + 1] {
            i += 1;
        }
        let end = i;
        i += 1;
        // Three samples along is a stretch. Fewer is a crossing's blur.
        if end - start < 2 {
            continue;
        }
        #[allow(clippy::cast_precision_loss)]
        let at = |k: usize| crange.0 + (crange.1 - crange.0) * (k as f64) / (SAMPLES as f64);
        // Each end refined by bisection into the neighbouring sample gap.
        let refine = |inside: f64, outside: f64| -> OgeomResult<f64> {
            let (mut a, mut b) = (inside, outside);
            for _ in 0..24 {
                let m = f64::midpoint(a, b);
                let p = curve.point_at(m, tol)?;
                if e.bound.expanded(width).contains(p)
                    && distance_to_edge_curve(&e.curve, e.crange, p, tol)? <= width
                {
                    a = m;
                } else {
                    b = m;
                }
            }
            Ok(a)
        };
        let lo = if start == 0 {
            at(0)
        } else {
            refine(at(start), at(start - 1))?
        };
        let hi = if end == SAMPLES {
            at(SAMPLES)
        } else {
            refine(at(end), at(end + 1))?
        };
        // A stretch ending at one of the edge's own ends ends at that end's
        // vertex, not a measuring width past it: within the width of the
        // vertex the curve is still near the edge's end, and read as along
        // the edge there the contact splits a hair beyond the vertex the
        // face across it keeps.
        let at_vertex = |t: f64| -> OgeomResult<f64> {
            let p = curve.point_at(t, tol)?;
            for end in [e.crange.0, e.crange.1] {
                let vertex = e.curve.point_at(end, tol)?;
                if vertex.distance(p) > width * 2.0 {
                    continue;
                }
                let foot = ogeom_algo::project_on_curve(curve, vertex, 64, tol)?;
                let (clo, chi) = (crange.0.min(crange.1), crange.0.max(crange.1));
                if foot.distance <= width && foot.parameter >= clo && foot.parameter <= chi {
                    return Ok(foot.parameter);
                }
            }
            Ok(t)
        };
        let lo = if start == 0 { lo } else { at_vertex(lo)? };
        let hi = if end == SAMPLES { hi } else { at_vertex(hi)? };
        if hi - lo <= tol.parametric() {
            continue;
        }
        // Two exact curves that lie on one another do so over the whole of
        // what they share, so a stretch of them ends where one of them
        // does. One that ends inside both is two curves converging and
        // parting (lines meeting at a vertex at a tiny angle), near each
        // other there only by the measuring width, and is no overlap.
        let ends_there = |t: f64, own_end: bool| -> OgeomResult<bool> {
            if own_end {
                return Ok(true);
            }
            let p = curve.point_at(t, tol)?;
            for end in [e.crange.0, e.crange.1] {
                if e.curve.point_at(end, tol)?.distance(p) <= width * 2.0 {
                    return Ok(true);
                }
            }
            Ok(false)
        };
        let (ends_lo, ends_hi) = (ends_there(lo, start == 0)?, ends_there(hi, end == SAMPLES)?);
        let (lo, hi) = if exact(curve) && exact(&e.curve) {
            if !(ends_lo && ends_hi) {
                continue;
            }
            (lo, hi)
        } else if ends_lo && ends_hi {
            (lo, hi)
        } else {
            // A fitted curve may come in along an edge tangentially and
            // leave the loose width inside both, its distance growing as the
            // square of the way from where they meet or slower. One that
            // leaves it growing in proportion, the two crossing at an angle
            // (a band's section across a drum, crossing the drum's own edge
            // at a shallow one), is near it only by the width: the stretch
            // is a crossing and no overlap.
            let off = |t: f64| -> OgeomResult<f64> {
                distance_to_edge_curve(&e.curve, e.crange, curve.point_at(t, tol)?, tol)
            };
            let mut meet = (lo, off(lo)?);
            for k in 1..=SAMPLES {
                #[allow(clippy::cast_precision_loss)]
                let t = lo + (hi - lo) * (k as f64) / (SAMPLES as f64);
                let d = off(t)?;
                if d < meet.1 {
                    meet = (t, d);
                }
            }
            let mut crossing = false;
            for (t, ends) in [(lo, ends_lo), (hi, ends_hi)] {
                if !ends {
                    crossing |= grows_in_proportion(off, meet, t)?;
                }
            }
            if crossing {
                continue;
            }
            (lo, hi)
        };
        if hi - lo <= tol.parametric() {
            continue;
        }
        // A fitted curve near an edge within the loose width may still
        // stand apart from it by more than the radii both hold to, and what
        // lies between them there is geometry, a lune the outline must
        // keep. Given those radii, the stretch is the runs along which the
        // two stand within them, each ended where they part by them: the
        // end on this curve lies within them of the other. A stretch that
        // never comes that near keeps the width's ends.
        let off = |t: f64| -> OgeomResult<f64> {
            distance_to_edge_curve(&e.curve, e.crange, curve.point_at(t, tol)?, tol)
        };
        let runs = match parted {
            Some(within) if !(exact(curve) && exact(&e.curve)) => {
                runs_within(&off, (lo, hi), within, SAMPLES)?.unwrap_or_else(|| vec![(lo, hi)])
            }
            _ => vec![(lo, hi)],
        };
        for (lo, hi) in runs {
            if hi - lo <= tol.parametric() {
                continue;
            }
            // An end carried to the other side is carried within the edge's
            // own window: a closed curve's two ends stand at one point, and the
            // edge covering one end of it does not cover the other.
            let on_edge = |t: f64| -> OgeomResult<f64> {
                let p = curve.point_at(t, tol)?;
                if parted.is_some() {
                    return Ok(nearest_on_edge_curve(&e.curve, e.crange, p, tol)?.1);
                }
                let foot = ogeom_algo::project_on_curve(&e.curve, p, 64, tol)?;
                Ok(onto_range(foot.parameter, &e.curve, e.crange, tol))
            };
            if *DEBUG_WIRE {
                eprintln!(
                    "CONTACT along edge {} measured over ({lo:.6}, {hi:.6}) within {width:.2e}",
                    e.node.index()
                );
            }
            out.push(ogeom_intersect::Overlap {
                on_a: (lo, hi),
                on_b: (on_edge(lo)?, on_edge(hi)?),
            });
        }
    }
    // The samples are spaced along the whole curve, and an edge lying
    // along it over less than three spacings gives no stretch. Measured
    // from the edge's side instead: where every sample of the edge lies
    // within the width of the curve, the edge runs along it end to end,
    // and the stretch is the curve's between the feet of its two ends.
    if out.is_empty()
        && let Some(overlap) = edge_along_curve(curve, crange, e, width, tol)?
    {
        out.push(overlap);
    }
    Ok(out)
}

/// The radius an edge holds to where stretches end at it: its widest
/// measured on any face of it, or its own tolerance.
fn held_radius(
    held: &ogeom_core::FastMap<EdgeKey, (f64, &BoundaryEdge)>,
    node: EdgeKey,
    tolerance: f64,
) -> f64 {
    held.get(&node)
        .map_or(tolerance, |&(r, _)| r)
        .max(tolerance)
}

/// A shallow crossing that stands at one curve's end vertex.
enum End {
    /// At an end of the edge: the contact splits at the vertex's foot on
    /// it, the vertex standing `gap` off it, and the edge does not split.
    OfEdge { on_contact: f64, gap: f64 },
    /// At an end of the contact: the edge splits at its foot.
    OfContact { on_edge: f64, gap: f64 },
}

/// Where a shallow crossing of the contact and the edge `e`, at `on` on
/// each, stands at an end vertex of one of them.
///
/// Two curves crossing at a turn whose sine is `s` stand within `width`,
/// the sum of the radii they hold to, of each other for `width / s` either
/// side of the crossing, and the crossing is known along them only that
/// far. A vertex of either curve within that way of it, which the other
/// curve passes within `width` of, is where they cross: found once from
/// each pair of edges the vertex parts, the crossing is two points either
/// side of the vertex, and one curve would split twice where the other
/// does once.
fn shallow_at_end(
    contact: &ContactRec,
    e: &BoundaryEdge,
    on: (f64, f64),
    width: f64,
    tol: Tolerances,
) -> OgeomResult<Option<End>> {
    let (da, db) = (contact.curve.d1_at(on.0, tol)?, e.curve.d1_at(on.1, tol)?);
    let (ma, mb) = (da.magnitude(), db.magnitude());
    if ma <= tol.confusion() || mb <= tol.confusion() {
        return Ok(None);
    }
    let turn = da.cross(db).magnitude() / (ma * mb);
    if turn <= f64::EPSILON {
        return Ok(None);
    }
    let along = width / turn;
    let at = contact.curve.point_at(on.0, tol)?;
    let mut best: Option<(f64, End)> = None;
    for end in [e.crange.0, e.crange.1] {
        let vertex = e.curve.point_at(end, tol)?;
        let away = vertex.distance(at);
        if away > along {
            continue;
        }
        let (gap, t) = nearest_on_edge_curve(&contact.curve, contact.crange, vertex, tol)?;
        if gap <= width && best.as_ref().is_none_or(|b| away < b.0) {
            best = Some((away, End::OfEdge { on_contact: t, gap }));
        }
    }
    for end in [contact.crange.0, contact.crange.1] {
        let vertex = contact.curve.point_at(end, tol)?;
        let away = vertex.distance(at);
        if away > along {
            continue;
        }
        let (gap, t) = nearest_on_edge_curve(&e.curve, e.crange, vertex, tol)?;
        if gap <= width && best.as_ref().is_none_or(|b| away < b.0) {
            best = Some((away, End::OfContact { on_edge: t, gap }));
        }
    }
    Ok(best.map(|(_, end)| end))
}

/// The runs of `span` along which `off` stays within `within`, each end
/// bisected to where it rises past it, from `samples` even samples; `None`
/// where no sample comes that near.
fn runs_within(
    off: &impl Fn(f64) -> OgeomResult<f64>,
    span: (f64, f64),
    within: f64,
    samples: usize,
) -> OgeomResult<Option<Vec<(f64, f64)>>> {
    #[allow(clippy::cast_precision_loss)]
    let at = |k: usize| span.0 + (span.1 - span.0) * (k as f64) / (samples as f64);
    let near: Vec<bool> = (0..=samples)
        .map(|k| off(at(k)).map(|d| d <= within))
        .collect::<OgeomResult<_>>()?;
    if !near.contains(&true) {
        return Ok(None);
    }
    let parting = |inside: f64, outside: f64| -> OgeomResult<f64> {
        let (mut a, mut b) = (inside, outside);
        for _ in 0..24 {
            let m = f64::midpoint(a, b);
            if off(m)? <= within {
                a = m;
            } else {
                b = m;
            }
        }
        Ok(a)
    };
    let mut runs = Vec::new();
    let mut k = 0;
    while k <= samples {
        if !near[k] {
            k += 1;
            continue;
        }
        let first = k;
        while k < samples && near[k + 1] {
            k += 1;
        }
        let lo = if first == 0 {
            span.0
        } else {
            parting(at(first), at(first - 1))?
        };
        let hi = if k == samples {
            span.1
        } else {
            parting(at(k), at(k + 1))?
        };
        runs.push((lo, hi));
        k += 1;
    }
    Ok(Some(runs))
}

/// The stretches the contact shares with the target edge `e`, each ended
/// where the two curves part by the sum of the radii they hold to (within
/// it, each could be the other), measured once for
/// the pair and carried to whichever of the two is met as the contact
/// later.
///
/// Measured from each curve's side, a tangential parting ends on that
/// curve, and the two ends stand apart along the curves by as much as the
/// curves stay within that radius over, a way no vertex weld reaches. So
/// the end is measured once, on the curve held to the tighter radius
/// (its points lie nearest the truth), and carried onto the other by
/// projection: both sides split there.
fn shared_overlaps(
    contact: &ContactRec,
    e: &BoundaryEdge,
    held: &ogeom_core::FastMap<EdgeKey, (f64, &BoundaryEdge)>,
    shared: &mut ogeom_core::FastMap<(EdgeKey, EdgeKey), Vec<ogeom_intersect::Overlap>>,
    tol: Tolerances,
) -> OgeomResult<Vec<ogeom_intersect::Overlap>> {
    if let Some(found) = shared.get(&(contact.node, e.node)) {
        return Ok(found.clone());
    }
    let swap = |overlaps: &[ogeom_intersect::Overlap]| -> Vec<ogeom_intersect::Overlap> {
        overlaps
            .iter()
            .map(|o| ogeom_intersect::Overlap {
                on_a: o.on_b,
                on_b: o.on_a,
            })
            .collect()
    };
    let own = held.get(&contact.node).copied();
    let held_by_contact = held_radius(held, contact.node, contact.tolerance);
    let held_by_edge = held_radius(held, e.node, e.tolerance);
    let within = (held_by_contact + held_by_edge).max(tol.confusion());
    // The contact's own record, where it covers just what the contact does,
    // to be measured against from the edge's side.
    let owner = own
        .map(|(_, owner)| owner)
        .filter(|owner| owner.crange == contact.crange && *owner.curve == contact.curve);
    let from_contact = measured_overlaps(
        &contact.curve,
        contact.crange,
        contact.tolerance,
        e,
        Some(within),
        tol,
    )?;
    let from_edge = match owner {
        Some(owner) => swap(&measured_overlaps(
            &e.curve,
            e.crange,
            e.tolerance,
            owner,
            Some(within),
            tol,
        )?),
        None => Vec::new(),
    };
    // Each side is sampled along its own curve, and a stretch shorter than
    // three of one side's samples goes unseen from that side while the
    // other's may see it. A stretch seen from both is kept as the tighter
    // side measures it; one seen from one side only, as that side does.
    let (mut found, other) = if held_by_edge < held_by_contact {
        (from_edge, from_contact)
    } else {
        (from_contact, from_edge)
    };
    let ordered = |r: (f64, f64)| if r.0 <= r.1 { r } else { (r.1, r.0) };
    let unseen: Vec<ogeom_intersect::Overlap> = other
        .into_iter()
        .filter(|o| {
            let (lo, hi) = ordered(o.on_a);
            found.iter().all(|f| {
                let (flo, fhi) = ordered(f.on_a);
                hi < flo || lo > fhi
            })
        })
        .collect();
    found.extend(unseen);
    shared.insert((e.node, contact.node), swap(&found));
    shared.insert((contact.node, e.node), found.clone());
    Ok(found)
}

/// The stretch of `curve` over `crange` that the edge `e` runs along end to
/// end within `width`, as an overlap with the edge's own parameters at its
/// ends; `None` where some point of the edge stands farther off.
fn edge_along_curve(
    curve: &Curve,
    crange: (f64, f64),
    e: &BoundaryEdge,
    width: f64,
    tol: Tolerances,
) -> OgeomResult<Option<ogeom_intersect::Overlap>> {
    const SAMPLES: u32 = 48;
    let at =
        |i: u32| (e.crange.1 - e.crange.0).mul_add(f64::from(i) / f64::from(SAMPLES), e.crange.0);
    // Its ends and middle first: an edge that only crosses the curve
    // leaves it at one of them.
    let order = [0, SAMPLES, SAMPLES / 2]
        .into_iter()
        .chain((1..SAMPLES).filter(|&i| i != SAMPLES / 2));
    let mut feet = [0.0; 2];
    for i in order {
        let p = e.curve.point_at(at(i), tol)?;
        let (off, t) = nearest_on_edge_curve(curve, crange, p, tol)?;
        if off > width {
            return Ok(None);
        }
        if i == 0 {
            feet[0] = t;
        } else if i == SAMPLES {
            feet[1] = t;
        }
    }
    let (on_a, on_b) = if feet[0] <= feet[1] {
        ((feet[0], feet[1]), e.crange)
    } else {
        ((feet[1], feet[0]), (e.crange.1, e.crange.0))
    };
    Ok((on_a.1 - on_a.0 > tol.parametric()).then_some(ogeom_intersect::Overlap { on_a, on_b }))
}

/// The pcurve's course over a sub-range of the *curve's* parameters.
fn pcurve_polyline(
    pcurve: &PlanarCurve,
    prange: (f64, f64),
    crange: (f64, f64),
    sub: (f64, f64),
    surface: &SurfaceGeometry,
    tol: Tolerances,
) -> OgeomResult<Vec<Point2>> {
    let sagged = matches!(surface, SurfaceGeometry::Plane(_));
    chart_polyline(pcurve, prange, crange, sub, surface, sagged, tol)
}

/// [`pcurve_polyline`] with its chords held within [`STRAND_SAG`] of the
/// pcurve on any surface, not only on a plane.
fn pcurve_polyline_within_sag(
    pcurve: &PlanarCurve,
    prange: (f64, f64),
    crange: (f64, f64),
    sub: (f64, f64),
    surface: &SurfaceGeometry,
    tol: Tolerances,
) -> OgeomResult<Vec<Point2>> {
    chart_polyline(pcurve, prange, crange, sub, surface, true, tol)
}

/// The pcurve's course over a sub-range of the curve's parameters, its
/// chords within [`STRAND_SAG`] where `sagged`.
fn chart_polyline(
    pcurve: &PlanarCurve,
    prange: (f64, f64),
    crange: (f64, f64),
    sub: (f64, f64),
    surface: &SurfaceGeometry,
    sagged: bool,
    tol: Tolerances,
) -> OgeomResult<Vec<Point2>> {
    let lo = rescale(sub.0, crange, prange);
    let hi = rescale(sub.1, crange, prange);
    // Enough samples that the first step approximates the tangent and the
    // scanline interior test has a faithful outline. Straight pcurves get
    // two points. Everything else a fixed fine sampling.
    let mut count = match pcurve {
        PlanarCurve::Line(_) => 1,
        _ => {
            let span = (hi - lo).abs().max(SCAFFOLD_CHORD);
            #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
            let n = (span / SCAFFOLD_CHORD).sqrt().ceil() as usize;
            n.clamp(8, 256)
        }
    };
    // And never a step [`unwrap_polyline`] could read as a period jump. A
    // straight pcurve is faithful at two points (a coaxial rim's image on
    // a cylinder is exactly a line across the chart), but one that crosses
    // more than half the turn looks to that reader like a wrap, and the
    // strand comes back running the complementary way: a bore's mouth
    // blended where the mouth circle starts anywhere but the wall's own
    // seam. The chart's span decides the count, not the parameter's.
    let ((ua, ub), (va, vb)) = surface.domain();
    let (first, last) = (pcurve.point_at(lo, tol)?, pcurve.point_at(hi, tol)?);
    for (periodic, period, reach) in [
        (surface.is_periodic_u(), ub - ua, (last.x - first.x).abs()),
        (surface.is_periodic_v(), vb - va, (last.y - first.y).abs()),
    ] {
        if !periodic || period <= 0.0 || !reach.is_finite() {
            continue;
        }
        let steps = (reach / (period / 3.0)).ceil();
        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
        let steps = steps.clamp(1.0, 4096.0) as usize;
        count = count.max(steps);
    }
    if sagged && !matches!(pcurve, PlanarCurve::Line(_)) {
        count = match circle_sag_count(pcurve, lo, hi, count) {
            Some(count) => count,
            None => sag_count(&|t| pcurve.point_at(t, tol), lo, hi, count)?.0,
        };
    }
    let mut out = Vec::with_capacity(count + 1);
    for i in 0..=count {
        #[allow(clippy::cast_precision_loss)]
        let t = lo + (hi - lo) * i as f64 / count as f64;
        out.push(pcurve.point_at(t, tol)?);
    }
    Ok(out)
}

// --- the filler --------------------------------------------------------------

/// One section curve between a face of `a` and a face of `b`.
struct SectionRec {
    curve: Curve,
    /// The pcurve on the A face's surface, sharing the curve's parameter.
    pc_a: PlanarCurve,
    /// The same on the B face.
    pc_b: PlanarCurve,
    face_a: usize,
    face_b: usize,
    closed: bool,
    /// How far the curve may sit from the true intersection: zero for an
    /// exact section, the trace-plus-fit budget for a marched one. Crossing
    /// filters widen their acceptance by this, or a fitted section would
    /// never register against the edges it genuinely meets.
    tolerance: f64,
}

/// A closed circular section whose seam stands a hair from a vertex of
/// either face on it, turned to start at that vertex.
///
/// The section's own start is wherever its frame happened to point (a
/// world axis projected into its plane), and a piece reaching across it is
/// split there to stay within one period. Where a face's vertex sits on
/// the circle a sliver of a turn from that start, the split leaves an arc
/// the paving takes for dust and collapses, dragging the vertex along the
/// circle. Starting the circle at the vertex leaves nothing to split. A
/// seam already on a vertex, or well clear of every one, is left alone.
fn seamed_at_a_stop(
    section: &SectionRec,
    fa: &GFace,
    fb: &GFace,
    tol: Tolerances,
) -> Option<SectionRec> {
    use core::f64::consts::TAU;
    if !section.closed || section.tolerance > 0.0 {
        return None;
    }
    let Curve::Circle(c) = &section.curve else {
        return None;
    };
    let circle = c.circle();
    let (centre, radius) = (circle.centre(), circle.radius());
    let frame = circle.frame();
    // The angle a point stands at along the curve's own parameter.
    let sweep = if c.is_reversed() { -1.0 } else { 1.0 };
    let angle_of = |p: Point| {
        let local = frame.to_local(p);
        (sweep * local.y.atan2(local.x)).rem_euclid(TAU)
    };
    let mut nearest: Option<f64> = None;
    for face in [fa, fb] {
        for e in &face.edges {
            for end in [e.crange.0, e.crange.1] {
                let Ok(p) = e.curve.point_at(end, tol) else {
                    continue;
                };
                let local = frame.to_local(p);
                let off = local.z.hypot(local.x.hypot(local.y) - radius);
                if off > tol.confusion() * 10.0 {
                    continue;
                }
                let a = angle_of(p);
                let shift = if a > TAU / 2.0 { a - TAU } else { a };
                if nearest.is_none_or(|n| shift.abs() < n.abs()) {
                    nearest = Some(shift);
                }
            }
        }
    }
    let shift = nearest?;
    if shift.abs() <= tol.parametric() || shift.abs() > 1e-2 {
        return None;
    }
    let start = c.point_at(shift, tol).ok()?;
    let x = ogeom_math::Direction::new(start - centre, tol).ok()?;
    let z = if c.is_reversed() {
        -frame.z()
    } else {
        frame.z()
    };
    let turned = ogeom_math::Frame::new(centre, z, x, tol).ok()?;
    let curve: Curve =
        ogeom_geom::CircleCurve::new(ogeom_math::Circle::new(turned, radius, tol).ok()?).into();
    let pc_a = ogeom_intersect::exact_pcurve_of(&curve, &fa.surface, tol)?;
    let pc_b = ogeom_intersect::exact_pcurve_of(&curve, &fb.surface, tol)?;
    Some(SectionRec {
        curve,
        pc_a,
        pc_b,
        face_a: section.face_a,
        face_b: section.face_b,
        closed: true,
        tolerance: section.tolerance,
    })
}

/// A closed marched section with its seam moved to `u`, its curve and both
/// images the same from the new start, each parameter naming the point it
/// named: the domain begins at `u`, and past the old end each image is the
/// old one a lap earlier, carried by the whole periods it climbs over the
/// lap.
///
/// A closed section's kept piece that runs across its seam is split there
/// to stay within one period. Moved to the piece's start, the seam splits
/// nothing.
///
/// `None` (the piece split at the seam, as before) unless the curve is a
/// clamped spline closed to the confusion and each image is a spline whose
/// end stands on its start, carried by whole periods of its chart, to the
/// parametric tolerance: then nothing moves but the seam.
fn reseamed_section(
    section: &SectionRec,
    u: f64,
    surfaces: [&SurfaceGeometry; 2],
    tol: Tolerances,
) -> Option<SectionRec> {
    let Curve::BSpline(spline) = &section.curve else {
        return None;
    };
    if spline.is_periodic() {
        return None;
    }
    let (start, end) = spline.domain();
    if spline
        .point_at(start, tol)
        .ok()?
        .distance(spline.point_at(end, tol).ok()?)
        > tol.confusion()
    {
        return None;
    }
    let image = |pcurve: &PlanarCurve, surface: &SurfaceGeometry| -> Option<PlanarCurve> {
        let PlanarCurve::BSpline(image) = pcurve else {
            return None;
        };
        let domain = image.domain();
        if (domain.0 - start).abs() > tol.parametric() || (domain.1 - end).abs() > tol.parametric()
        {
            return None;
        }
        let (head, tail) = (
            image.point_at(start, tol).ok()?,
            image.point_at(end, tol).ok()?,
        );
        // The lap is the whole periods nearest the image's climb; the
        // reseam itself refuses an image that misses it.
        let climb = [tail.x - head.x, tail.y - head.y];
        let mut lap = [0.0; 2];
        for (k, span) in chart_spans(surface, tol).into_iter().enumerate() {
            if let Some(span) = span {
                lap[k] = (climb[k] / span).round() * span;
            }
        }
        image
            .reseamed_at(u, ogeom_math::Vector2::new(lap[0], lap[1]), tol)
            .ok()
            .map(PlanarCurve::BSpline)
    };
    Some(SectionRec {
        curve: Curve::BSpline(spline.reseamed_at(u, tol).ok()?),
        pc_a: image(&section.pc_a, surfaces[0])?,
        pc_b: image(&section.pc_b, surfaces[1])?,
        face_a: section.face_a,
        face_b: section.face_b,
        closed: true,
        tolerance: section.tolerance,
    })
}

/// A face's welded chart outline, borrowed as the trim tests take it.
fn outline_refs(face: &GFace, tol: Tolerances) -> OgeomResult<Vec<&[Point2]>> {
    let Some(lines) = face.outline(tol) else {
        ogeom_bail!(
            Construction,
            "a face's boundary would not polyline in its chart"
        );
    };
    Ok(lines.iter().map(Vec::as_slice).collect())
}

/// The parameter intervals of a contact curve over which *both* faces
/// actually reach it.
///
/// Two surfaces touch along the whole of their contact. Two faces touch
/// along whatever part of it their trims both hold. That part is found by
/// sampling (sixty-four stations along the curve, each asked of both
/// charts) rather than by intersecting the contact with the boundary
/// edges, because a contact meets those boundaries tangentially too and the
/// crossing finder is the wrong instrument for it. The cost of sampling is
/// the usual one: a stretch shorter than a station can be missed, and an
/// endpoint is placed within a station of the truth.
fn contact_intervals(
    fused: &GeneralFused,
    contact: &TangentRec,
    tol: Tolerances,
) -> OgeomResult<Vec<(f64, f64)>> {
    // The same welded outline, both seam columns, that every other trim
    // test reads: with one column a full drum's trim is open, and every
    // station of a contact on it reads outside.
    let refs_a = outline_refs(&fused.a.faces[contact.face_a], tol)?;
    let refs_b = outline_refs(&fused.b.faces[contact.face_b], tol)?;

    const STATIONS: usize = 64;
    let domain = contact.curve.domain();
    let span = domain.1 - domain.0;
    let mut runs: Vec<(f64, f64)> = Vec::new();
    let mut open: Option<f64> = None;
    for k in 0..=STATIONS {
        #[expect(
            clippy::cast_precision_loss,
            reason = "a station index, far below the mantissa"
        )]
        let t = span.mul_add(k as f64 / STATIONS as f64, domain.0);
        // A periodic chart's parameters run out past its own window. The
        // trim test is only meaningful once they are folded back into it.
        let held = matches!(
            (
                contact.pc_a.point_at(t, tol),
                contact.pc_b.point_at(t, tol)
            ),
            (Ok(pa), Ok(pb))
                if arrange::inside_many(
                    &refs_a,
                    fold_point_into_chart(pa, &fused.a.faces[contact.face_a].surface, tol),
                ) && arrange::inside_many(
                    &refs_b,
                    fold_point_into_chart(pb, &fused.b.faces[contact.face_b].surface, tol),
                )
        );
        match (held, open) {
            (true, None) => open = Some(t),
            (false, Some(from)) => {
                if t - from > tol.parametric() {
                    runs.push((from, t));
                }
                open = None;
            }
            _ => {}
        }
    }
    if let Some(from) = open
        && domain.1 - from > tol.parametric()
    {
        runs.push((from, domain.1));
    }
    Ok(runs)
}

/// One curve along which two faces *touch* without crossing.
///
/// A contact carries no boundary parity (neither face passes through the
/// other), so it takes no part in the arrangement or the classification.
/// It is still a curve that exists on the result, and a section view
/// through a tangency has to show it, so it is carried alongside.
struct TangentRec {
    curve: Curve,
    pc_a: PlanarCurve,
    pc_b: PlanarCurve,
    face_a: usize,
    face_b: usize,
}

/// Whether a line edge of one face, its ends at `ends`, runs along a line
/// edge of `target` end to end, each end within `weld` of that edge.
fn shared_line(ends: &[Point], target: &GFace, weld: f64, tol: Tolerances) -> OgeomResult<bool> {
    for t in &target.edges {
        if !matches!(&*t.curve, Curve::Line(_)) {
            continue;
        }
        let (a, b) = (
            t.curve.point_at(t.crange.0, tol)?,
            t.curve.point_at(t.crange.1, tol)?,
        );
        let along = (b.x - a.x, b.y - a.y, b.z - a.z);
        let length2 = along.0 * along.0 + along.1 * along.1 + along.2 * along.2;
        if length2 <= 0.0 {
            continue;
        }
        let beside = |p: &Point| {
            let s =
                ((p.x - a.x) * along.0 + (p.y - a.y) * along.1 + (p.z - a.z) * along.2) / length2;
            let s = s.clamp(0.0, 1.0);
            p.distance(Point::new(
                a.x + s * along.0,
                a.y + s * along.1,
                a.z + s * along.2,
            ))
        };
        if ends.iter().all(|p| beside(p) <= weld) {
            return Ok(true);
        }
    }
    Ok(false)
}

/// Whether a face bounded by straight edges lies on one side of `plane`, its
/// corners past it by rounding at most: `None` where it crosses, has no
/// edges, or has an edge of another kind or a pole, whose extent off the
/// plane its corners do not bound; otherwise whether an edge of it lies in
/// the plane, both ends within the confusion distance.
fn one_side_of(
    face: &GFace,
    plane: ogeom_math::quadric::Plane,
    tol: Tolerances,
) -> OgeomResult<Option<bool>> {
    if face.edges.is_empty() || !face.poles.is_empty() {
        return Ok(None);
    }
    let (mut low, mut high) = (f64::INFINITY, f64::NEG_INFINITY);
    let mut edge_in = false;
    for e in &face.edges {
        if !matches!(&*e.curve, Curve::Line(_)) {
            return Ok(None);
        }
        let mut ends_in = true;
        for t in [e.crange.0, e.crange.1] {
            let d = plane.signed_distance_to(e.curve.point_at(t, tol)?);
            (low, high) = (low.min(d), high.max(d));
            ends_in &= d.abs() <= tol.confusion();
        }
        edge_in |= ends_in;
    }
    // A corner the face shares with the plane's own face stands off it by
    // rounding alone. A corner past it by more, however little, is a
    // crossing: two blocks hinged a hair apart cross a few nanometres inside
    // a side face, and that line bounds the sliver between them.
    let past = tol.confusion() * 1e-3;
    Ok((low >= -past || high <= past).then_some(edge_in))
}

/// A strand's tolerance as a junction may trust it: a fitted section whose
/// trace failed reports a budget of metres, and a weld that believed it
/// would join every vertex of the model. Nothing this pipeline fits is
/// honestly looser than ten thousand confusions.
fn honest(tolerance: f64, tol: Tolerances) -> f64 {
    tolerance.min(tol.confusion() * 1e4)
}

/// How far off the other surface a boundary edge may lie and still be
/// where a grazing section runs: ten confusions, fixed.
const GRAZE_REACH: f64 = 10.0;

/// The stretches of boundary edge a grazing section runs along, carried
/// onto the other face as contacts.
///
/// Where a face's boundary edge lies in the other surface's tangent plane
/// and touches it at one point (a drill whose wall runs along a plane
/// through a rim the rim's circle touches, or along a round's tangent line
/// into the corner where the round's end arc touches it), their section
/// meets the edge there to the fourth order, and stays within the
/// confusion distance of the edge for a stretch round it. The marcher stops
/// on the stretch, and the section ends on the edge short of where it
/// meets it: both ends on one edge, the loop handed back open, or one end
/// on an edge short of the edge's vertex where the section truly ends. The
/// face holding the edge is split there by its own boundary, but the other
/// face is not split along the stretch, and its piece the section bounds
/// never closes. The edge's stretch from the end to the other end or to
/// the vertex, where it lies on the other surface to within
/// [`GRAZE_REACH`] confusions, is the rest of the section: carried as a
/// contact it splits the other face as the section would, and both sides
/// share it as the edge it is.
///
/// With `crossings`, on the retries run again once every other has refused
/// a piece read on the other solid (see [`settled`]), a section line of two
/// planes also ends where it crosses an edge of either face: a line edge,
/// and on the retries after those, any edge ([`section_crossings`]). Two
/// walls leaning a hair apart cross a few microns inside one's edge, and
/// the strip between stands within rounding of the other wall: the edges
/// bounding the strip lie on that wall from the crossing on (an arc from
/// one crossing to the other), and carried there they split the other
/// wall's matching strip off, so the two are read as one contact and one
/// of them kept. Every earlier attempt leaves the edges where they are, so
/// whatever those resolve is resolved as before.
fn graze_contacts(
    ga: &GSolid,
    gb: &GSolid,
    sections: &[SectionRec],
    contacts: &[ContactRec],
    crossings: Crossings,
    tol: Tolerances,
) -> OgeomResult<Vec<ContactRec>> {
    let reach = tol.confusion() * GRAZE_REACH;
    // A stretch shorter than the weld is the junction itself, which the
    // crossing at the edge's end already snaps onto the vertex.
    let weld = tol.confusion() * 1e2;
    let mut out: Vec<ContactRec> = Vec::new();
    for section in sections.iter().filter(|s| !s.closed) {
        let (lo, hi) = section.curve.domain();
        let ends = [
            section.curve.point_at(lo, tol)?,
            section.curve.point_at(hi, tol)?,
        ];
        let middle = section.curve.point_at(f64::midpoint(lo, hi), tol)?;
        let near = tol.confusion().max(honest(section.tolerance, tol));
        for (owner, target, target_from_a, target_face) in [
            (
                &ga.faces[section.face_a],
                &gb.faces[section.face_b],
                false,
                section.face_b,
            ),
            (
                &gb.faces[section.face_b],
                &ga.faces[section.face_a],
                true,
                section.face_a,
            ),
        ] {
            for e in &owner.edges {
                let held = |c: &ContactRec| {
                    c.node == e.node
                        && c.target_from_a == target_from_a
                        && c.target_face == target_face
                };
                let reached = near.max(e.standoff);
                // A section line whose ends stand off the edge may still
                // leave the owner face across it. Crossed once, the
                // crossing is its one end there, the other staying out of
                // reach, and its middle is read an edge's length along from
                // the crossing; crossed twice, the two crossings are its
                // ends and its middle is halfway between them.
                let crossed = if crossings != Crossings::Off
                    && ends.iter().all(|p| e.bound.distance_to(*p) > reached)
                {
                    section_crossings(&section.curve, e, &owner.surface, crossings, reached, tol)?
                } else {
                    None
                };
                let (ends, middle) = match crossed {
                    Some(Crossed::Once(at, along)) => {
                        let length = e
                            .curve
                            .point_at(e.crange.0, tol)?
                            .distance(e.curve.point_at(e.crange.1, tol)?);
                        ([at, ends[1]], at + along * length)
                    }
                    Some(Crossed::Twice(first, second)) => {
                        ([first, second], first.midpoint(second))
                    }
                    None => (ends, middle),
                };
                let crossed = crossed.is_some() && !matches!(&*e.curve, Curve::Line(_));
                if ends.iter().all(|p| e.bound.distance_to(*p) > reached)
                    || contacts.iter().chain(&out).any(held)
                {
                    continue;
                }
                let mut feet: [Option<f64>; 2] = [None, None];
                for (k, end) in ends.iter().enumerate() {
                    if e.bound.distance_to(*end) > reached {
                        continue;
                    }
                    let foot = ogeom_algo::project_on_curve(&e.curve, *end, 64, tol)?;
                    if foot.distance <= reached
                        && foot.parameter >= e.crange.0 - tol.parametric()
                        && foot.parameter <= e.crange.1 + tol.parametric()
                    {
                        feet[k] = Some(foot.parameter.clamp(e.crange.0, e.crange.1));
                    }
                }
                // A section running along the edge (a wall's seam lying in
                // a plane it is tangent to) is that edge, not one that
                // leaves it.
                if feet.iter().all(Option::is_none)
                    || ogeom_algo::project_on_curve(&e.curve, middle, 64, tol)?.distance <= near
                {
                    continue;
                }
                let closed = e
                    .curve
                    .point_at(e.crange.0, tol)?
                    .distance(e.curve.point_at(e.crange.1, tol)?)
                    <= tol.confusion();
                // The ways the stretch may run, each a list of ranges on the
                // edge: between two ends (on a closed edge either way round
                // it, across its vertex), or from one end to a vertex.
                let mut ways: Vec<Vec<(f64, f64)>> = Vec::new();
                if let [Some(f0), Some(f1)] = feet {
                    let (t0, t1) = (f0.min(f1), f0.max(f1));
                    if t1 - t0 > tol.parametric() {
                        ways.push(vec![(t0, t1)]);
                        if closed {
                            ways.push(
                                [(t1, e.crange.1), (e.crange.0, t0)]
                                    .into_iter()
                                    .filter(|(a, b)| b - a > tol.parametric())
                                    .collect(),
                            );
                        }
                    }
                } else if !closed {
                    for t in feet.into_iter().flatten() {
                        ways.push(vec![(e.crange.0, t)]);
                        ways.push(vec![(t, e.crange.1)]);
                    }
                }
                let mut stretches = None;
                for way in ways {
                    let mut lies = !way.is_empty();
                    'way: for &(a, b) in &way {
                        let span = e
                            .curve
                            .point_at(a, tol)?
                            .distance(e.curve.point_at(b, tol)?);
                        if b - a <= tol.parametric() || span <= weld {
                            lies = false;
                            break;
                        }
                        for i in 0..=16 {
                            let t = a + (b - a) * f64::from(i) / 16.0;
                            let p = e.curve.point_at(t, tol)?;
                            if ogeom_algo::project_on_surface(&target.surface, p, 16, tol)?.distance
                                > reach
                            {
                                lies = false;
                                break 'way;
                            }
                        }
                    }
                    if lies {
                        stretches = Some(way);
                        break;
                    }
                }
                let Some(stretches) = stretches else {
                    continue;
                };
                for crange in stretches {
                    let Ok((pcurve, _, true, ..)) = ogeom_algo::pcurve_fit::fit_projected_pcurve(
                        &e.curve,
                        crange,
                        &target.surface,
                        tol,
                    ) else {
                        continue;
                    };
                    if *DEBUG_WIRE {
                        eprintln!(
                            "GRAZE edge {} over {crange:?} onto face {target_face} (from_a {target_from_a})",
                            e.node.index()
                        );
                    }
                    out.push(ContactRec {
                        curve: (*e.curve).clone(),
                        crange,
                        pcurve,
                        prange: crange,
                        node: e.node,
                        tolerance: e.tolerance.max(owner.tolerance + target.tolerance),
                        target_from_a,
                        target_face,
                        bound: e.bound,
                        crossed,
                    });
                }
            }
        }
    }
    Ok(out)
}

/// Which edges [`graze_contacts`] carries onto the other face from where a
/// section line crosses them.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Crossings {
    /// None: an edge is carried only from a section's own ends.
    Off,
    /// Line edges.
    Lines,
    /// Edges of any curve.
    Curves,
}

/// Where a section line crosses an edge of the face it lies on, as
/// [`section_crossings`] finds it.
enum Crossed {
    /// One crossing, on the line, with the line's unit direction.
    Once(Point, ogeom_math::Vector),
    /// Two crossings, on the line.
    Twice(Point, Point),
}

/// Where a section line crosses the boundary edge `e` of the face whose
/// surface is `owner`, within the edge's range: `None` unless the section
/// is a line, or where the edge is crossed other than once or twice.
///
/// A line edge is crossed where the two lines come nearest each other
/// ([`lines_crossing`]). Any other edge needs the face to be a plane, which
/// holds both it and the line. A circle is crossed where the line, laid in
/// the circle's plane, meets it: the two roots of a quadratic. Any other
/// curve is crossed where its signed distance from the line, square to the
/// line in the plane, changes sign: read at 64 steps along the range and
/// halved down to rounding at each change. Two crossings within one step
/// are not seen; what is found still carries a stretch only where the
/// stretch lies on the other face end to end. Each crossing is given on
/// the line, and kept only where the edge's nearest point to it is within
/// `reach` and inside the edge's range.
fn section_crossings(
    section: &Curve,
    e: &BoundaryEdge,
    owner: &SurfaceGeometry,
    crossings: Crossings,
    reach: f64,
    tol: Tolerances,
) -> OgeomResult<Option<Crossed>> {
    if matches!(&*e.curve, Curve::Line(_)) {
        return Ok(
            lines_crossing(section, &e.curve, tol)?.map(|(at, along)| Crossed::Once(at, along))
        );
    }
    if crossings != Crossings::Curves {
        return Ok(None);
    }
    let (Curve::Line(_), SurfaceGeometry::Plane(plane)) = (section, owner) else {
        return Ok(None);
    };
    let p = section.point_at(0.0, tol)?;
    let u = section.point_at(1.0, tol)? - p;
    let length = u.magnitude();
    if length <= 0.0 {
        return Ok(None);
    }
    let u = u / length;
    let mut found: Vec<Point> = Vec::new();
    if let Curve::Circle(c) = &*e.curve {
        let circle = c.circle();
        let axis = circle.frame().z().vector();
        let w = p - circle.centre();
        let w = w - axis * w.dot(axis);
        let v = u - axis * u.dot(axis);
        let (square, half, rest) = (
            v.dot(v),
            w.dot(v),
            w.dot(w) - circle.radius() * circle.radius(),
        );
        let discriminant = half * half - square * rest;
        if square <= 0.0 || discriminant <= 0.0 {
            return Ok(None);
        }
        let q = -(half + discriminant.sqrt().copysign(half));
        if q == 0.0 {
            return Ok(None);
        }
        found.extend([p + u * (q / square), p + u * (rest / q)]);
    } else {
        let across = u.cross(plane.plane().normal().vector());
        let size = across.magnitude();
        if size <= 0.0 {
            return Ok(None);
        }
        let across = across / size;
        let side = |q: Point| (q - p).dot(across);
        let corners = e.bound.expanded(reach).corners();
        if corners.iter().all(|q| side(*q) > 0.0) || corners.iter().all(|q| side(*q) < 0.0) {
            return Ok(None);
        }
        let (lo, hi) = e.crange;
        let at = |t: f64| -> OgeomResult<f64> { Ok(side(e.curve.point_at(t, tol)?)) };
        let mut before = (lo, at(lo)?);
        for i in 1..=64 {
            let t = lo + (hi - lo) * f64::from(i) / 64.0;
            let now = (t, at(t)?);
            if (before.1 < 0.0) != (now.1 < 0.0) {
                let (mut a, mut b, mut fa) = (before.0, now.0, before.1);
                for _ in 0..64 {
                    let m = f64::midpoint(a, b);
                    if m <= a || m >= b {
                        break;
                    }
                    let fm = at(m)?;
                    if (fa < 0.0) == (fm < 0.0) {
                        (a, fa) = (m, fm);
                    } else {
                        b = m;
                    }
                }
                let q = e.curve.point_at(f64::midpoint(a, b), tol)?;
                found.push(p + u * (q - p).dot(u));
            }
            before = now;
        }
    }
    let mut kept: Vec<Point> = Vec::new();
    for q in found {
        let foot = ogeom_algo::project_on_curve(&e.curve, q, 64, tol)?;
        if foot.distance <= reach
            && foot.parameter >= e.crange.0 - tol.parametric()
            && foot.parameter <= e.crange.1 + tol.parametric()
        {
            kept.push(q);
        }
    }
    Ok(match kept[..] {
        [at] => Some(Crossed::Once(at, u)),
        [first, second] => Some(Crossed::Twice(first, second)),
        _ => None,
    })
}

/// Where two lines come nearest each other, on the first, with the first's
/// unit direction: `None` unless both are lines and they are not parallel.
fn lines_crossing(
    first: &Curve,
    second: &Curve,
    tol: Tolerances,
) -> OgeomResult<Option<(Point, ogeom_math::Vector)>> {
    if !matches!(first, Curve::Line(_)) || !matches!(second, Curve::Line(_)) {
        return Ok(None);
    }
    let (p, q) = (first.point_at(0.0, tol)?, second.point_at(0.0, tol)?);
    let (u, v) = (
        first.point_at(1.0, tol)? - p,
        second.point_at(1.0, tol)? - q,
    );
    let across = u.cross(v);
    let square = across.dot(across);
    if square <= 0.0 {
        return Ok(None);
    }
    let s = (q - p).cross(v).dot(across) / square;
    Ok(Some((p + u * s, u / u.magnitude())))
}

/// The boundary edges a tangential contact runs along, carried onto the
/// other face as contacts.
///
/// Where two faces touch along a curve, neither passes through the other
/// there and the curve splits nothing: it is set aside from the
/// arrangement. But where the curve runs along a boundary edge of one
/// face, the solid's boundary turns at that edge onto a neighbour, and the
/// other face can pass from outside the solid into it across the line it
/// touches: a drill tangent to a wall along the edge where a concave round
/// leaves the wall, the drill flatter than the round, cuts a sliver of
/// material from the round's side on, and its wall is lined from the
/// tangent line to where it leaves the solid. The edge is carried onto the
/// other face as a contact, so the face is split along it and its pieces
/// either side are classified on their own; where both lie the same way,
/// the split costs an edge both faces already share.
fn tangent_contacts(
    ga: &GSolid,
    gb: &GSolid,
    tangents: &[TangentRec],
    contacts: &[ContactRec],
    tol: Tolerances,
) -> OgeomResult<Vec<ContactRec>> {
    let reach = tol.confusion() * GRAZE_REACH;
    let weld = tol.confusion() * 1e2;
    let mut out: Vec<ContactRec> = Vec::new();
    for contact in tangents {
        let (lo, hi) = contact.curve.domain();
        let mut contact_bound = ogeom_math::Aabb::EMPTY;
        for i in 0..=16 {
            let t = lo + (hi - lo) * f64::from(i) / 16.0;
            contact_bound = contact_bound.with_point(contact.curve.point_at(t, tol)?);
        }
        for (solid, owner, target, target_from_a, target_face) in [
            (
                ga,
                &ga.faces[contact.face_a],
                &gb.faces[contact.face_b],
                false,
                contact.face_b,
            ),
            (
                gb,
                &gb.faces[contact.face_b],
                &ga.faces[contact.face_a],
                true,
                contact.face_a,
            ),
        ] {
            for e in &owner.edges {
                let held = |c: &ContactRec| {
                    c.node == e.node
                        && c.target_from_a == target_from_a
                        && c.target_face == target_face
                };
                let near = reach.max(e.tolerance);
                if e.other_side.is_some()
                    || !e.bound.expanded(near).intersects(&contact_bound)
                    || contacts.iter().chain(&out).any(held)
                {
                    continue;
                }
                let span = e
                    .curve
                    .point_at(e.crange.0, tol)?
                    .distance(e.curve.point_at(e.crange.1, tol)?);
                if span <= weld {
                    continue;
                }
                // The edge lies along the contact curve and on the other
                // surface, end to end.
                let mut lies = true;
                for i in 0..=16 {
                    let t = e.crange.0 + (e.crange.1 - e.crange.0) * f64::from(i) / 16.0;
                    let p = e.curve.point_at(t, tol)?;
                    if ogeom_algo::project_on_curve(&contact.curve, p, 64, tol)?.distance > near
                        || ogeom_algo::project_on_surface(&target.surface, p, 16, tol)?.distance
                            > near
                    {
                        lies = false;
                        break;
                    }
                }
                if !lies {
                    continue;
                }
                // The solid's boundary turns across the other surface at
                // the edge: the face across the edge leaves that surface to
                // the other side from this one. A seam, or an edge whose
                // two faces both stay outside (a drill tangent to a box's
                // top along the top's edge), splits nothing.
                let Some(across) = solid.faces.iter().find(|f| {
                    !core::ptr::eq(*f, owner) && f.edges.iter().any(|x| x.node == e.node)
                }) else {
                    continue;
                };
                let Some(across_edge) = across.edges.iter().find(|x| x.node == e.node) else {
                    continue;
                };
                let (Some(own_side), Some(other_side)) = (
                    side_off_edge(owner, e, &target.surface, near, tol)?,
                    side_off_edge(across, across_edge, &target.surface, near, tol)?,
                ) else {
                    continue;
                };
                if own_side.signum() == other_side.signum() {
                    continue;
                }
                let Ok((pcurve, _, true, ..)) = ogeom_algo::pcurve_fit::fit_projected_pcurve(
                    &e.curve,
                    e.crange,
                    &target.surface,
                    tol,
                ) else {
                    continue;
                };
                if *DEBUG_WIRE {
                    eprintln!(
                        "TANGENT edge {} over {:?} onto face {target_face} (from_a {target_from_a})",
                        e.node.index(),
                        e.crange
                    );
                }
                out.push(ContactRec {
                    curve: (*e.curve).clone(),
                    crange: e.crange,
                    pcurve,
                    prange: e.crange,
                    node: e.node,
                    tolerance: e.tolerance.max(owner.tolerance + target.tolerance),
                    target_from_a,
                    target_face,
                    bound: e.bound,
                    crossed: false,
                });
            }
        }
    }
    Ok(out)
}

/// Which side of `other` the face lies on just off its edge `e`: the
/// signed distance along `other`'s normal of a point of the face a short
/// way in from the middle of the edge, or `None` where no such point is
/// decided (the face is narrower than any step tried, or lies on `other`
/// there to within the confusion distance).
///
/// The step is taken in the face's chart, square to the edge's pcurve,
/// starting at a twentieth of the edge's span and halving until the point
/// lands inside the face's trim.
fn side_off_edge(
    face: &GFace,
    e: &BoundaryEdge,
    other: &SurfaceGeometry,
    reach: f64,
    tol: Tolerances,
) -> OgeomResult<Option<f64>> {
    let (p0, p1) = e.prange;
    let tm = f64::midpoint(p0, p1);
    let h = (p1 - p0).abs() * 1e-3;
    if h <= 0.0 {
        return Ok(None);
    }
    let at = e.pcurve.point_at(tm, tol)?;
    let (before, after) = (
        e.pcurve.point_at(tm - h, tol)?,
        e.pcurve.point_at(tm + h, tol)?,
    );
    let along = (after.x - before.x, after.y - before.y);
    let length = along.0.hypot(along.1);
    if length <= f64::MIN_POSITIVE {
        return Ok(None);
    }
    let square = (-along.1 / length, along.0 / length);
    let (su, sv) = face.surface.d1_at(at.x, at.y, tol)?;
    let per_param = su.magnitude() * square.0.abs() + sv.magnitude() * square.1.abs();
    if per_param <= f64::MIN_POSITIVE {
        return Ok(None);
    }
    let span = e
        .curve
        .point_at(e.crange.0, tol)?
        .distance(e.curve.point_at(e.crange.1, tol)?);
    let mut step = span * 0.05;
    for _ in 0..8 {
        for sign in [1.0, -1.0] {
            let k = sign * step / per_param;
            let q2 = Point2::new(square.0.mul_add(k, at.x), square.1.mul_add(k, at.y));
            let Ok(q) = face.surface.point_at(q2.x, q2.y, tol) else {
                continue;
            };
            if chart_point_within(face, q, reach, tol).is_none() {
                continue;
            }
            let foot = ogeom_geom::project_on_surface(other, q, 16, tol)?;
            let normal = other.normal_at(foot.parameters.0, foot.parameters.1, tol)?;
            let side = (q - foot.point).dot(normal.vector());
            if side.abs() > tol.confusion() {
                return Ok(Some(side));
            }
            return Ok(None);
        }
        step *= 0.5;
    }
    Ok(None)
}

/// One split an edge is asked for, with how honestly it can be placed.
#[derive(Debug, Clone, Copy)]
struct Pave {
    /// The parameter on the edge's curve.
    t: f64,
    /// How far the strand that asked for it may honestly sit from the exact
    /// junction: its own tolerance, and its tangential doubt where the
    /// crossing was a touch.
    honesty: f64,
    /// The face of the other solid whose section crossed the edge here
    /// (whether that face is of `a`, and its index), where the pave is
    /// such a crossing.
    across: Option<(bool, usize)>,
    /// How far along the edge the crossing may stand from the one the
    /// face across the edge finds: a loose edge's tolerance over the sine
    /// of its lean out of the face that crosses it. Paves that near are
    /// one junction, which reaches only as far as they stand apart.
    spread: f64,
}

/// How far along a loose edge its crossing by `surface` at `at` may
/// stand from the crossing the face across the edge finds: the edge's
/// tolerance over the sine of its lean out of the surface there, held to
/// [`LEAN_SPREAD`] tolerances. None for a tight edge, and none where the
/// lean cannot be read (a cone's apex, a curve with no tangent there).
fn lean_spread(
    e: &BoundaryEdge,
    t: f64,
    surface: &SurfaceGeometry,
    at: Point,
    tol: Tolerances,
) -> f64 {
    if e.tolerance <= tol.confusion() * DRAWN_APART {
        return 0.0;
    }
    let Ok(along) = e.curve.d1_at(t, tol) else {
        return 0.0;
    };
    let length = along.magnitude();
    let Ok(foot) = ogeom_geom::project_on_surface(surface, at, 16, tol) else {
        return 0.0;
    };
    let Ok(normal) = surface.normal_at(foot.parameters.0, foot.parameters.1, tol) else {
        return 0.0;
    };
    if length <= 0.0 {
        return 0.0;
    }
    let sine = along.dot(normal.vector()).abs() / length;
    let most = e.tolerance * LEAN_SPREAD;
    if sine * most > e.tolerance {
        e.tolerance / sine
    } else {
        most
    }
}

/// How far along an edge its crossing by a fitted section at `at` may
/// stand from the true one where the edge touches the section's other
/// surface there: zero where it crosses that surface at an angle.
///
/// The section lies within `honesty` of the surface, so it meets the edge
/// anywhere along the stretch where the edge does. Along the edge, its
/// signed distance off the surface runs `g(s) = g1 s + g2 s^2 / 2` from the
/// crossing: `g1` the edge's lean out of the surface's tangent plane, `g2`
/// the edge's curvature towards the surface's normal less the surface's own
/// normal curvature along the edge. Where `g1^2 <= 2 |g2| honesty` the
/// valley's floor lies within `honesty` of the surface: the edge touches
/// the surface rather than crossing it twice, and the stretch runs to the
/// far side of the valley, `(|g1| + sqrt(g1^2 + 2 |g2| honesty)) / |g2|` from
/// the crossing. Two faces whose surfaces are tangent where a section
/// leaves them (two rounds of one top face whose rails cross) meet it so:
/// the face across splits its own edge at the rails' crossing, as much as
/// a hundredth of a millimetre from where the section meets this one.
/// Elsewhere the lean bounds the stretch at `honesty / |g1|`, which the
/// crossing's own honesty already covers.
fn touch_spread(
    (curve, t): (&Curve, f64),
    surface: &SurfaceGeometry,
    at: Point,
    honesty: f64,
    tol: Tolerances,
) -> f64 {
    if honesty <= 0.0 {
        return 0.0;
    }
    let Ok(d) = curve.derivatives_at(t, 2, tol) else {
        return 0.0;
    };
    let (Some(&d1), Some(&d2)) = (d.get(1), d.get(2)) else {
        return 0.0;
    };
    let speed = d1.magnitude();
    let Ok(foot) = ogeom_geom::project_on_surface(surface, at, 16, tol) else {
        return 0.0;
    };
    let (u, v) = foot.parameters;
    let (Ok((_, su, sv)), Ok((suu, suv, svv))) =
        (surface.point_d1_at(u, v, tol), surface.d2_at(u, v, tol))
    else {
        return 0.0;
    };
    let normal = su.cross(sv);
    let area = normal.magnitude();
    if speed <= 0.0 || area <= 0.0 {
        return 0.0;
    }
    let normal = normal * (1.0 / area);
    let tangent = d1 * (1.0 / speed);
    // The edge's unit tangent in the surface's parameters, solved on the
    // first fundamental form (whose determinant is `area^2`), and the
    // surface's normal curvature along it.
    let (e, f, g) = (su.dot(su), su.dot(sv), sv.dot(sv));
    let (tu, tv) = (tangent.dot(su), tangent.dot(sv));
    let du = g.mul_add(tu, -f * tv) / (area * area);
    let dv = e.mul_add(tv, -f * tu) / (area * area);
    let bends = (du * du).mul_add(
        suu.dot(normal),
        (2.0 * du * dv).mul_add(suv.dot(normal), dv * dv * svv.dot(normal)),
    );
    let lean = tangent.dot(normal).abs();
    let curving = (d2 - tangent * d2.dot(tangent)) * (1.0 / (speed * speed));
    let parting = (curving.dot(normal) - bends).abs();
    if parting <= 0.0 || lean * lean > 2.0 * parting * honesty {
        return 0.0;
    }
    (lean + lean.mul_add(lean, 2.0 * parting * honesty).sqrt()) / parting
}

/// Paves the edge cannot tell apart, as one junction each.
///
/// A tolerant rail meeting a wedge's faces near one corner collects a
/// cluster of crossings inside its own stated radius, and a fitted section
/// and a fitted contact asking for the same corner land a few microns
/// apart. Split at each, the edge shatters into dust no weld downstream can
/// rejoin. So consecutive paves whose gap along the edge in space is within
/// the edge's honesty or either pave's own are one cluster, its first pave
/// speaking for it, and so are the two ends of a graze (see [`grazed`]),
/// the graze's nearest approach speaking for them.
#[derive(Debug, Clone, Copy)]
struct PaveCluster {
    /// The representative parameter: the cluster's first pave, or the
    /// nearest approach of a graze it holds.
    t: f64,
    /// Where it sits.
    at: Point,
    /// How far the cluster's members reach from the representative.
    span: f64,
    /// The loosest honesty among the members.
    honesty: f64,
    /// How many paves the cluster holds.
    members: usize,
}

fn cluster_paves(
    curve: &Curve,
    crange: (f64, f64),
    edge_tolerance: f64,
    paves: &[Pave],
    off: Option<OffFace<'_>>,
    along: Along<'_>,
    tol: Tolerances,
) -> OgeomResult<Vec<PaveCluster>> {
    let mut ts: Vec<Pave> = paves
        .iter()
        .copied()
        .filter(|p| p.t > crange.0 + tol.parametric() && p.t < crange.1 - tol.parametric())
        .collect();
    ts.sort_by(|x, y| x.t.partial_cmp(&y.t).unwrap_or(core::cmp::Ordering::Equal));
    ts.dedup_by(|x, y| {
        if (x.t - y.t).abs() <= tol.parametric() {
            y.honesty = y.honesty.max(x.honesty);
            true
        } else {
            false
        }
    });
    let floor = edge_tolerance.max(tol.confusion() * 10.0);
    // A pave within the edge's honesty of its own end *is* the end: split
    // there, the sliver between them is dust one face keeps and the
    // face across the edge drops, and the sew finds it used once.
    let ends = [
        curve.point_at(crange.0, tol)?,
        curve.point_at(crange.1, tol)?,
    ];
    let mut clusters: Vec<PaveCluster> = Vec::new();
    let mut prev: Option<(Point, Pave)> = None;
    // Where the current cluster's members stand.
    let mut held_at: Vec<Point> = Vec::new();
    for pave in ts {
        let at = curve.point_at(pave.t, tol)?;
        if ends
            .iter()
            .any(|e| e.distance(at) <= floor.max(pave.honesty))
        {
            continue;
        }
        // Two crossings each known to within its honesty are one point
        // where they stand no further apart than both together. Two
        // crossings of a loose edge within their spreads are one junction
        // too, while every member stands within those spreads of the new
        // one: a series of shallow crossings, each within its spread of the
        // last, does not chain into a junction longer than the spreads.
        let joined = prev.is_some_and(|(held, last): (Point, Pave)| {
            let apart = held.distance(at);
            apart <= floor.max(last.honesty + pave.honesty)
                || (apart <= last.spread + pave.spread
                    && held_at
                        .iter()
                        .all(|p| p.distance(at) <= last.spread + pave.spread))
        });
        let touch = match (prev, off) {
            (Some((held, last)), Some(off)) if !joined => grazed(
                curve,
                (held, last),
                (at, pave),
                edge_tolerance,
                off,
                along,
                tol,
            )?,
            _ => None,
        };
        if (joined || touch.is_some())
            && let Some(cluster) = clusters.last_mut()
        {
            held_at.push(at);
            if let Some((t, point)) = touch {
                cluster.t = t;
                cluster.at = point;
            }
            cluster.span = held_at
                .iter()
                .map(|p| p.distance(cluster.at))
                .fold(0.0, f64::max);
            cluster.honesty = cluster.honesty.max(pave.honesty);
            cluster.members += 1;
        } else {
            held_at.clear();
            held_at.push(at);
            clusters.push(PaveCluster {
                t: pave.t,
                at,
                span: 0.0,
                honesty: pave.honesty,
                members: 1,
            });
        }
        prev = Some((at, pave));
    }
    Ok(clusters)
}

/// How far a point stands off a face of the other solid, the face named as
/// [`Pave::across`] names it.
type OffFace<'f> = &'f dyn Fn((bool, usize), Point) -> OgeomResult<f64>;

/// A stretch of an edge carried onto a face of the other solid from where
/// section lines cross it ([`ContactRec::crossed`]): its range on the edge,
/// and that face as [`Pave::across`] names it.
type Stretch = ((f64, f64), (bool, usize));

/// The [`Stretch`]es of one edge.
type Along<'h> = &'h [Stretch];

/// The [`Stretch`]es of every edge that has any.
type AlongEdges = ogeom_core::FastMap<EdgeKey, Vec<Stretch>>;

/// [`AlongEdges`] for the contacts carried.
fn crossed_along(contacts: &[ContactRec]) -> AlongEdges {
    let mut along = AlongEdges::default();
    for c in contacts.iter().filter(|c| c.crossed) {
        along
            .entry(c.node)
            .or_default()
            .push((c.crange, (c.target_from_a, c.target_face)));
    }
    along
}

/// How far `p` stands off the surface of a face of `a` (the flag set) or
/// of `b`.
fn off_face(
    ga: &GSolid,
    gb: &GSolid,
    (from_a, fi): (bool, usize),
    p: Point,
    tol: Tolerances,
) -> OgeomResult<f64> {
    let face = if from_a { &ga.faces[fi] } else { &gb.faces[fi] };
    Ok(ogeom_algo::project_on_surface(&face.surface, p, 16, tol)?.distance)
}

/// Where two consecutive crossings of an edge by sections on one face of
/// the other solid are the two ends of a graze: the edge between them never
/// leaving that face by more than the crossings' honesty or its own
/// tolerance. An exact edge dipping deeper into the face than its
/// tolerance crosses it twice, as the surfaces either side of it do, and
/// the sections ending there end apart. A face tangent
/// to the other solid's face along a line meets a third face of its own
/// solid a hair off the tangency (a round beside the face, its tangent edge
/// a few microns from the other solid). The sections either side of the
/// touch then cross the round's edge twice, the root of the hair times the
/// curvature apart, on an edge the other solid cannot be told from between
/// them. Split twice, the edge keeps a stub no face across it has. The two
/// are one junction at the edge's nearest approach to the face, its
/// parameter and point, while the stretch stays short: a graze and not an
/// edge running along the face. The honesty asked of the edge is held to
/// the fit-slop bound [`honest`] keeps (a micron at millimetre
/// tolerances), however loosely the sections state themselves. The two
/// crossings may stand at most a hundred times that bound apart, whatever
/// the sections state: how far apart a graze's crossings land is set by
/// the gap and the curvature at the touch, not by how closely the
/// sections were fitted, and a window read off their fit error would
/// split a graze or not as a fit happens to land. So the stub a junction
/// takes in is at most 0.1 long at millimetre tolerances, and the
/// junction's reach never grows with a section's stated error. A stretch
/// `along` carries onto the face between the two is an edge running along
/// it, and no graze.
fn grazed(
    curve: &Curve,
    (from, first): (Point, Pave),
    (to, second): (Point, Pave),
    edge_tolerance: f64,
    off: OffFace<'_>,
    along: Along<'_>,
    tol: Tolerances,
) -> OgeomResult<Option<(f64, Point)>> {
    let (Some(face), Some(other)) = (first.across, second.across) else {
        return Ok(None);
    };
    let honesty = honest(first.honesty.max(second.honesty).max(edge_tolerance), tol);
    if face != other || from.distance(to) > honest(f64::INFINITY, tol) * 1e2 {
        return Ok(None);
    }
    let (lo, hi) = (first.t.min(second.t), first.t.max(second.t));
    if along.iter().any(|&((a, b), onto)| {
        onto == face && a <= lo + tol.parametric() && b >= hi - tol.parametric()
    }) {
        return Ok(None);
    }
    let mut nearest: Option<(f64, f64, Point)> = None;
    for k in 1..8 {
        let t = (second.t - first.t).mul_add(f64::from(k) / 8.0, first.t);
        let p = curve.point_at(t, tol)?;
        let d = off(face, p)?;
        if d > honesty {
            return Ok(None);
        }
        if nearest.is_none_or(|(best, ..)| d < best) {
            nearest = Some((d, t, p));
        }
    }
    Ok(nearest.map(|(_, t, p)| (t, p)))
}

/// One kept sub-range of one section.
#[derive(Clone)]
struct SectionPiece {
    section: usize,
    range: (f64, f64),
    /// Whether this sub-range already *is* boundary on the A face, the B
    /// face, or neither. A piece that is boundary on one side is still the
    /// splitting curve on the other, and only the face it duplicates leaves
    /// it out.
    hugs: [bool; 2],
    /// Set when the piece was admitted by a hug: a split of the other face
    /// along this edge of the hugging face: (edge node, target from A,
    /// target face). Two sections hugging one edge onto one face are the
    /// same split, kept once.
    hug_key: Option<(EdgeKey, bool, usize)>,
}

/// One boundary edge of one argument's face, lying in a face of the other
/// argument's own surface: the splitting curve same-domain contact
/// contributes, since coincident surfaces have no section curve to offer.
struct ContactRec {
    /// The owner's world curve and the sub-range its edge covers.
    curve: Curve,
    crange: (f64, f64),
    /// The curve spoken in the *target* face's chart, over its own window,
    /// mapped proportionally from `crange` exactly as an edge's own stored
    /// pcurve is.
    pcurve: PlanarCurve,
    prange: (f64, f64),
    /// The owner edge's node, whose paves this record shares.
    node: EdgeKey,
    /// The owner edge's own tolerance: how far its curve may honestly sit
    /// from the exact geometry it meets, which is how far a crossing filter
    /// must reach to see a fitted rail cross an exact seam.
    tolerance: f64,
    /// The target: which argument's face list, and which face.
    target_from_a: bool,
    target_face: usize,
    /// The owner edge's conservative box: a target edge whose own box
    /// stands further off than a crossing can reach is not intersected.
    bound: ogeom_math::Aabb,
    /// Whether the stretch runs between two crossings of the edge by a
    /// section line, or from one to a vertex, where the edge is a curve
    /// (see [`graze_contacts`]): the edge runs along the target face there,
    /// however short the stretch.
    crossed: bool,
}

/// A same-domain contact edge's image in the shared surface's chart, where
/// no closed form exists: fitted by projection into the target's chart, or
/// (where the edge overhangs the target's own window, a blend's leg on a
/// spline host continued past the face) into the owner's, which is the
/// same chart wherever an extension kept its parent's parameters. The
/// owner's image is trusted only where lifting it through the *target*
/// lands back on the edge, sampled over the run the target's window holds.
///
/// `None` for an edge lying wholly outside the target's window, which the
/// target face cannot meet.
///
/// # Errors
///
/// [`OgeomError::NotDone`](ogeom_core::OgeomError::NotDone) if neither
/// chart holds the edge, or the owner's image lies off the target's window
/// while the edge lies on it.
fn projected_into_shared_chart(
    curve: &Curve,
    range: (f64, f64),
    owner: &SurfaceGeometry,
    target: &SurfaceGeometry,
    tol: Tolerances,
) -> OgeomResult<Option<PlanarCurve>> {
    let against_target = ogeom_algo::pcurve_fit::fit_projected_pcurve(curve, range, target, tol);
    if let Ok(fitted) = &against_target
        && fitted.2
    {
        return Ok(Some(fitted.0.clone()));
    }
    let Ok(on_owner) = ogeom_algo::pcurve_fit::fit_projected_pcurve(curve, range, owner, tol)
    else {
        ogeom_bail!(
            NotDone,
            "same-domain contact whose edge could not be projected into the \
             shared surface's chart: {}",
            against_target
                .err()
                .map_or_else(String::new, |e| e.to_string())
        );
    };
    let ((ua, ub), (va, vb)) = target.domain();
    let reach = tol.confusion() * 1e4;
    let at = |i: u32| range.0 + (range.1 - range.0) * f64::from(i) / 16.0;
    let mut checked = 0usize;
    for i in 0..=16 {
        let t = at(i);
        let uv = on_owner.0.point_at(t, tol)?;
        if uv.x < ua || uv.x > ub || uv.y < va || uv.y > vb {
            continue;
        }
        let lifted = target.point_at(uv.x, uv.y, tol)?;
        if lifted.distance(curve.point_at(t, tol)?) > reach {
            ogeom_bail!(
                NotDone,
                "same-domain contact whose edge overhangs the shared surface's \
                 window, on a chart the two surfaces do not share"
            );
        }
        checked += 1;
    }
    if checked == 0 {
        // The owner's image clear of the target's window says the edge is
        // clear of it only on a shared chart. Where the charts differ (the
        // axis reversed, so the owner's heights read negated), the edge's
        // own feet on the target say whether it reaches the window.
        for i in 0..=16 {
            if on_window(curve.point_at(at(i), tol)?, target, reach, tol)? {
                ogeom_bail!(
                    NotDone,
                    "same-domain contact whose edge lies on the shared surface's \
                     window, on a chart the two surfaces do not share"
                );
            }
        }
        return Ok(None);
    }
    Ok(Some(on_owner.0))
}

/// Whether a point's foot on a surface lies within `reach` of it and clear
/// of the rim of its window. A foot the search pinned to the rim is past
/// the window, not on it.
fn on_window(
    p: Point,
    surface: &SurfaceGeometry,
    reach: f64,
    tol: Tolerances,
) -> OgeomResult<bool> {
    let ((ua, ub), (va, vb)) = surface.domain();
    let (mu, mv) = ((ub - ua).abs() * 1e-9, (vb - va).abs() * 1e-9);
    let Ok(foot) = ogeom_algo::project_on_surface(surface, p, 16, tol) else {
        return Ok(false);
    };
    let (u, v) = foot.parameters;
    Ok(foot.distance <= reach
        && (!u.is_finite() || !ua.is_finite() || (u > ua + mu && u < ub - mu))
        && (!v.is_finite() || !va.is_finite() || (v > va + mv && v < vb - mv)))
}

/// The stretches of an edge that lie on a coincident surface's window, and
/// their images in that surface's chart, where the edge as a whole cannot
/// be imaged there: it runs on past the window (a converted part's wall
/// edge against a pad's shorter side swept from the part's own outline),
/// and only what lies within it can split the face on that surface.
///
/// The edge is sampled, and the samples whose foot on the surface is
/// within `reach` and clear of the window's rim make runs, one for each
/// time the edge comes onto the window. Each run's ends are narrowed onto
/// the rim by bisection and its image fitted over the run alone, so an
/// edge that leaves the window and comes back has one image per stretch.
/// Empty where no sample lands on the window. An error where a stretch's
/// fit fails.
fn clipped_into_chart(
    curve: &Curve,
    range: (f64, f64),
    target: &SurfaceGeometry,
    reach: f64,
    tol: Tolerances,
) -> OgeomResult<Vec<(PlanarCurve, (f64, f64))>> {
    const SAMPLES: u32 = 64;
    let on =
        |t: f64| -> OgeomResult<bool> { on_window(curve.point_at(t, tol)?, target, reach, tol) };
    let at = |i: u32| range.0 + (range.1 - range.0) * f64::from(i) / f64::from(SAMPLES);
    let mut inside = Vec::with_capacity(SAMPLES as usize + 1);
    for i in 0..=SAMPLES {
        inside.push(on(at(i))?);
    }
    // Each end narrowed between the last sample on the window and the
    // first past it.
    let narrow = |mut good: f64, mut bad: f64| -> OgeomResult<f64> {
        for _ in 0..40 {
            let mid = f64::midpoint(good, bad);
            if on(mid)? {
                good = mid;
            } else {
                bad = mid;
            }
        }
        Ok(good)
    };
    let mut stretches = Vec::new();
    let mut next = 0usize;
    while let Some(offset) = inside[next..].iter().position(|&x| x) {
        let first = next + offset;
        let last = inside[first..]
            .iter()
            .position(|&x| !x)
            .map_or(inside.len() - 1, |gap| first + gap - 1);
        next = last + 1;
        #[allow(clippy::cast_possible_truncation, reason = "sample indices")]
        let lo = if first == 0 {
            range.0
        } else {
            narrow(at(first as u32), at(first as u32 - 1))?
        };
        #[allow(clippy::cast_possible_truncation, reason = "sample indices")]
        let hi = if last == SAMPLES as usize {
            range.1
        } else {
            narrow(at(last as u32), at(last as u32 + 1))?
        };
        if hi - lo <= tol.parametric() {
            continue;
        }
        let fitted = ogeom_algo::pcurve_fit::fit_projected_pcurve(curve, (lo, hi), target, tol)?;
        if !fitted.2 {
            ogeom_bail!(
                NotDone,
                "same-domain contact whose edge's stretch on the shared surface's \
                 window has no image in its chart"
            );
        }
        stretches.push((fitted.0, (lo, hi)));
    }
    Ok(stretches)
}

/// The map from one cylinder's, cone's or torus's chart to another's where
/// both are one surface on two frames: the same axis line, within `slop`,
/// and the same radii, and for a torus the same centre on it. The frames
/// differ by a turn about the axis, a slide along it (a cylinder's or a
/// cone's), the axis reversed, or the handedness, so the map is exact:
/// `(u, v)` goes to `(σ·u + φ, s·v + c)`, `s` the sign between the axes,
/// `σ` the sign between the axes the two angles turn about (`x × y`, which
/// is `z` signed by the frame's handedness), `φ` the owner's angle zero read
/// in the target's frame, and `c` the owner's origin's height on the
/// target's axis, zero on a torus. On a torus `v` is the tube's angle,
/// turned over with the axis. A cone's `v` is a height along its axis too,
/// its radius `r + v tan(a)` on either frame: one cone where the half
/// angles agree up to the axes' sign and the owner's reference radius is
/// the target's radius at the owner's origin. Where `σ` and `s` agree the
/// map is a rigid motion of the plane, a half turn where both are negative;
/// where they differ it is a mirror.
fn coaxial_chart_map(
    owner: &SurfaceGeometry,
    target: &SurfaceGeometry,
    slop: f64,
    tol: Tolerances,
) -> Option<ogeom_math::Transform2> {
    let reach = slop.max(tol.confusion());
    let mut cones = None;
    let (fa, fb) = match (owner, target) {
        (SurfaceGeometry::Cylinder(a), SurfaceGeometry::Cylinder(b)) => {
            let (a, b) = (a.cylinder(), b.cylinder());
            if (a.radius() - b.radius()).abs() > reach {
                return None;
            }
            (a.frame(), b.frame())
        }
        (SurfaceGeometry::Cone(a), SurfaceGeometry::Cone(b)) => {
            let (a, b) = (a.cone(), b.cone());
            cones = Some((a, b));
            (a.frame(), b.frame())
        }
        (SurfaceGeometry::Torus(a), SurfaceGeometry::Torus(b)) => {
            let (a, b) = (a.torus(), b.torus());
            if (a.major_radius() - b.major_radius()).abs() > reach
                || (a.minor_radius() - b.minor_radius()).abs() > reach
                || a.frame().origin().distance(b.frame().origin()) > reach
            {
                return None;
            }
            (a.frame(), b.frame())
        }
        _ => return None,
    };
    let (za, zb) = (fa.z().vector(), fb.z().vector());
    let axis = ogeom_math::Axis::new(fb.origin(), fb.z());
    // The axes are one line where the owner's stands within `reach` of the
    // target's wherever the owner's face can be: at its origin, and tilted
    // by their angle over the farthest the face reaches from it, which is
    // the ends of a cylinder's or a cone's height window and a torus's
    // outer radius. An unbounded window is held to the angle alone.
    let lever = match owner {
        SurfaceGeometry::Torus(t) => t.torus().major_radius() + t.torus().minor_radius(),
        _ => {
            let (_, (va, vb)) = owner.domain();
            va.abs().max(vb.abs())
        }
    };
    let tilt = za.cross(zb).magnitude();
    let tilted = if lever.is_finite() {
        tilt * lever > reach
    } else {
        tilt > tol.angular()
    };
    if tilted || axis.distance_to(fa.origin()) > reach {
        return None;
    }
    let s = if za.dot(zb) >= 0.0 { 1.0 } else { -1.0 };
    let sigma = s * fa.handedness().sign() * fb.handedness().sign();
    let x = fa.x().vector();
    let phi = x.dot(fb.y().vector()).atan2(x.dot(fb.x().vector()));
    let c = if matches!(target, SurfaceGeometry::Torus(_)) {
        0.0
    } else {
        (fa.origin() - fb.origin()).dot(zb)
    };
    if let Some((a, b)) = cones
        && ((a.half_angle() - s * b.half_angle()).abs() > tol.angular()
            || (a.reference_radius() - b.radius_at(c)).abs() > reach)
    {
        return None;
    }
    let slide = ogeom_math::Transform2::translation(ogeom_math::Vector2::new(phi, c));
    Some(match (sigma > 0.0, s > 0.0) {
        (true, true) => slide,
        (false, false) => {
            ogeom_math::Transform2::rotation(Point2::new(phi / 2.0, c / 2.0), core::f64::consts::PI)
        }
        // `u` to `φ - u`: the mirror in the column `u = φ / 2`, slid by `c`.
        (false, true) => {
            ogeom_math::Transform2::translation(ogeom_math::Vector2::new(0.0, c))
                * ogeom_math::Transform2::line_mirror(
                    Point2::new(phi / 2.0, 0.0),
                    ogeom_math::Direction2::X,
                )
        }
        // `v` to `c - v`: the mirror in the row `v = c / 2`, slid by `φ`.
        (true, false) => {
            ogeom_math::Transform2::translation(ogeom_math::Vector2::new(phi, 0.0))
                * ogeom_math::Transform2::line_mirror(
                    Point2::new(0.0, c / 2.0),
                    ogeom_math::Direction2::Y,
                )
        }
    })
}

/// An owner face's pcurve carried into the target's chart by
/// [`coaxial_chart_map`], on the branch of the target's `u` window its middle
/// falls in.
fn carried_across(
    pcurve: &PlanarCurve,
    prange: (f64, f64),
    owner: &SurfaceGeometry,
    target: &SurfaceGeometry,
    slop: f64,
    tol: Tolerances,
) -> Option<PlanarCurve> {
    let map = coaxial_chart_map(owner, target, slop, tol)?;
    let carried = pcurve.transformed(&map, tol).ok()?;
    let middle = carried.point_at(0.5 * (prange.0 + prange.1), tol).ok()?;
    let ((ua, ub), (va, vb)) = target.domain();
    let turn = core::f64::consts::TAU;
    let turns = |at: f64, lo: f64, hi: f64| -> f64 {
        if at < lo {
            ((lo - at) / turn).ceil()
        } else if at > hi {
            -((at - hi) / turn).ceil()
        } else {
            0.0
        }
    };
    // A torus's tube angle is periodic too: carried over with a reversed
    // axis it may land a turn off the target's `v` window.
    let along_v = if target.is_periodic_v() {
        turns(middle.y, va, vb)
    } else {
        0.0
    };
    let shift = ogeom_math::Vector2::new(turns(middle.x, ua, ub) * turn, along_v * turn);
    if shift.x == 0.0 && shift.y == 0.0 {
        return Some(carried);
    }
    carried
        .transformed(&ogeom_math::Transform2::translation(shift), tol)
        .ok()
}

/// Whether two surfaces are the *identical chart*: the same
/// parameterization, frame and all, not merely the same point set.
///
/// The five analytics only: a fitted surface never qualifies, because two
/// independent fits of one geometry agree nowhere in parameter space. This
/// is what lets a stored pcurve stand in for a closed-form projection in the
/// same-domain melt: on the identical chart, the owner's pcurve already is
/// the projection.
fn same_chart(a: &SurfaceGeometry, b: &SurfaceGeometry, tol: Tolerances) -> bool {
    use SurfaceGeometry as S;
    // The handedness too: on frames sharing `x` and `z`, a left-handed
    // chart's `y` is the right-handed one's reversed, and its angle runs
    // the other way round.
    let frames = |fa: ogeom_math::Frame, fb: ogeom_math::Frame| -> bool {
        fa.handedness() == fb.handedness()
            && fa.origin().distance(fb.origin()) <= tol.confusion()
            && fa.z().vector().dot(fb.z().vector()) >= 1.0 - tol.angular()
            && fa.x().vector().dot(fb.x().vector()) >= 1.0 - tol.angular()
    };
    match (a, b) {
        (S::Plane(x), S::Plane(y)) => frames(x.plane().frame(), y.plane().frame()),
        (S::Cylinder(x), S::Cylinder(y)) => {
            frames(x.cylinder().frame(), y.cylinder().frame())
                && (x.cylinder().radius() - y.cylinder().radius()).abs() <= tol.confusion()
        }
        (S::Cone(x), S::Cone(y)) => {
            frames(x.cone().frame(), y.cone().frame())
                && (x.cone().reference_radius() - y.cone().reference_radius()).abs()
                    <= tol.confusion()
                && (x.cone().half_angle() - y.cone().half_angle()).abs() <= tol.angular()
        }
        (S::Sphere(x), S::Sphere(y)) => {
            frames(x.sphere().frame(), y.sphere().frame())
                && (x.sphere().radius() - y.sphere().radius()).abs() <= tol.confusion()
        }
        (S::Torus(x), S::Torus(y)) => {
            frames(x.torus().frame(), y.torus().frame())
                && (x.torus().major_radius() - y.torus().major_radius()).abs() <= tol.confusion()
                && (x.torus().minor_radius() - y.torus().minor_radius()).abs() <= tol.confusion()
        }
        // Two patches are one chart only as one patch: the same knots and
        // the same net, to the bit: a blend's leg built on the host's own
        // patch, widened in place and shared. Any other pair of patches
        // that merely coincides is not.
        (S::BSpline(x), S::BSpline(y)) => x == y,
        _ => false,
    }
}

/// What a face's arrangement strand stands for.
#[derive(Clone)]
enum Tag {
    /// A sub-range of boundary edge `edge` (index into the face's edges).
    Boundary { edge: usize, range: (f64, f64) },
    /// A sub-range of a global section.
    Section { section: usize, range: (f64, f64) },
    /// A sub-range of a global contact edge: another face's boundary edge
    /// lying in this face's own surface, splitting it.
    Contact { contact: usize, range: (f64, f64) },
    /// A sub-range of a pole of the face's own chart. The edge is a point in
    /// space whatever the range says. The range is where it runs in the
    /// chart, which is the only place it has length.
    Pole { pole: usize, range: (f64, f64) },
}

/// Where a piece stands relative to the other solid.
///
/// `In` and `Out` are the classifier's words. The two `On` states split the
/// case the classifier cannot decide alone: a piece lying on the other
/// boundary bounds material on one side here and one side there, and whether
/// those sides agree (outward normals aligned) or oppose is what every
/// operation's filter turns on.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PieceState {
    In,
    Out,
    /// On the other boundary, outward normals aligned: both solids' material
    /// on the same side. One copy of the piece bounds the union and the
    /// intersection alike.
    OnAligned,
    /// On the other boundary, outward normals opposed: material on both
    /// sides. The contact is interior to the union and vanishes from it.
    OnOpposed,
    /// Not classified: the other argument is a sheet, which bounds nothing.
    Unread,
}

/// A point in a polyline's *interior*: its half-way member, except that a
/// straight strand is two points and its half-way member is an endpoint,
/// which may sit exactly on a seam or a trim. The chord midpoint is on the
/// curve for a straight image and strictly inside either way.
fn interior_of(line: &[Point2]) -> Point2 {
    if line.len() == 2 {
        Point2::new(
            f64::midpoint(line[0].x, line[1].x),
            f64::midpoint(line[0].y, line[1].y),
        )
    } else {
        line[line.len() / 2]
    }
}

/// Fold a param-space polyline into a periodic surface's chart, by one
/// constant offset per axis.
///
/// A section's pcurve is *unwrapped* across a seam: continuous, and allowed
/// to leave the stated domain, because that is what crossing a seam is. The
/// arrangement lives in one chart, and the filler has already split every
/// section at its seam crossings, so each strand spans at most one chart
/// width and a single period shift per axis brings it home. The shift is
/// chosen by the strand's midpoint, so endpoints sitting exactly on the
/// chart's edge stay on whichever side the strand's body is.
fn fold_into_chart(line: &mut [Point2], surface: &SurfaceGeometry, tol: Tolerances) {
    let ((ua, _), (va, _)) = surface.domain();
    if line.is_empty() {
        return;
    }
    let mid = interior_of(line);
    let [span_u, span_v] = chart_spans(surface, tol);
    if let Some(span) = span_u {
        let shift = (ua + (mid.x - ua).rem_euclid(span)) - mid.x;
        for p in line.iter_mut() {
            p.x += shift;
        }
    }
    if let Some(span) = span_v {
        let shift = (va + (mid.y - va).rem_euclid(span)) - mid.y;
        for p in line.iter_mut() {
            p.y += shift;
        }
    }
}

/// The width a chart comes round by along each direction: its period, or
/// its span where it closes on itself without repeating (a drum spelt as a
/// clamped spline). A section's pcurve is unwrapped across either alike,
/// so a point of it lies a whole span off the chart's window wherever the
/// section crosses the closure, and folds back by that span.
fn chart_spans(surface: &SurfaceGeometry, tol: Tolerances) -> [Option<f64>; 2] {
    let ((ua, ub), (va, vb)) = surface.domain();
    [
        ((surface.is_periodic_u() || surface.is_closed_u(tol)) && ub > ua).then_some(ub - ua),
        ((surface.is_periodic_v() || surface.is_closed_v(tol)) && vb > va).then_some(vb - va),
    ]
}

/// The shifts by whole periods worth trying on a chart point after its fold,
/// nearest first: none, then one period along each periodic direction.
fn period_shifts(surface: &SurfaceGeometry, tol: Tolerances) -> Vec<(f64, f64)> {
    let mut out = vec![(0.0, 0.0)];
    let [span_u, span_v] = chart_spans(surface, tol);
    if let Some(span) = span_u {
        out.push((span, 0.0));
        out.push((-span, 0.0));
    }
    if let Some(span) = span_v {
        out.push((0.0, span));
        out.push((0.0, -span));
    }
    out
}

/// [`period_shifts`], then the shift by whole periods along both directions
/// at once that carries `from` nearest `centre`, the middle of the face's
/// trim, where it moves the point along both.
///
/// A torus face's trim can sit a period off the window in both directions
/// (its rims' circles run past a turn, its tube angle below zero), and a
/// point folded into the window reaches it only by that diagonal shift. It
/// is the one diagonal tried: asked of every diagonal, a trim still open
/// where a pole is yet to close it reads a point a period off both ways as
/// inside.
fn shifts_toward(
    surface: &SurfaceGeometry,
    from: Point2,
    centre: Point2,
    tol: Tolerances,
) -> Vec<(f64, f64)> {
    let mut out = period_shifts(surface, tol);
    if let [Some(du), Some(dv)] = chart_spans(surface, tol) {
        let toward = (
            ((centre.x - from.x) / du).round() * du,
            ((centre.y - from.y) / dv).round() * dv,
        );
        if toward.0 != 0.0 && toward.1 != 0.0 {
            out.push(toward);
        }
    }
    out
}

/// The middle of the box round chart lines.
fn middle_of<'a>(lines: impl IntoIterator<Item = &'a [Point2]>) -> Point2 {
    let (low, high) = lines.into_iter().flatten().fold(
        (
            Point2::new(f64::INFINITY, f64::INFINITY),
            Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
        ),
        |(low, high), p| {
            (
                Point2::new(low.x.min(p.x), low.y.min(p.y)),
                Point2::new(high.x.max(p.x), high.y.max(p.y)),
            )
        },
    );
    Point2::new(f64::midpoint(low.x, high.x), f64::midpoint(low.y, high.y))
}

/// A chart point folded to the side of the face's seam its trim is on.
///
/// The surface's fold puts a point in the period starting at the surface's
/// own zero, which is where a face's trim is only when its seam runs there.
/// A patch whose seam was cut elsewhere (a band opened along the widest gap
/// its mesh left, running diagonally round) covers a period starting at the
/// seam, and a point just short of it belongs a period on. The fold is kept
/// where it lands inside the trim, or where no shift does.
fn fold_inside(
    p: Point2,
    surface: &SurfaceGeometry,
    trim: &[&[Point2]],
    tol: Tolerances,
) -> Point2 {
    let folded = fold_point_into_chart(p, surface, tol);
    // A chart that does not come round has the one fold, inside or not.
    if trim.is_empty() || chart_spans(surface, tol).iter().all(Option::is_none) {
        return folded;
    }
    shifts_toward(surface, folded, middle_of(trim.iter().copied()), tol)
        .into_iter()
        .map(|(du, dv)| Point2::new(folded.x + du, folded.y + dv))
        .find(|q| inside_many(trim, *q))
        .unwrap_or(folded)
}

/// A strand folded into the chart as a whole, to the side of the face's
/// seam its interior lies inside the trim on, as [`fold_inside`] does for
/// a point.
fn fold_line_inside(
    line: &mut [Point2],
    surface: &SurfaceGeometry,
    trim: &arrange::Trim,
    tol: Tolerances,
) {
    fold_into_chart(line, surface, tol);
    if line.is_empty() || trim.is_empty() {
        return;
    }
    // The strand's middle can sit level with the boundary's own vertices
    // (a contact running across the chart ends where it paved the trim),
    // where the level ray passes through them. The leaning ray cannot.
    let mid = interior_of(line);
    if let Some((du, dv)) = shifts_toward(surface, mid, trim.middle(), tol)
        .into_iter()
        .find(|(du, dv)| trim.inside_slanted(Point2::new(mid.x + du, mid.y + dv)))
    {
        for p in line.iter_mut() {
            p.x += du;
            p.y += dv;
        }
    }
}

/// A face's boundary in its chart, each edge's image sampled, both sides of
/// a seam: enough to tell which side of the seam a point is on.
fn face_trim_lines(face: &GFace, tol: Tolerances) -> Vec<Vec<Point2>> {
    let sample = |pcurve: &PlanarCurve, range: (f64, f64)| -> Vec<Point2> {
        (0..=16)
            .filter_map(|k| {
                pcurve
                    .point_at(range.0 + (range.1 - range.0) * f64::from(k) / 16.0, tol)
                    .ok()
            })
            .collect()
    };
    let mut out = Vec::new();
    for e in &face.edges {
        out.push(sample(&e.pcurve, e.prange));
        if let Some((other, range)) = &e.other_side {
            out.push(sample(other, *range));
        }
    }
    out
}

/// Remove period tears from a sampled polyline, axis by axis.
fn unwrap_polyline(line: &mut [Point2], surface: &SurfaceGeometry, tol: Tolerances) {
    // A surface closed without being periodic (a sphere spelt as a spline)
    // tears the same way: a closed section's sample at its end folds back to
    // its start, one column across the chart from where the strand arrives.
    let [span_u, span_v] = chart_spans(surface, tol);
    let spans = (span_u.unwrap_or(0.0), span_v.unwrap_or(0.0));
    for i in 1..line.len() {
        if spans.0 > 0.0 {
            while line[i].x - line[i - 1].x > spans.0 * 0.5 {
                line[i].x -= spans.0;
            }
            while line[i].x - line[i - 1].x < -spans.0 * 0.5 {
                line[i].x += spans.0;
            }
        }
        if spans.1 > 0.0 {
            while line[i].y - line[i - 1].y > spans.1 * 0.5 {
                line[i].y -= spans.1;
            }
            while line[i].y - line[i - 1].y < -spans.1 * 0.5 {
                line[i].y += spans.1;
            }
        }
    }
}

/// Fold a point into a chart that comes round, as [`fold_into_chart`].
fn fold_point_into_chart(p: Point2, surface: &SurfaceGeometry, tol: Tolerances) -> Point2 {
    let mut one = [p];
    fold_into_chart(&mut one, surface, tol);
    one[0]
}

/// A sub-range of a closed curve, brought into its domain.
///
/// The filler split every wrap interval at the domain end, so a piece fits
/// within one period. The fold of its start may still land the end a hair
/// past the domain, which clamps. A piece starting a hair short of the
/// domain end is not split there (the split would leave dust), so its
/// start folds to just below the end with all its length past it: it is
/// read from the domain start instead, or clamping would shrink it to the
/// hair and weld both its ends into one vertex.
fn folded_range(range: (f64, f64), domain: (f64, f64), closed: bool) -> (f64, f64) {
    if !closed {
        return range;
    }
    let length = range.1 - range.0;
    let mut f0 = fold(range.0, domain);
    if f0 + length - domain.1 > domain.1 - f0 {
        f0 = domain.0.max(f0 - (domain.1 - domain.0));
    }
    let f1 = (f0 + length).min(domain.1);
    (f0, f1)
}

/// Fold a parameter into a closed curve's domain.
fn fold(t: f64, domain: (f64, f64)) -> f64 {
    let span = domain.1 - domain.0;
    if span <= 0.0 {
        return domain.0;
    }
    domain.0 + (t - domain.0).rem_euclid(span)
}

/// The parameter to evaluate a section at: folded where the curve is closed
/// and its pieces may run past the domain end, left alone where it is not.
///
/// An open section's own end *is* the domain end, and folding it lands on the
/// domain start instead: the far end of the curve. On a plane's section
/// through a ball's poles, where the marcher hands back two open half circles
/// each running pole to pole, that is the difference between an edge bounded
/// by the pole it reaches and one bounded by the pole on the other side.
fn at_param(t: f64, domain: (f64, f64), closed: bool) -> f64 {
    if closed { fold(t, domain) } else { t }
}

/// How far apart a face's chart holds two of its edges' ends as one point:
/// its loosest edge, the vertices that edge ends at, and the holes set
/// aside from it.
fn doubt_of(face: &GFace) -> f64 {
    face.edges
        .iter()
        .fold(0.0_f64, |acc, e| {
            acc.max(e.standoff * 2.0)
                .max(e.ends_tolerance + e.tolerance)
        })
        .max(
            face.holes_aside
                .iter()
                .fold(0.0_f64, |acc, hole| acc.max(hole.doubt)),
        )
}

/// How far apart a face's chart holds two points as one at `p`: the doubt
/// of each edge `p` lies within reach of (twice what it stands off the face
/// along it, its tolerance and its vertex's at either end), the face's own
/// tolerance, and the holes set aside from it. A loose edge welds what
/// crosses or ends near it, and leaves a crossing of a tight edge elsewhere
/// on the face where it is. Never more than [`doubt_of`], the face's
/// loosest.
fn doubt_at(face: &GFace, p: Point, tol: Tolerances) -> OgeomResult<f64> {
    let mut doubt = face
        .holes_aside
        .iter()
        .fold(face.tolerance, |acc, hole| acc.max(hole.doubt));
    for e in &face.edges {
        for (end, radius) in e.ends {
            let reach = radius + e.tolerance;
            if p.distance(end) <= reach {
                doubt = doubt.max(reach);
            }
        }
        let along = e.standoff * 2.0;
        if along > doubt
            && e.bound.distance_to(p) <= along
            && distance_to_edge_curve(&e.curve, e.crange, p, tol)? <= along
        {
            doubt = along;
        }
    }
    Ok(doubt.min(doubt_of(face)))
}

/// One hug decision for each stretch of an edge, shared by every section
/// running along it.
///
/// Where a face of one solid passes along an edge of the other, each face
/// of the edge meets it in its own section, and the two sections run
/// between the same crossings of the edge. Each section's hug is asked of
/// its own face's edges at its own width (a fitted section's is wider than
/// an exact one's), and the face both sections cross welds its chart at the
/// loosest doubt of anything it meets. Decided apart, one face of the edge
/// keeps the edge while the other keeps its section, or both keep their
/// sections while the crossed face welds the sliver between them to
/// nothing, and the kept pieces do not close.
///
/// Two such pieces are decided together. Where both stay along the edge
/// and along each other within the widest of their hug widths and the
/// weld at each point along them, the stretch is the edge's on both faces:
/// both pieces hug it, admitted onto the crossed face as a hugging piece
/// is. The weld at a point is the doubt of what lies near it on the three
/// faces ([`doubt_at`]): a loose edge at one end of the stretch does not
/// weld the rest of it.
fn share_hugs(
    pieces: &mut [SectionPiece],
    sections: &[SectionRec],
    solids: [&GSolid; 2],
    tol: Tolerances,
) -> OgeomResult<()> {
    let point_of = |section: &SectionRec, t: f64| -> OgeomResult<Point> {
        let domain = section.curve.domain();
        section
            .curve
            .point_at(at_param(t, domain, section.closed), tol)
    };
    let face_of = |s: &SectionRec, side: usize| if side == 0 { s.face_a } else { s.face_b };
    // Each face's weld: its own doubt and that of every face its sections
    // end on.
    let mut weld: [Vec<f64>; 2] = [
        solids[0].faces.iter().map(doubt_of).collect(),
        solids[1].faces.iter().map(doubt_of).collect(),
    ];
    for s in sections {
        let (a, b) = (
            doubt_of(&solids[0].faces[s.face_a]),
            doubt_of(&solids[1].faces[s.face_b]),
        );
        weld[0][s.face_a] = weld[0][s.face_a].max(b);
        weld[1][s.face_b] = weld[1][s.face_b].max(a);
    }
    // The width a piece already hugs at, or none.
    let hug_width = |p: &SectionPiece, side: usize| -> f64 {
        if p.hugs[side] {
            (tol.confusion() * 1e3).max(sections[p.section].tolerance * 3.0)
        } else {
            0.0
        }
    };
    // Whether the piece stays along the edge within the weld `near` sets
    // at each point of its length.
    let along_edge = |p: &SectionPiece,
                      e: &BoundaryEdge,
                      near: &dyn Fn(Point) -> OgeomResult<f64>|
     -> OgeomResult<bool> {
        let s = &sections[p.section];
        for i in 0..=4 {
            let t = p.range.0 + (p.range.1 - p.range.0) * f64::from(i) / 4.0;
            let at = point_of(s, t)?;
            let (drawn, drange, off) = e.drawn();
            let reach = near(at)?.max(off * 2.0);
            if distance_to_edge_curve(drawn, drange, at, tol)? > reach {
                return Ok(false);
            }
        }
        Ok(true)
    };
    let stretch =
        |s: &SectionRec, p: &SectionPiece| folded_range(p.range, s.curve.domain(), s.closed);
    let middles: Vec<Point> = pieces
        .iter()
        .map(|p| point_of(&sections[p.section], f64::midpoint(p.range.0, p.range.1)))
        .collect::<OgeomResult<_>>()?;
    let mut adopted: Vec<(usize, usize, EdgeKey)> = Vec::new();
    for side in 0..2 {
        let own = solids[side];
        for (x, px) in pieces.iter().enumerate() {
            if px.hugs[1 - side] {
                continue;
            }
            let sx = &sections[px.section];
            let (fx, crossed) = (face_of(sx, side), face_of(sx, 1 - side));
            for (y, py) in pieces.iter().enumerate().skip(x + 1) {
                if py.hugs[1 - side] || py.section == px.section || (px.hugs[side] && py.hugs[side])
                {
                    continue;
                }
                let sy = &sections[py.section];
                let fy = face_of(sy, side);
                if fy == fx || face_of(sy, 1 - side) != crossed {
                    continue;
                }
                let hugged = hug_width(px, side).max(hug_width(py, side));
                let widest = weld[1 - side][crossed].max(hugged);
                let (mx, my) = (middles[x], middles[y]);
                if mx.distance(my) > 2.0 * widest
                    || distance_to_edge_curve(&sx.curve, stretch(sx, px), my, tol)? > widest
                    || distance_to_edge_curve(&sy.curve, stretch(sy, py), mx, tol)? > widest
                {
                    continue;
                }
                let faces = [
                    &own.faces[fx],
                    &own.faces[fy],
                    &solids[1 - side].faces[crossed],
                ];
                let near = |at: Point| -> OgeomResult<f64> {
                    let mut near = hugged;
                    for face in faces {
                        near = near.max(doubt_at(face, at, tol)?);
                    }
                    Ok(near)
                };
                let middle = near(mx)?.max(near(my)?);
                if mx.distance(my) > 2.0 * middle
                    || distance_to_edge_curve(&sx.curve, stretch(sx, px), my, tol)? > middle
                    || distance_to_edge_curve(&sy.curve, stretch(sy, py), mx, tol)? > middle
                {
                    continue;
                }
                for ex in &own.faces[fx].edges {
                    let Some(ey) = own.faces[fy].edges.iter().find(|e| e.node == ex.node) else {
                        continue;
                    };
                    if along_edge(px, ex, &near)? && along_edge(py, ey, &near)? {
                        if !px.hugs[side] {
                            adopted.push((x, side, ex.node));
                        }
                        if !py.hugs[side] {
                            adopted.push((y, side, ey.node));
                        }
                        break;
                    }
                }
            }
        }
    }
    for (y, side, key) in adopted {
        let piece = &mut pieces[y];
        if piece.hugs[0] || piece.hugs[1] {
            continue;
        }
        let section = &sections[piece.section];
        if *DEBUG_WIRE {
            eprintln!(
                "PAVE s{}: ({:.6}, {:.6}) hugs the edge with the section beside it",
                piece.section, piece.range.0, piece.range.1
            );
        }
        piece.hugs[side] = true;
        piece.hug_key = Some(if side == 0 {
            (key, false, section.face_b)
        } else {
            (key, true, section.face_a)
        });
    }
    Ok(())
}

/// The move of each face of `own` standing on a drum that touches the
/// planes of `other`'s faces it meets along lines, each to within the
/// confusion distance as
/// [`drum_onto_plane`](ogeom_intersect::drum_onto_plane) reads the pair:
/// the one move across the axis that lays the drum on all of them. The
/// faces on one surface move together, the planes any of them meets asked
/// of all. `None` for a face no plane touches so, or whose planes ask for
/// moves no one move makes that is no longer than the longest of them.
///
/// The touching line is the pair's whole section, and every other section
/// of the drum (against a round the plane runs into, against the faces the
/// line ends on) must end where that line does, as it would on a drum
/// touching the plane exactly. Moved by no more than the confusion
/// distance, the drum stands within its edges' tolerance of where it was,
/// its chart unchanged, so the sections found on it are the drum's own and
/// their pcurves read on it as they stand.
fn drums_onto_planes(
    own: &GSolid,
    other: &GSolid,
    tol: Tolerances,
) -> Vec<Option<ogeom_math::Vector>> {
    let mut numbered: ogeom_core::FastMap<&(ogeom_topo::SurfaceId, Location), usize> =
        ogeom_core::FastMap::default();
    let mut asked: Vec<Vec<(ogeom_math::Vector, f64)>> = Vec::new();
    let mut of_face = Vec::with_capacity(own.faces.len());
    for face in &own.faces {
        let next = numbered.len();
        let at = *numbered.entry(&face.carrier).or_insert(next);
        if at == asked.len() {
            asked.push(Vec::new());
        }
        of_face.push(at);
        let SurfaceGeometry::Cylinder(drum) = &face.surface else {
            continue;
        };
        let drum = drum.cylinder();
        for theirs in &other.faces {
            let SurfaceGeometry::Plane(plane) = &theirs.surface else {
                continue;
            };
            if !face.filter.intersects(&theirs.filter) {
                continue;
            }
            let plane = plane.plane();
            if let Some(shift) = ogeom_intersect::drum_onto_plane(&plane, &drum, tol) {
                let normal = plane.normal().vector();
                asked[at].push((normal, shift.dot(normal)));
            }
        }
    }
    let moves: Vec<Option<ogeom_math::Vector>> = asked
        .iter()
        .map(|asked| {
            let &(n0, s0) = asked.first()?;
            // Every normal lies across the axis. The move is along the
            // first normal, and along the first normal not parallel to it
            // as well.
            let mut shift = n0 * s0;
            if let Some(&(n1, s1)) = asked
                .iter()
                .find(|(n, _)| n.cross(n0).magnitude() > tol.angular())
            {
                let (a, b, c) = (n0.dot(n0), n0.dot(n1), n1.dot(n1));
                let det = a.mul_add(c, -(b * b));
                shift = n0 * ((s0 * c - s1 * b) / det) + n1 * ((s1 * a - s0 * b) / det);
            }
            let agrees = asked
                .iter()
                .all(|&(n, s)| (n.dot(shift) - s).abs() <= tol.intersection());
            let longest = asked.iter().map(|(_, s)| s.abs()).fold(0.0, f64::max);
            (agrees && shift.magnitude() <= longest + tol.intersection()).then_some(shift)
        })
        .collect();
    of_face.into_iter().map(|at| moves[at]).collect()
}

/// Each face of `solid` moved as `moves` says (see [`drums_onto_planes`]),
/// with the edges that move along with it: an edge moves where every face
/// holding it moves by the same shift, or holds it on a plane the shift
/// runs along, which the edge moved by it stays on. A seam, a drum's rim
/// shared with its own flat cap, and the vertex where they meet move with
/// the drum, and the solid stays closed where it stood. An edge a face
/// set aside holds, or a face that does not move and takes the edge off
/// its surface, stays where it stands, which the moved faces then reach
/// within the move.
fn move_drums(
    solid: &mut GSolid,
    moves: &[Option<ogeom_math::Vector>],
    tol: Tolerances,
) -> OgeomResult<()> {
    if moves.iter().all(Option::is_none) {
        return Ok(());
    }
    let mut holders: ogeom_core::FastMap<EdgeKey, Vec<(usize, usize)>> =
        ogeom_core::FastMap::default();
    for (f, face) in solid.faces.iter().enumerate() {
        for (k, e) in face.edges.iter().enumerate() {
            holders.entry(e.node).or_default().push((f, k));
        }
    }
    let along_plane = |face: &GFace, shift: ogeom_math::Vector| match &face.surface {
        SurfaceGeometry::Plane(plane) => {
            plane.plane().normal().vector().dot(shift).abs() <= tol.angular() * shift.magnitude()
        }
        _ => false,
    };
    let mut shift_of: ogeom_core::FastMap<EdgeKey, ogeom_math::Vector> =
        ogeom_core::FastMap::default();
    for (key, held) in &holders {
        if solid.shared.contains_key(key) {
            continue;
        }
        let Some(shift) = held.iter().find_map(|&(f, _)| moves[f]) else {
            continue;
        };
        if held.iter().all(|&(f, _)| match moves[f] {
            Some(other) => other == shift,
            None => along_plane(&solid.faces[f], shift),
        }) {
            shift_of.insert(*key, shift);
        }
    }
    // A vertex moves where only moving edges end on it.
    let staying: ogeom_core::FastSet<[u64; 3]> = solid
        .faces
        .iter()
        .flat_map(|face| &face.edges)
        .filter(|e| !shift_of.contains_key(&e.node))
        .flat_map(|e| e.vertices)
        .map(|p| [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()])
        .collect();
    let mut curves: ogeom_core::FastMap<EdgeKey, std::sync::Arc<Curve>> =
        ogeom_core::FastMap::default();
    for (face, own) in solid.faces.iter_mut().zip(moves) {
        let far = own
            .or_else(|| {
                face.edges
                    .iter()
                    .find_map(|e| shift_of.get(&e.node).copied())
            })
            .map_or(0.0, |shift| shift.magnitude());
        if far == 0.0 {
            continue;
        }
        if let Some(shift) = own {
            face.surface = face
                .surface
                .transformed(&ogeom_math::Transform::translation(*shift), tol)?;
        }
        face.bound = face.bound.expanded(far);
        face.filter = face.filter.expanded(far);
        let chart_shift = |shift: ogeom_math::Vector| match &face.surface {
            SurfaceGeometry::Plane(plane) => {
                let frame = plane.plane().frame();
                Some(ogeom_math::Transform2::translation(
                    ogeom_math::Vector2::new(
                        shift.dot(frame.x().vector()),
                        shift.dot(frame.y().vector()),
                    ),
                ))
            }
            _ => None,
        };
        for e in &mut face.edges {
            let moved = shift_of.get(&e.node).copied();
            // The face's own image of an edge is its pcurve on its surface,
            // which moves with the surface.
            if let Some(image) = &e.image
                && let Some(shift) = moved.or(*own)
            {
                e.image = Some(std::sync::Arc::new(
                    image.transformed(&ogeom_math::Transform::translation(shift), tol)?,
                ));
            }
            let Some(shift) = moved else {
                continue;
            };
            let moving = ogeom_math::Transform::translation(shift);
            e.curve = match curves.get(&e.node) {
                Some(curve) => curve.clone(),
                None => {
                    let curve = std::sync::Arc::new(e.curve.transformed(&moving, tol)?);
                    curves.insert(e.node, curve.clone());
                    curve
                }
            };
            // On a plane that stays, the edge moves in the plane's chart.
            if own.is_none()
                && let Some(by) = chart_shift(shift)
            {
                e.pcurve = e.pcurve.transformed(&by, tol)?;
            }
            for end in &mut e.ends {
                end.0 = moving.apply(end.0);
            }
            for at in &mut e.vertices {
                if !staying.contains(&[at.x.to_bits(), at.y.to_bits(), at.z.to_bits()]) {
                    *at = moving.apply(*at);
                }
            }
            e.bound = e.bound.expanded(far);
        }
    }
    Ok(())
}

/// The sections between two gathered solids, with the paves they put on
/// boundary edges.
#[allow(clippy::type_complexity)]
fn fill(
    ga: &GSolid,
    gb: &GSolid,
    admit_all: bool,
    neighbours: Option<&[ogeom_core::FastSet<usize>]>,
    tol: Tolerances,
) -> OgeomResult<(
    Vec<SectionRec>,
    Vec<SectionPiece>,
    Vec<ContactRec>,
    Vec<TangentRec>,
    Vec<Vec<(f64, f64)>>,
    ogeom_core::FastMap<EdgeKey, Vec<Pave>>,
    Vec<Vec<usize>>,
    Vec<Vec<usize>>,
    Vec<Junction>,
)> {
    use ogeom_intersect::{
        CurveCurveOptions, IntersectOptions, SurfaceIntersection, intersect_curves,
        intersect_surfaces_within,
    };
    let mut sections: Vec<SectionRec> = Vec::new();
    let mut contacts: Vec<ContactRec> = Vec::new();
    let mut tangents: Vec<TangentRec> = Vec::new();
    let mut same_pairs: Vec<(usize, usize)> = Vec::new();
    // Marched sections are fitted. The fit is driven below the confusion
    // tolerance so a fitted curve meets edges, vertices and the mesh welder
    // on the same terms as an exact one. The budget each still carries is
    // recorded per section and widens the crossing filters.
    // Every pair of faces is its own question: each reads the two solids
    // and writes only its own findings, so the pairs are asked in parallel
    // and their findings joined in pair order, the order a single thread
    // would have produced them in.
    #[derive(Default)]
    struct PairFound {
        sections: Vec<SectionRec>,
        contacts: Vec<ContactRec>,
        tangents: Vec<TangentRec>,
        same_pairs: Vec<(usize, usize)>,
        rim_crossed: bool,
        #[cfg(feature = "test-hooks")]
        marched: usize,
    }
    let at_rims = AT_RIMS.get();
    let as_stated = AS_STATED.get();
    let mut pairs: Vec<(usize, usize)> = if admit_all {
        (0..ga.faces.len())
            .flat_map(|ia| (0..gb.faces.len()).map(move |ib| (ia, ib)))
            .collect()
    } else {
        // The second solid's face boxes in a tree, asked once per face of
        // the first: the pairs whose boxes meet, in the order every pair
        // tested in turn would find them.
        let filters: Vec<ogeom_math::Aabb> = gb.faces.iter().map(|f| f.filter).collect();
        let tree = box_tree::BoxTree::new(&filters);
        let mut meeting = Vec::new();
        let mut pairs = Vec::new();
        for (ia, fa) in ga.faces.iter().enumerate() {
            tree.meeting(&fa.filter, &mut meeting);
            pairs.extend(meeting.iter().map(|&ib| (ia, ib)));
        }
        pairs
    };
    // A solid against itself: a face meets its neighbours along the edges
    // and corners they share, which are no crossing, and itself everywhere.
    if let Some(neighbours) = neighbours {
        pairs.retain(|(ia, ib)| !neighbours[*ia].contains(ib));
    }
    #[cfg(feature = "test-hooks")]
    work::add(|w| w.face_pairs += pairs.len());
    // Each surface is marched over its faces' parameter boxes, not over
    // its whole stored domain, and a pair of surfaces is intersected once
    // for every pair of faces standing on them at the same chord.
    let (carriers_a, carriers_b) = (carrier_windows(ga, tol), carrier_windows(gb, tol));
    type Met = std::sync::Arc<std::sync::OnceLock<OgeomResult<SurfaceIntersection>>>;
    let met_once: std::sync::Mutex<ogeom_core::FastMap<(usize, usize, u64), Met>> =
        std::sync::Mutex::default();
    let found = ogeom_core::parallel::map_ordered(
        &pairs,
        |_, &(ia, ib)| -> OgeomResult<PairFound> {
            ogeom_core::progress::checkpoint()?;
            let (fa, fb) = (&ga.faces[ia], &gb.faces[ib]);
            let ((carrier_a, window_a), (carrier_b, window_b)) = (carriers_a[ia], carriers_b[ib]);
            let admitted = fa.filter.intersects(&fb.filter);
            let mut out = PairFound::default();
            let scale = fa.chord_scale.min(fb.chord_scale);
            let chord = (scale * 1e-7).max(tol.confusion() * 0.5);
            let options = IntersectOptions {
                // The fit budget scales with the chord: a section against a
                // fitted surface cannot honestly land closer than the
                // geometry it cuts, and whatever it carries is stated on
                // the record and widens every filter downstream.
                tolerance: chord,
                marching: ogeom_intersect::Marching {
                    chord,
                    ..ogeom_intersect::Marching::default()
                },
            };
            // A plane across a B-spline extrusion's rim, split there in
            // closed form on the run that asks for it, and noted on any
            // other.
            let at_rim = if at_rims {
                ogeom_intersect::plane_extrusion_at_rims(&fa.surface, &fb.surface, tol)
            } else {
                out.rim_crossed =
                    ogeom_intersect::crosses_extrusion_rim(&fa.surface, &fb.surface, tol);
                None
            };
            // The intersector measures a pair without a closed form for
            // coincidence at the chord; the faces' own stated looseness is
            // asked here, since only the faces know it.
            let met = if coincide_as_stated(fa, fb, as_stated, tol) {
                SurfaceIntersection::Same
            } else if let Some(found) = at_rim {
                if found.is_empty() {
                    SurfaceIntersection::Apart
                } else {
                    SurfaceIntersection::Along(found)
                }
            } else {
                let once = met_once
                    .lock()
                    .unwrap_or_else(std::sync::PoisonError::into_inner)
                    .entry((carrier_a, carrier_b, chord.to_bits()))
                    .or_default()
                    .clone();
                let met = once
                    .get_or_init(|| {
                        intersect_surfaces_within(
                            &fa.surface,
                            &fb.surface,
                            (window_a, window_b),
                            options,
                            tol,
                        )
                    })
                    .clone()?;
                let wide_a = reaching(&fa.surface, &fb.surface, &met, tol)?;
                let wide_b = reaching(&fb.surface, &fa.surface, &met, tol)?;
                if wide_a.is_some() || wide_b.is_some() {
                    // A stretched cylinder is walked whole: its faces'
                    // window would cut the stretch back off.
                    intersect_surfaces_within(
                        wide_a.as_ref().unwrap_or(&fa.surface),
                        wide_b.as_ref().unwrap_or(&fb.surface),
                        (
                            window_a.filter(|_| wide_a.is_none()),
                            window_b.filter(|_| wide_b.is_none()),
                        ),
                        options,
                        tol,
                    )?
                } else {
                    met
                }
            };
            match met {
                SurfaceIntersection::Apart => {}
                SurfaceIntersection::Same => {
                    // Coincident surfaces offer no section curve. What splits
                    // each face is the *other* face's boundary. Exact pcurve
                    // projection carries an edge into the other chart, and
                    // planes always have one. A curved pair's edge without
                    // one is carried across coaxial charts, read from the
                    // owner's own pcurve on the identical chart, or fitted
                    // by projection, and refused where none of those holds.
                    out.same_pairs.push((ia, ib));
                    for (owner_from_a, owner, target_from_a, target, target_face) in
                        [(false, fb, true, fa, ia), (true, fa, false, fb, ib)]
                    {
                        for e in &owner.edges {
                            // An edge off the target's surface by no more
                            // than the two faces' stated tolerances lies on
                            // it, as the contact itself says: its closed-form
                            // image is read at that looseness when the strict
                            // one finds it a hair off (a line an edge's slop
                            // from a cylinder it runs along). The target's
                            // looseness is its edges' widest.
                            let slop = target
                                .edges
                                .iter()
                                .map(|t| t.tolerance)
                                .fold(e.tolerance, f64::max)
                                .max(owner.tolerance + target.tolerance);
                            let exact =
                                ogeom_intersect::exact_pcurve_of(&e.curve, &target.surface, tol)
                                    .or_else(|| {
                                        if slop <= tol.confusion() {
                                            return None;
                                        }
                                        let loose = Tolerances::with_scale(
                                            tol.scale() * tol.confusion() / slop,
                                        )
                                        .ok()?;
                                        ogeom_intersect::exact_pcurve_of(
                                            &e.curve,
                                            &target.surface,
                                            loose,
                                        )
                                    });
                            let mut clipped_contact = if exact.is_none()
                                && !same_chart(&owner.surface, &target.surface, tol)
                                && carried_across(
                                    &e.pcurve,
                                    e.prange,
                                    &owner.surface,
                                    &target.surface,
                                    slop,
                                    tol,
                                )
                                .is_none()
                                && projected_into_shared_chart(
                                    &e.curve,
                                    e.crange,
                                    &owner.surface,
                                    &target.surface,
                                    tol,
                                )
                                .is_err()
                            {
                                let reach = slop
                                    .max(owner.tolerance + target.tolerance)
                                    .max(tol.confusion() * 1e2);
                                let stretches = clipped_into_chart(
                                    &e.curve,
                                    e.crange,
                                    &target.surface,
                                    reach,
                                    tol,
                                )?;
                                // Wholly off the target's window is wholly
                                // off the target.
                                if stretches.is_empty() {
                                    continue;
                                }
                                stretches
                            } else {
                                Vec::new()
                            };
                            let clipped = core::mem::take(&mut clipped_contact);
                            let shared_chart = exact.is_none()
                                && clipped.is_empty()
                                && same_chart(&owner.surface, &target.surface, tol);
                            // One cylinder on two frames whose fit the
                            // target's window cannot hold (a converted
                            // part's short wall against a pad's long one):
                            // the owner's own pcurve carried across the
                            // charts exactly.
                            let carried = if exact.is_none() && clipped.is_empty() && !shared_chart
                            {
                                carried_across(
                                    &e.pcurve,
                                    e.prange,
                                    &owner.surface,
                                    &target.surface,
                                    slop,
                                    tol,
                                )
                                .filter(|_| {
                                    projected_into_shared_chart(
                                        &e.curve,
                                        e.crange,
                                        &owner.surface,
                                        &target.surface,
                                        tol,
                                    )
                                    .is_err()
                                })
                            } else {
                                None
                            };
                            let images: Vec<(PlanarCurve, (f64, f64), (f64, f64))> = match (
                                exact,
                                clipped.is_empty(),
                                carried,
                            ) {
                                (Some(exact), _, _) => vec![(exact, e.crange, e.crange)],
                                // What the other branches cannot image whole
                                // but only runs on past the target's window
                                // is imaged over each stretch it has on the
                                // window, each its own contact.
                                (None, false, _) => clipped
                                    .into_iter()
                                    .map(|(pcurve, range)| (pcurve, range, range))
                                    .collect(),
                                // A fitted edge has no closed-form projection,
                                // but when the two faces sit on the
                                // *identical chart*, which is exactly the
                                // situation `Same` names for the analytics,
                                // the owner's own stored pcurve already is
                                // the projection, attached at construction,
                                // and it travels with its own window the way
                                // every stored pcurve does.
                                (None, true, _) if shared_chart => {
                                    vec![(e.pcurve.clone(), e.prange, e.crange)]
                                }
                                (None, true, Some(carried)) => vec![(carried, e.prange, e.crange)],
                                // Two patches that coincide as point sets
                                // without being one chart (a blend's leg
                                // on a spline host continued past the
                                // face, against the face's own patch) get
                                // the edge fitted by projection into the
                                // target's chart, same-parameter with the
                                // edge, the way every reader derives a
                                // pcurve it was not given.
                                (None, true, None) => {
                                    let Some(pcurve) = projected_into_shared_chart(
                                        &e.curve,
                                        e.crange,
                                        &owner.surface,
                                        &target.surface,
                                        tol,
                                    )?
                                    else {
                                        // Wholly outside the target's window
                                        // is wholly outside the target: a
                                        // blend's run-out past the face it
                                        // melts with splits nothing there.
                                        continue;
                                    };
                                    if *DEBUG_WIRE {
                                        eprintln!(
                                            "SAME owner {} face {} (from_a {owner_from_a}) edge {} of kind {:?}: {:?} .. {:?} against target face {target_face}",
                                            if owner_from_a { "a" } else { "b" },
                                            if owner_from_a { ia } else { ib },
                                            e.node.index(),
                                            core::mem::discriminant(&*e.curve),
                                            e.curve.point_at(e.crange.0, tol).ok(),
                                            e.curve.point_at(e.crange.1, tol).ok()
                                        );
                                    }
                                    vec![(pcurve, e.crange, e.crange)]
                                }
                            };
                            for (pcurve, prange, crange) in images {
                                out.contacts.push(ContactRec {
                                    curve: (*e.curve).clone(),
                                    crange,
                                    pcurve,
                                    prange,
                                    node: e.node,
                                    // The contact stands off the target as
                                    // far as the two faces say they may stand
                                    // off their own surfaces, not only its
                                    // edge.
                                    tolerance: e.tolerance.max(owner.tolerance + target.tolerance),
                                    target_from_a,
                                    target_face,
                                    bound: e.bound,
                                    crossed: false,
                                });
                            }
                        }
                    }
                }
                // A touch at a point bounds nothing: no curve to split a
                // face along, no side that is inside on one hand and
                // outside on the other. It contributes to the arrangement
                // exactly what a tangential contact curve does, which is
                // nothing, and the result carries the touch as the
                // non-manifold contact it is.
                SurfaceIntersection::Touching(_) => {}
                SurfaceIntersection::Along(curves) => {
                    // Two planes all but parallel cross along a line, and on
                    // either side of it stay within tolerance of each other
                    // for a stretch: a block stacked on another and tilted a
                    // hair. An edge of either lying on the other's plane
                    // there splits the other's face as a coincident pair's
                    // edge would, or the two faces walk different splits of
                    // the stretch they share.
                    if let (SurfaceGeometry::Plane(pa), SurfaceGeometry::Plane(pb)) =
                        (&fa.surface, &fb.surface)
                    {
                        let (na, nb) = (pa.plane().normal(), pb.plane().normal());
                        if na.vector().cross(nb.vector()).magnitude() <= 1e-3 {
                            for (owner, target, target_from_a, target_face) in
                                [(fb, fa, true, ia), (fa, fb, false, ib)]
                            {
                                let SurfaceGeometry::Plane(on) = &target.surface else {
                                    continue;
                                };
                                for e in &owner.edges {
                                    if !matches!(&*e.curve, Curve::Line(_)) {
                                        continue;
                                    }
                                    let lies = [e.crange.0, e.crange.1].iter().all(|&t| {
                                        e.curve.point_at(t, tol).is_ok_and(|p| {
                                            on.plane().distance_to(p) <= tol.confusion()
                                        })
                                    });
                                    if !lies {
                                        continue;
                                    }
                                    let Some(pcurve) = ogeom_intersect::exact_pcurve_of(
                                        &e.curve,
                                        &target.surface,
                                        tol,
                                    ) else {
                                        continue;
                                    };
                                    out.contacts.push(ContactRec {
                                        curve: (*e.curve).clone(),
                                        crange: e.crange,
                                        pcurve,
                                        prange: e.crange,
                                        node: e.node,
                                        tolerance: e
                                            .tolerance
                                            .max(owner.tolerance + target.tolerance),
                                        target_from_a,
                                        target_face,
                                        bound: e.bound,
                                        crossed: false,
                                    });
                                }
                            }
                        }
                    }
                    // Two planes at a small angle that share an edge only to
                    // their points' rounding (a pad's wall standing on a
                    // facet just under the top edge they both hold) cross on
                    // a line the solve places by that rounding over the
                    // angle's sine: microns of slop, tens of microns along.
                    // An edge of either lying on the other's plane to within
                    // the weld distance, and off the solved line by more than
                    // the confusion distance yet no more than that slop
                    // allows, is where they cross: it splits the other face
                    // as a contact, and the solved line, a sliver away from
                    // it, splits nothing. The angle may be well under a
                    // thousandth of a radian (a facet leaning off a wall by
                    // less than its chord sags) where the edge is one both
                    // faces hold and the planes part by more than the weld
                    // distance across the smaller face: the band where they
                    // stand within it of each other runs from the shared
                    // edge, and the face past it lies off the other plane.
                    // Where they never part by that much the faces are one
                    // surface to within the weld, and a contact along one
                    // edge does not settle them.
                    let mut replaced = false;
                    if let (SurfaceGeometry::Plane(pa), SurfaceGeometry::Plane(pb)) =
                        (&fa.surface, &fb.surface)
                    {
                        let sine = pa
                            .plane()
                            .normal()
                            .vector()
                            .cross(pb.plane().normal().vector())
                            .magnitude();
                        let lines: Vec<&Curve> = curves
                            .iter()
                            .filter(|c| !c.tangential)
                            .map(|c| &c.curve)
                            .collect();
                        let weld = tol.confusion() * 1e2;
                        let narrow = sine * fa.bound.diagonal().min(fb.bound.diagonal()) > weld;
                        if (sine > 1e-3 || narrow)
                            && let [solved] = lines.as_slice()
                            && matches!(solved, Curve::Line(_))
                        {
                            for (owner, target, target_from_a, target_face) in
                                [(fb, fa, true, ia), (fa, fb, false, ib)]
                            {
                                let SurfaceGeometry::Plane(on) = &target.surface else {
                                    continue;
                                };
                                for e in &owner.edges {
                                    if !matches!(&*e.curve, Curve::Line(_)) {
                                        continue;
                                    }
                                    let mut ends = Vec::with_capacity(2);
                                    for t in [e.crange.0, e.crange.1] {
                                        ends.push(e.curve.point_at(t, tol)?);
                                    }
                                    let stray = ends
                                        .iter()
                                        .map(|p| on.plane().distance_to(*p))
                                        .fold(0.0_f64, f64::max);
                                    if stray > weld {
                                        continue;
                                    }
                                    let mut off = 0.0_f64;
                                    for p in &ends {
                                        off = off.max(
                                            ogeom_algo::project_on_curve(solved, *p, 64, tol)?
                                                .distance,
                                        );
                                    }
                                    // The solve's own slop, the edge's
                                    // stray magnified by the shallow angle;
                                    // a line no further from the edge than
                                    // the edge from the plane is a crossing
                                    // the solve placed well.
                                    if off <= tol.confusion().max(stray * 2.0) || off > weld / sine
                                    {
                                        continue;
                                    }
                                    let Some(pcurve) = ogeom_intersect::exact_pcurve_of(
                                        &e.curve,
                                        &target.surface,
                                        tol,
                                    ) else {
                                        continue;
                                    };
                                    // Under a thousandth of a radian the
                                    // edge must be one the two faces share:
                                    // an edge of the other face beside it
                                    // end to end, to the weld distance. A
                                    // face whose edge only lies on the
                                    // other's plane there (a block stacked
                                    // on another tilted a hair) truly
                                    // crosses it on the solved line.
                                    if sine <= 1e-3 && !shared_line(&ends, target, weld, tol)? {
                                        continue;
                                    }
                                    replaced = true;
                                    // All but parallel, an edge on the
                                    // other's plane to the confusion
                                    // distance is a contact already.
                                    if sine <= 1e-3 && stray <= tol.confusion() {
                                        continue;
                                    }
                                    out.contacts.push(ContactRec {
                                        curve: (*e.curve).clone(),
                                        crange: e.crange,
                                        pcurve,
                                        prange: e.crange,
                                        node: e.node,
                                        tolerance: e
                                            .tolerance
                                            .max(owner.tolerance + target.tolerance),
                                        target_from_a,
                                        target_face,
                                        bound: e.bound,
                                        crossed: false,
                                    });
                                }
                            }
                        }
                    }
                    // A face whose outline lies on one side of the other's
                    // plane, to rounding, does not cross it, and their
                    // planes' line splits neither face. Where the two stand
                    // all but parallel (a corner facet meeting a wall only at
                    // a vertex and leaning off it by less than its points'
                    // rounding over its height) the solve places that line by
                    // the rounding over the angle's sine, across the facet a
                    // tenth of a millimetre from the vertex. At a wider angle
                    // a face touching the plane only at corners gives a line
                    // along its own edge to within the rounding (a facet's
                    // side edge beside the next wall), a stub the arrangement
                    // cannot tell from the edge. An edge lying in the plane is
                    // where the faces meet: all but parallel the edge is a
                    // contact already (above), and at a wider angle the line
                    // stays.
                    if !replaced
                        && let (SurfaceGeometry::Plane(pa), SurfaceGeometry::Plane(pb)) =
                            (&fa.surface, &fb.surface)
                    {
                        let sine = pa
                            .plane()
                            .normal()
                            .vector()
                            .cross(pb.plane().normal().vector())
                            .magnitude();
                        for (face, plane) in [(fa, pb.plane()), (fb, pa.plane())] {
                            if let Some(edge_in) = one_side_of(face, plane, tol)?
                                && (sine <= 1e-3 || !edge_in)
                            {
                                replaced = true;
                            }
                        }
                    }
                    // Where one curve has no chart image, the pair is
                    // marched whole, every branch at once: the sections its
                    // other curves already gave are replaced by the marched
                    // set, and the curves after it add no more, while its
                    // tangential contacts are still kept.
                    let before = out.sections.len();
                    let mut marched = false;
                    for sc in curves {
                        // A tangential curve is contact, not crossing: the
                        // two faces meet along it and neither passes
                        // through the other, so it is set aside from the
                        // arrangement entirely and kept for the consumers
                        // that draw contact rather than classify by it.
                        if sc.tangential {
                            if let (Some(pa), Some(pb)) = (sc.on_a, sc.on_b) {
                                out.tangents.push(TangentRec {
                                    curve: sc.curve,
                                    pc_a: pa,
                                    pc_b: pb,
                                    face_a: ia,
                                    face_b: ib,
                                });
                            }
                            continue;
                        }
                        if marched || replaced {
                            continue;
                        }
                        // A section can be no longer than a turn round the
                        // faces it cuts or round its own extent: a marched
                        // trace that wanders off beside a chart's pole comes
                        // back many times the length of the circle it stands
                        // for, faithfully fitted. That is no section, and is
                        // refused by name. A whole loop of two surfaces
                        // meeting all the way round, faces cutting only an
                        // arc of it, is one turn round its own extent.
                        if !sc.exact {
                            let (length, reach) = length_and_reach(&sc.curve, tol)?;
                            let turn =
                                4.0 * fa.bound.diagonal().max(fb.bound.diagonal()).max(reach);
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "SECTION CHECK faces {ia}/{ib} exact {} closed {} length {length:.4} turn {turn:.4} tol {:.2e}",
                                    sc.exact, sc.closed, sc.tolerance
                                );
                            }
                            if length > turn {
                                ogeom_bail!(
                                    NotDone,
                                    "a marched section of length {length} runs beyond a turn \
                                 round the faces it cuts ({turn}); its trace wandered \
                                 beside a chart's pole; see docs/CAPABILITIES.md, bool.booleans"
                                );
                            }
                        }
                        match (sc.on_a.clone(), sc.on_b.clone()) {
                            (Some(pa), Some(pb)) => out.sections.push(SectionRec {
                                curve: sc.curve,
                                pc_a: pa,
                                pc_b: pb,
                                face_a: ia,
                                face_b: ib,
                                closed: sc.closed,
                                tolerance: sc.tolerance,
                            }),
                            _ => {
                                // A section running through a chart
                                // degeneracy (a plane cutting a ball on its
                                // own axis meets it at both poles) has no
                                // single chart image, because the longitude
                                // jumps half a turn there. Each piece
                                // *between* the poles does have one, and it
                                // is exact. Split first. March only if that
                                // fails.
                                if let Some(split) = split_at_degeneracies(&sc.curve, fa, fb, tol)?
                                {
                                    for (curve, pa, pb) in split {
                                        out.sections.push(SectionRec {
                                            curve,
                                            pc_a: pa,
                                            pc_b: pb,
                                            face_a: ia,
                                            face_b: ib,
                                            closed: false,
                                            tolerance: 0.0,
                                        });
                                    }
                                    continue;
                                }
                                // An exact curve whose projection has no
                                // closed form keeps its exactness and has
                                // its chart image fitted: the curve's own
                                // points inverted on the surface, read in
                                // the chart, fitted at the curve's own
                                // parameters: a plane's circle passing
                                // beside a sphere chart's pole, whose image
                                // swings fast but is a curve all the same.
                                // Marching the pair instead wanders beside
                                // the pole.
                                let image = |surface: &SurfaceGeometry,
                                         have: Option<&PlanarCurve>|
                             -> OgeomResult<Option<(PlanarCurve, f64)>> {
                                if let Some(pc) = have {
                                    return Ok(Some((pc.clone(), 0.0)));
                                }
                                fitted_image(&sc.curve, surface, options.tolerance, tol)
                            };
                                if let (Some((pa, ea)), Some((pb, eb))) = (
                                    image(&fa.surface, sc.on_a.as_ref())?,
                                    image(&fb.surface, sc.on_b.as_ref())?,
                                ) {
                                    out.sections.push(SectionRec {
                                        curve: sc.curve,
                                        pc_a: pa,
                                        pc_b: pb,
                                        face_a: ia,
                                        face_b: ib,
                                        closed: sc.closed,
                                        tolerance: sc.tolerance.max(ea).max(eb),
                                    });
                                    continue;
                                }
                                // No image fits: march the pair instead, so
                                // curve and pcurves are fitted *together*.
                                if *DEBUG_WIRE {
                                    eprintln!(
                                        "MARCH PAIR faces {ia}/{ib} a {:?} b {:?} admitted {admitted}",
                                        core::mem::discriminant(&fa.surface),
                                        core::mem::discriminant(&fb.surface)
                                    );
                                }
                                out.sections.truncate(before);
                                marched = true;
                                let shared = if admitted {
                                    fa.bound.intersection(&fb.bound)
                                } else {
                                    // Audit only: disjoint bounds have no
                                    // window, and an empty window would mask
                                    // the very miss being hunted.
                                    fa.bound.union(&fb.bound)
                                };
                                let (wa, wb) = (
                                    windowed_to(&fa.surface, &shared),
                                    windowed_to(&fb.surface, &shared),
                                );
                                #[cfg(feature = "test-hooks")]
                                {
                                    out.marched += 1;
                                }
                                let (marched, pole_reach) = march_pair(&wa, &wb, &options, tol)?;
                                for fitted in marched {
                                    // The same two refusals the intersector's
                                    // own marched sections meet: a fit a
                                    // thousand chords off its trace, and a
                                    // trace longer than a turn round the
                                    // faces. A plane's circle passing beside
                                    // a sphere chart's pole marches both
                                    // ways, and stated as data either welds
                                    // the tool into a point.
                                    let budget =
                                        (options.marching.chord * 1e3).max(options.tolerance * 1e3);
                                    if fitted.fit_error > budget {
                                        ogeom_bail!(
                                            NotDone,
                                            "a marched section's fit misses its trace by {} \
                                         against a chord of {}; a branch passing beside a \
                                         chart's pole fits nothing yet; see docs/CAPABILITIES.md, \
                                         boolean.general",
                                            fitted.fit_error,
                                            options.marching.chord
                                        );
                                    }
                                    let curve: Curve = fitted.curve.into();
                                    let (length, reach) = length_and_reach(&curve, tol)?;
                                    let turn = 4.0
                                        * fa.bound.diagonal().max(fb.bound.diagonal()).max(reach);
                                    if length > turn {
                                        ogeom_bail!(
                                            NotDone,
                                            "a marched section of length {length} runs beyond a \
                                         turn round the faces it cuts ({turn}); its trace \
                                         wandered beside a chart's pole; see docs/CAPABILITIES.md, \
                                         boolean.general"
                                        );
                                    }
                                    out.sections.push(SectionRec {
                                        // A branch cut at a pole of either
                                        // chart ends on it twice, its images
                                        // apart there: closed in space, open
                                        // in the charts.
                                        closed: curve.is_closed(tol)
                                            && !on_a_chart_pole(&curve, [&wa, &wb], tol)?,
                                        // Cut at a pole within a reach, the
                                        // trace passes the pole up to that
                                        // reach off the truth.
                                        tolerance: (options.marching.chord + fitted.fit_error)
                                            .max(pole_reach),
                                        curve,
                                        pc_a: fitted.on_a.into(),
                                        pc_b: fitted.on_b.into(),
                                        face_a: ia,
                                        face_b: ib,
                                    });
                                }
                            }
                        }
                    }
                }
            }

            Ok(out)
        },
    );
    // An edge two faces of one solid hold, both lying on the other solid's
    // face (a top split in two by a fuse), is carried onto that face once
    // per holder; the second copy is the same strand, which the
    // arrangement would walk as a sliver between two coincident lines.
    let mut carried: ogeom_core::FastSet<(EdgeKey, bool, usize, [u64; 4])> =
        ogeom_core::FastSet::default();
    for pair in found {
        let pair = pair?;
        sections.extend(pair.sections);
        contacts.extend(pair.contacts.into_iter().filter(|c| {
            carried.insert((
                c.node,
                c.target_from_a,
                c.target_face,
                [
                    c.crange.0.to_bits(),
                    c.crange.1.to_bits(),
                    c.prange.0.to_bits(),
                    c.prange.1.to_bits(),
                ],
            ))
        }));
        tangents.extend(pair.tangents);
        same_pairs.extend(pair.same_pairs);
        if pair.rim_crossed {
            RIM_CROSSED.set(true);
        }
        #[cfg(feature = "test-hooks")]
        work::add(|w| w.marched_pairs += pair.marched);
    }
    for section in &mut sections {
        if let Some(rebased) = seamed_at_a_stop(
            section,
            &ga.faces[section.face_a],
            &gb.faces[section.face_b],
            tol,
        ) {
            *section = rebased;
        }
    }
    #[cfg(feature = "test-hooks")]
    work::add(|w| {
        w.widest_section = sections
            .iter()
            .fold(w.widest_section, |widest, s| widest.max(s.tolerance));
    });
    let grazed = graze_contacts(ga, gb, &sections, &contacts, FROM_CROSSINGS.get(), tol)?;
    contacts.extend(grazed);
    let touched = tangent_contacts(ga, gb, &tangents, &contacts, tol)?;
    contacts.extend(touched);

    // Boundary polylines per face, for the trim tests.
    let outline = |face: &GFace| -> OgeomResult<Vec<Vec<Point2>>> {
        let mut lines = Vec::new();
        for e in &face.edges {
            lines.push(pcurve_polyline_within_sag(
                &e.pcurve,
                e.prange,
                e.crange,
                e.crange,
                &face.surface,
                tol,
            )?);
            if let Some((other, orange)) = &e.other_side {
                lines.push(pcurve_polyline_within_sag(
                    other,
                    *orange,
                    e.crange,
                    e.crange,
                    &face.surface,
                    tol,
                )?);
            }
        }
        weld_outline_ends(&mut lines, face, tol);
        bridge_outline_gaps(&mut lines);
        Ok(lines)
    };
    // Only the faces a section crosses are asked about: on a large solid
    // and a small tool that is a handful, and drawing every face's outline
    // was most of the paving's cost.
    let crossed_a: ogeom_core::FastSet<usize> = sections.iter().map(|s| s.face_a).collect();
    let crossed_b: ogeom_core::FastSet<usize> = sections.iter().map(|s| s.face_b).collect();
    // The face's own outline is drawn once and kept for the later trim
    // tests; where it cannot be drawn, drawing it again says why.
    let mut outlines_a: Vec<std::borrow::Cow<'_, [Vec<Point2>]>> =
        Vec::with_capacity(ga.faces.len());
    let mut outlines_b: Vec<std::borrow::Cow<'_, [Vec<Point2>]>> =
        Vec::with_capacity(gb.faces.len());
    for (faces, crossed, outlines) in [
        (&ga.faces, &crossed_a, &mut outlines_a),
        (&gb.faces, &crossed_b, &mut outlines_b),
    ] {
        for (i, f) in faces.iter().enumerate() {
            outlines.push(if !crossed.contains(&i) {
                std::borrow::Cow::Owned(Vec::new())
            } else if let Some(lines) = f.outline(tol) {
                std::borrow::Cow::Borrowed(lines)
            } else {
                std::borrow::Cow::Owned(outline(f)?)
            });
        }
    }

    // Crossings of each section with the boundary edges of both its faces,
    // and with every other section sharing a face.
    let mut paves: ogeom_core::FastMap<EdgeKey, Vec<Pave>> = ogeom_core::FastMap::default();
    let mut pieces: Vec<SectionPiece> = Vec::new();
    // Each section's paving depends only on the sections and the two
    // gathered solids, all read-only here, and writes nothing the next
    // section reads. So the measuring runs in parallel and the accumulating
    // runs afterwards in section order: the same split `tessellate` uses,
    // and the same reason: nothing about scheduling can reach the answer.
    type SectionWork = (
        Vec<(EdgeKey, Pave)>,
        Vec<SectionPiece>,
        Vec<Junction>,
        Option<SectionRec>,
    );
    let mut hug_junctions: Vec<Junction> = Vec::new();
    // Each section's box, for skipping pairs of sections too far apart to
    // cross. A curve whose box cannot be had stands unbounded and is never
    // skipped.
    let section_bounds: Vec<Option<ogeom_math::Aabb>> = sections
        .iter()
        .map(|s| {
            ogeom_algo::curve_bounds(&s.curve, tol)
                .ok()
                .map(|b| b.expanded(s.tolerance))
        })
        .collect();
    // Read here, on the caller's thread: the sections are paved on worker
    // threads, which do not share it.
    let at_stated = AT_STATED.get();
    let paved: Vec<OgeomResult<SectionWork>> = ogeom_core::parallel::map_ordered(
        &sections,
        |si, section: &SectionRec| {
            ogeom_core::progress::checkpoint()?;
            let mut paves: Vec<(EdgeKey, Pave)> = Vec::new();
            let mut pieces: Vec<SectionPiece> = Vec::new();
            let mut junctions: Vec<Junction> = Vec::new();
            // A fitted section meets an edge within its own budget, not within
            // rounding.
            let reach = tol.confusion().max(section.tolerance * 2.0);
            let cc = CurveCurveOptions {
                gap: reach.max(CurveCurveOptions::default().gap),
                ..CurveCurveOptions::default()
            };
            let domain = section.curve.domain();
            let mut trim_ts: Vec<f64> = Vec::new();
            // Crossings with boundary edges: side, edge, parameter on the
            // edge, parameter on the section, and how honestly the stop sits.
            let mut hits: Vec<(usize, EdgeKey, f64, f64, f64, bool, f64)> = Vec::new();
            // Spans of the section running *along* a boundary edge. The split
            // such a span would make already exists as boundary (stacked boxes'
            // perpendicular side planes meet exactly at the boxes' own edges),
            // so the span is excluded from that face's strands rather than
            // refused or duplicated.
            //
            // Which face, though, is the whole point. A plane through a bore's
            // axis meets the wall along two rulings, and one of them is the
            // wall's own seam: on the wall that ruling is boundary already, and
            // on the plane it is the curve that separates the two halves the
            // section leaves. Dropped from both, the plane keeps one region where
            // it has two, and the result does not close. So the exclusion is
            // recorded per face.
            let mut along: [Vec<(f64, f64, usize)>; 2] = [Vec::new(), Vec::new()];
            for (side, own) in [
                (0_usize, &ga.faces[section.face_a]),
                (1, &gb.faces[section.face_b]),
            ] {
                // The other face the section must also lie in: a crossing
                // with this edge outside it stops nothing that is kept, and a
                // face bounded by thousands of edges would try every one.
                let across = if side == 0 {
                    &gb.faces[section.face_b]
                } else {
                    &ga.faces[section.face_a]
                };
                for (ei, e) in own.edges.iter().enumerate() {
                    if !admit_all && !e.bound.expanded(reach).intersects(&across.bound) {
                        continue;
                    }
                    // An edge within its own radius of the face (the boundary
                    // of a merged group of near-coplanar facets, a ruling of a
                    // fitted cone, a fitted rail between a cylinder and a
                    // helical flank) stands off the surface the section lies
                    // on by as much. The face stops where it draws the edge,
                    // its pcurve on its surface, and a section on the face
                    // meets that image exactly; the edge's curve is met only
                    // where it is the face's own to within what it stands
                    // off, and a near miss by that much is the crossing. A
                    // fitted section states only its own error, so its reach
                    // takes that standoff in as well.
                    let (drawn, drange, off) = e.drawn();
                    let reach = if section.tolerance > 0.0 {
                        reach + off
                    } else {
                        reach
                    };
                    let planar = matches!(own.surface, SurfaceGeometry::Plane(_));
                    let widened = planar || section.tolerance <= 0.0;
                    let edge_reach = if widened { reach + off } else { reach };
                    let cc = CurveCurveOptions {
                        gap: cc.gap.max(edge_reach),
                        ..cc
                    };
                    let found = intersect_curves(&section.curve, drawn, cc, tol)?;
                    // Met at the edge's widened reach, an exact section that
                    // dips under an exact edge's curve by no more than that
                    // reach reads as touching it, the touch spread along the
                    // valley. Where the valley takes in one of the edge's
                    // ends, the touch is read at that end, and the stretch
                    // of the valley on the edge, which the section runs along,
                    // is lost. Met at the section's own reach the two cross
                    // where they truly meet, either side of the valley's
                    // bottom, and those crossings stand for the touch: the
                    // one past the edge's end is beyond the edge and dropped
                    // below, and the stretch from the other to the end runs
                    // along the edge, as it does where the dip is deeper
                    // than the widened reach and the crossings are found
                    // in the first place.
                    let near_an_end = |c: &ogeom_intersect::Crossing<Point>| -> OgeomResult<bool> {
                        for end in [e.crange.0, e.crange.1] {
                            if e.curve.point_at(end, tol)?.distance(c.point) <= c.reach {
                                return Ok(true);
                            }
                        }
                        Ok(false)
                    };
                    let mut crossings = found.crossings.clone();
                    if section.tolerance <= 0.0
                        && e.image.is_none()
                        && exact(&section.curve)
                        && exact(drawn)
                        && edge_reach > reach
                    {
                        let mut touches = Vec::new();
                        for c in &found.crossings {
                            if c.reach > 0.0 && near_an_end(c)? {
                                touches.push(*c);
                            }
                        }
                        if !touches.is_empty() {
                            let narrow = intersect_curves(
                                &section.curve,
                                drawn,
                                CurveCurveOptions {
                                    gap: reach.max(CurveCurveOptions::default().gap),
                                    ..cc
                                },
                                tol,
                            )?;
                            let met: Vec<ogeom_intersect::Crossing<Point>> = narrow
                                .crossings
                                .into_iter()
                                .filter(|n| {
                                    n.reach <= 0.0
                                        && n.gap <= reach
                                        && touches
                                            .iter()
                                            .any(|t| t.point.distance(n.point) <= t.reach)
                                })
                                .collect();
                            if !met.is_empty() {
                                crossings.retain(|c| !touches.contains(c));
                                crossings.extend(met);
                            }
                        }
                    }
                    for crossing in &crossings {
                        if crossing.gap > edge_reach {
                            continue;
                        }
                        // On a curved face a rail can pass within its radius
                        // of a section without crossing it, running beside
                        // it: a near miss past the section's own reach counts
                        // only where the two meet at an angle. A rail
                        // crossing at a helix's shallow lead stays within its
                        // radius for a stretch many radii long and still
                        // crosses.
                        if !planar
                            && crossing.gap > reach
                            && tangential(&section.curve, crossing.on_a, drawn, crossing.on_b, tol)?
                        {
                            continue;
                        }
                        let mut on_b =
                            onto_range(e.onto_curve(crossing.on_b), &e.curve, e.crange, tol);
                        let mut honesty = honest(section.tolerance, tol);
                        // A crossing at a boundary edge's own end *is* that end's
                        // vertex, exactly. The stop the section keeps must be the
                        // vertex's parameter on the section: the meet of two
                        // curves a fit tolerance apart lands a couple of microns
                        // off, the boundary side keeps its exact vertex, and the
                        // rebuilt wire gapes by the difference.
                        let mut on_a = crossing.on_a;
                        // The window is the fit-slop scale, not the section's
                        // own: the boundary curve may be a fitted intersection
                        // from an earlier boolean carrying a couple of microns
                        // of wobble, and a stop that misses the vertex by that
                        // much gapes the rebuilt wire by the same. A fitted
                        // section's stop misses by its own honesty once more:
                        // the trace is off the true crossing by that, and
                        // the crossing found against the edge by that again.
                        // An exact section crossing an exact edge has no such
                        // slop and lands where it crosses: within the edge's
                        // and its vertices' own radii of the end it is the
                        // end, and past them it is not. A drum lowered two
                        // microns under a plate's top crosses the wall it
                        // stands in two microns under the wall's corner, and
                        // the strip between is the wall's.
                        let exact_pair = section.tolerance <= 0.0
                            && e.image.is_none()
                            && exact(&section.curve)
                            && exact(drawn);
                        let weld = if exact_pair {
                            (reach + e.tolerance.max(e.ends_tolerance)).max(tol.confusion() * 10.0)
                        } else {
                            (reach + honest(section.tolerance, tol)).max(tol.confusion() * 1e2)
                        };
                        let mut at_end: Option<(f64, Point)> = None;
                        for end in [e.crange.0, e.crange.1] {
                            let vertex = e.curve.point_at(end, tol)?;
                            if vertex.distance(crossing.point) <= weld + crossing.reach {
                                at_end = Some((end, vertex));
                                let snapped =
                                    ogeom_algo::project_on_curve(&section.curve, vertex, 64, tol)?;
                                if snapped.distance <= weld + crossing.reach {
                                    on_a = snapped.parameter;
                                    // And the edge's own parameter is the
                                    // end's: two rim circles through one
                                    // block corner meet at a shallow angle
                                    // there, the crossing lands a few
                                    // hundredths of a millimetre along the
                                    // rim from the corner, and paved there
                                    // it splits the rim into a sliver.
                                    on_b = end;
                                }
                                break;
                            }
                        }
                        // A touch at the section's own end *is* the end. A
                        // band's section through a wall meets the wall's drum
                        // edge tangentially where the band is tangent to the
                        // drum, and the touch of two fitted curves at a
                        // shallow angle wanders along them by far more than
                        // their honesty. But the section stops there because
                        // it leaves its own face, and that stop is the
                        // junction: the crossing takes the end's parameter
                        // and the edge splits under the end itself.
                        let touch = crossing.reach > 0.0
                            || tangential(
                                &section.curve,
                                crossing.on_a,
                                drawn,
                                crossing.on_b,
                                tol,
                            )?;
                        let mut ended = false;
                        // A closed section has no ends: where it starts is
                        // only where its circle's frame happened to point.
                        if touch && !section.closed {
                            let half = (domain.1 - domain.0) * 0.5;
                            for end in [domain.0, domain.1] {
                                if (crossing.on_a - end).abs() > half {
                                    continue;
                                }
                                let tip = section
                                    .curve
                                    .point_at(at_param(end, domain, section.closed), tol)?;
                                if crossing.reach > 0.0
                                    && tip.distance(crossing.point) > crossing.reach + weld
                                {
                                    continue;
                                }
                                // The tip stands where the marcher left the
                                // other face (on a fitted rail, to the rail's
                                // own honesty), so the edge is asked at the
                                // hug width, not the section's.
                                let foot = ogeom_algo::project_on_curve(drawn, tip, 64, tol)?;
                                let width =
                                    (crossing.reach + honest(weld, tol)).max(tol.confusion() * 1e3);
                                if *DEBUG_WIRE {
                                    eprintln!(
                                        "PAVE s{si}: touch on edge {} at {:.6}: tip {:.3e} off the edge, width {width:.2e}",
                                        e.node.index(),
                                        crossing.on_a,
                                        foot.distance
                                    );
                                }
                                if foot.distance <= width {
                                    ended = true;
                                    on_a = end;
                                    on_b = onto_range(
                                        e.onto_curve(foot.parameter),
                                        &e.curve,
                                        e.crange,
                                        tol,
                                    );
                                    // A touch at the edge's own end vertex
                                    // is that vertex: a section tangent to
                                    // the edge there runs along it for a
                                    // stretch either side, stops somewhere
                                    // on that stretch, and split where it
                                    // stopped the edge keeps a sliver the
                                    // face across the vertex never has.
                                    if let Some((end_b, vertex)) = at_end
                                        && tip.distance(vertex) <= width.min(tol.confusion() * 1e5)
                                    {
                                        on_b = end_b;
                                        let gap = tip.distance(vertex);
                                        if gap > tol.confusion() * 1e2 {
                                            junctions.push(Junction {
                                                at: vertex,
                                                reach: gap + tol.confusion() * 1e2,
                                                onto_vertex: true,
                                            });
                                        }
                                    }
                                    // Along the edge the touch is known only
                                    // as far as the two curves stay together:
                                    // a rail grazing a bore is met there by
                                    // the sections on the faces either side
                                    // of it a hundredth of a millimetre
                                    // apart, and those are one junction. No
                                    // further: a section touching an edge to
                                    // the fourth order stays beside it for
                                    // tenths of a millimetre, and a junction
                                    // that wide swallows the edge's vertex
                                    // and the section's other end with it.
                                    // An exact section's end is where its
                                    // closed form stops, and wanders nowhere.
                                    let wander = if section.tolerance > 0.0 {
                                        crossing.reach.min(tol.confusion() * 1e5)
                                    } else {
                                        0.0
                                    };
                                    honesty = honesty.max(foot.distance).max(wander);
                                }
                                break;
                            }
                        }
                        // A touch along the section is where the edge
                        // touches the other face's surface: the section
                        // lies in both surfaces, the edge in its own face's.
                        // The meet of the two curves has a double root
                        // there and lands anywhere in its valley, the root
                        // of the section's honesty times the radius they
                        // part at long, so the face across, meeting the
                        // section at the same point, splits it elsewhere.
                        // The touch is solved from the edge and the surface
                        // instead, and taken where it lies in the crossing's
                        // own valley with the section within its reach.
                        if touch
                            && !ended
                            && at_end.is_none()
                            && let Some(touched) = ogeom_intersect::touch_curve_surface(
                                drawn,
                                &across.surface,
                                crossing.on_b,
                                tol,
                            )
                            && touched.point.distance(crossing.point) <= crossing.reach + weld
                        {
                            let foot = ogeom_algo::project_on_curve(
                                &section.curve,
                                touched.point,
                                64,
                                tol,
                            )?;
                            if foot.distance <= reach {
                                on_a = foot.parameter;
                                on_b = onto_range(
                                    e.onto_curve(touched.on_curve),
                                    &e.curve,
                                    e.crange,
                                    tol,
                                );
                            }
                        }
                        // The curve is crossed over its whole length, the edge
                        // only over its range. A crossing past either end and
                        // farther than the weld from that end's vertex is on
                        // the curve beyond the edge: a line under a plane's
                        // edge crosses the circle of a round's end arc tangent
                        // to that edge twice, either side of the tangent point,
                        // and only one of the two is on the arc. A seam is
                        // left as it is: its circle runs on past a pole into
                        // the face it bounds, and a drill beside the pole
                        // crossing it there is stopped where the pole's own
                        // reading meets it.
                        if at_end.is_none()
                            && !ended
                            && e.seam.is_none()
                            && (on_b < e.crange.0 - tol.parametric()
                                || on_b > e.crange.1 + tol.parametric())
                            && distance_to_edge_curve(drawn, drange, crossing.point, tol)?
                                > weld + crossing.reach
                        {
                            continue;
                        }
                        // Where the edge runs all but in the other face's plane
                        // (a facet row's edge between two facets nearly
                        // coplanar with a wall that crosses them), the crossing
                        // stands from where it pierces that plane by its own
                        // distance off the plane over the sine of its lean out
                        // of it. A facet's plane misses the edge it shares with
                        // the next by its points' rounding, so the sections on
                        // the facets either side reach the edge apart by that
                        // rounding over the sine (a few tenths of a micron
                        // where the edge is a rung between two rows of facets
                        // lying all but in a wall, a micron where the
                        // rung leans out of the wall by a couple of
                        // thousandths of a radian), and those are one point;
                        // an exact pair meets with no gap and stays exact.
                        // The doubt seeds a junction that owns it, and the
                        // result's vertex there is widened to it. It runs past
                        // the micron any one tolerance is held to only where
                        // the gap is within the weld distance, rounding
                        // rather than a miss, and stops at two microns:
                        // the vertex a joined crossing leaves claims no more
                        // than two crossings each held to a micron would. A
                        // wider gap is held to the micron; crossings further
                        // apart than the doubt stay apart, and the boolean
                        // refuses rather than weld across a sliver it has
                        // not resolved.
                        if at_end.is_none()
                            && let SurfaceGeometry::Plane(plane) = &across.surface
                        {
                            let along_edge = e.curve.d1_at(on_b, tol)?;
                            let length = along_edge.magnitude();
                            if length > 0.0 {
                                let sine =
                                    along_edge.dot(plane.plane().normal().vector()).abs() / length;
                                if sine > 0.0 {
                                    let off = plane
                                        .plane()
                                        .signed_distance_to(e.curve.point_at(on_b, tol)?)
                                        .abs();
                                    let leaning = off / sine;
                                    honesty =
                                        honesty.max(if crossing.gap <= tol.confusion() * 1e2 {
                                            leaning.min(tol.confusion() * 2e4)
                                        } else {
                                            honest(leaning, tol)
                                        });
                                }
                            }
                        }
                        if *DEBUG_WIRE {
                            eprintln!(
                                "PAVE s{si}: side {side} edge {} crossing at {on_a:.6} (edge {on_b:.6}) gap {:.2e} reach {:.2e} honesty {honesty:.2e} at {:?}",
                                e.node.index(),
                                crossing.gap,
                                crossing.reach,
                                crossing.point
                            );
                        }
                        // A loose edge (a chord between a facet and the drum
                        // it was converted beside, standing off the drum by
                        // its sag) is met by the faces either side of it each
                        // where the other solid's face crosses its own image
                        // of it: up to the tolerance apart across the edge,
                        // and so that over the sine of the edge's lean out of
                        // the crossing face apart along it. A drill all but
                        // tangent to a round crosses the round's rim and the
                        // facet's chord beside it five hundredths apart.
                        // Held to ten tolerances, where the lean vanishes.
                        let spread = if at_end.is_none() {
                            lean_spread(e, on_b, &across.surface, crossing.point, tol).max(
                                touch_spread(
                                    (drawn, crossing.on_b),
                                    &across.surface,
                                    crossing.point,
                                    honest(section.tolerance, tol),
                                    tol,
                                ),
                            )
                        } else {
                            0.0
                        };
                        hits.push((side, e.node, on_b, on_a, honesty, at_end.is_none(), spread));
                    }
                    for overlap in &found.overlaps {
                        // The curves overlap. What is *boundary* is the stretch
                        // the edge actually covers. A sphere's seam and the far
                        // half of the same great circle lie on one curve, and
                        // reading the whole curve as boundary makes the meridian
                        // opposite the seam disappear, which is the octant's own
                        // edge, on a ball cut at its corner.
                        for ((lo, hi), ends) in overlap_within(overlap, drange, drawn, tol) {
                            // Where the edge's own end bounds the stretch, the
                            // stretch ends at that end's vertex, as a crossing
                            // at an edge's end does: the overlap states its
                            // correspondence by its own ends alone, and carried
                            // across in proportion the edge's end lands off the
                            // vertex along a fitted section by the curves'
                            // differing pace. A section touching the edge at
                            // its end to the fourth order lands there a few
                            // tenths of a micron off, the other crossings at
                            // the vertex fold into that stop and are dropped
                            // with it, and the edges they split stay whole.
                            // The foot is taken only within the overlap's own
                            // stretch, which the vertex, on the edge inside it,
                            // lies beside.
                            let (olo, ohi) = if overlap.on_a.0 <= overlap.on_a.1 {
                                overlap.on_a
                            } else {
                                (overlap.on_a.1, overlap.on_a.0)
                            };
                            let mut window = [lo, hi];
                            for (t, end) in window.iter_mut().zip(ends) {
                                let Some(end) = end else {
                                    continue;
                                };
                                let vertex = drawn.point_at(end, tol)?;
                                let foot =
                                    ogeom_algo::project_on_curve(&section.curve, vertex, 64, tol)?;
                                let mut f = foot.parameter;
                                if section.closed {
                                    let period = domain.1 - domain.0;
                                    f += period * ((*t - f) / period).round();
                                }
                                if foot.distance <= cc.gap
                                    && f >= olo - tol.parametric()
                                    && f <= ohi + tol.parametric()
                                {
                                    *t = f;
                                }
                            }
                            let [lo, hi] = window;
                            if hi - lo <= tol.parametric() {
                                continue;
                            }
                            if *DEBUG_WIRE {
                                eprintln!("PAVE s{si}: side {side} overlap ({lo:.6}, {hi:.6})");
                            }
                            // The edge splits where the shared stretch ends, as
                            // the section does: the stretch itself is the edge's
                            // to carry, and the section's next piece must meet
                            // the edge at a vertex the edge actually has. A band
                            // meeting a wall tangentially to the wall's own top
                            // edge hugs it for a few microns from their corner;
                            // without the split at the hug's far end the section
                            // dangles there and is pruned, and the wall never
                            // splits.
                            // The section leaves the edge at the hug's end by
                            // what the hug allowed, which no single strand's
                            // honesty covers: that junction owns the gap.
                            for t in [lo, hi] {
                                let at = section
                                    .curve
                                    .point_at(at_param(t, domain, section.closed), tol)?;
                                let foot = ogeom_algo::project_on_curve(drawn, at, 64, tol)?;
                                if foot.distance <= reach.max(tol.confusion() * 1e3) {
                                    let on_b = onto_range(
                                        e.onto_curve(foot.parameter),
                                        &e.curve,
                                        e.crange,
                                        tol,
                                    );
                                    // Drawn apart from its curve, the edge
                                    // splits there a standoff from the foot.
                                    let (split, gap) = if e.image.is_some() {
                                        let split = e.curve.point_at(on_b, tol)?;
                                        (split, at.distance(split))
                                    } else {
                                        (foot.point, foot.distance)
                                    };
                                    hits.push((
                                        side,
                                        e.node,
                                        on_b,
                                        t,
                                        honest(section.tolerance, tol).max(gap),
                                        false,
                                        0.0,
                                    ));
                                    if gap > tol.confusion() * 1e2 {
                                        junctions.push(Junction {
                                            at: split,
                                            reach: gap + tol.confusion() * 1e2,
                                            onto_vertex: false,
                                        });
                                    }
                                }
                            }
                            trim_ts.push(lo);
                            trim_ts.push(hi);
                            along[side].push((lo, hi, ei));
                        }
                    }
                }
            }
            // Inside a stretch the section runs along one of a face's edges,
            // that face's other edges cannot genuinely cross it: a boundary
            // is a simple loop, and they meet the hugged edge only at its
            // ends, which the stretch's own ends already stop at. What the
            // sampler reports there is the tangential dust of a leg touching
            // the arc it ends on: thirty near-crossings inside a micron,
            // which read as stops would shatter the section and pave the
            // leg at each.
            hits.retain(|(side, _, _, on_a, _, _, _)| {
                !along[*side].iter().any(|(lo, hi, _)| {
                    *on_a > lo + tol.parametric() && *on_a < hi - tol.parametric()
                })
            });
            #[allow(clippy::type_complexity)]
            let edge_hits: Vec<(
                EdgeKey,
                f64,
                f64,
                f64,
                Option<(bool, usize)>,
                f64,
                usize,
            )> = hits
                .iter()
                .map(|(side, node, on_b, on_a, honesty, crossed, spread)| {
                    let across = crossed.then(|| {
                        if *side == 0 {
                            (false, section.face_b)
                        } else {
                            (true, section.face_a)
                        }
                    });
                    (*node, *on_b, *on_a, *honesty, across, *spread, *side)
                })
                .collect();
            trim_ts.extend(hits.iter().map(|(_, _, _, on_a, _, _, _)| *on_a));
            let mut cross_ts: Vec<f64> = Vec::new();
            for (sj, other) in sections.iter().enumerate() {
                if sj == si {
                    continue;
                }
                if other.face_a != section.face_a && other.face_b != section.face_b {
                    continue;
                }
                let both = reach.max(tol.confusion().max(other.tolerance * 2.0));
                if !admit_all
                    && let (Some(x), Some(y)) = (&section_bounds[si], &section_bounds[sj])
                    && !x.expanded(both).intersects(y)
                {
                    continue;
                }
                // Where two sections share one face, a crossing matters only
                // inside the faces they do not share, since a section is kept
                // only where it lies in both its faces: one wall met by a
                // thousand facets carries a thousand sections, and only those
                // whose facets' bounds meet can cross where it counts. The
                // audit's unfiltered pass tries every pair still.
                if !admit_all {
                    let apart = |x: &ogeom_math::Aabb, y: &ogeom_math::Aabb| {
                        !x.expanded(both).intersects(&y.expanded(both))
                    };
                    let unshared_a = other.face_a != section.face_a
                        && apart(
                            &ga.faces[section.face_a].filter,
                            &ga.faces[other.face_a].filter,
                        );
                    let unshared_b = other.face_b != section.face_b
                        && apart(
                            &gb.faces[section.face_b].filter,
                            &gb.faces[other.face_b].filter,
                        );
                    if unshared_a || unshared_b {
                        continue;
                    }
                }
                let cc2 = CurveCurveOptions {
                    gap: both.max(CurveCurveOptions::default().gap),
                    ..CurveCurveOptions::default()
                };
                let found = intersect_curves(&section.curve, &other.curve, cc2, tol)?;
                for crossing in &found.crossings {
                    if crossing.gap > both {
                        continue;
                    }
                    let mut at = crossing.on_a;
                    // A touch at this section's end is the end, as against an
                    // edge: two sections through one wall from a band and
                    // the leg it is tangent to touch where the band's ends.
                    let touch = crossing.reach > 0.0
                        || tangential(
                            &section.curve,
                            crossing.on_a,
                            &other.curve,
                            crossing.on_b,
                            tol,
                        )?;
                    if touch {
                        let half = (domain.1 - domain.0) * 0.5;
                        for end in [domain.0, domain.1] {
                            if (crossing.on_a - end).abs() > half {
                                continue;
                            }
                            let tip = section
                                .curve
                                .point_at(at_param(end, domain, section.closed), tol)?;
                            let foot = ogeom_algo::project_on_curve(&other.curve, tip, 64, tol)?;
                            let width =
                                (crossing.reach + honest(both, tol)).max(tol.confusion() * 1e3);
                            if foot.distance <= width {
                                at = end;
                            }
                            break;
                        }
                    }
                    // Two sections through one face that lie on two different
                    // faces of the other solid cross only on the edge those
                    // two share, where each already stops. Meeting there
                    // tangentially (a wall through a plane and the fillet
                    // tangent to it), their own crossing is ill-conditioned
                    // and lands off the edge, as far off as the two stay
                    // within their doubt of each other. The edge's stop is
                    // the one where they cannot be told apart up to it.
                    let shared = |edges: &[BoundaryEdge], node: EdgeKey| {
                        edges.iter().any(|e| e.node == node)
                    };
                    let apart_on = if other.face_a == section.face_a {
                        Some(&gb.faces[other.face_b].edges)
                    } else if other.face_b == section.face_b {
                        Some(&ga.faces[other.face_a].edges)
                    } else {
                        None
                    };
                    if let Some(edges) = apart_on {
                        let close = both.max(tol.confusion() * 1e2);
                        let mut best: Option<(f64, f64)> = None;
                        for (node, _, on_a, ..) in &edge_hits {
                            if !shared(edges, *node)
                                || best.is_some_and(|(bd, _)| (on_a - at).abs() >= bd)
                            {
                                continue;
                            }
                            let mut together = true;
                            for k in 1..8 {
                                let t = (on_a - at).mul_add(f64::from(k) / 8.0, at);
                                let p = section
                                    .curve
                                    .point_at(at_param(t, domain, section.closed), tol)?;
                                if ogeom_algo::project_on_curve(&other.curve, p, 16, tol)?.distance
                                    > close
                                {
                                    together = false;
                                    break;
                                }
                            }
                            if together {
                                best = Some(((on_a - at).abs(), *on_a));
                            }
                        }
                        if let Some((_, on_a)) = best {
                            at = on_a;
                        } else if let (Some(own), Some(beside)) = if other.face_a == section.face_a
                        {
                            (gb.faces.get(section.face_b), gb.faces.get(other.face_b))
                        } else {
                            (ga.faces.get(section.face_a), ga.faces.get(other.face_a))
                        } {
                            // Off the edge the two faces share, the crossing
                            // is one only where the other section is kept:
                            // inside the other section's face, to within that
                            // face's doubt and a loose shared edge's
                            // tolerance. Beside a loose shared edge (a chord
                            // between a facet and the drum it was converted
                            // beside) the two faces' surfaces meet the
                            // crossing face again a sag's lean off the edge,
                            // on neither face, and a cut there leaves a stub
                            // inside the junction the edge's crossings make.
                            // Beside a tight one, the other section's surface
                            // can run on past its face's end: a round's
                            // cylinder meets a drum lowered under the round's
                            // tangent edge on both sides of that edge, the
                            // far branch a few thousandths off the round, and
                            // a cut there splits the drum's own top line
                            // where nothing else meets it.
                            let loose = beside
                                .edges
                                .iter()
                                .filter(|e| {
                                    e.tolerance > tol.confusion() * DRAWN_APART
                                        && own.edges.iter().any(|o| o.node == e.node)
                                })
                                .map(|e| e.tolerance)
                                .fold(None, |most: Option<f64>, t| {
                                    Some(most.map_or(t, |m| m.max(t)))
                                });
                            let doubt = doubt_at(beside, crossing.point, tol)?
                                .max(both)
                                .max(tol.confusion() * 1e3)
                                + loose.unwrap_or(0.0);
                            if !within_face(beside, crossing.point, doubt, tol)? {
                                if *DEBUG_WIRE {
                                    eprintln!(
                                        "PAVE s{si}: cross s{sj} at {at:.6} off s{sj}'s face, no cut"
                                    );
                                }
                                continue;
                            }
                        }
                    }
                    if *DEBUG_WIRE {
                        eprintln!(
                            "PAVE s{si}: cross s{sj} at {at:.6} gap {:.2e}",
                            crossing.gap
                        );
                    }
                    cross_ts.push(at);
                }
            }

            // Candidate intervals between trim crossings, kept where the middle
            // sits inside both faces' trims.
            trim_ts.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
            trim_ts.dedup_by(|a, b| (*a - *b).abs() <= tol.parametric());
            // Stops the section cannot tell apart are one stop: two
            // crossings a few nanometres apart along it would make an
            // interval of dust that one face keeps and the other drops.
            // A stop standing on the kept one (within the confusion
            // distance, a nanometre along the section and yet past the
            // parametric tolerance) is the same point: its crossings split
            // their edges at the kept stop too. One further off is dropped
            // with its crossings, which would split their edges where no
            // strand ends, unless the kept stop crosses nothing of that
            // crossing's face: the strand on that face ends at the kept stop
            // all the same, and the face's edge splits at the stop's foot.
            let mut speaks_for: Vec<(f64, f64, bool)> = Vec::with_capacity(trim_ts.len());
            {
                let floor = (honest(section.tolerance, tol) * 3.0).max(tol.confusion() * 10.0);
                let mut kept: Vec<f64> = Vec::with_capacity(trim_ts.len());
                let mut held: Option<Point> = None;
                for t in &trim_ts {
                    let at = section
                        .curve
                        .point_at(at_param(*t, domain, section.closed), tol)?;
                    if held.is_none_or(|h: Point| h.distance(at) > floor) {
                        kept.push(*t);
                        held = Some(at);
                    }
                    if let (Some(&first), Some(h)) = (kept.last(), held) {
                        speaks_for.push((*t, first, h.distance(at) > tol.confusion()));
                    }
                }
                trim_ts = kept;
            }
            // How far from an edge a stretch of the section may run and
            // still run along it, below the edge's own reach (see the hug
            // below). Wider than the crossing filters on purpose for a
            // fitted section: a tangentially-traced curve wobbles about the
            // boundary it hugs by far more than a fit budget, and a genuine
            // section keeps a distance of feature scale, not microns. An
            // exact section keeps to the edge's own honesty: a plane's
            // ellipse across a band touches the band's rail tangentially,
            // and the stretch within a tenth of a millimetre of the rail is
            // the section, not the rail. Read as a hug it leaves the cap's
            // crescent unable to close. On the last attempt a fitted
            // section, too, runs along an edge only within the sum of its
            // radius and the edge's: its tolerance is how far it may sit
            // from the true section, the shallow angle of the two surfaces
            // included, and a section leaving a rim it touches parts from it
            // by more than that well inside the loose width.
            let hug_floor = if section.tolerance > 0.0 && !at_stated {
                tol.confusion() * 1e3
            } else {
                tol.confusion() * 10.0
            };
            // A vertex of either face within that width of an exact section
            // is a stop of it. Running along a face's boundary, the section
            // passes there from one edge onto the next (a drill's top line a
            // few confusion distances under a plate's edge, on past its end
            // along the arc the edge runs into), and the hug reads a stretch
            // along one edge at a time: a piece along two reads as along
            // neither, and splits the face in a sliver within the width of
            // the face's own boundary. A section crossing a face's edges at
            // a vertex already stops there.
            let mut vertex_stops: Vec<f64> = Vec::new();
            if section.tolerance <= 0.0 {
                let width = hug_floor;
                let near_stop = |t: f64, at: Point| -> OgeomResult<bool> {
                    Ok(section
                        .curve
                        .point_at(at_param(t, domain, section.closed), tol)?
                        .distance(at)
                        <= width)
                };
                for own in [&ga.faces[section.face_a], &gb.faces[section.face_b]] {
                    for e in &own.edges {
                        for end in [e.crange.0, e.crange.1] {
                            let vertex = e.curve.point_at(end, tol)?;
                            if section_bounds[si]
                                .as_ref()
                                .is_some_and(|b| !b.expanded(width).contains(vertex))
                            {
                                continue;
                            }
                            let foot =
                                ogeom_algo::project_on_curve(&section.curve, vertex, 64, tol)?;
                            if foot.distance > width
                                || (!section.closed
                                    && (foot.parameter <= domain.0 + tol.parametric()
                                        || foot.parameter >= domain.1 - tol.parametric()))
                            {
                                continue;
                            }
                            let mut taken = false;
                            for &t in trim_ts.iter().chain(&vertex_stops) {
                                if near_stop(t, foot.point)? {
                                    taken = true;
                                    break;
                                }
                            }
                            if taken {
                                continue;
                            }
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "PAVE s{si}: stop at {:.6} beside the vertex {vertex:?}, {:.2e} off",
                                    foot.parameter, foot.distance
                                );
                            }
                            vertex_stops.push(foot.parameter);
                        }
                    }
                }
                trim_ts.extend_from_slice(&vertex_stops);
                trim_ts.sort_by(f64::total_cmp);
            }
            let mut candidates: Vec<(f64, f64)> = Vec::new();
            if section.closed {
                let period = domain.1 - domain.0;
                if trim_ts.is_empty() {
                    candidates.push(domain);
                } else {
                    for i in 0..trim_ts.len() {
                        let lo = trim_ts[i];
                        let hi = if i + 1 < trim_ts.len() {
                            trim_ts[i + 1]
                        } else {
                            trim_ts[0] + period
                        };
                        candidates.push((lo, hi));
                    }
                }
            } else {
                let mut stops = vec![domain.0];
                stops.extend(
                    trim_ts
                        .iter()
                        .copied()
                        .filter(|t| *t > domain.0 && *t < domain.1),
                );
                stops.push(domain.1);
                for pair in stops.windows(2) {
                    candidates.push((pair[0], pair[1]));
                }
            }

            // Whether the section at `t` lies inside each face's trim.
            // Whether a piece of the section lies inside each face. A planar
            // face with a curved rim is asked exactly at the piece's middle,
            // and where the middle stands too close to the rim to say (a
            // sliver a few microns wide, deepest at one end of the piece),
            // at points either side of it; the polyline answers only where
            // no point along the piece is clear of the rim.
            let inside_over = |lo: f64, hi: f64| -> OgeomResult<[bool; 2]> {
                let la: Vec<&[Point2]> = outlines_a[section.face_a]
                    .iter()
                    .map(Vec::as_slice)
                    .collect();
                let lb: Vec<&[Point2]> = outlines_b[section.face_b]
                    .iter()
                    .map(Vec::as_slice)
                    .collect();
                let face_a = &ga.faces[section.face_a];
                let face_b = &gb.faces[section.face_b];
                let at = |t: f64| -> OgeomResult<(Point2, Point2)> {
                    let tf = if section.closed { fold(t, domain) } else { t };
                    Ok((
                        fold_inside(section.pc_a.point_at(tf, tol)?, &face_a.surface, &la, tol),
                        fold_inside(section.pc_b.point_at(tf, tol)?, &face_b.surface, &lb, tol),
                    ))
                };
                let mid = f64::midpoint(lo, hi);
                let (ua, ub) = at(mid)?;
                let mut held = [
                    inside_plane_exactly(face_a, ua, tol),
                    inside_plane_exactly(face_b, ub, tol),
                ];
                for k in [3.0, 5.0, 2.0, 6.0, 1.0, 7.0] {
                    if held.iter().all(Option::is_some) {
                        break;
                    }
                    let (va, vb) = at(lo + (hi - lo) * k / 8.0)?;
                    if held[0].is_none() {
                        held[0] = inside_plane_exactly(face_a, va, tol);
                    }
                    if held[1].is_none() {
                        held[1] = inside_plane_exactly(face_b, vb, tol);
                    }
                }
                Ok([
                    held[0].unwrap_or_else(|| inside_many(&la, ua)),
                    held[1].unwrap_or_else(|| inside_many(&lb, ub)),
                ])
            };

            // Stretches running along an edge of each face, and the stops
            // where a kept piece ends.
            let mut bridges: Vec<(f64, f64, [Vec<usize>; 2])> = Vec::new();
            let mut kept_stops: Vec<f64> = Vec::new();
            let mut reseamed: Option<SectionRec> = None;
            for (lo, hi) in candidates {
                if hi - lo <= tol.parametric() {
                    continue;
                }
                let mid = f64::midpoint(lo, hi);
                let mid_folded = if section.closed {
                    fold(mid, domain)
                } else {
                    mid
                };
                let held = inside_over(lo, hi)?;
                if *DEBUG_WIRE {
                    let tf = if section.closed {
                        fold(mid, domain)
                    } else {
                        mid
                    };
                    eprintln!(
                        "PAVE s{si}: candidate ({lo:.6}, {hi:.6}) inside {held:?} at a {:?} b {:?}",
                        section
                            .pc_a
                            .point_at(tf, tol)
                            .ok()
                            .map(|q| fold_point_into_chart(
                                q,
                                &ga.faces[section.face_a].surface,
                                tol
                            )),
                        section
                            .pc_b
                            .point_at(tf, tol)
                            .ok()
                            .map(|q| fold_point_into_chart(
                                q,
                                &gb.faces[section.face_b].surface,
                                tol
                            ))
                    );
                }
                // A section that runs along a boundary edge of a face splits
                // nothing *there*: the split already exists as boundary. The
                // analytic overlap detection above catches the same-support
                // cases. This catches the rest (a fitted section tracing a
                // boundary curve, a surface meeting another exactly at its own
                // trim) by measurement rather than by recognising supports.
                // The hug is asked before the trim: a section on a face's own
                // edge reads inside or outside that face by a hair, and the
                // corner tool's block face meets a band exactly along the arc
                // that bounds it. On the hugging face it is boundary already;
                // what matters is whether the *other* face holds it.
                let mut hugs = [false; 2];
                // The edges each side hugs (a rim already in pieces is
                // several): they must split wherever the section does, and
                // the section wherever they end, or the two faces walk
                // different subdivisions of one curve.
                let mut hugged: [Vec<usize>; 2] = [Vec::new(), Vec::new()];
                for (side, own, side_from_a, side_face) in [
                    (0_usize, &ga.faces[section.face_a], true, section.face_a),
                    (1, &gb.faces[section.face_b], false, section.face_b),
                ] {
                    if let Some((_, _, ei)) = along[side]
                        .iter()
                        .find(|(alo, ahi, _)| mid_folded >= *alo && mid_folded <= *ahi)
                    {
                        hugs[side] = true;
                        hugged[side].push(*ei);
                        continue;
                    }
                    let mut all_near = true;
                    let mut votes: Vec<usize> = vec![0; own.edges.len()];
                    let mut contact_votes: Vec<usize> = vec![0; contacts.len()];
                    let samples = (0..=4)
                        .map(|i| {
                            let t = lo + (hi - lo) * f64::from(i) / 4.0;
                            let tf = if section.closed { fold(t, domain) } else { t };
                            section.curve.point_at(tf, tol)
                        })
                        .collect::<OgeomResult<Vec<Point>>>()?;
                    // A piece shorter than the width is within it of every
                    // edge through either of its ends: a stub between two
                    // crossings near a corner, leaving one edge along the
                    // other, reads as running along both. Along an edge
                    // such a piece keeps within a quarter of its own
                    // length of it (it leans off it by less than fifteen
                    // degrees), and the width is held to that.
                    let stub: f64 = samples.windows(2).map(|w| w[0].distance(w[1])).sum();
                    let held_to = |width: f64, own: f64| -> f64 {
                        if stub < width {
                            (stub * 0.25).max(own).max(tol.confusion() * 10.0)
                        } else {
                            width
                        }
                    };
                    for (i, &at) in samples.iter().enumerate() {
                        let mut near = false;
                        for (ei, e) in own.edges.iter().enumerate() {
                            let (drawn, drange, off) = e.drawn();
                            let radii = if at_stated && section.tolerance > 0.0 {
                                section.tolerance + e.tolerance.max(e.residual)
                            } else {
                                0.0
                            };
                            let width =
                                held_to(reach.max(hug_floor).max(radii).max(off * 2.0), off * 2.0);
                            // The edge's box holds its curve: a point outside
                            // the box grown by the width is not near it.
                            if !e.bound.expanded(width).contains(at) {
                                continue;
                            }
                            let d = distance_to_edge_curve(drawn, drange, at, tol)?;
                            if d <= width {
                                if *DEBUG_WIRE {
                                    eprintln!(
                                        "PAVE s{si}: side {side} sample {i} hugs edge {} at {d:.2e} (width {width:.2e}) range {:?} point {at:?}",
                                        e.node.index(),
                                        e.crange
                                    );
                                }
                                // Every edge within reach is hugged, not the
                                // first found: where three rims converge on
                                // a pole corner all three come within a
                                // micron of the section, and the one it
                                // actually runs along must not lose its
                                // vote to a neighbour listed before it.
                                near = true;
                                votes[ei] += 1;
                            }
                        }
                        let width = reach.max(hug_floor);
                        // A contact edge is a strand on this face too (the other
                        // solid's boundary, carried into a chart they share), so a
                        // section tracing one would be the same curve twice, and
                        // the arrangement cannot walk a line it meets from both
                        // sides at once. Two boxes side by side put the low one's
                        // lid exactly there.
                        for (ci, c) in contacts.iter().enumerate() {
                            if c.target_from_a != side_from_a || c.target_face != side_face {
                                continue;
                            }
                            let held = held_to(width.max(c.tolerance * 2.0), c.tolerance * 2.0);
                            if c.bound.expanded(held).contains(at)
                                && distance_to_edge_curve(&c.curve, c.crange, at, tol)? <= held
                            {
                                near = true;
                                contact_votes[ci] += 1;
                            }
                        }
                        if !near {
                            all_near = false;
                            break;
                        }
                    }
                    // And along one of them all the way: a section winding
                    // round a drum passes the drum's seam once a turn, and a
                    // stretch spanning whole turns puts every sample on the
                    // seam without running along it anywhere between.
                    let one_line = votes.iter().chain(&contact_votes).any(|&v| v == 5);
                    hugs[side] = all_near && one_line;
                    if all_near {
                        hugged[side].extend(
                            votes
                                .iter()
                                .enumerate()
                                .filter(|(_, c)| **c > 0)
                                .map(|(ei, _)| ei),
                        );
                    }
                }
                if *DEBUG_WIRE {
                    eprintln!("PAVE s{si}: candidate ({lo:.6}, {hi:.6}) hugs {hugs:?}");
                }
                // Inside both faces the piece is a section of both. Hugging
                // one face's own edge while that face's trim reads it out
                // (by a hair, on the edge), it is still the other face's
                // split, and is admitted there, unless that edge is already
                // carried onto the other face as a contact: then the split
                // is laid down once already, and a section would lay it
                // twice.
                let mut hug_key: Option<(EdgeKey, bool, usize)> = None;
                let admitted = if held[0] && held[1] {
                    // Inside both by a hair while running along one face's
                    // own edge, it is that edge's split of the other face,
                    // as a hug-admitted piece is: another face meeting the
                    // other along the same edge (a chamfer beside the face
                    // it bevels) lays the same split, and the two must be
                    // told apart below, or the other face is cut twice
                    // along one line.
                    if hugs[0] != hugs[1] {
                        let hugging = usize::from(hugs[1]);
                        let (own, other_from_a, other_face) = if hugging == 0 {
                            (&ga.faces[section.face_a], false, section.face_b)
                        } else {
                            (&gb.faces[section.face_b], true, section.face_a)
                        };
                        hug_key = hugged[hugging]
                            .first()
                            .map(|&ei| (own.edges[ei].node, other_from_a, other_face));
                    }
                    true
                } else if hugs[0] != hugs[1] {
                    let hugging = usize::from(hugs[1]);
                    let other = 1 - hugging;
                    let (own, other_from_a, other_face) = if hugging == 0 {
                        (&ga.faces[section.face_a], false, section.face_b)
                    } else {
                        (&gb.faces[section.face_b], true, section.face_a)
                    };
                    let carried = hugged[hugging].iter().any(|&ei| {
                        contacts.iter().any(|c| {
                            c.node == own.edges[ei].node
                                && c.target_from_a == other_from_a
                                && c.target_face == other_face
                        })
                    });
                    if held[other] && !carried {
                        hug_key = hugged[hugging]
                            .first()
                            .map(|&ei| (own.edges[ei].node, other_from_a, other_face));
                        true
                    } else {
                        false
                    }
                } else {
                    false
                };
                if hugs[0] && hugs[1] {
                    bridges.push((lo, hi, hugged.clone()));
                }
                if !admitted {
                    continue;
                }
                if hugs[0] && hugs[1] {
                    // Boundary on both sides: the split exists twice over and
                    // adding it a third time would cancel what it copies.
                    continue;
                }
                kept_stops.extend([lo, hi]);
                // Keep the paves that end a kept interval: those are where edges
                // genuinely split.
                let speaker = |on_section: f64| {
                    speaks_for
                        .iter()
                        .find(|(t, ..)| (t - on_section).abs() <= tol.parametric())
                        .map_or((on_section, false), |&(_, first, moved)| (first, moved))
                };
                for (node, on_edge, on_section, honesty, across, spread, side) in &edge_hits {
                    let (s, moved) = speaker(*on_section);
                    let near = |x: f64| {
                        (s - x).abs() <= tol.parametric()
                            || (section.closed
                                && ((s + (domain.1 - domain.0)) - x).abs() <= tol.parametric())
                    };
                    if !(near(lo) || near(hi)) {
                        continue;
                    }
                    if !moved {
                        paves.push((
                            *node,
                            Pave {
                                t: *on_edge,
                                honesty: *honesty,
                                across: *across,
                                spread: *spread,
                            },
                        ));
                        continue;
                    }
                    // The kept stop's own crossings on this face, or those
                    // standing on it, end the strand here already.
                    if edge_hits.iter().any(|(_, _, other, .., other_side)| {
                        other_side == side && speaker(*other) == (s, false)
                    }) {
                        continue;
                    }
                    let own = if *side == 0 {
                        &ga.faces[section.face_a]
                    } else {
                        &gb.faces[section.face_b]
                    };
                    let Some(e) = own.edges.iter().find(|e| e.node == *node) else {
                        continue;
                    };
                    let at = section
                        .curve
                        .point_at(at_param(s, domain, section.closed), tol)?;
                    let foot = ogeom_algo::project_on_curve(e.drawn().0, at, 64, tol)?;
                    if *DEBUG_WIRE {
                        eprintln!(
                            "PAVE s{si}: side {side} edge {} crossing at {on_section:.6} handed to the stop at {s:.6}, {:.2e} off",
                            node.index(),
                            foot.distance
                        );
                    }
                    paves.push((
                        *node,
                        Pave {
                            t: onto_range(e.onto_curve(foot.parameter), &e.curve, e.crange, tol),
                            honesty: honesty.max(foot.distance),
                            across: *across,
                            spread: *spread,
                        },
                    ));
                }
                // Split at section/section crossings inside the kept interval,
                // so every face sees the same subdivision.
                let mut cuts = vec![lo];
                // A wrap interval also splits at the curve's own domain end, so
                // every piece lives within one period and evaluates in-domain
                // after a single fold.
                if section.closed
                    && domain.1 > lo + tol.parametric()
                    && domain.1 < hi - tol.parametric()
                {
                    cuts.push(domain.1);
                }
                for &c in &cross_ts {
                    let c2 = if section.closed && c < lo {
                        c + (domain.1 - domain.0)
                    } else {
                        c
                    };
                    if c2 > lo + tol.parametric() && c2 < hi - tol.parametric() {
                        cuts.push(c2);
                    }
                }
                cuts.push(hi);
                // A hugged edge's own ends are cuts of the section too: the
                // edge may already be several pieces (a sphere's rim split
                // at its chart seam), and the section must walk the same
                // pieces, or the two faces never sew along it.
                for side in 0..2 {
                    if !hugs[side] {
                        continue;
                    }
                    let own = if side == 0 {
                        &ga.faces[section.face_a]
                    } else {
                        &gb.faces[section.face_b]
                    };
                    for &ei in &hugged[side] {
                        let e = &own.edges[ei];
                        for end in [e.crange.0, e.crange.1] {
                            let p = e.curve.point_at(end, tol)?;
                            let foot = ogeom_algo::project_on_curve(&section.curve, p, 64, tol)?;
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "PAVE s{si}: side {side} hugged edge {} end {end:.6} lands at {:.6} off {:.2e} against ({lo:.6}, {hi:.6})",
                                    e.node.index(),
                                    foot.parameter,
                                    foot.distance
                                );
                            }
                            if foot.distance > reach.max(tol.confusion() * 1e3) {
                                continue;
                            }
                            let mut t = foot.parameter;
                            if section.closed {
                                let period = domain.1 - domain.0;
                                while t < lo {
                                    t += period;
                                }
                                while t - period >= lo {
                                    t -= period;
                                }
                            }
                            if t > lo + tol.parametric() && t < hi - tol.parametric() {
                                if *DEBUG_WIRE {
                                    eprintln!(
                                        "PAVE s{si}: side {side} cut at {t:.6} where hugged edge {} ends",
                                        e.node.index()
                                    );
                                }
                                cuts.push(t);
                            }
                        }
                    }
                }
                cuts.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
                // Cuts the section cannot tell apart are one cut: two
                // crossings a few nanometres apart along it would leave a
                // piece of dust one face keeps and the other drops. The
                // interval's own ends stay.
                {
                    let floor = (honest(section.tolerance, tol) * 3.0).max(tol.confusion() * 10.0);
                    let mut kept: Vec<f64> = Vec::with_capacity(cuts.len());
                    let mut held: Option<Point> = None;
                    for (index, c) in cuts.iter().enumerate() {
                        let at = section
                            .curve
                            .point_at(at_param(*c, domain, section.closed), tol)?;
                        let last = index + 1 == cuts.len();
                        if index == 0 || last || held.is_none_or(|h: Point| h.distance(at) > floor)
                        {
                            kept.push(*c);
                            held = Some(at);
                        }
                    }
                    cuts = kept;
                }
                // A marched section's ends weld at a thousand confusions, and
                // a piece no longer than that between the domain-end split
                // and its neighbouring cut is dust the arrangement collapses
                // into one node: the loop then closes in space within that
                // weld and its image stops the piece's length short in the
                // chart. Where nothing moves but the seam, the curve's seam
                // moves to the interval's start instead, and nothing is
                // split there.
                if section.tolerance > 0.0
                    && let Some(at) = cuts.iter().position(|c| *c == domain.1)
                    && at > 0
                    && at + 1 < cuts.len()
                {
                    let span = |from: f64, to: f64| -> OgeomResult<f64> {
                        let mut length = 0.0;
                        let mut last = section.curve.point_at(at_param(from, domain, true), tol)?;
                        for k in 1..=16 {
                            let t = from + (to - from) * f64::from(k) / 16.0;
                            let p = section.curve.point_at(at_param(t, domain, true), tol)?;
                            length += last.distance(p);
                            last = p;
                        }
                        Ok(length)
                    };
                    let shortest = span(cuts[at - 1], cuts[at])?.min(span(cuts[at], cuts[at + 1])?);
                    if shortest <= tol.confusion() * 1e3 {
                        reseamed = reseamed_section(
                            section,
                            lo,
                            [
                                &ga.faces[section.face_a].surface,
                                &gb.faces[section.face_b].surface,
                            ],
                            tol,
                        );
                        if *DEBUG_WIRE {
                            eprintln!(
                                "PAVE s{si}: the domain-end split of ({lo:.6}, {hi:.6}) leaves {shortest:.3e}; {}",
                                if reseamed.is_some() {
                                    "the seam moves to the interval's start"
                                } else {
                                    "it stays"
                                }
                            );
                        }
                        if reseamed.is_some() {
                            cuts.remove(at);
                        }
                    }
                }
                // A hugged edge is boundary where this piece is section: it
                // must split at the piece's interior cuts too, or the face
                // that keeps the edge walks one long strand where its
                // neighbour walks three, and the sew pairs none of them.
                for side in 0..2 {
                    if !hugs[side] {
                        continue;
                    }
                    let own = if side == 0 {
                        &ga.faces[section.face_a]
                    } else {
                        &gb.faces[section.face_b]
                    };
                    for &ei in &hugged[side] {
                        let e = &own.edges[ei];
                        // The piece's own ends as well as its interior cuts: a
                        // stop against another face's edge is a split of the
                        // hugged edge too, or the section's neighbour walks two
                        // strands where the hugged edge's face walks one.
                        for c in &cuts {
                            let at = section
                                .curve
                                .point_at(at_param(*c, domain, section.closed), tol)?;
                            let foot = ogeom_algo::project_on_curve(e.drawn().0, at, 64, tol)?;
                            // A cut off the edge (past the stretch the
                            // section hugs, on a neighbouring edge) is no
                            // split of it. Stated as one with its distance
                            // for honesty it seeds a junction a feature wide.
                            if foot.distance > reach.max(tol.confusion() * 1e3) {
                                continue;
                            }
                            let on_e =
                                onto_range(e.onto_curve(foot.parameter), &e.curve, e.crange, tol);
                            if on_e <= e.crange.0.min(e.crange.1) + tol.parametric()
                                || on_e >= e.crange.0.max(e.crange.1) - tol.parametric()
                            {
                                continue;
                            }
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "PAVE s{si}: side {side} hugged edge {} paved at {on_e:.6} for the cut at {c:.6}",
                                    e.node.index()
                                );
                            }
                            paves.push((
                                e.node,
                                Pave {
                                    t: on_e,
                                    honesty: honest(section.tolerance, tol).max(foot.distance),
                                    across: None,
                                    spread: 0.0,
                                },
                            ));
                        }
                    }
                }
                for pair in cuts.windows(2) {
                    let (lo2, hi2) = (pair[0], pair[1]);
                    let from = section
                        .curve
                        .point_at(at_param(lo2, domain, section.closed), tol)?;
                    let to = section
                        .curve
                        .point_at(at_param(hi2, domain, section.closed), tol)?;
                    if from.distance(to) <= tol.confusion() {
                        // A full loop: two arcs, so every strand has two
                        // distinct endpoints.
                        let mid = f64::midpoint(lo2, hi2);
                        pieces.push(SectionPiece {
                            section: si,
                            range: (lo2, mid),
                            hugs,
                            hug_key,
                        });
                        pieces.push(SectionPiece {
                            section: si,
                            range: (mid, hi2),
                            hugs,
                            hug_key,
                        });
                    } else {
                        pieces.push(SectionPiece {
                            section: si,
                            range: (lo2, hi2),
                            hugs,
                            hug_key,
                        });
                    }
                }
            }
            // A stretch running along an edge of each face is those edges'
            // to carry, and they split where it ends, as the section does,
            // and where it passes a vertex of either face, from one edge
            // onto the next.
            // Two faces' edges all but in line (a merged facet column's
            // edge leaning off a pad's corner edge by a hundred-thousandth)
            // are crossed by a section lying all but along both a micron
            // apart along it and a nanometre across, and the piece kept on
            // one side of that stretch ends at one face's crossing: the
            // other face's edge splits under that end too, or its piece of
            // the section ends a nanometre inside it and the face is never
            // split.
            for (lo, hi, hugged) in &bridges {
                for stop in [*lo, *hi] {
                    if !kept_stops
                        .iter()
                        .chain(&vertex_stops)
                        .any(|k| (k - stop).abs() <= tol.parametric())
                    {
                        continue;
                    }
                    let at = section
                        .curve
                        .point_at(at_param(stop, domain, section.closed), tol)?;
                    for (side, own) in [&ga.faces[section.face_a], &gb.faces[section.face_b]]
                        .into_iter()
                        .enumerate()
                    {
                        for &ei in &hugged[side] {
                            let e = &own.edges[ei];
                            if edge_hits.iter().any(|(node, _, on_section, ..)| {
                                *node == e.node && (on_section - stop).abs() <= tol.parametric()
                            }) {
                                continue;
                            }
                            let foot = ogeom_algo::project_on_curve(e.drawn().0, at, 64, tol)?;
                            if foot.distance > reach.max(tol.confusion() * 1e3) {
                                continue;
                            }
                            let on_e =
                                onto_range(e.onto_curve(foot.parameter), &e.curve, e.crange, tol);
                            if on_e <= e.crange.0.min(e.crange.1) + tol.parametric()
                                || on_e >= e.crange.0.max(e.crange.1) - tol.parametric()
                            {
                                continue;
                            }
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "PAVE s{si}: side {side} edge {} along ({lo:.6}, {hi:.6}) paved at {on_e:.6} for the stop at {stop:.6}, {:.2e} off",
                                    e.node.index(),
                                    foot.distance
                                );
                            }
                            paves.push((
                                e.node,
                                Pave {
                                    t: on_e,
                                    honesty: honest(section.tolerance, tol).max(foot.distance),
                                    across: None,
                                    spread: 0.0,
                                },
                            ));
                        }
                    }
                }
            }
            Ok((paves, pieces, junctions, reseamed))
        },
    );
    let mut reseams: Vec<(usize, SectionRec)> = Vec::new();
    for (si, work) in paved.into_iter().enumerate() {
        let (found, made, hugged, reseamed) = work?;
        hug_junctions.extend(hugged);
        for (node, at) in found {
            paves.entry(node).or_default().push(at);
        }
        pieces.extend(made);
        if let Some(section) = reseamed {
            reseams.push((si, section));
        }
    }
    // A section whose seam moved names every point by the parameter it had,
    // a period on where it stood before the new start: each piece's range is
    // carried into the new domain, so nothing evaluates it out of domain.
    for (si, section) in reseams {
        let domain = section.curve.domain();
        for piece in pieces.iter_mut().filter(|p| p.section == si) {
            let start = fold(piece.range.0, domain);
            piece.range = (start, start + (piece.range.1 - piece.range.0));
        }
        sections[si] = section;
    }
    share_hugs(&mut pieces, &sections, [ga, gb], tol)?;
    // A piece running along a face's own edge and that edge are one curve,
    // split twice: the piece where its section's cuts fell, the edge where
    // every section that met it paved it, each worked out apart. A loop
    // hugging a rim is split at its middle, the rim wherever another
    // section crossed it. The two faces then walk different pieces of one
    // circle and never sew. Once every pave is in, each such piece is
    // cut wherever its edge is split, and the edge split wherever the piece
    // ends, twice over so a split one piece adds reaches the others.
    for _ in 0..2 {
        let mut settled: Vec<SectionPiece> = Vec::with_capacity(pieces.len());
        for piece in pieces.drain(..) {
            if !(piece.hugs[0] || piece.hugs[1]) {
                settled.push(piece);
                continue;
            }
            let section = &sections[piece.section];
            let domain = section.curve.domain();
            let period = domain.1 - domain.0;
            let (lo, hi) = piece.range;
            let at = |t: f64| {
                section
                    .curve
                    .point_at(at_param(t, domain, section.closed), tol)
            };
            let width = (tol.confusion() * 1e3).max(section.tolerance * 3.0);
            let mid = at(f64::midpoint(lo, hi))?;
            let mut hugged: Vec<&BoundaryEdge> = Vec::new();
            for (side, &hugs) in piece.hugs.iter().enumerate().take(2) {
                if !hugs {
                    continue;
                }
                let face = if side == 0 {
                    &ga.faces[section.face_a]
                } else {
                    &gb.faces[section.face_b]
                };
                for e in &face.edges {
                    let (drawn, drange, off) = e.drawn();
                    let near = width.max(off * 2.0);
                    if e.bound.expanded(near).contains(mid)
                        && distance_to_edge_curve(drawn, drange, mid, tol)? <= near
                    {
                        hugged.push(e);
                    }
                }
            }
            let mut cuts: Vec<f64> = Vec::new();
            for e in &hugged {
                let mut on_edge: Vec<f64> = vec![e.crange.0, e.crange.1];
                if let Some(list) = paves.get(&e.node) {
                    on_edge.extend(list.iter().map(|pave| pave.t));
                }
                let (drawn, _, off) = e.drawn();
                for t in on_edge {
                    let q = drawn.point_at(e.onto_drawn(t), tol)?;
                    let foot = ogeom_algo::project_on_curve(&section.curve, q, 64, tol)?;
                    if foot.distance > width.max(off * 2.0) {
                        continue;
                    }
                    let mut f = foot.parameter;
                    if section.closed && period > 0.0 {
                        while f < lo {
                            f += period;
                        }
                        while f - period >= lo {
                            f -= period;
                        }
                    }
                    if f > lo + tol.parametric() && f < hi - tol.parametric() {
                        cuts.push(f);
                    }
                }
            }
            cuts.push(lo);
            cuts.push(hi);
            cuts.sort_by(f64::total_cmp);
            cuts.dedup_by(|a, b| (*a - *b).abs() <= tol.parametric());
            // The edge split wherever the piece now ends.
            for e in &hugged {
                let (drawn, _, off) = e.drawn();
                for &c in &cuts {
                    let q = at(c)?;
                    let foot = ogeom_algo::project_on_curve(drawn, q, 64, tol)?;
                    if foot.distance > width.max(off * 2.0) {
                        continue;
                    }
                    let on_e = onto_range(e.onto_curve(foot.parameter), &e.curve, e.crange, tol);
                    if on_e <= e.crange.0.min(e.crange.1) + tol.parametric()
                        || on_e >= e.crange.0.max(e.crange.1) - tol.parametric()
                    {
                        continue;
                    }
                    let list = paves.entry(e.node).or_default();
                    if list
                        .iter()
                        .all(|pave| (pave.t - on_e).abs() > tol.parametric())
                    {
                        list.push(Pave {
                            t: on_e,
                            honesty: honest(section.tolerance, tol).max(foot.distance),
                            across: None,
                            spread: 0.0,
                        });
                    }
                }
            }
            for pair in cuts.windows(2) {
                settled.push(SectionPiece {
                    section: piece.section,
                    range: (pair[0], pair[1]),
                    hugs: piece.hugs,
                    hug_key: piece.hug_key,
                });
            }
        }
        pieces = settled;
    }
    // Two sections hugging onto one face along one line lay the same split
    // down twice (a top face's trace and its band's, both along the rail
    // they share, which need not be one edge node once a shell has been
    // built), and a line met from both sides at once breaks the
    // arrangement. Pieces of different sections admitted by a hug onto the
    // same face, each lying on the other's curve, are one split, and the
    // section covering the most of it speaks for it.
    {
        let width = tol.confusion() * 1e3;
        let mut drop: Vec<usize> = Vec::new();
        let hugged_onto: Vec<usize> = pieces
            .iter()
            .enumerate()
            .filter(|(_, p)| p.hug_key.is_some())
            .map(|(i, _)| i)
            .collect();
        let mid_of = |p: &SectionPiece| -> OgeomResult<Point> {
            let section = &sections[p.section];
            let domain = section.curve.domain();
            section.curve.point_at(
                at_param(f64::midpoint(p.range.0, p.range.1), domain, section.closed),
                tol,
            )
        };
        let length_of = |p: &SectionPiece| -> OgeomResult<f64> {
            let section = &sections[p.section];
            let domain = section.curve.domain();
            let a = section
                .curve
                .point_at(at_param(p.range.0, domain, section.closed), tol)?;
            let b = section
                .curve
                .point_at(at_param(p.range.1, domain, section.closed), tol)?;
            Ok(a.distance(b))
        };
        // A hug-admitted piece against every other piece kept on the same
        // face: a section admitted the ordinary way, inside both faces,
        // already speaks for the split, and the hug-admitted one yields
        // to it. Two hug-admitted ones yield to the longer.
        for &x in &hugged_onto {
            let px = &pieces[x];
            let Some((_, target_from_a, target_face)) = px.hug_key else {
                continue;
            };
            for (y, py) in pieces.iter().enumerate() {
                if y == x || py.section == px.section || drop.contains(&x) || drop.contains(&y) {
                    continue;
                }
                let sy = &sections[py.section];
                let on_target = if target_from_a {
                    sy.face_a == target_face && !py.hugs[0]
                } else {
                    sy.face_b == target_face && !py.hugs[1]
                };
                if !on_target {
                    continue;
                }
                let sx = &sections[px.section];
                // A closed section's pieces are ranged past its domain end
                // and folded on use. The distance helper samples the range
                // it is given, so it is given the folded one.
                let stretch = |section: &SectionRec, range: (f64, f64)| -> (f64, f64) {
                    folded_range(range, section.curve.domain(), section.closed)
                };
                let on_y =
                    distance_to_edge_curve(&sy.curve, stretch(sy, py.range), mid_of(px)?, tol)?
                        <= width;
                let on_x =
                    distance_to_edge_curve(&sx.curve, stretch(sx, px.range), mid_of(py)?, tol)?
                        <= width;
                if !(on_x && on_y) {
                    continue;
                }
                let loser = if py.hug_key.is_some() && length_of(px)? > length_of(py)? {
                    y
                } else {
                    x
                };
                if *DEBUG_WIRE {
                    eprintln!(
                        "PAVE: s{} and s{} split one face along one line; s{} speaks for it",
                        px.section,
                        py.section,
                        pieces[if loser == x { y } else { x }].section
                    );
                }
                drop.push(loser);
                if loser == x {
                    break;
                }
            }
        }
        let mut index = 0_usize;
        pieces.retain(|_| {
            let keep = !drop.contains(&index);
            index += 1;
            keep
        });
    }
    // The audit's verdict. A dropped pair whose surfaces intersect is not a
    // filter bug: planes meet along an infinite line the paving then trims
    // to the faces, usually to nothing. A dropped pair whose section
    // *survives paving* is: some of that curve lies inside both faces, so
    // the faces genuinely meet and the filter's boxes failed to. Contacts
    // need no check: a contact is an owner edge lying in the target face,
    // which forces the boxes to overlap where the edge does.
    //
    // This membership check is the audit's first tooth. The second is the
    // strict replay in general_fuse, which runs the *filtered* fill for the
    // production result and diffs this unfiltered one against it, so the
    // non-compositionality of paving (a section's kept intervals see the
    // other sections' paves) is caught rather than stated as a limit.
    if admit_all {
        for piece in &pieces {
            let section = &sections[piece.section];
            let (fa, fb) = (&ga.faces[section.face_a], &gb.faces[section.face_b]);
            assert!(
                fa.filter.intersects(&fb.filter),
                "bound filter audit: faces {}/{} were dropped by the bound \
                 filter, yet their section paved a surviving piece over \
                 {:?}; the filter under-approximates",
                section.face_a,
                section.face_b,
                piece.range,
            );
        }
    }
    // A contact edge splits where it crosses the target face's boundary,
    // and that crossing is a pave on *both* edges, so the owner's own face
    // splits its boundary consistently and the pieces sew back shared.
    let mut contact_along: Vec<Vec<(f64, f64)>> = vec![Vec::new(); contacts.len()];
    // Where stretches end at the radii the curves hold to, each edge holds
    // to the widest it is measured to on any face of it, and each edge's
    // own record is kept to measure a stretch from its side.
    let mut held: ogeom_core::FastMap<EdgeKey, (f64, &BoundaryEdge)> =
        ogeom_core::FastMap::default();
    if at_stated {
        for e in ga
            .faces
            .iter()
            .chain(&gb.faces)
            .flat_map(|f| f.edges.iter())
        {
            held.entry(e.node)
                .and_modify(|(most, _)| *most = most.max(e.residual))
                .or_insert((e.residual, e));
        }
    }
    // A stretch two edges share, as measured once for the pair: the
    // contact's side of it on `on_a`.
    let mut shared: ogeom_core::FastMap<(EdgeKey, EdgeKey), Vec<ogeom_intersect::Overlap>> =
        ogeom_core::FastMap::default();
    for (ci, contact) in contacts.iter().enumerate() {
        let target = if contact.target_from_a {
            &ga.faces[contact.target_face]
        } else {
            &gb.faces[contact.target_face]
        };
        // A fitted contact sits off exact geometry by its own tolerance, and
        // the crossings it genuinely makes gape by the same: the filter and
        // the finder both widen, or a fitted rail never registers against
        // the exact seam it crosses.
        let reach = tol.confusion().max(contact.tolerance * 2.0);
        let cc = CurveCurveOptions {
            gap: reach.max(CurveCurveOptions::default().gap),
            ..CurveCurveOptions::default()
        };
        for e in &target.edges {
            if !contact.bound.expanded(reach).intersects(&e.bound) {
                continue;
            }
            let found = intersect_curves(&contact.curve, &e.curve, cc, tol)?;
            for crossing in &found.crossings {
                if crossing.gap > reach {
                    continue;
                }
                // The target face's boundary is what its edges cover, not
                // their whole curves. A blend's rail lying on a wedge's end
                // face meets the circle of the end's arc twice: at the
                // arc's end, and a diameter on, outside the face, where a
                // pave leaves the rail a vertex no face needs. A crossing
                // past the edge's ends is on the boundary only within the
                // edge's radius, its ends' and the crossing's own.
                let on_b = onto_range(crossing.on_b, &e.curve, e.crange, tol);
                if (on_b < e.crange.0 - tol.parametric() || on_b > e.crange.1 + tol.parametric())
                    && distance_to_edge_curve(&e.curve, e.crange, crossing.point, tol)?
                        > reach + crossing.reach + e.tolerance.max(e.ends_tolerance)
                {
                    continue;
                }
                // A contact ending on a target edge needs no split of its
                // own there, but the edge does: the contact's strand ends
                // on it, and an edge left whole leaves the strand dangling.
                let at_end = crossing.on_a < contact.crange.0 + tol.parametric()
                    || crossing.on_a > contact.crange.1 - tol.parametric();
                if at_end
                    && (crossing.on_a < contact.crange.0 - tol.parametric()
                        || crossing.on_a > contact.crange.1 + tol.parametric())
                {
                    continue;
                }
                // Touching is not crossing, at curve level as at surface
                // level: where the two curves run nearly parallel (a blend
                // arc meeting the edge it is tangent to), the "crossing" is
                // numerical noise smeared along the contact, and paving it
                // would plant a vertex a hair off both curves. A crossing at
                // a shallow turn is no touch: the two part in proportion
                // either side of it, and each side of it is a strand of its
                // own. The two cross where they are found to, as at any
                // turn, not anywhere along a touching run.
                let mut reach = crossing.reach;
                let mut onto_end = None;
                if tangential(&contact.curve, crossing.on_a, &e.curve, crossing.on_b, tol)? {
                    let shallow = at_stated
                        && crosses_shallowly(
                            &contact.curve,
                            contact.crange,
                            contact.tolerance,
                            e,
                            (crossing.on_a, crossing.on_b),
                            tol,
                        )?;
                    if !shallow {
                        // A touch at the contact's end is the end's vertex
                        // lying on the edge: the contact's strand ends
                        // there, and the edge splits at the vertex's foot,
                        // which is known where the touch is not. A rounded
                        // box's arc between a corner ball and a round ends
                        // on a drill's seam that runs along the round's
                        // tangent line, tangent to it.
                        if at_end {
                            let end = if crossing.on_a
                                < f64::midpoint(contact.crange.0, contact.crange.1)
                            {
                                contact.crange.0
                            } else {
                                contact.crange.1
                            };
                            let vertex = contact.curve.point_at(end, tol)?;
                            let (gap, on_edge) =
                                nearest_on_edge_curve(&e.curve, e.crange, vertex, tol)?;
                            let width = held_radius(&held, contact.node, contact.tolerance)
                                + held_radius(&held, e.node, e.tolerance);
                            if gap <= width
                                && on_edge > e.crange.0 + tol.parametric()
                                && on_edge < e.crange.1 - tol.parametric()
                            {
                                paves.entry(e.node).or_default().push(Pave {
                                    t: on_edge,
                                    honesty: honest(contact.tolerance, tol).max(gap),
                                    across: None,
                                    spread: 0.0,
                                });
                            }
                        }
                        continue;
                    }
                    reach = 0.0;
                    let width = held_radius(&held, contact.node, contact.tolerance)
                        + held_radius(&held, e.node, e.tolerance);
                    onto_end =
                        shallow_at_end(contact, e, (crossing.on_a, crossing.on_b), width, tol)?;
                }
                let honesty = honest(contact.tolerance, tol).max(reach);
                match onto_end {
                    Some(End::OfEdge { on_contact, gap }) => {
                        if on_contact > contact.crange.0 + tol.parametric()
                            && on_contact < contact.crange.1 - tol.parametric()
                        {
                            paves.entry(contact.node).or_default().push(Pave {
                                t: on_contact,
                                honesty: honesty.max(gap),
                                across: None,
                                spread: 0.0,
                            });
                        }
                        continue;
                    }
                    Some(End::OfContact { on_edge, gap }) => {
                        if on_edge > e.crange.0 + tol.parametric()
                            && on_edge < e.crange.1 - tol.parametric()
                        {
                            paves.entry(e.node).or_default().push(Pave {
                                t: on_edge,
                                honesty: honesty.max(gap),
                                across: None,
                                spread: 0.0,
                            });
                        }
                        continue;
                    }
                    None => {}
                }
                if !at_end {
                    paves.entry(contact.node).or_default().push(Pave {
                        t: crossing.on_a,
                        honesty,
                        across: None,
                        spread: 0.0,
                    });
                }
                if on_b > e.crange.0 + tol.parametric() && on_b < e.crange.1 - tol.parametric() {
                    paves.entry(e.node).or_default().push(Pave {
                        t: on_b,
                        honesty,
                        across: None,
                        spread: 0.0,
                    });
                }
            }
            // A span of the contact running along a target boundary edge
            // splits nothing: it is already boundary on both sides
            // (identically stacked boxes are all such spans), and duplicating
            // it as a strand would cancel the boundary it copies.
            // The intersector answers coincidence in closed form for the
            // analytic pairs only. A fitted curve lying on an exact one
            // (a marched sphere's rim on a wedge cap's arc) comes back as
            // crossings or nothing. That span is measured instead: the
            // stretch of the contact within the pair's honesty of the edge.
            // An analytic overlap survives only where it lands inside the
            // contact's own window. A trimmed circle written a turn up
            // clips to nothing, and is then measured like a fitted one.
            let survives = |overlap: &ogeom_intersect::Overlap| -> bool {
                let (lo, hi) = if overlap.on_a.0 <= overlap.on_a.1 {
                    overlap.on_a
                } else {
                    (overlap.on_a.1, overlap.on_a.0)
                };
                let carried = if contact.curve.is_periodic() {
                    let (dlo, dhi) = contact.curve.domain();
                    let period = dhi - dlo;
                    let turn = ((contact.crange.0 - lo) / period).floor();
                    [turn, turn + 1.0, turn - 1.0]
                        .into_iter()
                        .map(|k| (k.mul_add(period, lo), k.mul_add(period, hi)))
                        .map(|(a, b)| b.min(contact.crange.1) - a.max(contact.crange.0))
                        .fold(f64::NEG_INFINITY, f64::max)
                } else {
                    hi.min(contact.crange.1) - lo.max(contact.crange.0)
                };
                carried > tol.parametric()
            };
            // The closed-form overlap is between the two *curves*. The
            // stretch that is boundary is what the *edge* covers of it. A
            // box cut from an L-bracket flush with the bracket's wall puts
            // the box's wall-side edge on the line of the end face's own
            // edge along the wall, a length below it: read as along that
            // edge over the whole curve, the strip's side is never paved
            // and the end face keeps the strip. Clipped through the
            // overlap's own correspondence so the carry below stays affine.
            let clipped: Vec<ogeom_intersect::Overlap> = found
                .overlaps
                .iter()
                .flat_map(|overlap| {
                    let span = overlap.on_a.1 - overlap.on_a.0;
                    let parts = if span.abs() <= f64::MIN_POSITIVE {
                        Vec::new()
                    } else {
                        overlap_within(overlap, e.crange, &contact.curve, tol)
                            .into_iter()
                            .map(|(part, _)| part)
                            .collect()
                    };
                    let to_b = move |t: f64| {
                        overlap.on_b.0
                            + (overlap.on_b.1 - overlap.on_b.0) * (t - overlap.on_a.0) / span
                    };
                    parts
                        .into_iter()
                        .map(move |(lo, hi)| ogeom_intersect::Overlap {
                            on_a: (lo, hi),
                            on_b: (to_b(lo), to_b(hi)),
                        })
                })
                .collect();
            // A line and a curved conic share no stretch, however loosely
            // either is held: a straight edge tangent to an arc stays within
            // the measuring width of it for a short run either side of the
            // touch, and read as a span there it splits the arc at a vertex
            // the face across the arc never has.
            let conic = |c: &Curve| {
                matches!(
                    c,
                    Curve::Circle(_) | Curve::Ellipse(_) | Curve::Hyperbola(_) | Curve::Parabola(_)
                )
            };
            let straight_on_conic = (matches!(contact.curve, Curve::Line(_)) && conic(&e.curve))
                || (conic(&contact.curve) && matches!(*e.curve, Curve::Line(_)));
            // Where the two are held to their own radii, a fitted pair is
            // measured, as the intersector's coincidence for it ends at its
            // own width and from one side only.
            let fitted = !(exact(&contact.curve) && exact(&e.curve));
            let clipped = if at_stated && fitted {
                Vec::new()
            } else {
                clipped
            };
            let measured: Vec<ogeom_intersect::Overlap> =
                if clipped.iter().any(survives) || straight_on_conic {
                    Vec::new()
                } else if at_stated {
                    shared_overlaps(contact, e, &held, &mut shared, tol)?
                } else {
                    measured_overlaps(
                        &contact.curve,
                        contact.crange,
                        contact.tolerance,
                        e,
                        None,
                        tol,
                    )?
                };
            for overlap in clipped.iter().chain(measured.iter()) {
                let ordered = |r: (f64, f64)| if r.0 <= r.1 { r } else { (r.1, r.0) };
                let (lo, hi) = ordered(overlap.on_a);
                // The overlap is between the two *curves*. What interferes is
                // the stretch both *edges* actually cover. A hole's arc and
                // the disc that fills it lie on one circle, so the curves
                // overlap over the whole turn while the arc covers three
                // quarters of it, and paving at the turn's ends says nothing,
                // where paving at the arc's ends is exactly the split the
                // other side needs to sew against.
                // A periodic curve's overlap is answered on its base turn;
                // an edge written a turn up (a wedge cap's arc at 2π..2.5π)
                // covers it only once the turn is carried across. A stretch
                // and a window that both run near a full turn can meet in
                // two turns, and each meeting is a stretch along the edge.
                let turns: Vec<f64> = if contact.curve.is_periodic() {
                    let (dlo, dhi) = contact.curve.domain();
                    let period = dhi - dlo;
                    let turn = ((contact.crange.0 - lo) / period).floor();
                    [turn - 1.0, turn, turn + 1.0]
                        .into_iter()
                        .map(|k| k * period)
                        .collect()
                } else {
                    vec![0.0]
                };
                for shift in turns {
                    let (lo, hi) = (
                        (lo + shift).max(contact.crange.0),
                        (hi + shift).min(contact.crange.1),
                    );
                    if hi - lo <= tol.parametric() {
                        continue;
                    }
                    let span = overlap.on_a.1 - overlap.on_a.0;
                    let carry = |t: f64| -> f64 {
                        if span.abs() <= f64::MIN_POSITIVE {
                            overlap.on_b.0
                        } else {
                            overlap.on_b.0
                                + (overlap.on_b.1 - overlap.on_b.0) * (t - overlap.on_a.0) / span
                        }
                    };
                    // A stretch ended where the two curves part by the radii
                    // they hold to has one end on each curve, that far apart
                    // or less: one vertex holds both, and the split on
                    // either curve owns the distance there.
                    let honesty = |t: f64| -> OgeomResult<f64> {
                        let own = honest(contact.tolerance, tol);
                        if !at_stated {
                            return Ok(own);
                        }
                        let gap = contact
                            .curve
                            .point_at(t, tol)?
                            .distance(e.curve.point_at(carry(t), tol)?);
                        Ok(own.max(gap))
                    };
                    for t in [lo, hi] {
                        paves.entry(contact.node).or_default().push(Pave {
                            t,
                            honesty: honesty(t)?,
                            across: None,
                            spread: 0.0,
                        });
                    }
                    if *DEBUG_WIRE {
                        eprintln!(
                            "CONTACT c{ci} along edge {} over ({lo:.6}, {hi:.6}) of {:?}: {:?} .. {:?}",
                            e.node.index(),
                            contact.crange,
                            contact.curve.point_at(lo, tol).ok(),
                            contact.curve.point_at(hi, tol).ok()
                        );
                    }
                    contact_along[ci].push((lo, hi));
                    let mut apart = 0.0_f64;
                    for t in [lo, f64::midpoint(lo, hi), hi] {
                        apart = apart.max(
                            contact
                                .curve
                                .point_at(t, tol)?
                                .distance(e.curve.point_at(carry(t), tol)?),
                        );
                    }
                    if apart > contact.tolerance.max(e.tolerance) {
                        ALONG_APART.set(ALONG_APART.get().max(apart));
                    }
                    // The *target* edge splits where the shared stretch ends,
                    // exactly as the contact does. Without this, the face across
                    // the overlap keeps one long boundary edge where its new
                    // neighbours carry two short ones, and sew (which matches
                    // edges whole) can pair it with neither. The clamped ends are
                    // carried across by the correspondence the overlap itself
                    // states, which is affine over the shared stretch.
                    let (mut tlo, mut thi) = ((carry(lo), honesty(lo)?), (carry(hi), honesty(hi)?));
                    if tlo.0 > thi.0 {
                        core::mem::swap(&mut tlo, &mut thi);
                    }
                    let target_domain = e.curve.domain();
                    let periodic = e.curve.is_periodic();
                    for (t, honesty) in [tlo, thi] {
                        // A correspondence across a full turn can run the
                        // parameter past the domain. The pave belongs where the
                        // edge actually is.
                        let t = if periodic { fold(t, target_domain) } else { t };
                        if t > e.crange.0 + tol.parametric() && t < e.crange.1 - tol.parametric() {
                            paves.entry(e.node).or_default().push(Pave {
                                t,
                                honesty,
                                across: None,
                                spread: 0.0,
                            });
                        }
                    }
                }
            }
        }
    }

    let mut same_a: Vec<Vec<usize>> = vec![Vec::new(); ga.faces.len()];
    let mut same_b: Vec<Vec<usize>> = vec![Vec::new(); gb.faces.len()];
    for (ia, ib) in same_pairs {
        same_a[ia].push(ib);
        same_b[ib].push(ia);
    }
    Ok((
        sections,
        pieces,
        contacts,
        tangents,
        contact_along,
        paves,
        same_a,
        same_b,
        hug_junctions,
    ))
}

/// An exact section cut at the chart degeneracies it runs through, each
/// piece carrying exact pcurves on both faces.
///
/// The degeneracies are not guessed from the surfaces: they are the faces'
/// own *pole edges*, the degenerate edges the topology already carries, so a
/// face whose chart has a pole says so and one that has none costs nothing.
///
/// `None` means the split is no use here (no degeneracy on the curve, or a
/// piece whose projection still has no closed form), and the caller falls
/// back to marching, which is the honest answer rather than a fitted pcurve
/// pretending to be exact.
fn split_at_degeneracies(
    curve: &Curve,
    fa: &GFace,
    fb: &GFace,
    tol: Tolerances,
) -> OgeomResult<Option<Vec<(Curve, PlanarCurve, PlanarCurve)>>> {
    let mut stops: Vec<f64> = Vec::new();
    let domain = curve.domain();
    // The split points are the *surfaces'* chart degeneracies, not merely the
    // faces' pole edges: a meridian section runs through both of a sphere's
    // poles, and a face that owns only the north one still cannot chart an
    // arc that wraps through the south. The surface knows where its chart
    // collapses whether or not the face's trim reaches there.
    let mut candidates: Vec<Point> = Vec::new();
    for face in [fa, fb] {
        for pole in &face.poles {
            candidates.push(pole.point);
        }
        match &face.surface {
            SurfaceGeometry::Sphere(s) => {
                let sphere = s.sphere();
                let axis = sphere.frame().z().vector();
                candidates.push(sphere.centre() + axis * sphere.radius());
                candidates.push(sphere.centre() - axis * sphere.radius());
            }
            SurfaceGeometry::Cone(c) => {
                candidates.push(c.cone().apex());
            }
            _ => {}
        }
    }
    for point in candidates {
        let found = ogeom_algo::project_on_curve(curve, point, 256, tol)?;
        if found.distance <= tol.confusion() {
            stops.push(found.parameter);
        }
    }
    if stops.is_empty() {
        return Ok(None);
    }
    stops.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
    stops.dedup_by(|a, b| (*a - *b).abs() <= tol.parametric());

    // A closed curve is cut into the arcs between successive stops, the last
    // wrapping past the domain end. An open one keeps its own ends as stops.
    let closed = curve.is_closed(tol) || curve.is_periodic();
    let mut arcs: Vec<(f64, f64)> = Vec::new();
    if closed {
        if stops.len() < 2 {
            // One stop on a closed curve leaves one arc, from the stop right
            // round to itself, which still has the pole at both ends.
            let period = domain.1 - domain.0;
            arcs.push((stops[0], stops[0] + period));
        } else {
            let period = domain.1 - domain.0;
            for i in 0..stops.len() {
                let lo = stops[i];
                let hi = if i + 1 < stops.len() {
                    stops[i + 1]
                } else {
                    stops[0] + period
                };
                arcs.push((lo, hi));
            }
        }
    } else {
        let mut cuts = vec![domain.0];
        cuts.extend(
            stops
                .iter()
                .copied()
                .filter(|t| *t > domain.0 + tol.parametric() && *t < domain.1 - tol.parametric()),
        );
        cuts.push(domain.1);
        for pair in cuts.windows(2) {
            arcs.push((pair[0], pair[1]));
        }
    }

    let mut out = Vec::with_capacity(arcs.len());
    for (lo, hi) in arcs {
        if hi - lo <= tol.parametric() {
            continue;
        }
        let (Some(pa), Some(pb)) = (
            ogeom_intersect::exact_pcurve_over(curve, (lo, hi), &fa.surface, tol),
            ogeom_intersect::exact_pcurve_over(curve, (lo, hi), &fb.surface, tol),
        ) else {
            return Ok(None);
        };
        let Ok(piece) = ogeom_geom::TrimmedCurve::new(curve.clone(), lo, hi, tol) else {
            return Ok(None);
        };
        out.push((piece.into(), pa, pb));
    }
    if out.is_empty() {
        return Ok(None);
    }
    Ok(Some(out))
}

/// Whether `curve` starts on a pole of either chart.
fn on_a_chart_pole(
    curve: &Curve,
    surfaces: [&SurfaceGeometry; 2],
    tol: Tolerances,
) -> OgeomResult<bool> {
    let start = curve.point_at(curve.domain().0, tol)?;
    Ok(surfaces.iter().any(|surface| {
        ogeom_intersect::march::chart_poles(surface, tol)
            .iter()
            .any(|&(_, _, pole)| pole.distance(start) <= tol.confusion())
    }))
}

/// Each face's carrier, numbered within the solid, with the window of the
/// carrier's parameters its faces' trims reach.
///
/// The window is the union of the parameter boxes of the faces on that
/// surface, read from their sampled trims and poles, grown a quarter of
/// its span on every side so a section crossing a trim is traced past it
/// and cut there by the trim. A face whose trim does not sample leaves its
/// carrier whole.
fn carrier_windows(
    g: &GSolid,
    tol: Tolerances,
) -> Vec<(usize, Option<ogeom_intersect::ParameterWindow>)> {
    let mut numbered: ogeom_core::FastMap<&(ogeom_topo::SurfaceId, Location), usize> =
        ogeom_core::FastMap::default();
    // Per carrier the box reached so far, low corner then high, or `None`
    // once a face on it fails to sample.
    let empty = (
        Point2::new(f64::INFINITY, f64::INFINITY),
        Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
    );
    let mut reach: Vec<Option<(Point2, Point2)>> = Vec::new();
    let mut of_face = Vec::with_capacity(g.faces.len());
    for face in &g.faces {
        let next = numbered.len();
        let at = *numbered.entry(&face.carrier).or_insert(next);
        if at == reach.len() {
            reach.push(Some(empty));
        }
        of_face.push(at);
        let Some((low, high)) = reach[at].as_mut() else {
            continue;
        };
        let mut points: Vec<Point2> = face.trim_lines(tol).iter().flatten().copied().collect();
        for pole in &face.poles {
            for k in 0..=4 {
                let t = pole.prange.0 + (pole.prange.1 - pole.prange.0) * f64::from(k) / 4.0;
                if let Ok(p) = pole.pcurve.point_at(t, tol) {
                    points.push(p);
                }
            }
        }
        if points.is_empty() || points.iter().any(|p| !p.x.is_finite() || !p.y.is_finite()) {
            reach[at] = None;
            continue;
        }
        for p in points {
            *low = Point2::new(low.x.min(p.x), low.y.min(p.y));
            *high = Point2::new(high.x.max(p.x), high.y.max(p.y));
        }
    }
    let grow = |lo: f64, hi: f64| {
        let margin = (hi - lo) * 0.25;
        (lo - margin, hi + margin)
    };
    let windows: Vec<Option<ogeom_intersect::ParameterWindow>> = reach
        .into_iter()
        .map(|bound| bound.map(|(low, high)| (grow(low.x, high.x), grow(low.y, high.y))))
        .collect();
    of_face.into_iter().map(|at| (at, windows[at])).collect()
}

/// A surface narrowed to the reach of a bound, for the marcher's benefit.
///
/// Seeding samples a surface's *parameter box*, so a plane stored over
/// ±10^9 (which is how an unbounded carrier reaches this code) is sampled
/// at a spacing a hundred million times anything it could be meeting, and
/// no seed ever lands near the curve. Narrowing to where the two faces
/// actually are is what lets the seeding see it. The chart is untouched:
/// only the window the marcher walks changes, so pcurves fitted in it mean
/// the same thing on the surface as stored.
fn windowed_to(surface: &SurfaceGeometry, bound: &ogeom_math::Aabb) -> SurfaceGeometry {
    let corners = bound.corners();
    if corners.is_empty() {
        return surface.clone();
    }
    match surface {
        SurfaceGeometry::Plane(p) => {
            let frame = p.plane().frame();
            let (mut u0, mut u1, mut v0, mut v1) = (
                f64::INFINITY,
                f64::NEG_INFINITY,
                f64::INFINITY,
                f64::NEG_INFINITY,
            );
            for c in &corners {
                let local = frame.to_local(*c);
                u0 = u0.min(local.x);
                u1 = u1.max(local.x);
                v0 = v0.min(local.y);
                v1 = v1.max(local.y);
            }
            let margin = ((u1 - u0) + (v1 - v0)).mul_add(0.25, 1.0);
            let (want_u, want_v) = ((u0 - margin, u1 + margin), (v0 - margin, v1 + margin));
            let (have_u, have_v) = ogeom_geom::Surface::domain(p);
            if have_u.1 - have_u.0 <= want_u.1 - want_u.0
                && have_v.1 - have_v.0 <= want_v.1 - want_v.0
            {
                return surface.clone();
            }
            ogeom_geom::PlaneSurface::over(p.plane(), want_u, want_v)
                .map_or_else(|_| surface.clone(), Into::into)
        }
        SurfaceGeometry::Cylinder(c) => {
            let frame = c.cylinder().frame();
            let (mut h0, mut h1) = (f64::INFINITY, f64::NEG_INFINITY);
            for corner in &corners {
                let h = (*corner - frame.origin()).dot(frame.z().vector());
                h0 = h0.min(h);
                h1 = h1.max(h);
            }
            let margin = (h1 - h0).mul_add(0.25, 1.0);
            let want = (h0 - margin, h1 + margin);
            let have = ogeom_geom::Surface::domain(c).1;
            if have.1 - have.0 <= want.1 - want.0 {
                return surface.clone();
            }
            ogeom_geom::CylinderSurface::new(c.cylinder(), want)
                .map_or_else(|_| surface.clone(), Into::into)
        }
        other => other.clone(),
    }
}

/// A cylinder whose marched sections with a patch stop short of an end of
/// its window, the window stretched along its axis to carry them past it.
///
/// A primitive's wall is stored over exactly its own height, so a section
/// crossing the rim is walked to the window's edge and stops there, a step
/// short of the rim, and the rim is never crossed. Stretched a fiftieth of
/// its height at that end, the walk carries on past the rim, crosses it like
/// any other boundary edge, and the face's trim cuts it there. The chart is
/// untouched, only the window grows. `None` where every section ends on the
/// window's ends or clear of them, for any other surface, and against an
/// analytic surface, whose sections are closed forms already exact to the
/// window.
fn reaching(
    surface: &SurfaceGeometry,
    other: &SurfaceGeometry,
    met: &ogeom_intersect::SurfaceIntersection,
    tol: Tolerances,
) -> OgeomResult<Option<SurfaceGeometry>> {
    let SurfaceGeometry::Cylinder(c) = surface else {
        return Ok(None);
    };
    if !matches!(other, SurfaceGeometry::BSpline(_)) {
        return Ok(None);
    }
    let ogeom_intersect::SurfaceIntersection::Along(curves) = met else {
        return Ok(None);
    };
    let frame = c.cylinder().frame();
    let have = ogeom_geom::Surface::domain(c).1;
    let past = (have.1 - have.0) * 0.02;
    let short = |gap: f64| gap > tol.confusion() && gap <= past;
    let (mut low, mut high) = (false, false);
    for section in curves {
        let (t0, t1) = section.curve.domain();
        for t in [t0, t1] {
            let at = section.curve.point_at(t, tol)?;
            let h = (at - frame.origin()).dot(frame.z().vector());
            low |= short(h - have.0);
            high |= short(have.1 - h);
        }
    }
    if !low && !high {
        return Ok(None);
    }
    let want = (
        if low { have.0 - past } else { have.0 },
        if high { have.1 + past } else { have.1 },
    );
    Ok(ogeom_geom::CylinderSurface::new(c.cylinder(), want)
        .ok()
        .map(Into::into))
}

/// March a pair whose exact section has no closed-form pcurve: the fitted
/// branches, and the reach they were cut at poles within, which their
/// tolerance must cover.
fn march_pair(
    a: &SurfaceGeometry,
    b: &SurfaceGeometry,
    options: &ogeom_intersect::IntersectOptions,
    tol: Tolerances,
) -> OgeomResult<(Vec<ogeom_intersect::IntersectionCurve>, f64)> {
    use ogeom_intersect::{approximate_branch, branches_cut_at_poles, passes_a_pole};
    // Fitted whole past a pole of either chart within its stated
    // tolerance, a section passes through the pole as far as the fit can
    // say: the pair is traced again, cut there as within the chord.
    let mut pole_reach = 0.0;
    let out = loop {
        let traced = branches_cut_at_poles(a, b, options.marching, pole_reach, tol)?;
        let mut out = Vec::new();
        let mut again: Option<f64> = None;
        for branch in &traced {
            let fitted = approximate_branch(a, b, branch, options.tolerance, tol)?;
            let stated = options.marching.chord + fitted.fit_error;
            if pole_reach == 0.0 && passes_a_pole(&fitted.curve.clone().into(), [a, b], stated, tol)
            {
                again = Some(again.map_or(stated, |r: f64| r.max(stated)));
            }
            out.push(fitted);
        }
        match again {
            Some(reach) => pole_reach = reach,
            None => break out,
        }
    };
    if out.is_empty() {
        // No branch found is two different stories. Surfaces that measurably
        // stand apart over their stated extents (a blend's cylinder and a
        // far-off bevel plane whose ellipse of intersection lies beyond
        // both) simply do not interact, and an empty section is the true
        // answer. Only a pair that comes close and still resolves nothing
        // is beyond the intersector.
        if surfaces_stand_apart(a, b, tol) {
            return Ok((out, pole_reach));
        }
        ogeom_bail!(
            NotDone,
            "an exact section has no closed-form pcurve and marching resolved \
             no branch; the configuration is beyond the intersector's current \
             reach"
        );
    }
    Ok((out, pole_reach))
}

/// Whether two surfaces measurably keep their distance over their stated
/// extents.
///
/// A conservative grid measurement: sample the smaller-extent surface and
/// project each sample onto the other. Apart means every sample clears a
/// margin scaled to the extents. Surfaces with unbounded or enormous stated
/// domains (an imported plane's billion units) are never called apart this
/// way, because a grid over them samples nothing.
fn surfaces_stand_apart(a: &SurfaceGeometry, b: &SurfaceGeometry, tol: Tolerances) -> bool {
    use ogeom_geom::Surface as _;
    let extent_of = |s: &SurfaceGeometry| -> f64 {
        let ((ua, ub), (va, vb)) = s.domain();
        (ub - ua).abs().max((vb - va).abs())
    };
    let (sample, against) = if extent_of(a) <= extent_of(b) {
        (a, b)
    } else {
        (b, a)
    };
    let span = extent_of(sample);
    if !span.is_finite() || span > 1e4 {
        return false;
    }
    let ((ua, ub), (va, vb)) = sample.domain();
    const GRID: usize = 9;
    // One seeding grid over the far surface, asked a hundred times: the
    // same seeds and the same Newton a per-call projection uses, at
    // hundreds of evaluations instead of tens of thousands for every
    // genuine near-miss.
    let Ok(seeds) = ogeom_algo::SurfaceSeeds::over(against, 16, tol) else {
        return false;
    };
    let mut clearance = f64::INFINITY;
    for i in 0..=GRID {
        for j in 0..=GRID {
            #[allow(clippy::cast_precision_loss)]
            let u = ua + (ub - ua) * i as f64 / GRID as f64;
            #[allow(clippy::cast_precision_loss)]
            let v = va + (vb - va) * j as f64 / GRID as f64;
            let Ok(p) = sample.point_at(u, v, tol) else {
                return false;
            };
            let Ok(projection) = seeds.project(against, p, tol) else {
                return false;
            };
            clearance = clearance.min(projection.distance);
            if clearance <= tol.confusion() * 1e3 {
                return false;
            }
        }
    }
    clearance > tol.confusion() * 1e3
}

/// Whether two faces lie on one surface where they overlap, to within what
/// they state they may stand off their own: a face fitted to a mesh, and a
/// face swept from a sketch of its outline whose points a float's rounding
/// moved a few microns, are one wall by the fit's own measure, though the
/// arc through the rounded points has another centre and radius and the
/// closed form, held to the confusion distance, sees two.
///
/// Asked only where the faces, or a fuzzy boolean's widened confusion,
/// allow more than the default confusion distance's few, or with
/// `as_stated` at any tolerance (see [`AS_STATED`]). The smaller face
/// is sampled on a grid over its chart, inside its
/// trim. Every sample inside the other face's trim must lie within the
/// stated tolerance of the other's surface, and a few must, for the answer
/// to mean anything. A pair that crosses fails at its first sample off the
/// other.
fn coincide_as_stated(fa: &GFace, fb: &GFace, as_stated: bool, tol: Tolerances) -> bool {
    const GRID: usize = 8;
    const EVIDENCE: usize = 4;
    // What the faces state, or the run's own confusion where a fuzzy
    // boolean has widened it past theirs: a fuzz is a statement of how far
    // the two solids' geometry may disagree and still be one.
    let reach = (fa.tolerance + fb.tolerance).max(tol.confusion() * 2.0);
    if reach <= ogeom_core::tolerance::CONFUSION * 10.0 && !as_stated {
        return false;
    }
    // Two closed forms of different kinds share no patch: a plane is no
    // cylinder anywhere, however close they pass.
    let kind = |s: &SurfaceGeometry| match s {
        SurfaceGeometry::Plane(_) => Some(0),
        SurfaceGeometry::Cylinder(_) => Some(1),
        SurfaceGeometry::Cone(_) => Some(2),
        SurfaceGeometry::Sphere(_) => Some(3),
        SurfaceGeometry::Torus(_) => Some(4),
        _ => None,
    };
    if let (Some(a), Some(b)) = (kind(&fa.surface), kind(&fb.surface))
        && a != b
    {
        return false;
    }
    let (sampled, against) = if fa.bound.diagonal() <= fb.bound.diagonal() {
        (fa, fb)
    } else {
        (fb, fa)
    };
    let Some(lines) = sampled.outline(tol) else {
        return false;
    };
    let borrowed: Vec<&[Point2]> = lines.iter().map(Vec::as_slice).collect();
    let (lo, hi) = lines.iter().flatten().fold(
        (
            Point2::new(f64::INFINITY, f64::INFINITY),
            Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
        ),
        |(lo, hi), p| {
            (
                Point2::new(lo.x.min(p.x), lo.y.min(p.y)),
                Point2::new(hi.x.max(p.x), hi.y.max(p.y)),
            )
        },
    );
    if !(lo.x.is_finite() && hi.x.is_finite() && lo.y.is_finite() && hi.y.is_finite()) {
        return false;
    }
    // Wide enough to find the other face's trim about a sample standing
    // off its surface, so a sample off it is caught rather than skipped.
    let search = reach.max(sampled.bound.diagonal().max(against.bound.diagonal()) * 1e-3);
    let mut evidence = 0_usize;
    for i in 0..GRID {
        for j in 0..GRID {
            #[allow(clippy::cast_precision_loss)]
            let at = Point2::new(
                lo.x + (hi.x - lo.x) * ((i as f64 + 0.5) / GRID as f64),
                lo.y + (hi.y - lo.y) * ((j as f64 + 0.5) / GRID as f64),
            );
            if !arrange::inside_many(&borrowed, at) {
                continue;
            }
            let Ok(p) = sampled.surface.point_at(at.x, at.y, tol) else {
                return false;
            };
            if !against.bound.expanded(search).contains(p) {
                continue;
            }
            let Some(uv) = chart_point_within(against, p, search, tol) else {
                continue;
            };
            let Ok(foot) = against.surface.point_at(uv.x, uv.y, tol) else {
                return false;
            };
            if foot.distance(p) > reach {
                return false;
            }
            evidence += 1;
        }
    }
    evidence >= EVIDENCE
}

/// How far off a partner's surface a probe of `face` may stand and still
/// be read on it: what the two faces state, or the confusion distance's
/// few.
fn partner_reach(face: &GFace, partner: &GFace, tol: Tolerances) -> f64 {
    (face.tolerance + partner.tolerance).max(tol.confusion() * 10.0)
}

/// How many chords a curved strand of a planar piece is resampled into.
const FINE: usize = 1024;

/// How many of a resampled arc's chords are passed over together where a
/// ray cannot reach them.
const FINE_BLOCK: usize = 32;

/// A planar piece's rings resampled finely off their exact curves. The
/// piece's own polylines bow inside a curved strand by more than the width
/// of a sliver beside it, so a probe picked inside them can stand outside
/// the piece. These rings hold it to a few microns.
///
/// A circular strand's samples are drawn as a ray asks for them: a ray
/// meets a circle in at most two places, and the samples far from its
/// height cannot be crossed by it.
struct FineRings<'a> {
    rings: Vec<Vec<FinePart<'a>>>,
    tol: Tolerances,
}

/// One strand of a [`FineRings`] ring.
enum FinePart<'a> {
    /// Its samples, in the ring's direction.
    Points(Vec<Point2>),
    /// A circle's samples, drawn when first asked for.
    Arc(FineArc<'a>),
}

/// A circular strand's [`FINE`] chords, each sample drawn once, when a ray
/// first needs it.
struct FineArc<'a> {
    curve: &'a PlanarCurve,
    circle: ogeom_math::Circle2,
    from: f64,
    to: f64,
    wrap: Option<(f64, f64)>,
    reversed: bool,
    /// The samples drawn so far; empty until the first is.
    drawn: core::cell::RefCell<Vec<Option<Point2>>>,
}

impl FineArc<'_> {
    /// The parameter sample `i` is drawn at.
    fn parameter(&self, i: usize) -> f64 {
        #[allow(clippy::cast_precision_loss)]
        let t = self.from + (self.to - self.from) * (i as f64 / FINE as f64);
        self.wrap.map_or(t, |domain| fold(t, domain))
    }

    /// Sample `i`. A circle is drawn at any parameter.
    fn point(&self, i: usize, tol: Tolerances) -> Point2 {
        if let Some(Some(p)) = self.drawn.borrow().get(i) {
            return *p;
        }
        let p = self
            .curve
            .point_at(self.parameter(i), tol)
            .unwrap_or(Point2::new(f64::NAN, f64::NAN));
        let mut drawn = self.drawn.borrow_mut();
        if drawn.is_empty() {
            drawn.resize(FINE + 1, None);
        }
        drawn[i] = Some(p);
        p
    }

    /// How far the circle's coordinates stand from its centre's, over and
    /// above its rounding.
    fn slack(&self) -> f64 {
        let centre = self.circle.centre();
        1e-9 * (1.0 + self.circle.radius() + centre.x.abs() + centre.y.abs())
    }

    /// Whether a horizontal ray from `p` may cross a chord between samples
    /// `lo` and `hi`. Every sample between them lies within the arc's length
    /// between their parameters of sample `lo`, so where that reach stays
    /// wholly above or below `p`'s height no chord there straddles it. A
    /// parameter folded across its domain's end inside the block, or a
    /// sample that is not finite, leaves the block to be asked chord by
    /// chord.
    fn may_cross(&self, lo: usize, hi: usize, p: Point2, tol: Tolerances) -> bool {
        let (t0, t1) = (self.parameter(lo), self.parameter(hi));
        #[allow(clippy::cast_precision_loss)]
        let step = (self.to - self.from) * ((hi - lo) as f64 / FINE as f64);
        let unfolded = self
            .wrap
            .is_none_or(|(a, b)| ((t1 - t0) - step).abs() <= 0.5 * (b - a).abs());
        let start = self.point(lo, tol);
        let reach = self.circle.radius() * (t1 - t0).abs() + self.slack();
        if !(unfolded && reach.is_finite() && start.y.is_finite() && p.y.is_finite()) {
            return true;
        }
        start.y - reach <= p.y && start.y + reach >= p.y
    }

    /// The greatest x and the least and greatest y any sample may have,
    /// none drawn: a sample is the centre moved along each axis by the
    /// radius times a cosine or a sine.
    fn extent(&self) -> (f64, f64, f64) {
        let frame = self.circle.frame();
        let (x, y) = (frame.x().vector(), frame.y().vector());
        let r = self.circle.radius();
        let centre = self.circle.centre();
        let across = r * (x.x.abs() + y.x.abs()) + self.slack();
        let up = r * (x.y.abs() + y.y.abs()) + self.slack();
        (centre.x + across, centre.y - up, centre.y + up)
    }
}

impl<'a> FineRings<'a> {
    /// `None` for a face that is not a plane, or a ring with a strand this
    /// cannot resample (a contact or a pole). Where `only` is given, a ring
    /// it marks false is left empty.
    fn of(
        face: &'a GFace,
        rings: &[Vec<Traversal<Tag>>],
        sections: &'a [SectionRec],
        from_a: bool,
        only: Option<&[bool]>,
        tol: Tolerances,
    ) -> Option<Self> {
        if !matches!(face.surface, SurfaceGeometry::Plane(_)) {
            return None;
        }
        let mut lines: Vec<Vec<FinePart<'a>>> = Vec::with_capacity(rings.len());
        for (k, ring) in rings.iter().enumerate() {
            let mut line: Vec<FinePart<'a>> = Vec::new();
            if only.is_some_and(|wanted| !wanted.get(k).copied().unwrap_or(true)) {
                lines.push(line);
                continue;
            }
            for traversal in ring {
                let (curve, a, b, wrap) = fine_strand(face, sections, from_a, &traversal.tag)?;
                if let PlanarCurve::Circle(circle) = curve {
                    line.push(FinePart::Arc(FineArc {
                        curve,
                        circle: circle.circle(),
                        from: a,
                        to: b,
                        wrap,
                        reversed: traversal.reversed,
                        drawn: core::cell::RefCell::new(Vec::new()),
                    }));
                    continue;
                }
                let count = if matches!(curve, PlanarCurve::Line(_)) {
                    1
                } else {
                    FINE
                };
                let mut points: Vec<Point2> = Vec::with_capacity(count + 1);
                for i in 0..=count {
                    #[allow(clippy::cast_precision_loss)]
                    let t = a + (b - a) * (i as f64 / count as f64);
                    let t = wrap.map_or(t, |domain| fold(t, domain));
                    points.push(curve.point_at(t, tol).ok()?);
                }
                if traversal.reversed {
                    points.reverse();
                }
                line.push(FinePart::Points(points));
            }
            lines.push(line);
        }
        Some(Self { rings: lines, tol })
    }

    /// Even-odd containment of `p` in the rings, counted as
    /// [`inside_rings`] counts it over the rings drawn in full.
    fn inside(&self, p: Point2) -> bool {
        self.rings
            .iter()
            .fold(false, |acc, ring| acc != self.ring_inside(ring, p))
    }

    /// Whether a ray from `p` crosses `ring` an odd number of times: each
    /// strand's chords, the joins between strands, and the closing join,
    /// whether a ray crosses a chord not depending on the way it runs.
    fn ring_inside(&self, ring: &[FinePart<'_>], p: Point2) -> bool {
        let tol = self.tol;
        let mut inside = false;
        let mut flip = |a: Point2, b: Point2| {
            if arrange::ray_crosses(a, b, p) {
                inside = !inside;
            }
        };
        let mut first: Option<Point2> = None;
        let mut last: Option<Point2> = None;
        for part in ring {
            let (head, tail) = match part {
                FinePart::Points(points) => {
                    for w in points.windows(2) {
                        flip(w[0], w[1]);
                    }
                    (points[0], points[points.len() - 1])
                }
                FinePart::Arc(arc) => {
                    let mut lo = 0;
                    while lo < FINE {
                        let hi = (lo + FINE_BLOCK).min(FINE);
                        if arc.may_cross(lo, hi, p, tol) {
                            for i in lo..hi {
                                flip(arc.point(i, tol), arc.point(i + 1, tol));
                            }
                        }
                        lo = hi;
                    }
                    let ends = (arc.point(0, tol), arc.point(FINE, tol));
                    if arc.reversed { (ends.1, ends.0) } else { ends }
                }
            };
            if let Some(at) = last {
                flip(at, head);
            }
            first.get_or_insert(head);
            last = Some(tail);
        }
        if let (Some(first), Some(last)) = (first, last) {
            flip(last, first);
        }
        inside
    }

    /// Whether a ray from `p` cannot reach `ring`: every sample of it lies
    /// below or above `p`, or to its left, so no chord of it straddles the
    /// ray where the ray runs.
    fn out_of_reach(ring: &[FinePart<'_>], p: Point2) -> bool {
        let (mut right, mut low, mut high) = (f64::NEG_INFINITY, f64::INFINITY, f64::NEG_INFINITY);
        let mut reach = |x: f64, y: f64| {
            right = right.max(x);
            low = low.min(y);
            high = high.max(y);
            x.is_finite() && y.is_finite()
        };
        for part in ring {
            let finite = match part {
                FinePart::Points(points) => points.iter().all(|q| reach(q.x, q.y)),
                FinePart::Arc(arc) => {
                    let (x, lo, hi) = arc.extent();
                    arc.from.is_finite() && arc.to.is_finite() && reach(x, lo) && reach(x, hi)
                }
            };
            if !finite {
                return false;
            }
        }
        ring.is_empty() || p.y < low || p.y > high || p.x > right
    }

    /// [`FineRings::inside`] for `p` over the rings `reached` marks and any
    /// others it could be asked over, where those others cannot change the
    /// answer: `None` where a ring `reached` leaves out is crossed by the
    /// ray an odd number of times, so the answer depends on whether it is
    /// counted.
    fn inside_beside(&self, p: Point2, reached: &[bool]) -> Option<bool> {
        let mut inside = false;
        for (k, ring) in self.rings.iter().enumerate() {
            let counted = reached.get(k).copied().unwrap_or(true);
            if !counted && Self::out_of_reach(ring, p) {
                continue;
            }
            let crossed = self.ring_inside(ring, p);
            if !counted && crossed {
                return None;
            }
            inside ^= crossed;
        }
        Some(inside)
    }

    /// Every ring's samples, drawn in full, in the ring's direction.
    fn points(&self) -> Vec<Vec<Point2>> {
        self.rings
            .iter()
            .map(|ring| {
                let mut line = Vec::new();
                for part in ring {
                    match part {
                        FinePart::Points(points) => line.extend_from_slice(points),
                        FinePart::Arc(arc) => {
                            let start = line.len();
                            line.extend((0..=FINE).map(|i| arc.point(i, self.tol)));
                            if arc.reversed {
                                line[start..].reverse();
                            }
                        }
                    }
                }
                line
            })
            .collect()
    }
}

/// A pcurve, the range of it a strand covers, and the domain the range
/// folds into where it does.
type FineStrand<'a> = (&'a PlanarCurve, f64, f64, Option<(f64, f64)>);

/// The pcurve a strand of a planar piece is resampled along, its range,
/// and the domain a closed section's parameters fold into. `None` for a
/// contact or a pole, or a tag naming nothing.
fn fine_strand<'a>(
    face: &'a GFace,
    sections: &'a [SectionRec],
    from_a: bool,
    tag: &Tag,
) -> Option<FineStrand<'a>> {
    Some(match *tag {
        Tag::Boundary { edge, range } => {
            let e = face.edges.get(edge)?;
            (
                &e.pcurve,
                rescale(range.0, e.crange, e.prange),
                rescale(range.1, e.crange, e.prange),
                None,
            )
        }
        Tag::Section { section, range } => {
            let record = sections.get(section)?;
            let pcurve = if from_a { &record.pc_a } else { &record.pc_b };
            let wrap = record.closed.then(|| record.curve.domain());
            (pcurve, range.0, range.1, wrap)
        }
        Tag::Contact { .. } | Tag::Pole { .. } => return None,
    })
}

/// Which of a piece's rings a horizontal ray from any of `probes` may
/// cross: those whose outline, widened past what its chords bow, spans the
/// probe's height and reaches to its right. A ray crosses no other, coarse
/// or fine, and an empty ring in its place counts the same.
fn rings_near(outlines: &[Vec<Point2>], probes: &[Point2]) -> Vec<bool> {
    outlines
        .iter()
        .map(|line| {
            let (mut low, mut high) = (
                Point2::new(f64::INFINITY, f64::INFINITY),
                Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
            );
            for p in line {
                low = Point2::new(low.x.min(p.x), low.y.min(p.y));
                high = Point2::new(high.x.max(p.x), high.y.max(p.y));
            }
            if low
                .x
                .partial_cmp(&high.x)
                .is_none_or(core::cmp::Ordering::is_gt)
            {
                return true;
            }
            let margin = 1e-3 + 1e-2 * low.distance(high);
            probes
                .iter()
                .any(|p| p.y >= low.y - margin && p.y <= high.y + margin && p.x <= high.x + margin)
        })
        .collect()
}

/// Whether a chart point lies inside a planar face, counted exactly: the
/// crossings of a ray from it with the boundary's own pcurves, not their
/// polylines. A trim's chords bow inside a curved rim by more than the
/// width of a sliver beside it (the annulus a drum a few hundredths of a
/// millimetre wider leaves on a cap), and a point in that sliver reads
/// outside the polyline. `None` for a face that is not a plane or has no
/// curved edge, or where every ray tried meets the boundary at an end, a
/// tangency or the start.
fn inside_plane_exactly(face: &GFace, p: Point2, tol: Tolerances) -> Option<bool> {
    // A boundary of straight edges is its own polyline: nothing to correct.
    if !matches!(face.surface, SurfaceGeometry::Plane(_))
        || face
            .edges
            .iter()
            .all(|e| matches!(e.pcurve, PlanarCurve::Line(_)))
    {
        return None;
    }
    // On the boundary to well within the weld distance (three quarters of
    // it, or an edge's own doubt where wider) is on it: a sliver that thin is
    // welded, no parity speaks for such a point, and the outline's reading
    // stands. One at the weld distance itself is read exactly, as two drums
    // that far apart are sectioned.
    let at = face.surface.point_at(p.x, p.y, tol).ok()?;
    for e in &face.edges {
        let doubt = (e.standoff * 2.0).max(tol.confusion() * 75.0);
        if !e.bound.expanded(doubt).contains(at) {
            continue;
        }
        if distance_to_edge_curve(&e.curve, e.crange, at, tol).ok()? <= doubt {
            return None;
        }
    }
    let reach = face
        .edges
        .iter()
        .map(|e| e.bound.diagonal())
        .sum::<f64>()
        .max(1.0)
        * 4.0;
    let mut curves: Vec<(PlanarCurve, (f64, f64))> = Vec::new();
    for e in &face.edges {
        curves.push((e.pcurve.clone(), e.prange));
        if let Some((other, range)) = &e.other_side {
            curves.push((other.clone(), *range));
        }
    }
    for pole in &face.poles {
        curves.push((pole.pcurve.clone(), pole.prange));
    }
    let options = ogeom_intersect::CurveCurveOptions::default();
    'directions: for (dx, dy) in [(1.0, 0.0137), (-0.31, 1.0), (-1.0, -0.47), (0.53, -1.0)] {
        let length = f64::hypot(dx, dy);
        let far = Point2::new(p.x + dx / length * reach, p.y + dy / length * reach);
        let Ok(ray) = ogeom_geom::Line2d::segment(p, far, tol) else {
            return None;
        };
        let ray: PlanarCurve = ray.into();
        let mut crossings = 0_usize;
        for (curve, (a, b)) in &curves {
            let (lo, hi) = (a.min(*b), a.max(*b));
            if hi - lo <= tol.parametric() {
                continue;
            }
            let Ok(piece) = ogeom_geom::Trimmed2d::new(curve.clone(), lo, hi, tol) else {
                continue 'directions;
            };
            let piece: PlanarCurve = piece.into();
            let Ok(met) = ogeom_intersect::intersect_curves_2d(&ray, &piece, options, tol) else {
                continue 'directions;
            };
            if !met.overlaps.is_empty() {
                continue 'directions;
            }
            let span = hi - lo;
            for hit in &met.crossings {
                let at_start = hit.on_a <= tol.confusion();
                let at_end =
                    (hit.on_b - lo).abs() <= span * 1e-9 || (hi - hit.on_b).abs() <= span * 1e-9;
                if at_start || at_end || hit.reach > 0.0 {
                    continue 'directions;
                }
                crossings += 1;
            }
        }
        return Some(crossings % 2 == 1);
    }
    None
}

// --- the general fuse --------------------------------------------------------

/// One piece of one argument face, classified against the other argument.
struct FacePiece {
    /// Which argument's face list, and which face.
    from_a: bool,
    face: usize,
    rings: Vec<Vec<Traversal<Tag>>>,
    /// The rings as chart polylines, for the coincidence pairing below.
    outlines: Vec<Vec<Point2>>,
    /// The interior point the state was decided at, in space.
    probe: Point,
    state: PieceState,
    /// Whether the *other* argument already contributes this same patch of
    /// this same surface.
    ///
    /// Two faces lying on one surface with their material on the same side
    /// bound the union and the intersection once between them, not twice,
    /// but "once" is a statement about the *patch*, not about which argument
    /// it came from. Where a tool's cap fills a hole its own bore left, the
    /// part has no piece there at all, and dropping the tool's by argument
    /// identity leaves the result with a hole in it. So the duplicate is
    /// identified by containment, and only a piece genuinely stood in for is
    /// dropped.
    covered: bool,
    /// Whether the piece is its whole face, untouched: nothing crosses it
    /// and none of its edges is split.
    whole: bool,
}

struct GeneralFused {
    a: GSolid,
    b: GSolid,
    sections: Vec<SectionRec>,
    contacts: Vec<ContactRec>,
    /// Curves the two boundaries touch along without crossing. They take no
    /// part in the classification below (that is what tangency means) and
    /// are carried for the consumers that want the contact itself.
    tangents: Vec<TangentRec>,
    pieces: Vec<FacePiece>,
    /// Pieces of the two arguments standing for one patch of one surface,
    /// as indices into `pieces`: the first argument's piece, then the
    /// second's.
    coincident: Vec<(usize, usize)>,
    /// Junctions several paves describe, each resolved once for every
    /// strand that ends in it.
    junctions: Vec<Junction>,
}

/// One junction the paving found several times over.
///
/// A tolerant rail meeting a wedge's faces near one corner collects a
/// cluster of crossings inside its own stated radius: each face's section
/// stops at its own crossing with the rail, and the crossings sit a few
/// tenths of a micron to a few hundred apart along it. The rail's strands
/// split once per cluster, at its first pave. The sections' ends still name
/// their own crossings. And the two descriptions of the junction can sit
/// apart by the cluster's whole span, which no single strand's honesty
/// covers. So the junction is one vertex standing at the first pave, owning
/// the span the paves disagree by, and every strand end inside that span
/// names it, whichever pave its own trim stopped at.
#[derive(Debug, Clone, Copy)]
struct Junction {
    /// Where the cluster's first pave sits.
    at: Point,
    /// How far a strand end may sit from `at` and still be this junction:
    /// the cluster's span plus the rail's own reach.
    reach: f64,
    /// Whether `at` is an edge's own end vertex that a section tangent to
    /// the edge was welded onto: the section's chart image is bent onto it
    /// rather than left where the section stopped.
    onto_vertex: bool,
}

/// Paves on each seam of `solid`'s faces where a junction the seam passes
/// through holds section ends of the face on both sides of it.
///
/// The ends of one junction are one point, and a strand end is carried onto
/// a node the junction holds, or onto another end, across the face's chart.
/// Ends either side of a seam stand near its two columns, a period apart in
/// the chart, and no path inside the chart joins them: with no node on the
/// seam they dangle on either side of it. Split where it passes nearest the
/// junction, the seam puts a node on each column, and each end is carried
/// onto the one on its side, as ends a junction holds on one side of the
/// seam are carried onto one another.
fn seams_through_junctions(
    solid: &GSolid,
    from_a: bool,
    (sections, pieces): (&[SectionRec], &[SectionPiece]),
    junctions: &[Junction],
    paves: &mut ogeom_core::FastMap<EdgeKey, Vec<Pave>>,
    tol: Tolerances,
) -> OgeomResult<()> {
    for (fi, face) in solid.faces.iter().enumerate() {
        let seams: Vec<&BoundaryEdge> = face
            .edges
            .iter()
            .filter(|e| e.other_side.is_some())
            .collect();
        if seams.is_empty() {
            continue;
        }
        // Each end of the face's section pieces, in space and in the chart.
        let mut ends: Vec<(Point, Point2)> = Vec::new();
        for sp in pieces {
            let section = &sections[sp.section];
            let (face_of, pcurve, hugs) = if from_a {
                (section.face_a, &section.pc_a, sp.hugs[0])
            } else {
                (section.face_b, &section.pc_b, sp.hugs[1])
            };
            if face_of != fi || hugs || section.closed {
                continue;
            }
            for t in [sp.range.0, sp.range.1] {
                ends.push((section.curve.point_at(t, tol)?, pcurve.point_at(t, tol)?));
            }
        }
        for e in seams {
            let Some((other, orange)) = &e.other_side else {
                continue;
            };
            for junction in junctions {
                if !e.bound.expanded(junction.reach).contains(junction.at) {
                    continue;
                }
                let (gap, t) = nearest_on_edge_curve(&e.curve, e.crange, junction.at, tol)?;
                if gap > junction.reach {
                    continue;
                }
                let paved = paves.get(&e.node).is_some_and(|list| {
                    list.iter().any(|p| {
                        e.curve
                            .point_at(p.t, tol)
                            .is_ok_and(|q| junction.at.distance(q) <= junction.reach)
                    })
                });
                if paved {
                    continue;
                }
                let columns = [
                    e.pcurve.point_at(rescale(t, e.crange, e.prange), tol)?,
                    other.point_at(rescale(t, e.crange, *orange), tol)?,
                ];
                let mut sides = [false; 2];
                for (at, chart) in &ends {
                    if junction.at.distance(*at) <= junction.reach {
                        let nearer =
                            usize::from(chart.distance(columns[1]) < chart.distance(columns[0]));
                        sides[nearer] = true;
                    }
                }
                if sides == [true; 2] {
                    if *DEBUG_WIRE {
                        eprintln!(
                            "PAVE seam e{} at {t:.6}: a junction at {:?} holds ends on both sides",
                            e.node.index(),
                            junction.at
                        );
                    }
                    paves.entry(e.node).or_default().push(Pave {
                        t,
                        honesty: gap,
                        across: None,
                        spread: 0.0,
                    });
                }
            }
        }
    }
    Ok(())
}

/// Junctions whose balls overlap, merged transitively into one junction
/// each: at the members' centroid, reaching as far as the farthest member's
/// own reach extends from it.
fn merge_junctions(junctions: Vec<Junction>) -> Vec<Junction> {
    let n = junctions.len();
    let mut parent: Vec<usize> = (0..n).collect();
    fn root(parent: &mut [usize], mut i: usize) -> usize {
        while parent[i] != i {
            parent[i] = parent[parent[i]];
            i = parent[i];
        }
        i
    }
    // Swept along x: two balls overlap only if their centres are within
    // both reaches along every axis, so each junction is asked only of those
    // ahead of it by no more than its reach and the widest. The groups are
    // the same as asking every pair, which for the tens of thousands of
    // junctions a converted part carries costs seconds.
    let widest = junctions.iter().map(|j| j.reach).fold(0.0_f64, f64::max);
    let mut order: Vec<usize> = (0..n).collect();
    order.sort_by(|&x, &y| junctions[x].at.x.total_cmp(&junctions[y].at.x));
    for (k, &i) in order.iter().enumerate() {
        let limit = junctions[i].at.x + junctions[i].reach + widest;
        for &j in &order[k + 1..] {
            if junctions[j].at.x > limit {
                break;
            }
            if junctions[i].at.distance(junctions[j].at) <= junctions[i].reach + junctions[j].reach
            {
                let (ri, rj) = (root(&mut parent, i), root(&mut parent, j));
                if ri != rj {
                    parent[rj] = ri;
                }
            }
        }
    }
    let mut groups: Vec<Vec<usize>> = Vec::new();
    let mut of_root: Vec<Option<usize>> = vec![None; n];
    for i in 0..n {
        let r = root(&mut parent, i);
        match of_root[r] {
            Some(g) => groups[g].push(i),
            None => {
                of_root[r] = Some(groups.len());
                groups.push(vec![i]);
            }
        }
    }
    // A group is one junction only while it stays a junction's size: a
    // chain of overlapping balls along an edge would otherwise merge into
    // one reaching the chain's length, and the rebuild would weld the edge
    // into a point. A group reaching beyond four of its widest member stays
    // as it was.
    let mut out = Vec::with_capacity(groups.len());
    for members in groups {
        if members.len() == 1 {
            out.push(junctions[members[0]]);
            continue;
        }
        let mut sum = ogeom_math::Vector::ZERO;
        for &m in &members {
            sum += junctions[m].at - Point::ORIGIN;
        }
        #[allow(clippy::cast_precision_loss)]
        let at = Point::ORIGIN + sum / (members.len() as f64);
        let reach = members
            .iter()
            .map(|&m| at.distance(junctions[m].at) + junctions[m].reach)
            .fold(0.0_f64, f64::max);
        let widest = members
            .iter()
            .map(|&m| junctions[m].reach)
            .fold(0.0_f64, f64::max);
        if reach > widest * 4.0 {
            out.extend(members.iter().map(|&m| junctions[m]));
        } else {
            out.push(Junction {
                at,
                reach,
                onto_vertex: members.iter().any(|&m| junctions[m].onto_vertex),
            });
        }
    }
    out
}

/// The junctions the paves describe more than once, or more loosely than
/// the edge itself, per edge in face order.
fn pave_junctions(
    ga: &GSolid,
    gb: &GSolid,
    paves: &ogeom_core::FastMap<EdgeKey, Vec<Pave>>,
    along: &AlongEdges,
    tol: Tolerances,
) -> OgeomResult<Vec<Junction>> {
    let mut seen: ogeom_core::FastSet<EdgeKey> = ogeom_core::FastSet::default();
    let mut junctions = Vec::new();
    for e in ga
        .faces
        .iter()
        .chain(gb.faces.iter())
        .flat_map(|f| f.edges.iter())
    {
        if !seen.insert(e.node) {
            continue;
        }
        let Some(ts) = paves.get(&e.node) else {
            continue;
        };
        // A tolerant edge (a merged facet group's boundary, a fitted rail)
        // is met by a section up to its own radius off it, so the section's
        // end and the edge's split point are one junction that far apart,
        // on either side of the edge.
        let tolerant = e.tolerance > tol.confusion() * 1e2;
        let floor = if tolerant {
            e.tolerance * 2.0
        } else {
            e.tolerance
        }
        .max(tol.confusion() * 10.0);
        let off = |face, p| off_face(ga, gb, face, p, tol);
        let along = along.get(&e.node).map_or(&[][..], Vec::as_slice);
        for cluster in cluster_paves(&e.curve, e.crange, e.tolerance, ts, Some(&off), along, tol)? {
            if cluster.members > 1 || cluster.honesty > tol.confusion() * 1e2 || tolerant {
                junctions.push(Junction {
                    at: cluster.at,
                    reach: cluster.span + cluster.honesty.max(floor),
                    onto_vertex: false,
                });
            }
        }
    }
    Ok(junctions)
}

/// How long an edge of a face left alone must be: a shorter one may be
/// dust some other chart collapses, which only the face's own split finds.
const QUIET_EDGE: f64 = 1e-2;

/// The one piece of a face the other solid leaves alone: its own wires as
/// rings, its state read at the middle of one of its edges, which no
/// section touches and which therefore stands inside the other solid or
/// out of it with the whole face, or [`PieceState::Unread`] where there is no
/// `boundary` to read it against. `None` where that edge reads on the other
/// boundary after all, or a wire's edge is not one the face was gathered
/// with.
fn quiet_piece(
    model: &Model,
    from_a: bool,
    fi: usize,
    face: &GFace,
    boundary: Option<&ogeom_algo::SolidBoundary>,
    tol: Tolerances,
) -> OgeomResult<Option<FacePiece>> {
    let forward = face.face.oriented(ogeom_topo::Orientation::Forward);
    // A face with many holes is looked up by key, not walked once per edge.
    let indexed: Option<ogeom_core::FastMap<EdgeKey, usize>> = (face.edges.len() > 16).then(|| {
        let mut first =
            ogeom_core::FastMap::with_capacity_and_hasher(face.edges.len(), Default::default());
        for (index, e) in face.edges.iter().enumerate() {
            first.entry(e.node).or_insert(index);
        }
        first
    });
    let aside: ogeom_core::FastSet<ogeom_topo::TShapeId> = face
        .holes_aside
        .iter()
        .map(|hole| hole.wire.node())
        .collect();
    let mut rings = Vec::new();
    for wire in model.ordered_children_of(&forward)? {
        if aside.contains(&wire.node()) {
            continue;
        }
        let mut ring = Vec::new();
        for edge in model.ordered_children_of(&wire)? {
            let key = EdgeKey::of(&edge);
            if face.slits.contains(&key) {
                continue;
            }
            let found = match &indexed {
                Some(first) => first.get(&key).copied(),
                None => face.edges.iter().position(|e| e.node == key),
            };
            let Some(index) = found else {
                return Ok(None);
            };
            ring.push(Traversal {
                tag: Tag::Boundary {
                    edge: index,
                    range: face.edges[index].crange,
                },
                reversed: edge.orientation() == ogeom_topo::Orientation::Reversed,
                nodes: None,
            });
        }
        rings.push(ring);
    }
    let Some(e) = face.edges.first() else {
        return Ok(None);
    };
    let probe = e
        .curve
        .point_at(f64::midpoint(e.crange.0, e.crange.1), tol)?;
    let Some(boundary) = boundary else {
        return Ok(Some(FacePiece {
            from_a,
            face: fi,
            rings,
            outlines: Vec::new(),
            probe,
            state: PieceState::Unread,
            covered: false,
            whole: true,
        }));
    };
    let state = match boundary.holds(model, probe, tol) {
        Ok(Containment::In) => PieceState::In,
        Ok(Containment::Out) => PieceState::Out,
        Ok(Containment::On) | Err(ogeom_core::OgeomError::NotDone(_)) => return Ok(None),
        Err(e) => return Err(e),
    };
    Ok(Some(FacePiece {
        from_a,
        face: fi,
        rings,
        outlines: Vec::new(),
        probe,
        state,
        covered: false,
        whole: true,
    }))
}

/// A face's strands with its lone holes taken out: the rest, the place of
/// each among all of them, and the holes, each walked alone.
type Apart = (Vec<Strand<Tag>>, Vec<usize>, Vec<arrange::Lone<Tag>>);

/// The holes of a planar face whose strands stand apart from every other
/// strand, each walked alone (see [`arrange::Lone`]), with the rest of the
/// strands and their places among all of them; `None` where no hole does.
///
/// A hole stands apart when no strand of another wire ends within a few
/// snaps of its box, no section, contact or pole strand's box comes that
/// near it, and its box lies inside the outer wire's.
fn lone_holes(
    model: &Model,
    face: &GFace,
    strands: &[Strand<Tag>],
    snap: f64,
) -> OgeomResult<Option<Apart>> {
    // Fewer strands than this are walked together for no cost worth
    // sparing.
    const FEW: usize = 64;
    if strands.len() < FEW
        || !matches!(face.surface, SurfaceGeometry::Plane(_))
        || !face.poles.is_empty()
    {
        return Ok(None);
    }
    // Each edge's wire, `None` for an edge in no wire or in two.
    let index: ogeom_core::FastMap<EdgeKey, usize> = face
        .edges
        .iter()
        .enumerate()
        .map(|(i, e)| (e.node, i))
        .collect();
    let mut wire_of: Vec<Option<Option<usize>>> = vec![None; face.edges.len()];
    let wires = model.ordered_children_of(&face.face.oriented(ogeom_topo::Orientation::Forward))?;
    for (w, wire) in wires.iter().enumerate() {
        for edge in model.ordered_children_of(wire)? {
            if let Some(&i) = index.get(&EdgeKey::of(&edge)) {
                wire_of[i] = match wire_of[i] {
                    None => Some(Some(w)),
                    Some(_) => Some(None),
                };
            }
        }
    }
    let strand_wire: Vec<Option<usize>> = strands
        .iter()
        .map(|st| match st.tag {
            Tag::Boundary { edge, .. } if st.boundary => {
                wire_of.get(edge).copied().flatten().flatten()
            }
            _ => None,
        })
        .collect();
    let mut by_wire: Vec<Vec<usize>> = vec![Vec::new(); wires.len()];
    for (k, w) in strand_wire.iter().enumerate() {
        if let Some(w) = w {
            by_wire[*w].push(k);
        }
    }
    let boxed = |ks: &[usize]| -> (Point2, Point2) {
        let mut lo = Point2::new(f64::INFINITY, f64::INFINITY);
        let mut hi = Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);
        for &k in ks {
            for p in &strands[k].polyline {
                lo = Point2::new(lo.x.min(p.x), lo.y.min(p.y));
                hi = Point2::new(hi.x.max(p.x), hi.y.max(p.y));
            }
        }
        (lo, hi)
    };
    let Some(outer) = by_wire.first().filter(|ks| !ks.is_empty()) else {
        return Ok(None);
    };
    let (outer_lo, outer_hi) = boxed(outer);
    // Every strand end, by abscissa; and the box of every strand no wire
    // owns.
    let mut ends: Vec<(f64, f64, usize)> = Vec::with_capacity(strands.len() * 2);
    let mut loose: Vec<(Point2, Point2)> = Vec::new();
    for (k, st) in strands.iter().enumerate() {
        for p in [st.polyline.first(), st.polyline.last()]
            .into_iter()
            .flatten()
        {
            ends.push((p.x, p.y, k));
        }
        if strand_wire[k].is_none() {
            loose.push(boxed(&[k]));
        }
    }
    ends.sort_by(|a, b| a.0.total_cmp(&b.0));
    let margin = snap * 4.0;
    let mut lone = Vec::new();
    let mut taken = vec![false; strands.len()];
    for (w, ks) in by_wire.iter().enumerate().skip(1) {
        if ks.is_empty() {
            continue;
        }
        let (lo, hi) = boxed(ks);
        let (lo, hi) = (
            Point2::new(lo.x - margin, lo.y - margin),
            Point2::new(hi.x + margin, hi.y + margin),
        );
        if !(lo.x > outer_lo.x && lo.y > outer_lo.y && hi.x < outer_hi.x && hi.y < outer_hi.y) {
            continue;
        }
        let first = ends.partition_point(|e| e.0 < lo.x);
        let crowded = ends[first..]
            .iter()
            .take_while(|e| e.0 <= hi.x)
            .any(|&(_, y, k)| y >= lo.y && y <= hi.y && strand_wire[k] != Some(w));
        let crossed = loose
            .iter()
            .any(|(a, b)| a.x <= hi.x && b.x >= lo.x && a.y <= hi.y && b.y >= lo.y);
        if crowded || crossed {
            continue;
        }
        let mine: Vec<Strand<Tag>> = ks.iter().map(|&k| strands[k].clone()).collect();
        let Some(ring) = arrange::lone_ring(&mine, ks, snap) else {
            continue;
        };
        for &k in ks {
            taken[k] = true;
        }
        lone.push(ring);
    }
    if lone.is_empty() {
        return Ok(None);
    }
    let (rest, places): (Vec<Strand<Tag>>, Vec<usize>) = strands
        .iter()
        .enumerate()
        .filter(|(k, _)| !taken[*k])
        .map(|(k, st)| (st.clone(), k))
        .unzip();
    Ok(Some((rest, places, lone)))
}

/// The face's outward normal at a chart point: the surface's, flipped when
/// the face presents its other side.
fn outward_normal(face: &GFace, at: Point2, tol: Tolerances) -> OgeomResult<ogeom_math::Vector> {
    let n = face.surface.normal_at(at.x, at.y, tol)?.vector();
    Ok(
        if face.face.orientation() == ogeom_topo::Orientation::Reversed {
            -n
        } else {
            n
        },
    )
}

/// How far apart two of a face's edges may honestly end in its chart: the
/// loosest edge's tolerance, or the hug width where an edge is a fitted
/// section that once ran along another before parting from it.
fn outline_snap(face: &GFace, tol: Tolerances) -> f64 {
    face.edges
        .iter()
        .fold(tol.confusion() * 1e2, |acc, e| acc.max(e.tolerance * 2.0))
        .max(
            if face.edges.iter().any(|e| e.tolerance > tol.confusion()) {
                tol.confusion() * 1e3
            } else {
                0.0
            },
        )
}

/// Polyline ends sorted by their chart `x`, for finding the ends within a
/// reach of a point without comparing every pair.
struct EndsByX {
    /// Indices into the ends, by ascending `x`.
    order: Vec<usize>,
    xs: Vec<f64>,
}

impl EndsByX {
    fn new(ends: &[(usize, bool, Point2)]) -> Self {
        let mut order: Vec<usize> = (0..ends.len()).collect();
        order.sort_by(|&a, &b| ends[a].2.x.total_cmp(&ends[b].2.x));
        let xs = order.iter().map(|&k| ends[k].2.x).collect();
        Self { order, xs }
    }

    /// The ends whose `x` lies within `reach` of `p`'s, in ascending order
    /// of their index: a superset of the ends within `reach` of `p`.
    fn near(&self, p: Point2, reach: f64) -> Vec<usize> {
        let lo = self.xs.partition_point(|&x| x < p.x - reach);
        let hi = self.xs.partition_point(|&x| x <= p.x + reach);
        let mut out = self.order[lo..hi.max(lo)].to_vec();
        out.sort_unstable();
        out
    }
}

/// Join the outline's ends the weld left apart, each to the unmatched end
/// nearest it where that end is nearest it too and the opening is small
/// against the outline.
///
/// The topology says a face's boundary closes. Where two edges' pcurves end
/// further apart in the chart than their tolerances reach (a fitted blend
/// edge meeting a column on a narrow torus wedge, a pole's row with no edge
/// along it), a ray cast for containment passes through the opening, counts
/// one crossing, and a point level with it reads inside. A short segment
/// across each opening closes the outline as the topology does.
fn bridge_outline_gaps(lines: &mut Vec<Vec<Point2>>) {
    let ends: Vec<(usize, bool, Point2)> = lines
        .iter()
        .enumerate()
        .filter(|(_, line)| line.len() >= 2)
        .flat_map(|(i, line)| [(i, false, line[0]), (i, true, line[line.len() - 1])])
        .collect();
    // Ends that meet within the parametric snap but not exactly are joined
    // where they stand: the weld leaves them, since moving one by rounding
    // noise takes a probe on a seam off it, but a ray level with the sliver
    // between them still slips through.
    let by_x = EndsByX::new(&ends);
    let mut joins: Vec<Vec<Point2>> = Vec::new();
    for (k, &(i, end_i, p)) in ends.iter().enumerate() {
        for m in by_x.near(p, PARAM_SNAP) {
            let (j, end_j, q) = ends[m];
            let d = p.distance(q);
            if m > k && (j, end_j) != (i, end_i) && d > 0.0 && d <= PARAM_SNAP {
                joins.push(vec![p, q]);
            }
        }
    }
    let open: Vec<Point2> = ends
        .iter()
        .filter(|&&(i, end_i, p)| {
            !by_x.near(p, PARAM_SNAP).into_iter().any(|m| {
                let (j, end_j, q) = ends[m];
                (j, end_j) != (i, end_i) && p.distance(q) <= PARAM_SNAP
            })
        })
        .map(|&(_, _, p)| p)
        .collect();
    // Only an opening small against the outline itself: a pole's row
    // spans the chart and is the pole's to bound, not a gap.
    let (mut lo, mut hi) = (
        Point2::new(f64::INFINITY, f64::INFINITY),
        Point2::new(f64::NEG_INFINITY, f64::NEG_INFINITY),
    );
    for p in lines.iter().flatten() {
        lo = Point2::new(lo.x.min(p.x), lo.y.min(p.y));
        hi = Point2::new(hi.x.max(p.x), hi.y.max(p.y));
    }
    let reach = lo.distance(hi) * 1e-3;
    let nearest = |k: usize| {
        (0..open.len()).filter(|&m| m != k).min_by(|&a, &b| {
            open[k]
                .distance(open[a])
                .total_cmp(&open[k].distance(open[b]))
        })
    };
    for k in 0..open.len() {
        if let Some(m) = nearest(k)
            && k < m
            && nearest(m) == Some(k)
            && open[k].distance(open[m]) <= reach
        {
            lines.push(vec![open[k], open[m]]);
        }
    }
    lines.extend(joins);
}

/// Close the gaps between a face's outline polylines.
///
/// The edges are polylined one by one, and where two of them meet at a
/// vertex that owns some tolerance (a fitted section's end welded to the
/// edge it hugged, a few dozen microns off), their polylines stop that far
/// apart. A ray cast for containment slips through such a gap, and a probe
/// standing inside the face within a hug's width of the seam reads as
/// outside. Ends within the face's snap ([`outline_snap`]) of another
/// edge's end are made one point, so the outline is closed exactly as the
/// topology says it is.
///
/// The snap is a length in space, and so is every gap it is held against:
/// two ends meet only where their points on the surface do too. A chart
/// stretched along one direction (a wall a micron tall charted over a
/// tenth of a unit) holds a whole edge within a chart distance the snap
/// would read as a gap. Nor does the weld reach as far as half the face's
/// shortest edge, measured the same way: the two ends of that edge would
/// then read as one point, and the outline would close over nothing. Two
/// ends of one edge are never joined.
fn weld_outline_ends(lines: &mut [Vec<Point2>], face: &GFace, tol: Tolerances) {
    let snap = outline_snap(face, tol);
    if snap <= 0.0 {
        return;
    }
    // Which edge drew each line: a seam draws two, one per column.
    let owner: Vec<usize> = face
        .edges
        .iter()
        .enumerate()
        .flat_map(|(i, e)| std::iter::repeat_n(i, 1 + usize::from(e.other_side.is_some())))
        .collect();
    if owner.len() != lines.len() {
        return;
    }
    let lift = |p: Point2| face.surface.point_at(p.x, p.y, tol).ok();
    // How far apart in space two ends may be welded: the snap, and no
    // further than half the face's shortest edge there. A line with no
    // length in space (a pole's or an apex's row) has no ends to tell
    // apart.
    let mut within = snap;
    for line in lines.iter() {
        let points: Vec<Point> = line.iter().filter_map(|p| lift(*p)).collect();
        let length: f64 = points.windows(2).map(|w| w[0].distance(w[1])).sum();
        if points.len() == line.len() && length > tol.confusion() {
            within = within.min(length / 2.0);
        }
    }
    // Every polyline end, as (line, is its last point, where), and its
    // point on the surface.
    let ends: Vec<(usize, bool, Point2)> = lines
        .iter()
        .enumerate()
        .flat_map(|(i, line)| {
            let first = line.first().map(|p| (i, false, *p));
            let last = line.last().map(|p| (i, true, *p));
            first.into_iter().chain(last)
        })
        .collect();
    let lifted: Vec<Option<Point>> = ends.iter().map(|&(_, _, p)| lift(p)).collect();
    // Each end moves onto the nearest other end within reach that sorts
    // before it, so a matched pair lands on one point rather than trading
    // places. Within reach in the chart, as a gap the snap is read across
    // there, and on the surface.
    let by_x = EndsByX::new(&ends);
    let mut moves: Vec<(usize, bool, Point2)> = Vec::new();
    for (k, &(i, end_i, p)) in ends.iter().enumerate() {
        let Some(at) = lifted[k] else {
            continue;
        };
        let nearest = by_x
            .near(p, snap)
            .into_iter()
            .filter_map(|m| {
                let (j, end_j, q) = ends[m];
                let d = p.distance(q);
                // Ends closer than the parametric snap already meet for
                // every purpose here, and moving one by rounding noise
                // takes a probe that stands exactly on a chart's seam off
                // it.
                if (j, end_j) >= (i, end_i) || owner[j] == owner[i] || d <= PARAM_SNAP || d > snap {
                    return None;
                }
                (lifted[m]?.distance(at) <= within).then_some((d, q))
            })
            .min_by(|a, b| a.0.total_cmp(&b.0));
        if let Some((_, q)) = nearest {
            moves.push((i, end_i, q));
        }
    }
    for (i, end_i, q) in moves {
        let slot = if end_i {
            lines[i].last_mut()
        } else {
            lines[i].first_mut()
        };
        if let Some(p) = slot {
            *p = q;
        }
    }
}

/// A curve's length and the diagonal of the box its points span, both from
/// the same 64 samples: a trace lapping one place many times is far longer
/// than its box, and a loop is about a turn round it.
fn length_and_reach(curve: &Curve, tol: Tolerances) -> OgeomResult<(f64, f64)> {
    use ogeom_geom::Curve3d as _;
    let (lo, hi) = curve.domain();
    let mut length = 0.0_f64;
    let mut last: Option<Point> = None;
    let mut span = ogeom_math::Aabb::default();
    for k in 0..=64 {
        let t = if k == 64 {
            hi
        } else {
            lo + (hi - lo) * f64::from(k) / 64.0
        };
        let p = curve.point_at(t, tol)?;
        if let Some(q) = last {
            length += q.distance(p);
        }
        last = Some(p);
        span = span.with_point(p);
    }
    Ok((length, span.diagonal()))
}

/// Whether a point a face's surface holds to within `margin` lies inside
/// the face's trim, or within `margin` of its boundary as the face draws it.
fn within_face(face: &GFace, p: Point, margin: f64, tol: Tolerances) -> OgeomResult<bool> {
    if chart_point_within(face, p, margin.max(tol.confusion() * 1e2), tol).is_some() {
        return Ok(true);
    }
    for e in &face.edges {
        if !e.bound.expanded(margin).contains(p) {
            continue;
        }
        let (drawn, drange, _) = e.drawn();
        if distance_to_edge_curve(drawn, drange, p, tol)? <= margin {
            return Ok(true);
        }
    }
    Ok(false)
}

/// Where a point sits in a face's chart, for a point up to `reach` off the
/// face's surface and inside its trim. `None` elsewhere.
fn chart_point_within(face: &GFace, p: Point, reach: f64, tol: Tolerances) -> Option<Point2> {
    // Closed-form inversion for the analytic surfaces: the same-domain
    // resolution asks "where does this probe sit in the partner's chart", and
    // the partner may be any surface a face melts along: a plane against a
    // plane, but equally a wall band against the cylinder it copies. The
    // reach check keeps the answer honest: a point off the surface has no
    // chart position, whatever the inversion returns.
    use ogeom_math::elementary;
    let raw = match &face.surface {
        SurfaceGeometry::Plane(x) => {
            let local = x.plane().frame().to_local(p);
            if local.z.abs() > reach {
                return None;
            }
            Point2::new(local.x, local.y)
        }
        SurfaceGeometry::Cylinder(x) => {
            let cylinder = x.cylinder();
            if cylinder.distance_to(p) > reach {
                return None;
            }
            let (u, v) = elementary::cylinder_parameters(&cylinder, p, tol).ok()?;
            Point2::new(u, v)
        }
        SurfaceGeometry::Cone(x) => {
            let cone = x.cone();
            if cone.distance_to(p) > reach {
                return None;
            }
            let (u, v) = elementary::cone_parameters(&cone, p, tol).ok()?;
            Point2::new(u, v)
        }
        SurfaceGeometry::Sphere(x) => {
            let sphere = x.sphere();
            if sphere.distance_to(p) > reach {
                return None;
            }
            let (u, v) = elementary::sphere_parameters(&sphere, p, tol).ok()?;
            Point2::new(u, v)
        }
        SurfaceGeometry::Torus(x) => {
            let torus = x.torus();
            if torus.distance_to(p) > reach {
                return None;
            }
            let (u, v) = elementary::torus_parameters(&torus, p, tol).ok()?;
            Point2::new(u, v)
        }
        // No closed form (a fitted patch, a swept or revolved surface)
        // inverts by projection, held to the same reach: a blend's leg on
        // a spline host is a partner like any other.
        other => {
            let foot = ogeom_algo::project_on_surface(other, p, 24, tol).ok()?;
            if foot.distance > reach {
                return None;
            }
            Point2::new(foot.parameters.0, foot.parameters.1)
        }
    };
    let at = fold_point_into_chart(raw, &face.surface, tol);
    let lines = face.outline(tol)?;
    let trim = face.outline_trim(tol)?;
    // The face's boundary polylines are unwrapped (a winding ring may span
    // any one period's window, not necessarily the chart's canonical one,
    // and a wire chained onto one branch of the chart may sit whole periods
    // away from it), so the probe is carried to the outline's own branch
    // first, and asked at the neighbouring images as well.
    let mut shifts = vec![0.0];
    if face.surface.is_periodic_u() {
        let ((ua, ub), _) = face.surface.domain();
        if ub > ua {
            let period = ub - ua;
            let (sum, count) = lines
                .iter()
                .flatten()
                .fold((0.0_f64, 0_usize), |(s, n), q| (s + q.x, n + 1));
            #[allow(clippy::cast_precision_loss)]
            let centre = if count > 0 { sum / count as f64 } else { at.x };
            let home = ((centre - at.x) / period).round() * period;
            shifts = vec![home, home + period, home - period];
        }
    }
    for shift in shifts {
        let shifted = Point2::new(at.x + shift, at.y);
        if trim.inside(shifted) {
            return Some(shifted);
        }
    }
    None
}

/// Whether `p`, on the face's surface, stands inside the face, read at
/// the face's edge nearest it: where the nearest point of the boundary is
/// inside an edge, `p` stands off it square to it, and is inside just
/// where it stands on the side the face keeps its material on, the left
/// of the edge as the face walks it about its outward normal. `None`
/// where the nearest point is an edge's end (a corner reads both sides),
/// a seam's, or within the edge's own radius of it.
fn inside_beside_edge(face: &GFace, p: Point, tol: Tolerances) -> OgeomResult<Option<bool>> {
    let mut nearest: Option<(f64, usize, f64)> = None;
    for (k, e) in face.edges.iter().enumerate() {
        let (off, t) = nearest_on_edge_curve(&e.curve, e.crange, p, tol)?;
        if nearest.is_none_or(|n| off < n.0) {
            nearest = Some((off, k, t));
        }
    }
    let Some((off, k, t)) = nearest else {
        return Ok(None);
    };
    let e = &face.edges[k];
    let (lo, hi) = (e.crange.0.min(e.crange.1), e.crange.0.max(e.crange.1));
    let Some(forward) = e.walked else {
        return Ok(None);
    };
    if off <= e.tolerance.max(tol.confusion())
        || t <= lo + tol.parametric()
        || t >= hi - tol.parametric()
    {
        return Ok(None);
    }
    let at = e.pcurve.point_at(rescale(t, e.crange, e.prange), tol)?;
    let tangent = e.curve.d1_at(t, tol)?;
    let walked = if forward { tangent } else { -tangent };
    let left = outward_normal(face, at, tol)?.cross(walked);
    Ok(Some((p - e.curve.point_at(t, tol)?).dot(left) > 0.0))
}

/// What the strands bounding a piece say of it, where its probes cannot.
enum Thin {
    /// The piece is no thinner than the band, or not planar: its probes
    /// stand.
    Wide,
    /// Thin, but some strand bounding it says nothing.
    Undecided,
    /// Thin, and every strand the other solid draws round it agrees.
    Reads(PieceState),
    /// Thin, and the strands disagree.
    Disagree,
}

/// A thin planar piece read by the other solid's edges it is bounded by.
///
/// A piece whose area is at most the classification band times half its
/// perimeter is on average narrower than the band, and no probe of it can
/// stand outside the band: each reads it on the other solid's boundary. A
/// strand that is the image of the other solid's edge `E`, between its
/// faces `g` on this face's surface and `h`, separates "on `g`" from
/// "beyond `g`". Which side the piece lies on is the arrangement's: its
/// rings keep it on their left about the chart's normal, as `g` keeps its
/// material on the left of its own rings about its outward normal. Beyond
/// `g` the other solid's wedge at `E` answers: past a convex edge (where
/// `h` turns away behind `g`) the plane beyond `g` is outside it, past a
/// concave one inside. Neither answer depends on how thin the piece is.
///
/// Only contact strands speak: a piece a section bounds is left to its
/// probes, as is one beside an edge whose two faces run on tangentially,
/// one it lies on `g`'s side of (a coincidence, which the partner reads),
/// or one whose faces are not both gathered.
fn thin_by_strands(
    face: &GFace,
    rings: &[Vec<Traversal<Tag>>],
    outlines: &[Vec<Point2>],
    contacts: &[ContactRec],
    theirs: &GSolid,
    tol: Tolerances,
) -> OgeomResult<Thin> {
    if !matches!(face.surface, SurfaceGeometry::Plane(_)) {
        return Ok(Thin::Wide);
    }
    // A plane's chart is its own frame, so lengths and areas in it are
    // the plane's.
    let (mut area, mut perimeter) = (0.0, 0.0);
    for (k, ring) in outlines.iter().enumerate() {
        let n = ring.len();
        let mut twice = 0.0;
        for i in 0..n {
            let (a, b) = (ring[i], ring[(i + 1) % n]);
            twice += a.x * b.y - b.x * a.y;
            perimeter += (b - a).magnitude();
        }
        area += if k == 0 { twice.abs() } else { -twice.abs() } / 2.0;
    }
    if area > tol.confusion() * 1e4 * perimeter / 2.0 {
        return Ok(Thin::Wide);
    }
    let mut read: Option<PieceState> = None;
    let mut spoke = false;
    for traversal in rings.iter().flatten() {
        let (contact, range) = match &traversal.tag {
            Tag::Contact { contact, range } => (&contacts[*contact], *range),
            Tag::Section { .. } => return Ok(Thin::Undecided),
            Tag::Boundary { .. } | Tag::Pole { .. } => continue,
        };
        let Some(state) = beyond_edge(face, contact, range, traversal.reversed, theirs, tol)?
        else {
            return Ok(Thin::Undecided);
        };
        spoke = true;
        match read {
            Some(said) if said != state => return Ok(Thin::Disagree),
            _ => read = Some(state),
        }
    }
    Ok(match read {
        Some(state) if spoke => Thin::Reads(state),
        _ => Thin::Undecided,
    })
}

/// Where the piece on the left of the contact strand over `range`, walked
/// back where `reversed`, stands against the solid whose edge the contact
/// is: `None` where the strand says nothing (see [`thin_by_strands`]).
fn beyond_edge(
    face: &GFace,
    contact: &ContactRec,
    range: (f64, f64),
    reversed: bool,
    theirs: &GSolid,
    tol: Tolerances,
) -> OgeomResult<Option<PieceState>> {
    let t = f64::midpoint(range.0, range.1);
    let p = contact.curve.point_at(t, tol)?;
    let along = contact.curve.d1_at(t, tol)?;
    let walked = if (range.1 < range.0) != reversed {
        -along
    } else {
        along
    };
    let uv = contact
        .pcurve
        .point_at(rescale(t, contact.crange, contact.prange), tol)?;
    let chart = face.surface.normal_at(uv.x, uv.y, tol)?.vector();
    let Ok(left) = chart.cross(walked).normalized(tol) else {
        return Ok(None);
    };
    // The edge's two faces, each with the way into its material from the
    // edge and its outward normal there.
    let mut sides = Vec::with_capacity(2);
    for other in &theirs.faces {
        for e in other.edges.iter().filter(|e| e.node == contact.node) {
            let Some(forward) = e.walked else {
                return Ok(None);
            };
            let (_, te) = nearest_on_edge_curve(&e.curve, e.crange, p, tol)?;
            let at = e.pcurve.point_at(rescale(te, e.crange, e.prange), tol)?;
            let normal = outward_normal(other, at, tol)?;
            let tangent = e.curve.d1_at(te, tol)?;
            let tangent = if forward { tangent } else { -tangent };
            let Ok(into) = normal.cross(tangent).normalized(tol) else {
                return Ok(None);
            };
            let Ok(normal) = normal.normalized(tol) else {
                return Ok(None);
            };
            sides.push((into, normal));
        }
    }
    let [(into_a, normal_a), (into_b, normal_b)] = sides[..] else {
        return Ok(None);
    };
    // `g` is the face lying along this one: its way in runs along the
    // piece's, one way or the other.
    let along_this = |into: ogeom_math::Vector| into.cross(left).magnitude() < TANGENT_TURN;
    let ((into_g, normal_g), into_h) = match (along_this(into_a), along_this(into_b)) {
        (true, false) => ((into_a, normal_a), into_b),
        (false, true) => ((into_b, normal_b), into_a),
        _ => return Ok(None),
    };
    if into_g.dot(left) > 0.0 {
        return Ok(None);
    }
    let turn = into_h.dot(normal_g);
    if turn.abs() < TANGENT_TURN {
        return Ok(None);
    }
    Ok(Some(if turn < 0.0 {
        PieceState::Out
    } else {
        PieceState::In
    }))
}

/// The sine of the turn under which two curves meet tangentially at a
/// crossing: the parallel-noise gate for pave placement. One degree is far
/// below any deliberate crossing and far above the smear a tangency leaves
/// in the general intersector.
pub(crate) const TANGENT_TURN: f64 = 2e-2;

/// Whether two curves meet tangentially at a crossing: their tangents turn
/// by less than [`TANGENT_TURN`].
fn tangential(a: &Curve, ta: f64, b: &Curve, tb: f64, tol: Tolerances) -> OgeomResult<bool> {
    let da = a.d1_at(ta, tol)?;
    let db = b.d1_at(tb, tol)?;
    let (ma, mb) = (da.magnitude(), db.magnitude());
    if ma <= tol.confusion() || mb <= tol.confusion() {
        return Ok(true);
    }
    Ok(da.cross(db).magnitude() / (ma * mb) < TANGENT_TURN)
}

/// The chart image of an exact curve on a surface, fitted at the curve's
/// own parameters from its points inverted on the surface, with the
/// distance the image honestly sits off the curve, or nothing, when the
/// fit misses its budget by more than a chart's swing beside a pole allows.
fn fitted_image(
    curve: &Curve,
    surface: &SurfaceGeometry,
    budget: f64,
    tol: Tolerances,
) -> OgeomResult<Option<(PlanarCurve, f64)>> {
    use ogeom_geom::Surface as _;
    const SAMPLES: usize = 96;
    let (lo, hi) = curve.domain();
    if !hi.is_finite() || !lo.is_finite() || hi <= lo {
        return Ok(None);
    }
    let ((ua, ub), (va, vb)) = surface.domain();
    let periods = (
        if surface.is_periodic_u() {
            ub - ua
        } else {
            0.0
        },
        if surface.is_periodic_v() {
            vb - va
        } else {
            0.0
        },
    );
    // The image sampled where it moves: beside a pole a circle's image
    // swings half a turn within a hair of arc, and a uniform sampling puts
    // one point in the swing. Between any two samples whose images sit
    // further apart than a small step of the chart a sample is added, until
    // the image is walked at that step or the budget of samples is spent.
    let invert = |t: f64, guess: Option<(f64, f64)>| -> OgeomResult<Option<((f64, f64), f64)>> {
        let p = curve.point_at(t, tol)?;
        // A plane's image is its frame's own coordinates, exact and
        // unbounded: the face's chart window is a trim, not a limit on
        // where the curve may be read, and a projection clamped to it puts
        // the circle's far side off the surface by the window's shortfall.
        if let SurfaceGeometry::Plane(plane) = surface {
            let local = plane.plane().frame().to_local(p);
            let back = plane
                .plane()
                .frame()
                .to_world(ogeom_math::Point::new(local.x, local.y, 0.0));
            return Ok(Some(((local.x, local.y), back.distance(p))));
        }
        // A sphere's image is its frame's longitude and latitude, exact
        // where the projection's Newton cannot refine beside a pole and
        // hands back a coarse scan sample instead. The reading is checked
        // round the trip and left to the projection if the chart's
        // convention is not this one.
        if let SurfaceGeometry::Sphere(ball) = surface {
            let frame = ball.sphere().frame();
            let local = frame.to_local(p);
            let flat = local.x.hypot(local.y);
            // Kept a hair inside the poles: a spline fitted through points
            // on the pole itself overshoots it between them, and the chart
            // refuses a latitude past its end.
            let half = core::f64::consts::FRAC_PI_2 - 1e-6;
            let v = local.z.atan2(flat).clamp(-half, half);
            let u = local.y.atan2(local.x).rem_euclid(core::f64::consts::TAU);
            let back = surface.point_at(u, v, tol)?;
            if back.distance(p) <= budget.max(tol.confusion() * 1e2) {
                return Ok(Some(((u, v), back.distance(p))));
            }
        }
        // A cone's image is read in closed form too, past its window's ends:
        // an open conic it cuts is stated over a span that climbs beyond the
        // window, which the face trims, and a projection clamped to the
        // window puts those points off the surface.
        if let SurfaceGeometry::Cone(cone) = surface
            && let Ok((u, v)) = ogeom_math::elementary::cone_parameters(&cone.cone(), p, tol)
        {
            let back = ogeom_math::elementary::cone_at(&cone.cone(), u, v).point;
            if back.distance(p) <= budget.max(tol.confusion() * 1e2) {
                return Ok(Some(((u, v), back.distance(p))));
            }
        }
        let mut foot = match guess {
            Some(g) => ogeom_algo::project_on_surface_from(surface, p, g, tol)?,
            None => ogeom_algo::project_on_surface(surface, p, 24, tol)?,
        };
        if foot.distance > budget.max(tol.confusion() * 1e2) && guess.is_some() {
            foot = ogeom_algo::project_on_surface(surface, p, 48, tol)?;
        }
        if foot.distance > budget.max(tol.confusion() * 1e2) {
            if *DEBUG_WIRE {
                eprintln!(
                    "IMAGE FIT: a point sits {:.2e} off the surface; no image",
                    foot.distance
                );
            }
            return Ok(None);
        }
        Ok(Some((foot.parameters, foot.distance)))
    };
    let unwrap = |uv: (f64, f64), before: Option<Point2>| -> Point2 {
        let mut uv = Point2::new(uv.0, uv.1);
        if let Some(prev) = before {
            for (coord, period, before) in [
                (&mut uv.x, periods.0, prev.x),
                (&mut uv.y, periods.1, prev.y),
            ] {
                if period > 0.0 {
                    while *coord - before > period / 2.0 {
                        *coord -= period;
                    }
                    while before - *coord > period / 2.0 {
                        *coord += period;
                    }
                }
            }
        }
        uv
    };
    let mut samples: Vec<(f64, Point2)> = Vec::with_capacity(SAMPLES + 1);
    let mut guess: Option<(f64, f64)> = None;
    for k in 0..=SAMPLES {
        #[allow(clippy::cast_precision_loss)]
        let t = lo + (hi - lo) * (k as f64) / (SAMPLES as f64);
        let Some((uv, _)) = invert(t, guess)? else {
            return Ok(None);
        };
        guess = Some(uv);
        let before = samples.last().map(|(_, p)| *p);
        samples.push((t, unwrap(uv, before)));
    }
    let step = {
        let (su, sv) = (
            if periods.0 > 0.0 { periods.0 } else { ub - ua },
            if periods.1 > 0.0 { periods.1 } else { vb - va },
        );
        su.min(sv) * 0.01
    };
    const CAP: usize = 4096;
    let mut refined = true;
    while refined && samples.len() < CAP {
        refined = false;
        let mut next: Vec<(f64, Point2)> = Vec::with_capacity(samples.len() * 2);
        for pair in samples.windows(2) {
            let ((t0, p0), (t1, p1)) = (pair[0], pair[1]);
            next.push((t0, p0));
            if p0.distance(p1) > step && t1 - t0 > (hi - lo) * 1e-7 && next.len() < CAP {
                let tm = f64::midpoint(t0, t1);
                let Some((uv, _)) = invert(tm, Some((p0.x, p0.y)))? else {
                    return Ok(None);
                };
                next.push((tm, unwrap(uv, Some(p0))));
                refined = true;
            }
        }
        next.push(samples[samples.len() - 1]);
        samples = next;
    }
    let params: Vec<f64> = samples.iter().map(|(t, _)| *t).collect();
    let image: Vec<Point2> = samples.iter().map(|(_, p)| *p).collect();
    let fitted =
        ogeom_geom::fit::fit_points_2d_at(&params, &image, 3, tol.confusion() * 10.0, tol)?;
    let planar: PlanarCurve = fitted.curve.into();
    // The honest error is in space: the surface read through the image
    // against the curve itself, between the samples as well as at them.
    // Checked at the samples and between each pair of them: where the
    // image swings the samples are dense, and a uniform check would step
    // over the swing and read the fit as honest.
    // An image that leaves the chart between its samples (a spline
    // overshooting the pole it was fitted up to) is no image either.
    let mut off = 0.0_f64;
    let mut checks: Vec<f64> = Vec::with_capacity(params.len() * 2);
    for pair in params.windows(2) {
        checks.push(pair[0]);
        checks.push(f64::midpoint(pair[0], pair[1]));
    }
    if let Some(&t) = params.last() {
        checks.push(t);
    }
    // A cone is read past its window's ends, as its points were inverted.
    // So is a cylinder where its window refuses the point: a circle a
    // rounding off square to the axis climbs a hair past the wall's end
    // round half its turn, and the fit through points held at that end
    // follows it there.
    let lift = |u: f64, v: f64| match surface {
        SurfaceGeometry::Cone(cone) => {
            Ok(ogeom_math::elementary::cone_at(&cone.cone(), u, v).point)
        }
        SurfaceGeometry::Cylinder(drum) => surface
            .point_at(u, v, tol)
            .or_else(|_| Ok(ogeom_math::elementary::cylinder_at(&drum.cylinder(), u, v).point)),
        _ => surface.point_at(u, v, tol),
    };
    for t in checks {
        let uv = planar.point_at(t, tol)?;
        let Ok(on_surface) = lift(uv.x, uv.y) else {
            if *DEBUG_WIRE {
                eprintln!("IMAGE FIT: the image leaves the chart at {uv:?}; no image");
            }
            return Ok(None);
        };
        off = off.max(on_surface.distance(curve.point_at(t, tol)?));
    }
    if *DEBUG_WIRE {
        eprintln!(
            "IMAGE FIT: image off the curve by {off:.2e} against {:.2e} (fit error {:.2e} met {})",
            budget.max(tol.confusion() * 1e3),
            fitted.error,
            fitted.met
        );
    }
    if off > budget.max(tol.confusion() * 1e3) {
        return Ok(None);
    }
    Ok(Some((planar, off)))
}

/// The distance from a point to a bounded edge curve, through a sampling
/// fine enough for the along-boundary question it answers.
fn distance_to_edge_curve(
    curve: &Curve,
    crange: (f64, f64),
    p: Point,
    tol: Tolerances,
) -> OgeomResult<f64> {
    Ok(nearest_on_edge_curve(curve, crange, p, tol)?.0)
}

/// [`distance_to_edge_curve`], with the parameter of the nearest point.
fn nearest_on_edge_curve(
    curve: &Curve,
    crange: (f64, f64),
    p: Point,
    tol: Tolerances,
) -> OgeomResult<(f64, f64)> {
    // Coarse bracket, then two rounds of local refinement: the answer feeds
    // the hug filters, whose widths are fractions of a millimetre, and a
    // long arc's 48-segment polyline sags by more than that on its own.
    let scan = |lo: f64, hi: f64, steps: u32| -> OgeomResult<(f64, f64)> {
        let mut best = f64::INFINITY;
        let mut best_t = lo;
        let mut previous: Option<(f64, Point)> = None;
        for i in 0..=steps {
            let t = lo + (hi - lo) * f64::from(i) / f64::from(steps);
            let at = curve.point_at(t, tol)?;
            if let Some((t0, last)) = previous {
                let d = at - last;
                let len2 = d.dot(d);
                let s = if len2 > 0.0 {
                    ((p - last).dot(d) / len2).clamp(0.0, 1.0)
                } else {
                    0.0
                };
                let dist = p.distance(last + d * s);
                if dist < best {
                    best = dist;
                    best_t = (t - t0).mul_add(s, t0);
                }
            }
            previous = Some((t, at));
        }
        Ok((best, best_t))
    };
    let span = crange.1 - crange.0;
    let (_, t1) = scan(crange.0, crange.1, 48)?;
    let step = span / 48.0;
    let (_, t2) = scan((t1 - step).max(crange.0), (t1 + step).min(crange.1), 16)?;
    let fine = span / (48.0 * 8.0);
    scan((t2 - fine).max(crange.0), (t2 + fine).min(crange.1), 16)
}

/// Pair up the pieces two coincident faces contribute for the same patch of
/// one surface, and mark the second argument's copy as stood in for where
/// the material is on the same side.
///
/// Returns each pair, first argument's piece first, the opposed ones
/// included: whichever of the two the operation drops, its face is recorded
/// as having become the one it keeps.
///
/// The substitution is by *region*, not by argument: a piece of `b` is a
/// duplicate exactly where a piece of `a`, on the same side and on a surface
/// they share, already covers the point `b`'s piece was classified at. Where
/// `a` has nothing there (a bore refilled by the cylinder that cut it, whose
/// caps fill holes the part no longer has faces for), nothing stands in, and
/// `b`'s piece is the only description of that patch there is.
fn mark_covered_coincidences(
    ga: &GSolid,
    gb: &GSolid,
    pieces: &mut [FacePiece],
    tol: Tolerances,
) -> Vec<(usize, usize)> {
    let on = |state: PieceState| matches!(state, PieceState::OnAligned | PieceState::OnOpposed);
    // Which pieces of the first argument stand on a shared surface.
    let from_a: Vec<(usize, usize, PieceState)> = pieces
        .iter()
        .enumerate()
        .filter(|(_, p)| p.from_a && on(p.state))
        .map(|(i, p)| (i, p.face, p.state))
        .collect();
    if from_a.is_empty() {
        return Vec::new();
    }
    let mut pairs: Vec<(usize, usize)> = Vec::new();
    for (index, piece) in pieces.iter().enumerate() {
        if piece.from_a || !on(piece.state) {
            continue;
        }
        for &(other, face_a, state) in &from_a {
            if state != piece.state {
                continue;
            }
            let host = &ga.faces[face_a];
            // The point `b`'s piece stands at, read in `a`'s face's chart,
            // as far off it as the two faces say they may stand. A point
            // that is not on that surface at all has no chart position.
            let reach = partner_reach(&gb.faces[piece.face], host, tol);
            let Some(at) = chart_point_within(host, piece.probe, reach, tol) else {
                continue;
            };
            // The host piece's rings, not its boundary strands: a ring is a
            // closed loop whose last point does not repeat its first, so the
            // test has to close it. Asked as though the rings were strands
            // that jointly close, the segment from the ring's end back to its
            // start goes uncounted, and a point the ring plainly encloses
            // comes back outside whenever that missing segment would have
            // been crossed.
            if inside_rings(&pieces[other].outlines, at) {
                pairs.push((other, index));
                break;
            }
        }
    }
    for &(_, index) in &pairs {
        if pieces[index].state == PieceState::OnAligned {
            pieces[index].covered = true;
        }
    }
    pairs
}

/// The face-bound filter's audit: admit every pair, and name any the filter
/// would have dropped that then produces a record. A conservative filter is
/// a correctness precondition (a pair wrongly dropped is absorbed by the
/// empty-result fallback, and would be a wrong solid if that fallback came
/// up empty too), and this is the check that makes the precondition
/// falsifiable. Costs one branch per pair when off.
static AUDIT_BOUNDS: std::sync::LazyLock<bool> =
    std::sync::LazyLock::new(|| std::env::var("OGEOM_BOOL_AUDIT_BOUNDS").is_ok());
/// The debug dumps, read once rather than once per face: `env::var` takes a
/// process-wide lock and allocates, and a large model asks thousands of
/// times to be told no.
static DEBUG_WIRE: std::sync::LazyLock<bool> =
    std::sync::LazyLock::new(|| std::env::var("OGEOM_DEBUG_WIRE").is_ok());
static DEBUG_STRANDS: std::sync::LazyLock<bool> =
    std::sync::LazyLock::new(|| std::env::var("OGEOM_DEBUG_STRANDS").is_ok());
thread_local! {
    /// Whether a piece read on the other solid's boundary, with no coincident
    /// partner, is settled by asking just off it on both sides. Off on the
    /// first attempt, so a configuration the nested fallback answers exactly
    /// keeps that answer. On for the second. Read once per boolean on the
    /// calling thread.
    static SETTLE_FROM_BOTH_SIDES: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    /// Whether a piece that reads in or out is read again at the centre of
    /// its area. Off but for the attempt after kept pieces fail to close.
    /// Read once per boolean on the calling thread.
    static PROBE_AT_CENTRE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    /// The farthest apart a contact and a boundary edge it was read along
    /// stand, where that is past what either edge states: the paving takes
    /// the two for one edge and splits neither face along them, so only the
    /// sew can join them. Zero where every such pair lies within its stated
    /// tolerances. Gathered by the attempts since [`settled`] began.
    static ALONG_APART: std::cell::Cell<f64> = const { std::cell::Cell::new(0.0) };
    /// The gap the kept pieces are sewn across: zero but for the attempt
    /// [`settled`] makes last, across the distance [`ALONG_APART`] measured.
    /// Read once per assembly on the calling thread.
    static SEW_ACROSS: std::cell::Cell<f64> = const { std::cell::Cell::new(0.0) };
    /// Whether contacts are read at the radii their curves hold to (see
    /// [`settled`]). Off but for the last attempt. Read once per boolean
    /// on the calling thread.
    static AT_STATED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    /// Which edges a section line also ends where it crosses, for the edges
    /// it carries onto the other face (see [`graze_contacts`]). Off but for
    /// the retries run again once every other has refused a piece read on
    /// the other solid's boundary. Read once per boolean on the calling
    /// thread.
    static FROM_CROSSINGS: std::cell::Cell<Crossings> = const { std::cell::Cell::new(Crossings::Off) };
    /// The farthest apart two faces may stand and still be dropped as a
    /// membrane (see [`without_membranes`]), whatever weld the attempt
    /// itself runs at: during the retries at a widened confusion, the weld
    /// their result is held to, and unbounded otherwise. A shell dropped
    /// whole leaves no edge or vertex behind to state how far apart its
    /// faces stood. Read once per assembly on the calling thread.
    static MEMBRANE_WITHIN: std::cell::Cell<f64> = const { std::cell::Cell::new(f64::INFINITY) };
    /// Whether a plane's section with an extrusion of a B-spline profile
    /// crossing a rim of it is split at the rim in closed form
    /// ([`ogeom_intersect::plane_extrusion_at_rims`]) rather than marched.
    /// Off but for the retries [`settled`] runs once every other has
    /// refused. Read once per assembly on the calling thread.
    static AT_RIMS: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    /// Whether an assembly since [`settled`] began met such a pair with
    /// [`AT_RIMS`] off.
    static RIM_CROSSED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    /// Whether two faces are asked whether they coincide within the
    /// tolerances they state ([`coincide_as_stated`]) where those are the
    /// default ones too. Off but for the attempt [`settled`] makes last.
    /// Read once per assembly on the calling thread.
    static AS_STATED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}

/// An operation run once, and where it refuses, again in three steps. Where
/// the refusal is a piece on the other solid's boundary
/// with no coincident partner, once more with such pieces settled from both
/// sides of them. Where the kept pieces did not close, once more with each
/// piece read at the centre of its area: a face
/// leaning off the other's by microradians, the two meeting along an edge
/// and nothing splitting it, stands within rounding of the other near that
/// edge, and a probe there can read the wrong side. And where it still
/// refuses, at a confusion distance ten
/// and then a hundred times wider: a sliver a few microns thick (two walls
/// a few microns apart, a face tilted a few microradians) is then the kind
/// the boolean welds, and the result is kept only if nothing in it states
/// a tolerance past the weld distance, a hundred confusion distances (and
/// the ten the welding run states its own vertices to). A shell those
/// retries drop as a membrane leaves nothing behind to state that, so it
/// is dropped only where its faces stand within that same weld of each
/// other, and a sliver any thicker is never lost to the retry.
///
/// Then, at the given confusion, with contacts read at the radii their
/// curves hold to rather than at the loose width a fitted curve is
/// measured within: a fitted curve leaving an exact one tangentially
/// leaves a lune between them wider than those radii, which is geometry.
/// Each stretch the two share ends where they part by those radii,
/// measured once for the pair so both sides split at one vertex; a shallow
/// crossing splits both curves, at a vertex of either it cannot be told
/// from; a contact stretch near an edge is read inside or out at that
/// edge; a fitted section's hug width welds only a face it leaves a strand
/// on; and a piece thinner than the classification band is read by the
/// other solid's edges bounding it ([`thin_by_strands`]).
///
/// Last, where the refusal was a piece on the other solid's boundary and
/// every retry refused too, the same retries again with the line edges a
/// section line crosses carried onto the other face from the crossing on
/// ([`graze_contacts`]): a strip of one wall between such a crossing and
/// its edge, standing on another wall a hair's angle off it, is then split
/// off both and read as one contact. Where those refuse too, once more
/// with edges of any curve carried so, the result kept only where nothing
/// in it states a tolerance past the weld distance: an arc's strip is
/// shorter than a line's, and a junction welding its two ends together
/// would weld the faces beside it into one. What the retries without them
/// resolve is resolved as before.
///
/// Where all of that refuses and a plane crossed an extrusion of a
/// B-spline profile across a rim of it, whose marched section stops short
/// of the rim, the run once more from the first attempt with that section
/// split where it crosses the rim in closed form ([`AT_RIMS`]), its result
/// kept only where nothing in it states a tolerance past the weld
/// distance.
///
/// And where the kept pieces still did not close and the first attempt
/// read a contact along a boundary edge it stands further from than either
/// states (a floor edge lying its tolerance off a mirror plane, against its
/// mirror image as far off the other way), once more with the pieces sewn
/// across that distance ([`SEW_ACROSS`]), where it is within the weld
/// distance the retries above hold to: the paving took the two for one
/// edge and split neither face along them, so the edge kept widens to
/// reach where the other ran. The attempt runs at the given confusion, and
/// the sew widens nothing further than that distance beyond what the
/// pieces already state, so its result is not held to the weld distance a
/// second time: a part may itself state wider tolerances.
///
/// After all of that, where the refusal was a piece on the other solid's
/// boundary with no coincident partner and every retry above refused too,
/// once more with every pair of faces asked whether they coincide within
/// the tolerances they state, the default ones included ([`AS_STATED`]). A
/// face leaning a rounding off another it meets along an edge (a pocket's
/// floor sketched a tenth of a micron off the plane it stands on) parts
/// from it by a hair past the confusion distance at its far edge: the
/// closed form reads the two as crossing along the edge they share, which
/// splits neither, and the leaning face reads on the other's boundary
/// everywhere with no partner. Within what the two faces state they are one
/// surface, and each face is split by the other's boundary as a coincident
/// face is.
fn settled(
    model: &mut Model,
    tol: Tolerances,
    mut attempt: impl FnMut(&mut Model, Tolerances) -> OgeomResult<Built>,
) -> OgeomResult<Built> {
    RIM_CROSSED.set(false);
    ALONG_APART.set(0.0);
    let refusal = match attempt(model, tol) {
        Ok(built) => return Ok(built),
        Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
            return Err(e);
        }
        Err(e) => e,
    };
    let apart = ALONG_APART.get();
    if let Some(built) = resettled(model, tol, &refusal, &mut attempt)? {
        return Ok(built);
    }
    if apart > 0.0
        && apart + tol.confusion() <= weld_limit(tol)
        && refusal.to_string().contains("did not close into a shell")
    {
        struct Plain;
        impl Drop for Plain {
            fn drop(&mut self) {
                SEW_ACROSS.set(0.0);
            }
        }
        SEW_ACROSS.set(apart + tol.confusion());
        let _plain = Plain;
        match attempt(model, tol) {
            Ok(built) => return Ok(built),
            Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
                return Err(e);
            }
            Err(_) => {}
        }
    }
    if refusal.to_string().contains("no coincident partner face") {
        struct Plain;
        impl Drop for Plain {
            fn drop(&mut self) {
                AS_STATED.set(false);
            }
        }
        AS_STATED.set(true);
        let _plain = Plain;
        match attempt(model, tol) {
            Ok(built) => return Ok(built),
            Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
                return Err(e);
            }
            Err(_) => {}
        }
    }
    Err(refusal)
}

/// The retries [`settled`] runs after the first attempt refused with
/// `refusal`, short of the last, and the first result one of them keeps.
fn resettled(
    model: &mut Model,
    tol: Tolerances,
    refusal: &ogeom_core::OgeomError,
    attempt: &mut impl FnMut(&mut Model, Tolerances) -> OgeomResult<Built>,
) -> OgeomResult<Option<Built>> {
    if let Some(built) = settled_after(model, tol, refusal, attempt)? {
        return Ok(Some(built));
    }
    if !RIM_CROSSED.get() {
        return Ok(None);
    }
    struct Rims;
    impl Drop for Rims {
        fn drop(&mut self) {
            AT_RIMS.set(false);
        }
    }
    AT_RIMS.set(true);
    let _rims = Rims;
    let limit = weld_limit(tol);
    let at_rims = match attempt(model, tol) {
        Ok(built) if welded_within(model, &built.shape, limit)? => return Ok(Some(built)),
        Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
            return Err(e);
        }
        Ok(_) => return Ok(None),
        Err(e) => e,
    };
    if let Some(built) = settled_after(model, tol, &at_rims, attempt)?
        && welded_within(model, &built.shape, limit)?
    {
        return Ok(Some(built));
    }
    Ok(None)
}

/// The retries [`settled`] runs after an attempt refused with `refusal`,
/// pieces on the other solid's boundary settled from both sides of them,
/// and the first result one of them keeps.
fn settled_after(
    model: &mut Model,
    tol: Tolerances,
    refusal: &ogeom_core::OgeomError,
    attempt: &mut impl FnMut(&mut Model, Tolerances) -> OgeomResult<Built>,
) -> OgeomResult<Option<Built>> {
    struct Reset;
    impl Drop for Reset {
        fn drop(&mut self) {
            SETTLE_FROM_BOTH_SIDES.set(false);
        }
    }
    SETTLE_FROM_BOTH_SIDES.set(true);
    let _reset = Reset;
    if let Some(built) = retried(model, tol, refusal, attempt)? {
        return Ok(Some(built));
    }
    if refusal.to_string().contains("no coincident partner face") {
        struct Plain;
        impl Drop for Plain {
            fn drop(&mut self) {
                FROM_CROSSINGS.set(Crossings::Off);
            }
        }
        let _plain = Plain;
        FROM_CROSSINGS.set(Crossings::Lines);
        if let Some(built) = retried(model, tol, refusal, attempt)? {
            return Ok(Some(built));
        }
        FROM_CROSSINGS.set(Crossings::Curves);
        if let Some(built) = retried(model, tol, refusal, attempt)?
            && welded_within(model, &built.shape, weld_limit(tol))?
        {
            return Ok(Some(built));
        }
    }
    Ok(None)
}

/// The retries [`settled`] runs after a first attempt refused with
/// `refusal`, each in turn, and the first result one of them keeps.
fn retried(
    model: &mut Model,
    tol: Tolerances,
    refusal: &ogeom_core::OgeomError,
    attempt: &mut impl FnMut(&mut Model, Tolerances) -> OgeomResult<Built>,
) -> OgeomResult<Option<Built>> {
    if refusal.to_string().contains("no coincident partner face") {
        match attempt(model, tol) {
            Ok(built) => return Ok(Some(built)),
            Err(ogeom_core::OgeomError::Cancelled) => {
                return Err(ogeom_core::OgeomError::Cancelled);
            }
            Err(_) => {}
        }
    }
    if refusal.to_string().contains("did not close into a shell") {
        struct Clear;
        impl Drop for Clear {
            fn drop(&mut self) {
                PROBE_AT_CENTRE.set(false);
            }
        }
        PROBE_AT_CENTRE.set(true);
        let _clear = Clear;
        match attempt(model, tol) {
            Ok(built) => return Ok(Some(built)),
            Err(ogeom_core::OgeomError::Cancelled) => {
                return Err(ogeom_core::OgeomError::Cancelled);
            }
            Err(_) => {}
        }
    }
    let limit = weld_limit(tol);
    struct Restore(f64);
    impl Drop for Restore {
        fn drop(&mut self) {
            MEMBRANE_WITHIN.set(self.0);
        }
    }
    let restore = Restore(MEMBRANE_WITHIN.replace(limit.min(MEMBRANE_WITHIN.get())));
    for widen in [10.0, 100.0] {
        let Ok(wider) = Tolerances::with_scale(tol.scale() / widen) else {
            continue;
        };
        match attempt(model, wider) {
            Ok(built) if welded_within(model, &built.shape, limit)? => return Ok(Some(built)),
            Err(ogeom_core::OgeomError::Cancelled) => {
                return Err(ogeom_core::OgeomError::Cancelled);
            }
            _ => {}
        }
    }
    drop(restore);
    {
        struct Off;
        impl Drop for Off {
            fn drop(&mut self) {
                AT_STATED.set(false);
            }
        }
        AT_STATED.set(true);
        let _off = Off;
        #[cfg(feature = "test-hooks")]
        work::add(|w| w.stated_retries += 1);
        match attempt(model, tol) {
            Ok(built) => return Ok(Some(built)),
            Err(ogeom_core::OgeomError::Cancelled) => {
                return Err(ogeom_core::OgeomError::Cancelled);
            }
            Err(_) => {}
        }
    }
    Ok(None)
}

/// The widest tolerance a retried result may state: the weld distance, and
/// the wider confusion the welding run itself states its vertices to.
fn weld_limit(tol: Tolerances) -> f64 {
    (tol.confusion() * 1e2 + tol.confusion() * 10.0) * (1.0 + 1e-9)
}

/// Whether every edge and vertex of `shape` states a tolerance within
/// `weld`.
fn welded_within(model: &Model, shape: &Shape, weld: f64) -> OgeomResult<bool> {
    for kind in [ShapeType::Edge, ShapeType::Vertex] {
        for sub in explore_unique(model, shape, kind)? {
            if model.tolerance_of(&sub)?.is_some_and(|t| t.get() > weld) {
                return Ok(false);
            }
        }
    }
    Ok(true)
}

static ARRANGE_DEBUG: std::sync::LazyLock<bool> =
    std::sync::LazyLock::new(|| std::env::var("OGEOM_ARRANGE_DEBUG").is_ok());

/// The strict audit's verdict: the filtered fill and the unfiltered fill
/// keep the same material.
///
/// Pieces are compared as merged parameter intervals per section: the
/// unfiltered run sees more curves, and a dropped pair's dead section can
/// still cross a live one and split its pieces differently, so individual
/// piece boundaries are noise and the kept *union* is the signal. Sections
/// are keyed by their face pair and a sampled point, because indices differ
/// between the runs.
fn audit_fill_equivalence(
    filtered: (&[SectionRec], &[SectionPiece]),
    unfiltered: (&[SectionRec], &[SectionPiece]),
    tol: Tolerances,
) {
    type Key = (usize, usize, [i64; 3]);
    let key_of = |section: &SectionRec, tol: Tolerances| -> Key {
        let (lo, hi) = section.curve.domain();
        let p = section
            .curve
            .point_at(f64::midpoint(lo, hi), tol)
            .unwrap_or(ogeom_math::Point::ORIGIN);
        let grid = (tol.confusion() * 100.0).max(1e-9);
        #[allow(clippy::cast_possible_truncation)]
        let q = |x: f64| (x / grid).round() as i64;
        (section.face_a, section.face_b, [q(p.x), q(p.y), q(p.z)])
    };
    let merged = |sections: &[SectionRec], pieces: &[SectionPiece], tol: Tolerances| {
        let mut kept: ogeom_core::FastMap<Key, Vec<(f64, f64)>> = ogeom_core::FastMap::default();
        for piece in pieces {
            kept.entry(key_of(&sections[piece.section], tol))
                .or_default()
                .push(piece.range);
        }
        let slop = tol.parametric() * 10.0;
        for ranges in kept.values_mut() {
            ranges.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(core::cmp::Ordering::Equal));
            let mut out: Vec<(f64, f64)> = Vec::with_capacity(ranges.len());
            for &(lo, hi) in ranges.iter() {
                match out.last_mut() {
                    Some(last) if lo <= last.1 + slop => last.1 = last.1.max(hi),
                    _ => out.push((lo, hi)),
                }
            }
            *ranges = out;
        }
        kept
    };
    let a = merged(filtered.0, filtered.1, tol);
    let b = merged(unfiltered.0, unfiltered.1, tol);
    let slop = tol.parametric() * 20.0;
    let matches = |x: &Vec<(f64, f64)>, y: &Vec<(f64, f64)>| {
        x.len() == y.len()
            && x.iter()
                .zip(y)
                .all(|(p, q)| (p.0 - q.0).abs() <= slop && (p.1 - q.1).abs() <= slop)
    };
    for (key, ranges) in &b {
        let held = a.get(key);
        assert!(
            held.is_some_and(|r| matches(r, ranges)),
            "strict bound-filter audit: the unfiltered fill keeps {ranges:?} \
             on section {key:?}, the filtered fill keeps {held:?}; the \
             filter drops material"
        );
    }
    for (key, ranges) in &a {
        assert!(
            b.contains_key(key),
            "strict bound-filter audit: the filtered fill keeps {ranges:?} \
             on section {key:?} the unfiltered fill never made"
        );
    }
}

fn general_fuse(
    model: &Model,
    a: &Shape,
    b: &Shape,
    aside: Option<&[aside::Aside; 2]>,
    tol: Tolerances,
) -> OgeomResult<GeneralFused> {
    general_fuse_as(model, a, b, Operands::Solids, aside, tol)
}

/// [`general_fuse`] for an operation that keeps pieces by their state,
/// refusing a classification that cannot hold: the boundaries meet along
/// sections, every piece of both reads outside the other, and yet the
/// solids overlap.
///
/// Two solids sharing volume share it within a region bounded by pieces of
/// their boundaries, and each such piece lies inside the other solid or on
/// its boundary. So where no piece is in or on, the solids are apart, and a
/// section that leaves them overlapping was not arranged into the faces it
/// splits (a loop through a point where the surfaces touch, read as one
/// ring round both its lobes). Kept as read, the cut would keep the whole
/// solid and the union both solids whole. The overlap is asked of sampled
/// boundaries, only where every piece reads out and sections were found.
fn general_fuse_classified(
    model: &Model,
    a: &Shape,
    b: &Shape,
    aside: Option<&[aside::Aside; 2]>,
    tol: Tolerances,
) -> OgeomResult<GeneralFused> {
    let fused = general_fuse(model, a, b, aside, tol)?;
    #[cfg(feature = "test-hooks")]
    work::add(|w| w.pieces += fused.pieces.len());
    if !fused.sections.is_empty()
        && fused.pieces.iter().all(|p| p.state == PieceState::Out)
        && !apart(model, a, b, tol)?
    {
        ogeom_bail!(
            NotDone,
            "the boundaries cross yet every piece of both reads outside the other, \
             though the solids overlap; a section was not arranged into the faces it \
             splits"
        );
    }
    Ok(fused)
}

/// For each gathered face, the faces of the same solid it shares a vertex
/// with, itself among them, by their places in `solid.faces`.
fn neighbouring_faces(
    model: &Model,
    solid: &GSolid,
) -> OgeomResult<Vec<ogeom_core::FastSet<usize>>> {
    // A vertex is its node where it is placed, as an edge is (see
    // [`EdgeKey`]): one node placed twice is two corners in space.
    let mut by_vertex: ogeom_core::FastMap<EdgeKey, Vec<usize>> = ogeom_core::FastMap::default();
    for (index, face) in solid.faces.iter().enumerate() {
        for vertex in explore_unique(model, &face.face, ShapeType::Vertex)? {
            by_vertex
                .entry(EdgeKey::of(&vertex))
                .or_default()
                .push(index);
        }
    }
    let mut neighbours: Vec<ogeom_core::FastSet<usize>> = (0..solid.faces.len())
        .map(|index| std::iter::once(index).collect())
        .collect();
    for faces in by_vertex.values() {
        for &i in faces {
            neighbours[i].extend(faces.iter().copied());
        }
    }
    Ok(neighbours)
}

/// The general fuse of `a` and `b` taken as `operands` says. Where `a` is a
/// sheet only its pieces are made, and the pieces of `b` are not. The
/// faces `aside` names are left out.
fn general_fuse_as(
    model: &Model,
    a: &Shape,
    b: &Shape,
    operands: Operands,
    aside: Option<&[aside::Aside; 2]>,
    tol: Tolerances,
) -> OgeomResult<GeneralFused> {
    // Read here, on the caller's thread: the pieces are classified on
    // worker threads, which do not share it.
    let settle = SETTLE_FROM_BOTH_SIDES.get();
    let read_at_centre = PROBE_AT_CENTRE.get();
    let read_thin = AT_STATED.get();
    ogeom_core::progress::stage("boolean: gather");
    let mut ga = gather(
        model,
        a,
        matches!(operands, Operands::SheetBySolid | Operands::SheetBySheet),
        aside.map(|aside| &aside[0]),
        tol,
    )?;
    let mut gb = gather(
        model,
        b,
        operands == Operands::SheetBySheet,
        aside.map(|aside| &aside[1]),
        tol,
    )?;
    let (onto_a, onto_b) = (
        drums_onto_planes(&ga, &gb, tol),
        drums_onto_planes(&gb, &ga, tol),
    );
    move_drums(&mut ga, &onto_a, tol)?;
    move_drums(&mut gb, &onto_b, tol)?;
    #[cfg(feature = "test-hooks")]
    work::add(|w| w.faces_gathered += ga.faces.len() + gb.faces.len());
    let neighbours = if operands == Operands::Itself {
        Some(neighbouring_faces(model, &ga)?)
    } else {
        None
    };
    ogeom_core::progress::stage("boolean: intersect");
    let (
        sections,
        section_pieces,
        contacts,
        tangents,
        contact_along,
        mut paves,
        same_a,
        same_b,
        hugs,
    ) = fill(&ga, &gb, false, neighbours.as_deref(), tol)?;
    if operands == Operands::SheetBySheet && same_a.iter().any(|partners| !partners.is_empty()) {
        ogeom_bail!(
            NotDone,
            "the sheets lie on one surface where they overlap; a sheet split \
             by another lying along it is not resolved"
        );
    }
    for section in &sections {
        for (pcurve, face) in [
            (&section.pc_a, &ga.faces[section.face_a]),
            (&section.pc_b, &gb.faces[section.face_b]),
        ] {
            past_a_pole(section, pcurve, face, tol)?;
        }
    }
    let along = crossed_along(&contacts);
    let mut junctions = pave_junctions(&ga, &gb, &paves, &along, tol)?;
    if *DEBUG_WIRE {
        for j in &junctions {
            eprintln!("JUNCTION from paves at {:?} reach {:.3e}", j.at, j.reach);
        }
        for j in &hugs {
            eprintln!("JUNCTION from hugs at {:?} reach {:.3e}", j.at, j.reach);
        }
    }
    junctions.extend(hugs);
    // A vertex of an edge shared with a face set aside is that vertex in
    // the rebuild, which every strand ending within its span names.
    let mut kept_bins = bins::Bins::new(tol.confusion() * 1e2);
    let kept_points: Vec<Point> = ga
        .shared_vertices
        .iter()
        .chain(&gb.shared_vertices)
        .map(|(at, _)| *at)
        .collect();
    for (index, at) in kept_points.iter().enumerate() {
        kept_bins.insert(*at, index);
    }
    let mut near_kept = Vec::new();
    for face in ga.faces.iter().chain(gb.faces.iter()) {
        // An input vertex that owns a span (the corner an earlier boolean
        // welded three rims into, each ending a fraction of a micron from
        // the others) is a junction here as well: the rebuild's positional
        // weld reaches only a few honesties, and minted separately those
        // ends stand as three vertices with hairlines between them.
        for e in &face.edges {
            for (at, radius) in e.ends {
                let mut kept = || {
                    !kept_points.is_empty()
                        && if kept_bins.near_into(at, radius, &mut near_kept) {
                            near_kept
                                .iter()
                                .any(|&i| kept_points[i].distance(at) <= radius)
                        } else {
                            kept_points.iter().any(|p| p.distance(at) <= radius)
                        }
                };
                if radius > tol.confusion() * 10.0 && !kept() {
                    if *DEBUG_WIRE {
                        eprintln!("JUNCTION from vertex at {at:?} radius {radius:.3e}");
                    }
                    junctions.push(Junction {
                        at,
                        reach: radius,
                        onto_vertex: false,
                    });
                }
            }
        }
    }
    // Junctions whose balls overlap are one junction: two pave clusters a
    // fraction of a micron apart at a corner where rims meet, each owning
    // a span that reaches into the other's, would weld a strand end to
    // whichever covers it first, and the corner would stand as two
    // vertices with a hairline between them, kept on one face, dropped
    // on another. Merged, the corner is one vertex whose reach covers
    // every member's span, on every face alike.
    junctions = merge_junctions(junctions);
    for (from_a, gathered) in [(true, &ga), (false, &gb)] {
        seams_through_junctions(
            gathered,
            from_a,
            (&sections, &section_pieces),
            &junctions,
            &mut paves,
            tol,
        )?;
    }
    if *DEBUG_WIRE {
        for j in &junctions {
            eprintln!("JUNCTION at {:?} reach {:.3e}", j.at, j.reach);
        }
        let kind = |sf: &SurfaceGeometry| match sf {
            SurfaceGeometry::Plane(_) => "plane",
            SurfaceGeometry::Cylinder(_) => "cyl",
            SurfaceGeometry::BSpline(_) => "bspline",
            _ => "other",
        };
        for (si, sec) in sections.iter().enumerate() {
            let fa = &ga.faces[sec.face_a];
            let fb = &gb.faces[sec.face_b];
            let d = sec.curve.domain();
            let mut worst_a: f64 = 0.0;
            let mut worst_b: f64 = 0.0;
            let mut len = 0.0;
            let mut prev: Option<Point> = None;
            for i in 0..=32 {
                let t = if i == 32 {
                    d.1
                } else {
                    d.0 + (d.1 - d.0) * f64::from(i) / 32.0
                };
                let at = sec.curve.point_at(t, tol)?;
                if let Some(p) = prev {
                    len += p.distance(at);
                }
                prev = Some(at);
                let near = |f: &GFace| -> OgeomResult<f64> {
                    let mut best = f64::INFINITY;
                    for e in &f.edges {
                        best = best.min(distance_to_edge_curve(&e.curve, e.crange, at, tol)?);
                    }
                    Ok(best)
                };
                worst_a = worst_a.max(near(fa)?);
                worst_b = worst_b.max(near(fb)?);
            }
            let pieces = section_pieces.iter().filter(|p| p.section == si).count();
            eprintln!(
                "SECTION s{si} a{}({}) x b{}({}) tol {:.2e} closed {} len {:.4} pieces {pieces} hug-dist a {:.3e} b {:.3e}",
                sec.face_a,
                kind(&fa.surface),
                sec.face_b,
                kind(&fb.surface),
                sec.tolerance,
                sec.closed,
                len,
                worst_a,
                worst_b
            );
        }
        eprintln!("TANGENTS {}  CONTACTS {}", tangents.len(), contacts.len());
    }
    // The strict audit: fill again with every pair admitted and demand the
    // same kept material. The production result above is always the
    // filtered run (under audit too), so the audit compares rather than
    // substitutes, and a filtered run *is* replayed exactly. Zero cost with
    // the variable unset.
    if *AUDIT_BOUNDS {
        // A pair only the unfiltered fill tries may refuse (a march beside a
        // pole the filter never sends it), which says nothing of the
        // filter. The audit says so and compares nothing.
        match fill(&ga, &gb, true, neighbours.as_deref(), tol) {
            Ok((audit_sections, audit_pieces, ..)) => audit_fill_equivalence(
                (&sections, &section_pieces),
                (&audit_sections, &audit_pieces),
                tol,
            ),
            Err(e @ ogeom_core::OgeomError::Cancelled) => return Err(e),
            Err(e) => eprintln!("bound-filter audit skipped: the unfiltered fill refused: {e}"),
        }
    }

    ogeom_core::progress::stage("boolean: split");
    let mut pieces: Vec<FacePiece> = Vec::new();
    // Every face's strands, before any face is arranged: the dust decision
    // (a piece shorter than its face's snap collapses to one node) must
    // be one decision per shared edge piece, and a sub-piece of one edge
    // lies in several charts, each with its own snap and its own metric.
    // A band's rail hugging a wedge's cylinder for a quarter of a micron
    // is dust in the wall's chart and a strand in the cylinder's, and the
    // sew then finds the cylinder's piece used once.
    let chart_length =
        |line: &[Point2]| -> f64 { line.windows(2).map(|w| w[0].distance(w[1])).sum::<f64>() };
    // Each edge's end vertices where they stand, each with its radius and
    // the edge's own: a contact strand on the other solid's face ends at
    // one of them.
    let mut edge_vertices: ogeom_core::FastMap<EdgeKey, [(Point, f64); 2]> =
        ogeom_core::FastMap::default();
    for e in ga
        .faces
        .iter()
        .chain(gb.faces.iter())
        .flat_map(|f| f.edges.iter())
    {
        edge_vertices.entry(e.node).or_insert([
            (e.vertices[0], e.ends[0].1 + e.tolerance),
            (e.vertices[1], e.ends[1].1 + e.tolerance),
        ]);
    }
    let strands_of = |from_a: bool,
                      fi: usize,
                      face: &GFace|
     -> OgeomResult<(Vec<Strand<Tag>>, f64, Vec<Junction>)> {
        let mut strands: Vec<Strand<Tag>> = Vec::new();
        // How far apart the paves one junction stands for lie. A section
        // meeting the edge all but tangentially (its fitted end sliding
        // along it) paves it a few microns from where an exact section
        // crosses. The first pave speaks for both, and the other's strand
        // must still reach it.
        // Each such junction where it stands in space and in this chart,
        // and how far its members reach: the strands ending at a member are
        // carried onto it below.
        let mut gathered: Vec<(Point, Point2, f64)> = Vec::new();
        for (ei, e) in face.edges.iter().enumerate() {
            let mut stops = vec![e.crange.0];
            if let Some(ts) = paves.get(&e.node) {
                // Paves the edge itself cannot tell apart are one
                // junction, and the cluster's representative speaks for it.
                let off = |face, p| off_face(&ga, &gb, face, p, tol);
                let along = along.get(&e.node).map_or(&[][..], Vec::as_slice);
                for c in cluster_paves(&e.curve, e.crange, e.tolerance, ts, Some(&off), along, tol)?
                {
                    if c.members > 1 {
                        let chart = e.pcurve.point_at(rescale(c.t, e.crange, e.prange), tol)?;
                        gathered.push((c.at, chart, c.span + c.honesty));
                    }
                    stops.push(c.t);
                }
            }
            stops.push(e.crange.1);
            // A closed boundary edge (a cap's full circle) needs two
            // distinct endpoints per strand.
            let closed_edge = e
                .curve
                .point_at(e.crange.0, tol)?
                .distance(e.curve.point_at(e.crange.1, tol)?)
                <= tol.confusion();
            if closed_edge && stops.len() == 2 {
                stops.insert(1, f64::midpoint(e.crange.0, e.crange.1));
            }
            for pair in stops.windows(2) {
                let sub = (pair[0], pair[1]);
                if sub.1 - sub.0 <= tol.parametric() {
                    continue;
                }
                strands.push(Strand {
                    polyline: pcurve_polyline(
                        &e.pcurve,
                        e.prange,
                        e.crange,
                        sub,
                        &face.surface,
                        tol,
                    )?,
                    tag: Tag::Boundary {
                        edge: ei,
                        range: sub,
                    },
                    boundary: true,
                    sag: f64::INFINITY,
                });
                if let Some((other_pc, orange)) = &e.other_side {
                    strands.push(Strand {
                        polyline: pcurve_polyline(
                            other_pc,
                            *orange,
                            e.crange,
                            sub,
                            &face.surface,
                            tol,
                        )?,
                        tag: Tag::Boundary {
                            edge: ei,
                            range: sub,
                        },
                        boundary: true,
                        sag: f64::INFINITY,
                    });
                }
            }
        }
        // The trim the strands are folded inside: the boundary strands as
        // they stand and the poles whole, with their boxes, drawn once for
        // the face. The poles become strands only after the sections that
        // cut them, and a trim without them is open where it reaches one: a
        // point inside reads outside along a ray leaving through the gap.
        let pole_lines = face
            .poles
            .iter()
            .map(|pole| {
                pcurve_polyline(
                    &pole.pcurve,
                    pole.prange,
                    pole.prange,
                    pole.prange,
                    &face.surface,
                    tol,
                )
            })
            .collect::<OgeomResult<Vec<_>>>()?;
        let mut section_trim: Option<arrange::Trim> = None;
        for sp in &section_pieces {
            let section = &sections[sp.section];
            let (belongs, pcurve) = if from_a {
                (section.face_a == fi && !sp.hugs[0], &section.pc_a)
            } else {
                (section.face_b == fi && !sp.hugs[1], &section.pc_b)
            };
            if !belongs {
                continue;
            }
            let domain = section.curve.domain();
            let sub = if section.closed {
                (
                    fold(sp.range.0, domain),
                    sp.range.1 - sp.range.0 + fold(sp.range.0, domain),
                )
            } else {
                sp.range
            };
            // The pcurve shares the curve's parameterization. Sampling
            // uses folded parameters for periodic curves.
            let fold_at = |t: f64| if section.closed { fold(t, domain) } else { t };
            // A section's sampling on a plane holds its chords to a sag,
            // which the arrangement can read it to.
            let (count, sag) = if !matches!(face.surface, SurfaceGeometry::Plane(_)) {
                (32, f64::INFINITY)
            } else if matches!(pcurve, PlanarCurve::Line(_)) {
                (32, 0.0)
            } else {
                match circle_sag_count(pcurve, sub.0, sub.1, 32) {
                    Some(count) => (
                        count,
                        circle_sag(pcurve, sub.0, sub.1, count).unwrap_or(f64::INFINITY),
                    ),
                    None => sag_count(&|t| pcurve.point_at(fold_at(t), tol), sub.0, sub.1, 32)?,
                }
            };
            let mut line = Vec::with_capacity(count + 1);
            for i in 0..=count {
                #[allow(clippy::cast_precision_loss)]
                let t = sub.0 + (sub.1 - sub.0) * i as f64 / count as f64;
                let tf = if section.closed { fold(t, domain) } else { t };
                line.push(pcurve.point_at(tf, tol)?);
            }
            // Folding the parameter can tear the sampled polyline at the
            // period. Unwrap it pointwise, then bring the whole strand
            // into the chart with one shift.
            unwrap_polyline(&mut line, &face.surface, tol);
            let trim = section_trim.get_or_insert_with(|| {
                arrange::Trim::new(
                    strands
                        .iter()
                        .filter(|st| st.boundary)
                        .map(|st| st.polyline.clone())
                        .chain(pole_lines.iter().cloned())
                        .collect(),
                )
            });
            fold_line_inside(&mut line, &face.surface, trim, tol);
            strands.push(Strand {
                polyline: line,
                tag: Tag::Section {
                    section: sp.section,
                    range: sp.range,
                },
                boundary: false,
                sag,
            });
        }
        // A section's end the paving read at a pole (its crossing within
        // the window that reads a crossing as an edge's end vertex, at the
        // pole vertex of a seam) stands beside the pole in space by at most
        // that window, but in the chart that can be anywhere along the
        // pole's line, the chart's free parameter shrinking to nothing
        // there: off the pole row by the window over the radius, and along
        // it by any amount, past the line's end where it crosses the seam
        // beside the pole. It is the pole, and is carried onto the pole's
        // line at its foot, held to the line (every point of which is the
        // pole), where the pole is cut for it below.
        for strand in &mut strands {
            let Tag::Section { section, .. } = strand.tag else {
                continue;
            };
            let s = &sections[section];
            let reach = tol.confusion().max(s.tolerance * 2.0);
            let window = (reach + honest(s.tolerance, tol)).max(tol.confusion() * 1e2);
            let last = strand.polyline.len() - 1;
            for end in [0, last] {
                let at = strand.polyline[end];
                let Ok(q) = face.surface.point_at(at.x, at.y, tol) else {
                    continue;
                };
                for pole in &face.poles {
                    let PlanarCurve::Line(line) = &pole.pcurve else {
                        continue;
                    };
                    if q.distance(pole.point) > window {
                        continue;
                    }
                    let axis = line.axis();
                    let along = (at - axis.location)
                        .dot(axis.direction.vector())
                        .clamp(pole.prange.0, pole.prange.1);
                    strand.polyline[end] = axis.point_at(along);
                }
            }
        }
        // The poles, after the sections, because a section can end *on*
        // a pole (a plane through a ball's axis cuts it exactly there),
        // and the pole has to be cut where that happens or the two meet
        // at no shared node and the arrangement sees a dangling section.
        for (pi, pole) in face.poles.iter().enumerate() {
            let mut stops = vec![pole.prange.0, pole.prange.1];
            if let PlanarCurve::Line(line) = &pole.pcurve {
                let axis = line.axis();
                for strand in &strands {
                    if strand.boundary {
                        continue;
                    }
                    for end in [strand.polyline.first(), strand.polyline.last()]
                        .into_iter()
                        .flatten()
                    {
                        let along = (*end - axis.location).dot(axis.direction.vector());
                        let foot = axis.point_at(along);
                        if foot.distance(*end) <= PARAM_SNAP
                            && along > pole.prange.0 + PARAM_SNAP
                            && along < pole.prange.1 - PARAM_SNAP
                        {
                            stops.push(along);
                        }
                    }
                }
            }
            stops.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
            stops.dedup_by(|a, b| (*a - *b).abs() <= PARAM_SNAP);
            for pair in stops.windows(2) {
                let sub = (pair[0], pair[1]);
                strands.push(Strand {
                    polyline: pcurve_polyline(
                        &pole.pcurve,
                        pole.prange,
                        pole.prange,
                        sub,
                        &face.surface,
                        tol,
                    )?,
                    tag: Tag::Pole {
                        pole: pi,
                        range: sub,
                    },
                    boundary: true,
                    sag: f64::INFINITY,
                });
            }
        }
        let mut contact_trim: Option<arrange::Trim> = None;
        for (ci, contact) in contacts.iter().enumerate() {
            if contact.target_from_a != from_a || contact.target_face != fi {
                continue;
            }
            // The owner's paves split its edge. The contact strands split
            // at the same parameters, so the sub-edges rebuilt from both
            // sides are the same edges and sew shared.
            let mut stops = vec![contact.crange.0];
            if let Some(ts) = paves.get(&contact.node) {
                stops.extend(
                    cluster_paves(
                        &contact.curve,
                        contact.crange,
                        contact.tolerance,
                        ts,
                        None,
                        &[],
                        tol,
                    )?
                    .iter()
                    .map(|c| c.t),
                );
            }
            stops.push(contact.crange.1);
            let closed_contact = contact
                .curve
                .point_at(contact.crange.0, tol)?
                .distance(contact.curve.point_at(contact.crange.1, tol)?)
                <= tol.confusion();
            if closed_contact && stops.len() == 2 {
                stops.insert(1, f64::midpoint(contact.crange.0, contact.crange.1));
            }
            for pair in stops.windows(2) {
                let sub = (pair[0], pair[1]);
                if sub.1 - sub.0 <= tol.parametric() {
                    continue;
                }
                let mid_t = f64::midpoint(sub.0, sub.1);
                if contact_along[ci]
                    .iter()
                    .any(|(lo, hi)| mid_t >= *lo && mid_t <= *hi)
                {
                    // Already boundary on both sides.
                    if *DEBUG_STRANDS {
                        eprintln!("CONTACT c{ci} {sub:?} on fi={fi}: along boundary, skipped");
                    }
                    continue;
                }
                // Keep only what lies inside this face's trim. The rest
                // of the owner's boundary splits nothing here.
                let mut line = pcurve_polyline(
                    &contact.pcurve,
                    contact.prange,
                    contact.crange,
                    sub,
                    &face.surface,
                    tol,
                )?;
                unwrap_polyline(&mut line, &face.surface, tol);
                let trim = contact_trim.get_or_insert_with(|| {
                    arrange::Trim::new(
                        strands
                            .iter()
                            .filter(|st| st.boundary)
                            .map(|st| st.polyline.clone())
                            .collect(),
                    )
                });
                fold_line_inside(&mut line, &face.surface, trim, tol);
                let mid = interior_of(&line);
                // On the last attempt, where the stretch stands nearest an
                // edge's inside, it is inside the face just where it stands
                // on the side the face keeps its material on: the edge's
                // own curve says so where the outline's chords sag past it.
                let beside = if read_thin {
                    inside_beside_edge(face, contact.curve.point_at(mid_t, tol)?, tol)?
                } else {
                    None
                };
                if !beside.unwrap_or_else(|| trim.inside_slanted(mid)) {
                    if *DEBUG_STRANDS {
                        eprintln!(
                            "CONTACT c{ci} {sub:?} on fi={fi}: outside the trim at {mid:?}, skipped"
                        );
                    }
                    continue;
                }
                strands.push(Strand {
                    polyline: line,
                    tag: Tag::Contact {
                        contact: ci,
                        range: sub,
                    },
                    boundary: false,
                    sag: f64::INFINITY,
                });
            }
        }

        // A tolerant contact's chart image meets the boundary it paved
        // only as closely as its own slop allows. The arrangement's node
        // weld reaches that far on this face, or the strand dangles a
        // few microns from the junction it belongs to.
        // A fitted section that hugs one of this face's edges leaves it
        // at the hug's far end by up to the hug's own width. Its strand
        // must still find the edge's node there.
        // A strand ending at another member of a junction than the one that
        // speaks for it ends where its curve all but runs along the edge (a
        // section crossing it at a shallow angle, whose crossing is only
        // known along the edge to within the run). An exact section moved
        // along to the junction stays within tolerance of both curves, and
        // carried there it meets the edge's split exactly, so the face's
        // weld need not widen to the cluster's span, which would swallow a
        // sliver beside the edge whole. A fitted one wanders by more than
        // that, and the weld widens for it.
        // On the last attempt that weld is each such end's alone: the face's
        // node weld also decides which regions are too thin to hold a point,
        // and a junction's run along one edge says nothing of a sliver
        // elsewhere on the face.
        let mut spread = 0.0_f64;
        let mut spread_at: Vec<[f64; 2]> = vec![[0.0; 2]; strands.len()];
        for (si, strand) in strands
            .iter_mut()
            .enumerate()
            .filter(|(_, st)| !st.boundary)
        {
            let exact = matches!(strand.tag, Tag::Section { section, .. }
                if sections.get(section).is_some_and(|s| s.tolerance <= 0.0));
            let last = strand.polyline.len().saturating_sub(1);
            for (side, end) in [0, last].into_iter().enumerate() {
                let Some(&at) = strand.polyline.get(end) else {
                    continue;
                };
                let Ok(q) = face.surface.point_at(at.x, at.y, tol) else {
                    continue;
                };
                let landed = gathered
                    .iter()
                    .filter(|(junction, _, reach)| junction.distance(q) <= *reach)
                    .min_by(|x, y| x.0.distance(q).total_cmp(&y.0.distance(q)));
                match landed {
                    // A junction on a seam stands on both sides of it, and
                    // the strand is carried to the side it arrives from.
                    Some(&(_, chart, _)) if exact => {
                        strand.polyline[end] = period_shifts(&face.surface, tol)
                            .into_iter()
                            .map(|(du, dv)| Point2::new(chart.x + du, chart.y + dv))
                            .min_by(|p, r| p.distance(at).total_cmp(&r.distance(at)))
                            .unwrap_or(chart);
                    }
                    Some(&(_, _, reach)) => {
                        spread = spread.max(reach);
                        spread_at[si][side] = reach;
                    }
                    None => {}
                }
            }
        }
        // What the face holds everywhere in its chart: its own tolerance
        // and its holes set aside, and twice the run's confusion, which two
        // ends each within it of one point keep between them (a fuzzy
        // run's confusion is its fuzz). What its edges and vertices add
        // holds only near them, and each strand end is welded at the doubt
        // where it stands, below.
        let everywhere = |face: &GFace| -> f64 {
            face.holes_aside
                .iter()
                .fold(face.tolerance, |acc, hole| acc.max(hole.doubt))
                .min(doubt_of(face))
        };
        let near = contacts
            .iter()
            .filter(|c| c.target_from_a == from_a && c.target_face == fi)
            .fold(PARAM_SNAP, |acc, c| acc.max(c.tolerance * 2.0))
            .max(tol.confusion() * 2.0)
            .max(everywhere(face))
            .max(if read_thin { 0.0 } else { spread })
            .max(
                if !read_thin
                    && sections.iter().any(|s| {
                        s.tolerance > 0.0
                            && if from_a {
                                s.face_a == fi
                            } else {
                                s.face_b == fi
                            }
                    })
                {
                    tol.confusion() * 1e3
                } else {
                    0.0
                },
            );
        // The face a section shares with this one.
        let other = |section: usize| -> &GFace {
            let s = &sections[section];
            if from_a {
                &gb.faces[s.face_b]
            } else {
                &ga.faces[s.face_a]
            }
        };
        let face_snap = near.max(
            (0..sections.len())
                .filter(|&k| {
                    if from_a {
                        sections[k].face_a == fi
                    } else {
                        sections[k].face_b == fi
                    }
                })
                .map(|k| everywhere(other(k)))
                .fold(0.0_f64, f64::max),
        );
        // The weld at a strand's end, in space. An edge's end lands in the
        // chart within its vertex's own recorded doubt plus its own image's:
        // a projected pcurve is honest to the edge's tolerance, and the
        // vertex it ends at was welded to some earlier gap. A section ends
        // where it crosses the other face's boundary, and lands there within
        // that boundary's own doubt: two sections through neighbouring
        // facets of a converted mesh stop on the edge they share a few
        // microns apart, each on its own facet's plane, and meet on this
        // face only if the weld reaches that far. Both doubts are those of
        // the edges and vertices near the end ([`doubt_at`]): a loose edge
        // welds what crosses or ends near it, and a section crossing a
        // tight edge elsewhere on the face keeps its crossing, as it does on
        // the face across that edge.
        let mut ends: Vec<(usize, usize, Point2, Point, f64)> = Vec::new();
        for (si, st) in strands.iter().enumerate() {
            if st.polyline.len() < 2 || matches!(st.tag, Tag::Pole { .. }) {
                continue;
            }
            let last = st.polyline.len() - 1;
            for end in [0, last] {
                let at = st.polyline[end];
                let Ok(q) = face.surface.point_at(at.x, at.y, tol) else {
                    continue;
                };
                let mut weld = doubt_at(face, q, tol)?.max(near);
                if let Tag::Section { section, .. } = st.tag {
                    weld = weld.max(doubt_at(other(section), q, tol)?);
                    // An exact section's stop read at an exact edge's end
                    // vertex (see the crossings in [`fill`]) stands beside
                    // the vertex by as far as the section passes it, up to
                    // the weld that read it there, and is that vertex.
                    let s = &sections[section];
                    if s.tolerance <= 0.0 && exact(&s.curve) {
                        let reach = tol.confusion();
                        for e in face
                            .edges
                            .iter()
                            .filter(|e| e.image.is_none() && exact(&e.curve))
                        {
                            let read_at = (reach + e.tolerance.max(e.ends_tolerance))
                                .max(tol.confusion() * 10.0);
                            for end_t in [e.crange.0, e.crange.1] {
                                let gap = e.curve.point_at(end_t, tol)?.distance(q);
                                if gap <= read_at {
                                    weld = weld.max(gap + tol.confusion());
                                }
                            }
                        }
                    }
                }
                // A contact's end is its own edge's end vertex, within that
                // vertex's radius, as an edge of this face ends at its own.
                if let Tag::Contact { contact, .. } = st.tag
                    && let Some(vertices) = edge_vertices.get(&contacts[contact].node)
                {
                    for &(v, radius) in vertices {
                        if q.distance(v) <= radius {
                            weld = weld.max(radius);
                        }
                    }
                }
                // On the last attempt the face weld leaves out a junction's
                // run and a fitted section's hug width, and they hold at the
                // ends they concern: a fitted section's end, hugging an edge
                // within the two curves' radii or crossing it, meets the
                // edge's node within its own reach, twice its tolerance.
                if read_thin {
                    weld = weld.max(spread_at[si][usize::from(end != 0)]);
                    if let Tag::Section { section, .. } = st.tag {
                        weld = weld.max(honest(sections[section].tolerance, tol) * 2.0);
                    }
                }
                ends.push((si, end, at, q, weld));
            }
        }
        // The doubts above are lengths in space, and the weld runs in the
        // chart. Where the chart stretches every direction (a sphere of a
        // few millimetres runs a radian over its whole radius), a gap in
        // space is that many times narrower in the chart, and a weld taken
        // at the space length would swallow whole edges of a small patch.
        // Where some direction shrinks instead (a pole, a thin cylinder's
        // turn), the length stands.
        let stretch = strands
            .iter()
            .flat_map(|st| st.polyline.iter())
            .step_by(8)
            .filter_map(|p| face.surface.d1_at(p.x, p.y, tol).ok())
            .map(|(du, dv)| du.magnitude().min(dv.magnitude()))
            .fold(f64::INFINITY, f64::min);
        let in_chart = |length: f64| -> f64 {
            if stretch.is_finite() && stretch > 1.0 {
                (length / stretch).max(PARAM_SNAP)
            } else {
                length
            }
        };
        let face_snap = in_chart(face_snap);
        let mut reach: Vec<f64> = ends.iter().map(|e| in_chart(e.4)).collect();
        // Where only one direction stretches (a cylinder's turn against its
        // straight length) no single scale holds, and a strand can be short
        // in the chart yet long in space. A strand longer in space than its
        // own doubt is no dust, so no weld near it reaches as far as its
        // chart length, or it collapses and takes its neighbours' ends with
        // it.
        let own_doubt = |si: usize| -> f64 {
            let at_ends = ends
                .iter()
                .filter(|e| e.0 == si)
                .fold(near, |acc, e| acc.max(e.4));
            match strands[si].tag {
                Tag::Section { section, .. } => at_ends.max(everywhere(other(section))),
                Tag::Pole { .. } => f64::INFINITY,
                Tag::Boundary { .. } | Tag::Contact { .. } => at_ends,
            }
        };
        let loosest = reach.iter().copied().fold(face_snap, f64::max);
        let kept: Vec<(Point2, Point2, f64)> = strands
            .iter()
            .enumerate()
            .filter(|(_, st)| st.polyline.len() >= 2 && chart_length(&st.polyline) <= loosest)
            .filter_map(|(si, st)| {
                let points: Vec<Point> = st
                    .polyline
                    .iter()
                    .filter_map(|p| face.surface.point_at(p.x, p.y, tol).ok())
                    .collect();
                let space: f64 = points.windows(2).map(|w| w[0].distance(w[1])).sum();
                (space > own_doubt(si)).then(|| {
                    (
                        st.polyline[0],
                        st.polyline[st.polyline.len() - 1],
                        chart_length(&st.polyline) / 2.0,
                    )
                })
            })
            .collect();
        let face_snap = kept
            .iter()
            .filter(|k| k.2 * 2.0 <= face_snap)
            .fold(face_snap, |acc, k| acc.min(k.2))
            .max(PARAM_SNAP);
        for (e, r) in ends.iter().zip(reach.iter_mut()) {
            for &(a, b, half) in &kept {
                if half * 2.0 <= *r && (e.2.distance(a) <= *r || e.2.distance(b) <= *r) {
                    *r = r.min(half);
                }
            }
            *r = r.max(face_snap);
        }
        // Each end whose own weld reaches past the face's is welded here,
        // onto one node with every end within its reach: a node of the
        // face's boundary where one stands among them, the nearest to a
        // vertex of the face first. A strand whose ends both land on the
        // node and which is no longer than the weld there is dust.
        let mut class: Vec<usize> = (0..ends.len()).collect();
        fn root(class: &mut [usize], mut i: usize) -> usize {
            while class[i] != i {
                class[i] = class[class[i]];
                i = class[i];
            }
            i
        }
        let mut welds: Vec<Junction> = Vec::new();
        let mut welded = false;
        // Two ends that each stand within a vertex's radius (its own and
        // its edge's) of the same vertex are that vertex: the curves a file
        // closes on one vertex can stop either side of it, each within the
        // radius. The vertex is one of this face's edges', or one ending
        // the other solid's edge a contact strand runs along. In the chart they stand as far apart as both their
        // reaches, or further where the chart stretches more than the
        // reaches allow for (a cylinder narrower than the radius turns a
        // quarter within it); there the stretch between them, read as an
        // edge is at seventeen points, lies within the vertex too, on a
        // chart with no pole's line: about a pole the whole chart may lie
        // within one vertex, and the pole's line is what joins the ends
        // there. Two ends at one point in space are no such gap: apart in
        // the chart, they stand on a pole's line, whose ends the pole keeps
        // apart.
        let poled = strands.iter().any(|st| matches!(st.tag, Tag::Pole { .. }));
        let one_vertex = |i: usize, j: usize| -> bool {
            let (a, b) = (ends[i].3, ends[j].3);
            let (from, to) = (ends[i].2, ends[j].2);
            if a.distance(b) <= tol.confusion() {
                return false;
            }
            let close = from.distance(to) <= reach[i] + reach[j];
            let contact_vertices = [i, j]
                .into_iter()
                .filter_map(|k| match strands[ends[k].0].tag {
                    Tag::Contact { contact, .. } => edge_vertices.get(&contacts[contact].node),
                    _ => None,
                })
                .flatten()
                .copied();
            face.edges
                .iter()
                .flat_map(|e| {
                    e.vertices
                        .iter()
                        .zip(e.ends)
                        .map(|(&v, (_, radius))| (v, radius + e.tolerance))
                })
                .chain(contact_vertices)
                .any(|(v, within)| {
                    a.distance(v) <= within
                        && b.distance(v) <= within
                        && (close
                            || !poled
                                && (1..16).all(|k| {
                                    let t = f64::from(k) / 16.0;
                                    let at = Point2::new(
                                        from.x + (to.x - from.x) * t,
                                        from.y + (to.y - from.y) * t,
                                    );
                                    face.surface
                                        .point_at(at.x, at.y, tol)
                                        .is_ok_and(|q| q.distance(v) <= within)
                                }))
                })
        };
        for i in 0..ends.len() {
            if reach[i] <= face_snap {
                continue;
            }
            for j in 0..ends.len() {
                if j != i && (ends[i].2.distance(ends[j].2) <= reach[i] || one_vertex(i, j)) {
                    let (ri, rj) = (root(&mut class, i), root(&mut class, j));
                    if ri != rj {
                        class[ri.max(rj)] = ri.min(rj);
                        welded = true;
                    }
                }
            }
        }
        if welded {
            let off_vertex = |q: Point| -> f64 {
                face.edges
                    .iter()
                    .flat_map(|e| e.ends.iter())
                    .map(|(v, _)| v.distance(q))
                    .fold(f64::INFINITY, f64::min)
            };
            let rank = |m: usize| {
                (
                    u8::from(!strands[ends[m].0].boundary),
                    off_vertex(ends[m].3),
                )
            };
            let mut node: Vec<Option<usize>> = vec![None; ends.len()];
            let mut weld_of = vec![0.0_f64; ends.len()];
            for (i, &weld) in reach.iter().enumerate() {
                let r = root(&mut class, i);
                weld_of[r] = weld_of[r].max(weld);
                let better = node[r].is_none_or(|k| {
                    let (x, y) = (rank(i), rank(k));
                    x.0.cmp(&y.0).then(x.1.total_cmp(&y.1)).is_lt()
                });
                if better {
                    node[r] = Some(i);
                }
            }
            // A node holding ends that stand apart in space is one vertex
            // there, on every face: a junction reaching each of them, unless
            // one the paving found holds them all already.
            let mut spread_of = vec![0.0_f64; ends.len()];
            let mut held = vec![true; ends.len()];
            for i in 0..ends.len() {
                let r = root(&mut class, i);
                if let Some(k) = node[r] {
                    spread_of[r] = spread_of[r].max(ends[k].3.distance(ends[i].3));
                    held[r] &= junctions.iter().any(|j| {
                        j.at.distance(ends[k].3) <= j.reach && j.at.distance(ends[i].3) <= j.reach
                    });
                }
            }
            for (r, k) in node.iter().enumerate() {
                if let Some(k) = *k
                    && spread_of[r] > tol.confusion() * 1e2
                    && !held[r]
                {
                    welds.push(Junction {
                        at: ends[k].3,
                        reach: spread_of[r] + tol.confusion() * 1e2,
                        onto_vertex: false,
                    });
                }
            }
            let lengths: Vec<f64> = strands
                .iter()
                .map(|st| chart_length(&st.polyline))
                .collect();
            let mut landed: Vec<[Option<usize>; 2]> = vec![[None, None]; strands.len()];
            for i in 0..ends.len() {
                let r = root(&mut class, i);
                let Some(k) = node[r] else {
                    continue;
                };
                let (si, end, at, _, _) = ends[i];
                let target = ends[k].2;
                // A node on a seam stands on both sides of it, and the end
                // is carried to the side it arrives from.
                strands[si].polyline[end] = period_shifts(&face.surface, tol)
                    .into_iter()
                    .map(|(du, dv)| Point2::new(target.x + du, target.y + dv))
                    .min_by(|p, q| p.distance(at).total_cmp(&q.distance(at)))
                    .unwrap_or(target);
                landed[si][usize::from(end != 0)] = Some(r);
            }
            for (si, st) in strands.iter_mut().enumerate() {
                if let [Some(a), Some(b)] = landed[si]
                    && a == b
                    && lengths[si] <= weld_of[a]
                {
                    if *DEBUG_STRANDS {
                        eprintln!(
                            "WELD from_a={from_a} fi={fi}: strand {si} is dust at its ends' weld {:.3e}",
                            weld_of[a]
                        );
                    }
                    st.polyline = vec![st.polyline[0], st.polyline[0]];
                }
            }
        }
        // A section that runs along one of this face's edges into its end
        // stops within the hug's width of the node the edge was split at,
        // and two sections meeting a rail that grazes this face stop on it
        // as far apart as the rail stays within tolerance of the face. The
        // junction there says each pair is one point. Where a chart unit is
        // shorter than a millimetre, or the graze long, that gap is wider in
        // the chart than the weld, and the section dangles beside the node it
        // ends at. Its end moves onto a boundary node the junction holds, or
        // onto the first section end already there.
        let mut anchors: Vec<(Option<usize>, Point2, Point)> = strands
            .iter()
            .filter(|st| st.boundary && st.polyline.len() >= 2)
            .flat_map(|st| [st.polyline[0], st.polyline[st.polyline.len() - 1]])
            .filter_map(|p| {
                face.surface
                    .point_at(p.x, p.y, tol)
                    .ok()
                    .map(|q| (None, p, q))
            })
            .collect();
        for st in strands
            .iter_mut()
            .filter(|st| matches!(st.tag, Tag::Section { .. }) && st.polyline.len() >= 2)
        {
            let last = st.polyline.len() - 1;
            let mut moved_into: Option<usize> = None;
            for at in [0, last] {
                let p = st.polyline[at];
                if anchors
                    .iter()
                    .any(|(held, n, _)| held.is_none() && n.distance(p) <= face_snap)
                {
                    continue;
                }
                let Ok(q) = face.surface.point_at(p.x, p.y, tol) else {
                    continue;
                };
                let Some((ji, junction)) = junctions
                    .iter()
                    .enumerate()
                    .filter(|(_, j)| j.at.distance(q) <= j.reach)
                    .min_by(|(a, x), (b, y)| {
                        x.at.distance(q).total_cmp(&y.at.distance(q)).then(a.cmp(b))
                    })
                else {
                    continue;
                };
                // The nearest in space the junction also holds, and reached
                // across the chart without leaving it: the chart's midpoint
                // of the two lies midway in space too, where a node in
                // another period's copy would not.
                let anchor = anchors
                    .iter()
                    .filter(|(held, _, s)| {
                        held.is_none_or(|h| h == ji) && junction.at.distance(*s) <= junction.reach
                    })
                    .filter(|(_, n, s)| {
                        face.surface
                            .point_at((n.x + p.x) / 2.0, (n.y + p.y) / 2.0, tol)
                            .is_ok_and(|m| m.distance(q.midpoint(*s)) <= junction.reach)
                    })
                    .min_by(|a, b| {
                        a.2.distance(q)
                            .partial_cmp(&b.2.distance(q))
                            .unwrap_or(core::cmp::Ordering::Equal)
                    })
                    .map(|(_, n, _)| *n);
                match anchor {
                    Some(n) => {
                        st.polyline[at] = n;
                        moved_into = Some(ji);
                    }
                    None => anchors.push((Some(ji), p, q)),
                }
            }
            // A piece of section lying wholly inside one junction, its ends
            // carried onto one node, is that junction: two crossings a
            // shallow angle leaves a hair apart along an edge bound a stub
            // of the section between them, and kept as a strand from the
            // node back to itself it encloses a sliver with no inside.
            // Carried to a point, it is dust, and the faces either side of
            // it drop it alike.
            if let Some(ji) = moved_into
                && st.polyline[0].distance(st.polyline[last]) <= face_snap
            {
                let junction = &junctions[ji];
                let mut inside = true;
                for p in &st.polyline {
                    inside &= face
                        .surface
                        .point_at(p.x, p.y, tol)
                        .is_ok_and(|q| junction.at.distance(q) <= junction.reach);
                }
                if inside {
                    st.polyline = vec![st.polyline[0], st.polyline[0]];
                }
            }
        }
        if *DEBUG_STRANDS {
            eprintln!(
                "FACE-SNAP from_a={from_a} fi={fi}: snap {face_snap:.3e} edges {:?}",
                face.edges
                    .iter()
                    .map(|e| (
                        format!("{:.2e}", e.tolerance),
                        format!("{:.2e}", e.ends_tolerance)
                    ))
                    .collect::<Vec<_>>()
            );
            for (si, st) in strands.iter().enumerate() {
                let tag = match st.tag {
                    Tag::Boundary { edge, range } => format!("Boundary e{edge} {range:?}"),
                    Tag::Contact { contact, range } => format!("Contact c{contact} {range:?}"),
                    Tag::Section { section, range } => format!("Section s{section} {range:?}"),
                    Tag::Pole { pole, range } => format!("Pole p{pole} {range:?}"),
                };
                let (a, b) = (st.polyline[0], st.polyline[st.polyline.len() - 1]);
                eprintln!(
                    "STRAND from_a={from_a} fi={fi} {si}: boundary={} {tag} pts={} {a:?} .. {b:?}",
                    st.boundary,
                    st.polyline.len()
                );
            }
        }
        Ok((strands, face_snap, welds))
    };
    // The identity of a piece across faces: a boundary or contact piece by
    // its edge node, a section piece by its section: the same section is
    // split the same way on both faces it cuts, and a piece that is dust
    // in a sphere's chart at the pole must be dust on the plane it also
    // lies in.
    let node_of = |face: &GFace, tag: &Tag| -> Option<(usize, usize, (f64, f64))> {
        match tag {
            Tag::Boundary { edge, range } => {
                Some((0, face.edges[*edge].node.index() as usize, *range))
            }
            Tag::Contact { contact, range } => {
                Some((1, contacts[*contact].node.index() as usize, *range))
            }
            Tag::Section { section, range } => Some((2, *section, *range)),
            Tag::Pole { .. } => None,
        }
    };
    /// A face's strands, its snap and the junctions its welds make,
    /// waiting to be arranged.
    type Prepared = Option<(Vec<Strand<Tag>>, f64, Vec<Junction>)>;
    // A face the other solid leaves alone (no section on it, no contact
    // into it, no edge of it split, no coincident partner, no pole, no
    // edge short enough to be anyone's dust) is one piece, itself, and is
    // neither split nor arranged: its rings are its own wires and its state
    // is read once. On a large solid and a small tool that is nearly every
    // face.
    let mut quiet: [Vec<bool>; 2] = [vec![true; ga.faces.len()], vec![true; gb.faces.len()]];
    for s in &sections {
        quiet[0][s.face_a] = false;
        quiet[1][s.face_b] = false;
    }
    for c in &contacts {
        quiet[usize::from(!c.target_from_a)][c.target_face] = false;
    }
    for t in &tangents {
        quiet[0][t.face_a] = false;
        quiet[1][t.face_b] = false;
    }
    for (side, solid, same) in [(0_usize, &ga, &same_a), (1, &gb, &same_b)] {
        for (fi, face) in solid.faces.iter().enumerate() {
            if !same[fi].is_empty()
                || !face.poles.is_empty()
                || face.edges.iter().any(|e| {
                    paves.contains_key(&e.node)
                        || e.ends[0].0.distance(e.ends[1].0) <= QUIET_EDGE
                        || e.bound.diagonal() <= QUIET_EDGE
                })
            {
                quiet[side][fi] = false;
            }
        }
    }
    let mut prepared: [Vec<Prepared>; 2] = [Vec::new(), Vec::new()];
    let mut dust: Vec<(usize, usize, (f64, f64))> = Vec::new();
    for (side, solid, from_a) in [(0_usize, &ga, true), (1, &gb, false)] {
        // A sheet's tool only cuts: its own faces are not split.
        if side == 1 && operands != Operands::Solids {
            break;
        }
        for (fi, face) in solid.faces.iter().enumerate() {
            ogeom_core::progress::checkpoint()?;
            if quiet[side][fi] {
                prepared[side].push(Some((Vec::new(), 0.0, Vec::new())));
                continue;
            }
            let (strands, snap, welds) = strands_of(from_a, fi, face)?;
            for st in &strands {
                if st.polyline.len() >= 2
                    && chart_length(&st.polyline) <= snap
                    && let Some(key) = node_of(face, &st.tag)
                {
                    dust.push(key);
                }
            }
            prepared[side].push(Some((strands, snap, welds)));
        }
    }
    ogeom_core::progress::stage("boolean: split arrange");
    let same_key = |a: &(usize, usize, (f64, f64)), b: &(usize, usize, (f64, f64))| {
        a.0 == b.0
            && a.1 == b.1
            && (a.2.0 - b.2.0).abs() <= tol.parametric()
            && (a.2.1 - b.2.1).abs() <= tol.parametric()
    };
    // The other solid's boundary, prepared once per side. It is asked once
    // per face piece, and what it costs to prepare (every face's trimming
    // rings, polylined) does not depend on the point being asked about.
    // Rebuilt per question, the preparation costs hundreds of times the
    // question.
    // A sheet bounds nothing, so nothing is classified against one.
    let boundaries = [
        if matches!(operands, Operands::SheetBySheet | Operands::Itself) {
            None
        } else {
            Some(ogeom_algo::SolidBoundary::of_kept(
                model,
                &gb.solid,
                tol.confusion() * 1e4,
                gb.closed,
                tol,
            )?)
        },
        // A solid of one shell whose edges setting faces aside read closed
        // is not asked again.
        if operands == Operands::Solids {
            Some(ogeom_algo::SolidBoundary::of_kept(
                model,
                &ga.solid,
                tol.confusion() * 1e4,
                ga.closed,
                tol,
            )?)
        } else {
            None
        },
    ];
    // Each face is split and its pieces classified on its own: it reads
    // the two solids, the sections, the contacts and the junctions found
    // so far, and writes only its own pieces and the junctions it adds. So
    // the faces run in parallel, and their findings are joined in face
    // order, the order one thread would have made them in.
    type FaceWork = std::sync::Mutex<Prepared>;
    let mut work: Vec<(bool, usize, FaceWork)> = Vec::new();
    for (side, slots) in prepared.iter_mut().enumerate() {
        for (fi, slot) in slots.iter_mut().enumerate() {
            let Some(prepared_face) = slot.take() else {
                ogeom_bail!(Construction, "a face was prepared twice");
            };
            work.push((side == 0, fi, std::sync::Mutex::new(Some(prepared_face))));
        }
    }
    let found = ogeom_core::parallel::map_ordered(
        &work,
        |_, (from_a, fi, prepared_face)| -> OgeomResult<(Vec<FacePiece>, Vec<Junction>)> {
            ogeom_core::progress::checkpoint()?;
            let (from_a, fi) = (*from_a, *fi);
            let (own, other, boundary) = if from_a {
                (&ga, &gb.solid, boundaries[0].as_ref())
            } else {
                (&gb, &ga.solid, boundaries[1].as_ref())
            };
            let face = &own.faces[fi];
            let mut junctions: Vec<Junction> = Vec::new();
            let Some((mut strands, mut face_snap, welds)) = prepared_face
                .lock()
                .map_err(|_| ogeom_core::ogeom_err!(Construction, "a face's work was poisoned"))?
                .take()
            else {
                ogeom_bail!(Construction, "a face was prepared twice");
            };
            junctions.extend(welds);
            if quiet[usize::from(!from_a)][fi] {
                if let Some(piece) = quiet_piece(model, from_a, fi, face, boundary, tol)? {
                    return Ok((vec![piece], Vec::new()));
                }
                // Read on the other solid after all: split it as any face.
                let welds;
                (strands, face_snap, welds) = strands_of(from_a, fi, face)?;
                junctions.extend(welds);
            }
            let mut pieces: Vec<FacePiece> = Vec::new();
            // A strand's ends in space, or none for a pole.
            let space_ends = |face: &GFace, tag: &Tag| -> OgeomResult<Option<(Point, Point)>> {
                Ok(Some(match tag {
                    Tag::Boundary { edge, range } => {
                        let e = &face.edges[*edge];
                        (
                            e.curve.point_at(range.0, tol)?,
                            e.curve.point_at(range.1, tol)?,
                        )
                    }
                    Tag::Contact { contact, range } => {
                        let c = &contacts[*contact];
                        (
                            c.curve.point_at(range.0, tol)?,
                            c.curve.point_at(range.1, tol)?,
                        )
                    }
                    Tag::Section { section, range } => {
                        let sec = &sections[*section];
                        let domain = sec.curve.domain();
                        (
                            sec.curve
                                .point_at(at_param(range.0, domain, sec.closed), tol)?,
                            sec.curve
                                .point_at(at_param(range.1, domain, sec.closed), tol)?,
                        )
                    }
                    Tag::Pole { .. } => return Ok(None),
                }))
            };
            // A strand this face's own weld collapses is one point in space
            // as well: its ends become one junction, or the pieces either
            // side of it end on two vertices the chart says are one, and a
            // loop cut at a seam a few microns from its own start closes in
            // the chart and stays open in space.
            for st in &strands {
                if st.polyline.len() >= 2
                    && chart_length(&st.polyline) <= face_snap
                    && let Some((from, to)) = space_ends(face, &st.tag)?
                    && from.distance(to) > tol.confusion() * 1e2
                {
                    junctions.push(Junction {
                        at: from.midpoint(to),
                        reach: from.distance(to) / 2.0 + tol.confusion() * 1e2,
                        onto_vertex: false,
                    });
                }
            }
            // A piece some other chart already collapsed collapses here too:
            // its ends become one node, every neighbour meeting them moves
            // onto it, and one junction owns the span in space so the
            // rebuilt vertices agree on every face.
            let forced: Vec<usize> = strands
                .iter()
                .enumerate()
                .filter(|(_, st)| {
                    st.polyline.len() >= 2
                        && chart_length(&st.polyline) > face_snap
                        && node_of(face, &st.tag)
                            .is_some_and(|k| dust.iter().any(|d| same_key(d, &k)))
                })
                .map(|(i, _)| i)
                .collect();
            if !forced.is_empty() {
                let mut reps: Vec<(Point2, usize)> = Vec::new();
                let canon = |p: Point2, reps: &mut Vec<(Point2, usize)>| -> usize {
                    match reps.iter().position(|(q, _)| q.distance(p) <= face_snap) {
                        Some(i) => i,
                        None => {
                            reps.push((p, reps.len()));
                            reps.len() - 1
                        }
                    }
                };
                fn root(reps: &mut [(Point2, usize)], mut i: usize) -> usize {
                    while reps[i].1 != i {
                        reps[i].1 = reps[reps[i].1].1;
                        i = reps[i].1;
                    }
                    i
                }
                for &i in &forced {
                    let st = &strands[i];
                    let a = canon(st.polyline[0], &mut reps);
                    let b = canon(st.polyline[st.polyline.len() - 1], &mut reps);
                    let (ra, rb) = (root(&mut reps, a), root(&mut reps, b));
                    if ra != rb {
                        reps[rb].1 = ra;
                    }
                    let Some((from, to)) = space_ends(face, &st.tag)? else {
                        continue;
                    };
                    if *DEBUG_STRANDS {
                        eprintln!(
                            "DUST from_a={from_a} fi={fi}: strand {i} collapses with its partners, {from:?} -> {to:?}"
                        );
                    }
                    junctions.push(Junction {
                        at: from.midpoint(to),
                        reach: from.distance(to) / 2.0 + tol.confusion() * 1e2,
                        onto_vertex: false,
                    });
                }
                for (i, st) in strands.iter_mut().enumerate() {
                    if forced.contains(&i) {
                        continue;
                    }
                    let last = st.polyline.len() - 1;
                    for end in [0, last] {
                        if let Some(k) = reps
                            .iter()
                            .position(|(q, _)| q.distance(st.polyline[end]) <= face_snap)
                        {
                            let r = root(&mut reps, k);
                            st.polyline[end] = reps[r].0;
                        }
                    }
                }
                let mut index = 0_usize;
                strands.retain(|_| {
                    let keep = !forced.contains(&index);
                    index += 1;
                    keep
                });
            }
            // A hole nothing comes near is walked on its own, and the face's
            // walk is spared it: a face crossed by a small tool can hold
            // hundreds of holes the tool never reaches.
            let lone = lone_holes(model, face, &strands, face_snap)?;
            let every: Vec<usize>;
            let (walked, places, lone): (&[Strand<Tag>], &[usize], &[arrange::Lone<Tag>]) =
                match &lone {
                    Some((rest, places, lone)) => (rest, places, lone),
                    None => {
                        every = (0..strands.len()).collect();
                        (&strands, &every, &[])
                    }
                };
            let split = match arrange_pieces(walked, places, face_snap, lone) {
                Ok(split) => split,
                Err(err) => {
                    if *ARRANGE_DEBUG {
                        eprintln!("ARRANGE from_a={from_a} fi={fi} failed: {err}");
                        for (si, st) in strands.iter().enumerate() {
                            let (a, b) = (st.polyline[0], st.polyline[st.polyline.len() - 1]);
                            let describe = |curve: &Curve, range: (f64, f64)| -> String {
                                let mid = curve
                                    .point_at(f64::midpoint(range.0, range.1), tol)
                                    .map(|p| format!("({:.4},{:.4},{:.4})", p.x, p.y, p.z))
                                    .unwrap_or_default();
                                match curve {
                                    Curve::Circle(c) => format!(
                                        "circle centre {:?} r {:.4} mid {mid}",
                                        c.circle().centre(),
                                        c.circle().radius()
                                    ),
                                    other => {
                                        format!("{:?} mid {mid}", core::mem::discriminant(other))
                                    }
                                }
                            };
                            let geometry = match st.tag {
                                Tag::Boundary { edge, range } => {
                                    describe(&face.edges[edge].curve, range)
                                }
                                Tag::Contact { contact, range } => {
                                    format!(
                                        "{} window {:?} along {:?} node {}",
                                        describe(&contacts[contact].curve, range),
                                        contacts[contact].crange,
                                        contact_along[contact],
                                        contacts[contact].node.index()
                                    )
                                }
                                _ => String::new(),
                            };
                            eprintln!("    {geometry}");
                            eprintln!(
                                "  strand {si} boundary={} {:?} {a:?} .. {b:?}",
                                st.boundary,
                                match st.tag {
                                    Tag::Boundary { edge, range } =>
                                        format!("Boundary e{edge} {range:?}"),
                                    Tag::Contact { contact, range } =>
                                        format!("Contact c{contact} {range:?}"),
                                    Tag::Section { section, range } =>
                                        format!("Section s{section} {range:?}"),
                                    Tag::Pole { pole, range } => format!("Pole p{pole} {range:?}"),
                                }
                            );
                        }
                    }
                    return Err(err);
                }
            };
            for mut piece in split {
                let Some(boundary) = boundary else {
                    let probe = face.surface.point_at(piece.first.x, piece.first.y, tol)?;
                    pieces.push(FacePiece {
                        from_a,
                        face: fi,
                        rings: piece.rings,
                        outlines: piece.outlines,
                        probe,
                        state: PieceState::Unread,
                        covered: false,
                        whole: false,
                    });
                    continue;
                };
                // Where a piece stands is asked at its interior probes in
                // turn. The first is the roomiest, and usually the only one
                // needed. The rest are for the piece that merely *touches*
                // the other solid, whose roomiest probe can land on the
                // contact and read neither in nor out.
                //
                // A partner face is asked before the classifier, not after.
                // Where a piece sits on a surface the other solid also
                // carries, the partner *is* the answer, and getting there
                // through the classifier means every ray grazing the shared
                // face, its whole fan of directions exhausted, before it
                // reports the On the partner list already knew, which on a
                // part whose bore is refilled by its own cylinder is orders
                // of magnitude slower.
                //
                // A probe every ray from which is ambiguous (one a hair off
                // the other solid's faces, where they run along this one)
                // says nothing either way, and the next is asked. Only a
                // piece none of whose probes can be read is refused.
                let partners = if from_a { &same_a[fi] } else { &same_b[fi] };
                let mut chosen = None;
                let mut unread = None;
                // What a probe reads: on a coincident partner, or what the
                // other solid's boundary says.
                let ask = |candidate: Point2| -> OgeomResult<(Point, OgeomResult<Containment>)> {
                    let at = face.surface.point_at(candidate.x, candidate.y, tol)?;
                    let shared = !partners.is_empty()
                        && partners.iter().any(|&pi| {
                            let partner = if from_a { &gb.faces[pi] } else { &ga.faces[pi] };
                            chart_point_within(partner, at, partner_reach(face, partner, tol), tol)
                                .is_some()
                        });
                    if shared {
                        return Ok((at, Ok(Containment::On)));
                    }
                    match boundary.holds(model, at, tol) {
                        Err(e @ ogeom_core::OgeomError::NotDone(_)) => Ok((at, Err(e))),
                        Err(e) => Err(e),
                        says => Ok((at, says)),
                    }
                };
                // The roomiest probe settles most pieces on its own, so it is
                // asked before the rest are found, wherever the rest could not
                // change whether it is asked first: on a face that is not a
                // plane every probe is kept, and on a plane bounded by lines
                // and circles its exact rings' count for it does not depend on
                // the rings drawn for the rest. Where it reads neither in nor
                // out, every probe is asked in turn below, as if it had not
                // been.
                let first_kept = match face.surface {
                    SurfaceGeometry::Plane(_) => {
                        let drawn = piece.rings.iter().flatten().all(|t| {
                            fine_strand(face, &sections, from_a, &t.tag).is_some_and(|s| {
                                matches!(s.0, PlanarCurve::Line(_) | PlanarCurve::Circle(_))
                            })
                        });
                        drawn
                            .then(|| {
                                FineRings::of(face, &piece.rings, &sections, from_a, None, tol)
                            })
                            .flatten()
                            .and_then(|every| {
                                let reached = rings_near(&piece.outlines, &[piece.first]);
                                every.inside_beside(piece.first, &reached)
                            })
                    }
                    _ => Some(true),
                };
                if first_kept == Some(true)
                    && let (at, Ok(says @ (Containment::In | Containment::Out))) = ask(piece.first)?
                {
                    chosen = Some((piece.first, at, says));
                }
                // A planar piece's probes are held to its exact rings, and
                // where none of them is inside those, the rings offer their
                // own: a sliver narrower than the outline's chords bow has
                // every coarse probe in a neighbour.
                // Only the rings a probe's ray can cross are drawn finely: on a
                // face with hundreds of holes the rest are far from every probe.
                let mut fine = None;
                if chosen.is_none() {
                    let mut interiors: Vec<Point2> = piece.interiors().to_vec();
                    let reached = rings_near(&piece.outlines, &interiors);
                    fine =
                        FineRings::of(face, &piece.rings, &sections, from_a, Some(&reached), tol);
                    if let Some(fine) = &fine {
                        interiors.retain(|p| fine.inside(*p));
                        if interiors.is_empty()
                            && let Some(every) =
                                FineRings::of(face, &piece.rings, &sections, from_a, None, tol)
                        {
                            interiors =
                                arrange::interior_points_of(&every.points(), tol.parametric());
                        }
                    }
                    for candidate in &interiors {
                        let says = match ask(*candidate)? {
                            (at, Ok(says)) => (at, says),
                            (_, Err(e)) => {
                                unread = Some(e);
                                continue;
                            }
                        };
                        if chosen.is_none() || !matches!(says.1, Containment::On) {
                            chosen = Some((*candidate, says.0, says.1));
                        }
                        if !matches!(says.1, Containment::On) {
                            break;
                        }
                    }
                }
                // On the attempt after kept pieces failed to close, a piece
                // is read at the centre of its area where that lies inside
                // it: the roomiest probe can stand by a corner, and a face
                // leaning microradians off the other solid's, the two
                // sharing an edge, reads within rounding of it there.
                if read_at_centre
                    && matches!(chosen, Some((_, _, Containment::In | Containment::Out)))
                    && let Some(centre) = arrange::centroid_of(&piece.outlines)
                    && arrange::inside_rings(&piece.outlines, centre)
                {
                    if fine.is_none() {
                        let reached = rings_near(&piece.outlines, &[centre]);
                        fine = FineRings::of(
                            face,
                            &piece.rings,
                            &sections,
                            from_a,
                            Some(&reached),
                            tol,
                        );
                    }
                    if fine.as_ref().is_none_or(|f| f.inside(centre)) {
                        let at = face.surface.point_at(centre.x, centre.y, tol)?;
                        if let Ok(says @ (Containment::In | Containment::Out)) =
                            boundary.holds(model, at, tol)
                        {
                            chosen = Some((centre, at, says));
                        }
                    }
                }
                let Some((interior, probe, said)) = chosen else {
                    if let Some(e) = unread {
                        return Err(e);
                    }
                    ogeom_bail!(
                        Construction,
                        "a piece of a face has no interior point to classify at"
                    );
                };
                // On the last attempt, a piece thinner than the band the
                // other solid is read within, every probe of it on that
                // solid's boundary, is read by the strands bounding it.
                let thin = if read_thin && matches!(said, Containment::On) {
                    let theirs = if from_a { &gb } else { &ga };
                    thin_by_strands(face, &piece.rings, &piece.outlines, &contacts, theirs, tol)?
                } else {
                    Thin::Wide
                };
                match thin {
                    Thin::Reads(state) => {
                        pieces.push(FacePiece {
                            from_a,
                            face: fi,
                            rings: piece.rings,
                            outlines: piece.outlines,
                            probe,
                            state,
                            covered: false,
                            whole: false,
                        });
                        continue;
                    }
                    Thin::Disagree => ogeom_bail!(
                        NotDone,
                        "a piece thinner than the boolean reads the other solid \
                         within lies beside that solid's edges on sides that \
                         disagree on whether it is inside: it is dust the \
                         boolean does not resolve"
                    ),
                    Thin::Wide | Thin::Undecided => {}
                }
                let state = match said {
                    Containment::In => PieceState::In,
                    Containment::Out => PieceState::Out,
                    Containment::On => {
                        // On the other boundary: same-domain contact. The
                        // partner face on the shared surface decides whether
                        // the two materials lie on the same side or oppose.
                        let own_normal = outward_normal(face, interior, tol)?;
                        let mut resolved = None;
                        for &pi in partners {
                            let partner = if from_a { &gb.faces[pi] } else { &ga.faces[pi] };
                            let Some(uv) = chart_point_within(
                                partner,
                                probe,
                                partner_reach(face, partner, tol),
                                tol,
                            ) else {
                                continue;
                            };
                            let theirs = outward_normal(partner, uv, tol)?;
                            resolved = Some(if own_normal.dot(theirs) > 0.0 {
                                PieceState::OnAligned
                            } else {
                                PieceState::OnOpposed
                            });
                            break;
                        }
                        let Some(state) = resolved else {
                            // On with no partner containing the probe: the
                            // band's generosity may have read proximity as
                            // coincidence. Ask again at a width where it
                            // cannot. What stays on the boundary there is a
                            // genuine contact, settled below.
                            match ogeom_algo::classify_in_solid_exact_banded(
                                model,
                                other,
                                probe,
                                tol.confusion() * 10.0,
                                tol,
                            )? {
                                Containment::In => {
                                    pieces.push(FacePiece {
                                        from_a,
                                        face: fi,
                                        rings: piece.rings,
                                        outlines: piece.outlines,
                                        probe,
                                        state: PieceState::In,
                                        covered: false,
                                        whole: false,
                                    });
                                    continue;
                                }
                                Containment::Out => {
                                    pieces.push(FacePiece {
                                        from_a,
                                        face: fi,
                                        rings: piece.rings,
                                        outlines: piece.outlines,
                                        probe,
                                        state: PieceState::Out,
                                        covered: false,
                                        whole: false,
                                    });
                                    continue;
                                }
                                Containment::On => {}
                            }
                            // Every probe the piece offered stands on the
                            // other solid's boundary, and none on a coincident
                            // face. Where the two touch only along lines or at
                            // points the piece does not cross the other
                            // boundary there (a crossing would have split it),
                            // so it lies wholly on one side, and any point of
                            // it off the contact says which. Points at golden
                            // fractions of the piece's extent miss a contact
                            // that met its halves and quarters. Where they
                            // read on the boundary too, the contact covers a
                            // region, which is not this case.
                            let mut off_contact = None;
                            for candidate in
                                arrange::off_contact_points(&piece.outlines, tol.parametric())
                            {
                                if !arrange::inside_rings(&piece.outlines, candidate)
                                    || fine.as_ref().is_some_and(|f| !f.inside(candidate))
                                {
                                    continue;
                                }
                                let at = face.surface.point_at(candidate.x, candidate.y, tol)?;
                                match boundary.holds(model, at, tol) {
                                    Ok(Containment::In) => {
                                        off_contact = Some(PieceState::In);
                                        break;
                                    }
                                    Ok(Containment::Out) => {
                                        off_contact = Some(PieceState::Out);
                                        break;
                                    }
                                    Ok(Containment::On)
                                    | Err(ogeom_core::OgeomError::NotDone(_)) => {}
                                    Err(e) => return Err(e),
                                }
                            }
                            if let Some(state) = off_contact {
                                pieces.push(FacePiece {
                                    from_a,
                                    face: fi,
                                    rings: piece.rings,
                                    outlines: piece.outlines,
                                    probe,
                                    state,
                                    covered: false,
                                    whole: false,
                                });
                                continue;
                            }
                            // Still on it, on the boolean's second attempt
                            // (see [`settled`]): a face all but coplanar with
                            // the other's, crossing it at a hair's angle, keeps
                            // a sliver within tolerance of it with no
                            // coincident partner. Just off the piece on both
                            // sides the other solid answers plainly: the
                            // same on both, the piece is that. Inside only
                            // on the piece's own material side, the other's
                            // face runs along it backed the same way, the
                            // aligned contact, which the first solid's piece
                            // speaks for. Inside only beyond it, opposed.
                            if settle {
                                let off = own_normal * (tol.confusion() * 1e3);
                                let side = |q: Point| {
                                    ogeom_algo::classify_in_solid_exact_banded(
                                        model,
                                        other,
                                        q,
                                        tol.confusion() * 10.0,
                                        tol,
                                    )
                                };
                                let (beyond, within) = (side(probe + off)?, side(probe - off)?);
                                let read = match (beyond, within) {
                                    (Containment::In, Containment::In) => {
                                        Some((PieceState::In, false))
                                    }
                                    (Containment::Out, Containment::Out) => {
                                        Some((PieceState::Out, false))
                                    }
                                    (Containment::Out, Containment::In) => {
                                        Some((PieceState::OnAligned, !from_a))
                                    }
                                    (Containment::In, Containment::Out) => {
                                        Some((PieceState::OnOpposed, false))
                                    }
                                    _ => None,
                                };
                                if let Some((state, covered)) = read {
                                    pieces.push(FacePiece {
                                        from_a,
                                        face: fi,
                                        rings: piece.rings,
                                        outlines: piece.outlines,
                                        probe,
                                        state,
                                        covered,
                                        whole: false,
                                    });
                                    continue;
                                }
                            }
                            if *DEBUG_WIRE {
                                eprintln!(
                                    "ON-CONTACT piece of {} face {fi} probe {probe:?} partners {partners:?}",
                                    if from_a { "A" } else { "B" }
                                );
                            }
                            ogeom_bail!(
                                NotDone,
                                "a piece lies on the other solid's boundary \
                             at every point it was asked at, with no \
                             coincident partner face to compare sides \
                             against; a contact over a region of faces not \
                             recognised as coincident is refused; see the \
                             open items in docs/PLAN.md"
                            );
                        };
                        state
                    }
                };
                pieces.push(FacePiece {
                    from_a,
                    face: fi,
                    rings: piece.rings,
                    outlines: piece.outlines,
                    probe,
                    state,
                    covered: false,
                    whole: false,
                });
            }
            // A face nothing crosses, its boundary unsplit, is one piece:
            // itself.
            let untouched = strands.iter().all(|st| match &st.tag {
                Tag::Boundary { edge, range } => {
                    let full = face.edges[*edge].crange;
                    (range.0.min(range.1) - full.0.min(full.1)).abs() <= tol.parametric()
                        && (range.0.max(range.1) - full.0.max(full.1)).abs() <= tol.parametric()
                }
                Tag::Pole { .. } => true,
                Tag::Section { .. } | Tag::Contact { .. } => false,
            });
            if untouched
                && let [piece] = pieces.as_mut_slice()
                && matches!(
                    piece.state,
                    PieceState::In | PieceState::Out | PieceState::Unread
                )
            {
                piece.whole = true;
            }

            Ok((pieces, junctions))
        },
    );
    for face in found {
        let (face_pieces, face_junctions) = face?;
        pieces.extend(face_pieces);
        junctions.extend(face_junctions);
    }
    let coincident = mark_covered_coincidences(&ga, &gb, &mut pieces, tol);
    if *ARRANGE_DEBUG {
        for (fi, partners) in same_a.iter().enumerate() {
            if !partners.is_empty() {
                eprintln!("SAME a{fi} with b{partners:?}");
            }
        }
        for (ci, contact) in contacts.iter().enumerate() {
            eprintln!(
                "CONTACT c{ci} onto {}{} over {:?} prange {:?} node {} pcurve {:?}",
                if contact.target_from_a { "a" } else { "b" },
                contact.target_face,
                contact.crange,
                contact.prange,
                contact.node.index(),
                contact.pcurve
            );
        }
        for (i, p) in pieces.iter().enumerate() {
            let own = if p.from_a {
                &ga.faces[p.face]
            } else {
                &gb.faces[p.face]
            };
            let kind = match &own.surface {
                SurfaceGeometry::Plane(_) => "plane",
                SurfaceGeometry::Cylinder(_) => "cyl",
                SurfaceGeometry::Torus(_) => "torus",
                SurfaceGeometry::BSpline(_) => "bspline",
                _ => "other",
            };
            eprintln!(
                "PIECE {i} from_a={} face={} {kind} state={:?} covered={} probe={:?} rings {:?}",
                p.from_a,
                p.face,
                p.state,
                p.covered,
                p.probe,
                p.rings.iter().map(Vec::len).collect::<Vec<_>>()
            );
        }
    }
    ogeom_core::progress::stage("boolean: classified");
    // Merged again: the arrangement adds junctions of its own (a strand
    // that collapsed with its partners becomes one) after the first
    // merge, and two of those at one triple point, each within the other's
    // reach, weld the ends of one band to two vertices with a hairline
    // between them.
    let junctions = merge_junctions(junctions);
    Ok(GeneralFused {
        a: ga,
        b: gb,
        sections,
        contacts,
        tangents,
        pieces,
        coincident,
        junctions,
    })
}

// --- rebuilding --------------------------------------------------------------

/// Everything the rebuild shares across pieces.
struct Rebuild<'m> {
    model: &'m mut Model,
    /// World surface ids, minted once per source face.
    surfaces_a: Vec<Option<ogeom_topo::SurfaceId>>,
    surfaces_b: Vec<Option<ogeom_topo::SurfaceId>>,
    /// Vertices shared by position: a wire's connectivity is checked by node
    /// identity, so two sub-edges meeting at a point must *name* the same
    /// vertex, not merely coincide there.
    vertices: Vec<(Point, Shape)>,
    /// `vertices` binned by position.
    vertex_bins: bins::Bins,
    /// The entries a bin query found, kept between queries.
    near: Vec<usize>,
    /// The widest tolerance any vertex in `vertices` holds: every widening
    /// of one goes through [`Rebuild::vertex`] or [`Rebuild::widen`], so an
    /// end is compared only with the vertices this far and a weld from it.
    widest: f64,
    /// How far two honest descriptions of one junction may sit apart: a
    /// hundred confusions as the floor, widened to three times the loosest
    /// contact edge's or fitted section's own tolerance when one took part:
    /// the strand's own, the crossing's, and the edge's it stopped on.
    weld: f64,
    /// The paving's junctions, each minted as a vertex the first time a
    /// strand end lands inside it.
    junctions: Vec<(Junction, Option<Shape>)>,
    /// `junctions` binned by position.
    junction_bins: bins::Bins,
    /// The widest reach of any junction.
    junction_reach: f64,
    /// Vertices minted from junctions at an edge's own end vertex, which a
    /// tangent section's chart image is bent onto.
    onto_vertex: ogeom_core::FastSet<ogeom_topo::TShapeId>,
    /// Boundary edges rebuilt whole, by the edge they were: the face on the
    /// other side of one finds it built and adds its own pcurve, where a
    /// second build would leave the sew a twin to find.
    whole_edges: ogeom_core::FastMap<EdgeKey, Shape>,
    /// The vertices of edges shared with faces set aside, which the rebuild
    /// names as they are and never changes, each where it stands.
    kept: ogeom_core::FastMap<ogeom_topo::TShapeId, Point>,
    /// Whether a strand end asked a kept vertex to reach further than it
    /// does.
    strained: bool,
}

impl Rebuild<'_> {
    fn vertex(&mut self, p: Point, tol: Tolerances) -> Shape {
        // A junction several paves described is one vertex owning the span
        // they disagree by, and every strand end inside it names that
        // vertex, whichever pave its own trim stopped at.
        // The rim is as generous as the positional weld below: two strand
        // ends a weld apart must not fall on opposite sides of it.
        let slack = self.weld.max(tol.confusion() * 1e2);
        if *DEBUG_WIRE {
            eprintln!("VERTEX ask {p:?}");
        }
        let reach = self.junction_reach;
        let inside = |slot: &usize| {
            let j = &self.junctions[*slot].0;
            j.at.distance(p) <= j.reach + slack
        };
        let mut near = core::mem::take(&mut self.near);
        let first = if self.junction_bins.near_into(p, reach + slack, &mut near) {
            near.iter().copied().find(inside)
        } else {
            (0..self.junctions.len()).find(inside)
        };
        if let Some(slot) = first {
            let junction = self.junctions[slot].0;
            let shape = match &self.junctions[slot].1 {
                Some(shape) => shape.clone(),
                None => {
                    let shape = make_vertex(self.model, junction.at).shape;
                    self.junctions[slot].1 = Some(shape.clone());
                    self.remember(junction.at, &shape);
                    shape
                }
            };
            self.near = near;
            if junction.onto_vertex {
                self.onto_vertex.insert(shape.node());
            }
            // The junction owns its span, and an end welded in from the rim
            // widens it by what it actually sat off by, as any weld does.
            let gap = junction.at.distance(p);
            if let Some(node) = self.model.node_mut(&shape)
                && let ogeom_topo::NodeData::Vertex(data) = node.data_mut()
            {
                // A confusion of slack past the measured gap: an edge built
                // against this vertex measures the same gap through its own
                // rounding, and a tolerance equal to it fails by an ulp.
                data.tolerance = data
                    .tolerance
                    .widen_to(junction.reach.max(gap) + tol.confusion());
            }
            self.note_tolerance(&shape);
            return shape;
        }
        // The weld reach covers what the inputs may honestly disagree by: a
        // boundary curve that is itself a fitted intersection from an
        // earlier boolean carries a couple of microns of slop, and two
        // descriptions of one junction arrive that far apart. A hundred
        // confusions at millimetre tolerances is ten microns, below any
        // feature this pipeline can resolve, and every weld wider than
        // confusion is recorded on the vertex, not papered over.
        // And as far again as the vertex already owns: a vertex widened by
        // the descriptions it has taken in claims its point within that
        // tolerance, an end arriving within that and the weld of it may be
        // the same point, and a boolean cannot show it is not. Several
        // descriptions of one junction (three bands meeting at an apex)
        // can arrive in turn, each within the last's reach and none within
        // the first's, and measured from the first alone the wire round
        // the band's end has two vertices where it needs one. So every end
        // taken in is remembered where it arrived, and the next end is
        // measured from the description nearest it.
        let floor = self.weld.max(tol.confusion() * 1e2);
        if !self
            .vertex_bins
            .near_into(p, floor + self.widest, &mut near)
        {
            near.extend(0..self.vertices.len());
        }
        let found = near
            .iter()
            .filter_map(|&index| {
                let (q, shape) = &self.vertices[index];
                let own = self
                    .model
                    .node(shape)
                    .and_then(|n| n.data().as_vertex())
                    .map_or(0.0, |d| d.tolerance.get());
                let gap = q.distance(p);
                (gap <= floor.max(own + floor)).then_some((gap, index))
            })
            .min_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(core::cmp::Ordering::Equal))
            .map(|(gap, index)| (gap, self.vertices[index].1.clone()));
        self.near = near;
        if let Some((gap, shape)) = found {
            // Two descriptions of one junction may disagree by a general
            // crossing's residual. The vertex's tolerance is where that
            // disagreement is recorded, so the sub-edges built against
            // either description still reach it honestly.
            let (at, own) = self
                .model
                .node(&shape)
                .and_then(|n| n.data().as_vertex())
                .map_or((p, 0.0), |d| (d.point, d.tolerance.get()));
            let off = at.distance(p);
            if let Some(stands) = self.kept.get(&shape.node()) {
                // A kept vertex is never widened: an end it does not reach
                // as it stands strains the rebuild.
                let off = stands.distance(p);
                self.strained |= off > tol.confusion() && off + tol.confusion() > own;
            } else if off > tol.confusion()
                && let Some(node) = self.model.node_mut(&shape)
                && let ogeom_topo::NodeData::Vertex(data) = node.data_mut()
            {
                data.tolerance = data.tolerance.widen_to(off + tol.confusion());
            }
            self.note_tolerance(&shape);
            if gap > tol.confusion() {
                self.remember(p, &shape);
            }
            return shape;
        }
        let shape = make_vertex(self.model, p).shape;
        self.remember(p, &shape);
        shape
    }

    /// Take in `shape` as described at `p`.
    fn remember(&mut self, p: Point, shape: &Shape) {
        self.vertex_bins.insert(p, self.vertices.len());
        self.vertices.push((p, shape.clone()));
        self.note_tolerance(shape);
    }

    /// Keep `widest` covering `shape`'s tolerance.
    fn note_tolerance(&mut self, shape: &Shape) {
        if let Some(data) = self.model.node(shape).and_then(|n| n.data().as_vertex()) {
            self.widest = self.widest.max(data.tolerance.get());
        }
    }

    /// Widen a vertex this rebuild handed out. A kept vertex is not
    /// widened: one that would need it strains the rebuild.
    fn widen(&mut self, vertex: &Shape, to: f64) -> OgeomResult<()> {
        if self.kept.contains_key(&vertex.node()) {
            let own = self
                .model
                .node(vertex)
                .and_then(|n| n.data().as_vertex())
                .map_or(0.0, |d| d.tolerance.get());
            self.strained |= own < to;
            return Ok(());
        }
        self.model.widen(vertex, ogeom_core::Tolerance::new(to)?)?;
        self.note_tolerance(vertex);
        Ok(())
    }

    fn surface_id(
        &mut self,
        fused: &GeneralFused,
        from_a: bool,
        face: usize,
    ) -> ogeom_topo::SurfaceId {
        let slot = if from_a {
            &mut self.surfaces_a[face]
        } else {
            &mut self.surfaces_b[face]
        };
        if let Some(id) = slot {
            return *id;
        }
        let own = if from_a {
            fused.a.faces[face].own_surface
        } else {
            fused.b.faces[face].own_surface
        };
        if let Some(id) = own {
            *slot = Some(id);
            return id;
        }
        let surface = if from_a {
            fused.a.faces[face].surface.clone()
        } else {
            fused.b.faces[face].surface.clone()
        };
        let id = self.model.geometry_mut().add_surface(surface);
        *slot = Some(id);
        id
    }
}

/// The sub-edges built of each strand of a piece, keyed by strand, each
/// with the parameter range it covers, in the order they were built.
type StrandEdges = ogeom_core::FastMap<(usize, u8), Vec<((f64, f64), Shape)>>;

/// Build one piece as a face, orientation matching its source face's side.
fn build_piece(
    rebuild: &mut Rebuild,
    fused: &GeneralFused,
    piece: &FacePiece,
    tol: Tolerances,
) -> OgeomResult<Option<Shape>> {
    let own = if piece.from_a { &fused.a } else { &fused.b };
    let face = &own.faces[piece.face];
    let surface_id = rebuild.surface_id(fused, piece.from_a, piece.face);

    // Sub-edges cached within the piece, so a seam used from both sides is
    // one edge appearing twice. Keyed by strand, each with the ranges built
    // of it in order.
    let mut cache: StrandEdges = ogeom_core::FastMap::default();
    let mut wires = Vec::new();
    for ring in &piece.rings {
        let mut edges = Vec::with_capacity(ring.len());
        // The edges shared with faces set aside this ring has taken, each
        // the way it runs.
        let mut taken: Vec<(EdgeKey, bool)> = Vec::new();
        for traversal in ring {
            // An edge shared with a face set aside is itself, whole: nothing
            // reaches it to split it, and it carries its pcurve on the
            // face's own surface already. Its strands (a closed edge's two
            // halves) stand for it once each way it is walked.
            if let Tag::Boundary { edge, .. } = &traversal.tag
                && let Some(kept) = own.shared.get(&face.edges[*edge].node)
            {
                if face.own_surface != Some(surface_id) {
                    rebuild.strained = true;
                }
                let key = (face.edges[*edge].node, traversal.reversed);
                if !taken.contains(&key) {
                    taken.push(key);
                    edges.push(if traversal.reversed {
                        kept.reversed()
                    } else {
                        kept.clone()
                    });
                }
                continue;
            }
            let (key_edge, key_kind, range) = match &traversal.tag {
                Tag::Boundary { edge, range } => (*edge, 0_u8, *range),
                Tag::Section { section, range } => (*section, 1, *range),
                Tag::Contact { contact, range } => (*contact, 2, *range),
                Tag::Pole { pole, range } => (*pole, 3, *range),
            };
            let near = |a: (f64, f64), b: (f64, f64)| {
                (a.0 - b.0).abs() <= tol.parametric() && (a.1 - b.1).abs() <= tol.parametric()
            };
            if *DEBUG_WIRE && (range.1 - range.0).abs() < 1e-4 {
                let kind = match &traversal.tag {
                    Tag::Boundary { .. } => "boundary",
                    Tag::Section { .. } => "section",
                    Tag::Contact { .. } => "contact",
                    Tag::Pole { .. } => "pole",
                };
                eprintln!(
                    "DUST {kind} {key_edge} range {range:?} in piece from_a={} face={}",
                    piece.from_a, piece.face
                );
            }
            let built = if let Some((_, shape)) = cache
                .get(&(key_edge, key_kind))
                .and_then(|built| built.iter().find(|(r, _)| near(*r, range)))
            {
                shape.clone()
            } else {
                let shape = build_sub_edge(
                    rebuild,
                    fused,
                    piece.from_a,
                    face,
                    surface_id,
                    (&traversal.tag, traversal.nodes),
                    tol,
                )?;
                cache
                    .entry((key_edge, key_kind))
                    .or_default()
                    .push((range, shape.clone()));
                shape
            };
            // A piece whose two ends welded to one vertex and whose whole
            // length lies within the vertex's reach is that vertex's dust
            // (a rim's last fraction of a micron before a pole corner) and
            // no edge of the wire. A closed edge on one vertex, a full
            // circle, reaches far from it and stays.
            if !matches!(traversal.tag, Tag::Pole { .. })
                && let Some((v0, v1)) = ogeom_algo::edge_vertices(rebuild.model, &built)?
                && v0.node() == v1.node()
                && let Some(vd) = rebuild
                    .model
                    .node(&v0)
                    .and_then(|n| n.data().as_vertex())
                    .map(|d| (d.point, d.tolerance.get()))
                && let Some(ed) = rebuild.model.node(&built).and_then(|n| n.data().as_edge())
                && let Some(ogeom_topo::EdgeRepr::Curve3d {
                    curve, range: r3, ..
                }) = ed.curve3d()
                && let Some(g) = rebuild.model.geometry().curve(*curve)
                && g.point_at(f64::midpoint(r3.0, r3.1), tol)?.distance(vd.0)
                    <= vd.1.max(tol.confusion() * 1e4)
            {
                if *DEBUG_WIRE {
                    eprintln!(
                        "DUST piece closing on one vertex at {:?} dropped from piece from_a={} face={}",
                        vd.0, piece.from_a, piece.face
                    );
                }
                continue;
            }
            edges.push(if traversal.reversed {
                built.reversed()
            } else {
                built
            });
        }
        // A ring every piece of which is dust stands within its vertices'
        // reach of one point: a hole of it is no hole, and a boundary of
        // it bounds no face.
        if edges.is_empty() {
            if wires.is_empty() {
                if *DEBUG_WIRE {
                    eprintln!(
                        "DUST piece from_a={} face={}: its boundary closes on one point",
                        piece.from_a, piece.face
                    );
                }
                return Ok(None);
            }
            continue;
        }
        let wire = match make_wire(rebuild.model, &edges, tol) {
            Ok(w) => w.shape,
            Err(e) => {
                if *DEBUG_WIRE {
                    eprintln!(
                        "WIRE FAIL piece from_a={} face={}",
                        piece.from_a, piece.face
                    );
                    for built in &edges {
                        if let Some((a, b)) = ogeom_algo::edge_vertices(rebuild.model, built)? {
                            let at = |v: &Shape| {
                                rebuild
                                    .model
                                    .node(v)
                                    .and_then(|n| n.data().as_vertex())
                                    .map(|d| (d.point, d.tolerance.get()))
                            };
                            eprintln!(
                                "   built {:?}{}: v{} {:?} -> v{} {:?}",
                                built.node(),
                                if built.orientation() == ogeom_topo::Orientation::Reversed {
                                    " rev"
                                } else {
                                    ""
                                },
                                a.node().index(),
                                at(&a),
                                b.node().index(),
                                at(&b)
                            );
                        }
                    }
                    for t in ring {
                        let tag = match &t.tag {
                            Tag::Boundary { edge, range } => format!(
                                "Boundary e{edge} {range:?} tol {:.2e}",
                                face.edges[*edge].tolerance
                            ),
                            Tag::Contact { contact, range } => format!(
                                "Contact c{contact} {range:?} tol {:.2e}",
                                fused.contacts[*contact].tolerance
                            ),
                            Tag::Section { section, range } => format!(
                                "Section s{section} {range:?} tol {:.2e}",
                                fused.sections[*section].tolerance
                            ),
                            Tag::Pole { pole, range } => format!("Pole p{pole} {range:?}"),
                        };
                        eprintln!("   {tag} reversed={}", t.reversed);
                    }
                }
                return Err(e);
            }
        };
        wires.push(wire);
    }
    let built = match make_face_on(rebuild.model, surface_id, &wires, tol) {
        Ok(b) => b.shape,
        Err(e) => {
            if *DEBUG_WIRE {
                eprintln!(
                    "FACE FAIL piece from_a={} face={}: {e}",
                    piece.from_a, piece.face
                );
                for (wi, wire) in wires.iter().enumerate() {
                    for edge in rebuild.model.ordered_children_of(wire)? {
                        if let Some((a, b)) = ogeom_algo::edge_vertices(rebuild.model, &edge)? {
                            let at = |v: &Shape| {
                                rebuild
                                    .model
                                    .node(v)
                                    .and_then(|n| n.data().as_vertex())
                                    .map(|d| d.point)
                            };
                            eprintln!(
                                "   wire {wi} edge {:?}{}: v{} {:?} -> v{} {:?}",
                                edge.node(),
                                if edge.orientation() == ogeom_topo::Orientation::Reversed {
                                    " rev"
                                } else {
                                    ""
                                },
                                a.node().index(),
                                at(&a),
                                b.node().index(),
                                at(&b)
                            );
                        }
                    }
                }
            }
            return Err(e);
        }
    };
    Ok(Some(
        if face.face.orientation() == ogeom_topo::Orientation::Reversed {
            built.reversed()
        } else {
            built
        },
    ))
}

/// Build the exact sub-edge a tag names, pcurves attached, with the nodes
/// the face's arrangement closed its ring on at the strand's two ends.
fn build_sub_edge(
    rebuild: &mut Rebuild,
    fused: &GeneralFused,
    from_a: bool,
    face: &GFace,
    surface_id: ogeom_topo::SurfaceId,
    (tag, nodes): (&Tag, Option<[Point2; 2]>),
    tol: Tolerances,
) -> OgeomResult<Shape> {
    match tag {
        Tag::Pole { pole, range } => {
            // A pole rebuilds as what it was: one vertex, an edge with no
            // curve bounded by it twice, and the chart line that says where
            // it runs in this face's parameters.
            let p = &face.poles[*pole];
            let at = rebuild.vertex(p.point, tol);
            let model = &mut *rebuild.model;
            let mut data = ogeom_topo::EdgeData::new();
            data.degenerate = true;
            let built = model.add_edge(data, &[at.clone(), at])?;
            ogeom_algo::attach_pcurve(
                model,
                &built,
                p.pcurve.clone(),
                surface_id,
                Location::identity(),
                *range,
            )?;
            Ok(built)
        }
        Tag::Boundary { edge, range } => {
            let e = &face.edges[*edge];
            let whole = e.other_side.is_none()
                && (range.0 - e.crange.0).abs() <= tol.parametric()
                && (range.1 - e.crange.1).abs() <= tol.parametric();
            // On the face's own surface, which other faces may stand on
            // too, an edge its node states as a seam stays one: the faces
            // either side each walk their own column of it, which two
            // plain pcurves on the one surface could not tell apart.
            let seam = match &e.seam {
                Some(pair) if e.other_side.is_none() && face.own_surface == Some(surface_id) => {
                    Some(pair)
                }
                _ => None,
            };
            if whole && let Some(built) = rebuild.whole_edges.get(&e.node).cloned() {
                let attached = rebuild
                    .model
                    .node(&built)
                    .and_then(|n| n.data().as_edge())
                    .is_some_and(|d| d.pcurve_on(surface_id).is_some());
                match seam {
                    // The face on the other side, on the same surface,
                    // attached the seam with the edge's first build.
                    Some(_) if attached => {}
                    Some((forward, reversed)) => ogeom_algo::attach_seam(
                        rebuild.model,
                        &built,
                        forward.clone(),
                        reversed.clone(),
                        surface_id,
                        Location::identity(),
                        e.prange,
                    )?,
                    None => ogeom_algo::attach_pcurve(
                        rebuild.model,
                        &built,
                        e.pcurve.clone(),
                        surface_id,
                        Location::identity(),
                        e.prange,
                    )?,
                }
                return Ok(built);
            }
            let from = e.curve.point_at(range.0, tol)?;
            let to = e.curve.point_at(range.1, tol)?;
            let v0 = rebuild.vertex(from, tol);
            let v1 = rebuild.vertex(to, tol);
            let model = &mut *rebuild.model;
            let built = make_edge_between(model, (*e.curve).clone(), *range, &v0, &v1, tol)?.shape;
            // A piece of a tolerant edge is the same curve with the same
            // honest radius: a fitted rail's stated slop must survive the
            // split, or the next boolean over this solid measures the rail
            // against a tolerance it never had. The ends own it too: a
            // junction on a tolerant curve is a junction to the curve's own
            // resolution, and the wires rebuilt through it meet within that.
            // A fuzzy boolean's confusion is its fuzz, which is no floor
            // here: a piece is born at the smallest tolerance an edge
            // states, and keeps whatever its edge stated above that.
            if e.tolerance > ogeom_core::Tolerance::MIN.get() {
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen_to(e.tolerance);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, e.tolerance)?;
                }
            }
            let model = &mut *rebuild.model;
            let sub_p = (
                rescale(range.0, e.crange, e.prange),
                rescale(range.1, e.crange, e.prange),
            );
            match (&e.other_side, seam) {
                (None, Some((forward, reversed))) => ogeom_algo::attach_seam(
                    model,
                    &built,
                    forward.clone(),
                    reversed.clone(),
                    surface_id,
                    Location::identity(),
                    sub_p,
                )?,
                (None, None) => ogeom_algo::attach_pcurve(
                    model,
                    &built,
                    e.pcurve.clone(),
                    surface_id,
                    Location::identity(),
                    sub_p,
                )?,
                (Some((other, _)), _) => {
                    // A seam: both sides attach over the one range a seam
                    // carries, and an occurrence picks its side by its
                    // orientation.
                    ogeom_algo::attach_seam(
                        model,
                        &built,
                        e.pcurve.clone(),
                        other.clone(),
                        surface_id,
                        Location::identity(),
                        sub_p,
                    )?;
                }
            }
            // An edge's pcurve need only lie on its curve within the
            // tolerance, not keep pace with it: lifted, it may run a little
            // ahead or behind. Cut short, the piece's end is read at one
            // parameter on both, and that lag stands between the piece's
            // vertex and its image in the chart. The piece states it.
            if !whole
                && let Some(gap) = ogeom_algo::edge_pcurve_gap(model, &built, tol)?
                && let Some(data) = model.node(&built).and_then(|n| n.data().as_edge())
                && gap > data.tolerance.get()
            {
                let widened = ogeom_core::Tolerance::new(gap * (1.0 + 1e-6))?;
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen(widened);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, widened.get())?;
                }
            }
            if whole {
                rebuild.whole_edges.insert(e.node, built.clone());
            }
            Ok(built)
        }
        Tag::Contact { contact, range } => {
            let c = &fused.contacts[*contact];
            let from = c.curve.point_at(range.0, tol)?;
            let to = c.curve.point_at(range.1, tol)?;
            let v0 = rebuild.vertex(from, tol);
            let v1 = rebuild.vertex(to, tol);
            let model = &mut *rebuild.model;
            let built = make_edge_between(model, c.curve.clone(), *range, &v0, &v1, tol)?.shape;
            // A tolerant contact's pieces and ends own its stated slop, as a
            // boundary's and a section's do: three kinds of strand close one
            // ring, and every junction meets at the strands' own honesty.
            if c.tolerance > ogeom_core::Tolerance::MIN.get() {
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen_to(c.tolerance);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, c.tolerance)?;
                }
            }
            let model = &mut *rebuild.model;
            // The stored image keeps its own window. The attached copy names
            // the sub-window this piece covers under the proportional map.
            let sub_p = (
                rescale(range.0, c.crange, c.prange),
                rescale(range.1, c.crange, c.prange),
            );
            let mid = c.pcurve.point_at(f64::midpoint(sub_p.0, sub_p.1), tol)?;
            let trim: Vec<&[Point2]> = face.trim_lines(tol).iter().map(Vec::as_slice).collect();
            let folded = fold_inside(mid, &face.surface, &trim, tol);
            let shifted = c
                .pcurve
                .transformed(&ogeom_math::Transform2::translation(folded - mid), tol)?;
            ogeom_algo::attach_pcurve(
                model,
                &built,
                shifted,
                surface_id,
                Location::identity(),
                sub_p,
            )?;
            // A contact's curve lies on the target's surface only to the
            // weld or the fuzz (a rim on a drum a micron off its own), and
            // its image there, lifted, stands off the curve by as much. The
            // piece states that, and its ends hold it.
            if let Some(gap) = ogeom_algo::edge_pcurve_gap(model, &built, tol)?
                && let Some(data) = model.node(&built).and_then(|n| n.data().as_edge())
                && gap > data.tolerance.get()
            {
                let widened = ogeom_core::Tolerance::new(gap * (1.0 + 1e-6))?;
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen(widened);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, widened.get())?;
                }
            }
            Ok(built)
        }
        Tag::Section { section, range } => {
            let s = &fused.sections[*section];
            let domain = s.curve.domain();
            let (f0, f1) = folded_range(*range, domain, s.closed);
            let from = s.curve.point_at(at_param(f0, domain, s.closed), tol)?;
            let to = s.curve.point_at(at_param(f1, domain, s.closed), tol)?;
            let v0 = rebuild.vertex(from, tol);
            let v1 = rebuild.vertex(to, tol);
            let model = &mut *rebuild.model;
            let built = make_edge_between(model, s.curve.clone(), (f0, f1), &v0, &v1, tol)?.shape;
            // A piece welded into a junction some way off its own end (a
            // section tangent to an edge at the edge's vertex, stopped
            // where it began to hug the edge) owns that gap as the vertex
            // does: the face it bounds meets its neighbour there only that
            // closely, in its chart as in space.
            let at = |v: &Shape| {
                model
                    .node(v)
                    .and_then(|n| n.data().as_vertex())
                    .map(|d| d.point)
            };
            let ends = [at(&v0), at(&v1)];
            let welded = [(ends[0], from), (ends[1], to)]
                .iter()
                .filter_map(|(v, p)| v.map(|v| v.distance(*p)))
                .fold(0.0, f64::max);
            let own = s.tolerance.max(welded);
            // A fitted section's pieces and their ends own the section's
            // stated slop, exactly as a tolerant boundary's do: the ring
            // they close alternates between the two, and both sides must
            // meet at the junction's own resolution.
            if own > ogeom_core::Tolerance::MIN.get() {
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen_to(own);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, own)?;
                }
            }
            let model = &mut *rebuild.model;
            // The section's pcurve is unwrapped across any seam. The face's
            // triangulator lives in one chart, so the attached copy is folded
            // home by the same period shift the arrangement gave this
            // strand's polyline (to the side of the face's seam its trim is
            // on), decided by the sub-range's midpoint, so an
            // endpoint sitting exactly on the chart's edge stays on the side
            // the arc's body is.
            let pcurve = if from_a { &s.pc_a } else { &s.pc_b };
            let mid = pcurve.point_at(f64::midpoint(f0, f1), tol)?;
            let trim: Vec<&[Point2]> = face.trim_lines(tol).iter().map(Vec::as_slice).collect();
            let folded = fold_inside(mid, &face.surface, &trim, tol);
            let shifted =
                pcurve.transformed(&ogeom_math::Transform2::translation(folded - mid), tol)?;
            // The chart image ends where the vertex is, as the edge does in
            // space to its tolerance: a welded end left where the section
            // stopped leaves the face's outline open by the weld in its
            // chart, wider there than any later arrangement's snap.
            let loose = s.tolerance.max(tol.confusion() * 1e2);
            let bent = [
                rebuild.onto_vertex.contains(&v0.node()),
                rebuild.onto_vertex.contains(&v1.node()),
            ];
            let targets = [
                ends[0].filter(|v| bent[0] && v.distance(from) > loose),
                ends[1].filter(|v| bent[1] && v.distance(to) > loose),
            ];
            // Elsewhere the image ends on the node the arrangement closed
            // the ring on, where its own end stands further off it than any
            // later arrangement's snap and the node lifts nearer the piece's
            // end in space than the image's end does. A fitted image can lag
            // its curve by a few microns. Beside a pole, where a micron spans
            // a hundred times as much of the chart, that leaves it a
            // ten-thousandth of a radian off the seam column its neighbour
            // ends on, and the face's ring open there to every later
            // boolean. A piece whose own end stops short of its node (a loop
            // whose last hair was welded away) keeps the image of that end.
            let mut onto = [None, None];
            for (k, ((target, t), at)) in targets.iter().zip([f0, f1]).zip([from, to]).enumerate() {
                let end = shifted.point_at(t, tol)?;
                if let Some(target) = target {
                    onto[k] = Some(chart_foot(&face.surface, *target, end, tol)?);
                    continue;
                }
                let Some(node) = nodes.map(|n| n[k]) else {
                    continue;
                };
                let node = period_shifts(&face.surface, tol)
                    .into_iter()
                    .map(|(du, dv)| Point2::new(node.x + du, node.y + dv))
                    .min_by(|p, q| p.distance(end).total_cmp(&q.distance(end)))
                    .unwrap_or(node);
                let vertex = if k == 0 { &v0 } else { &v1 };
                let radius = model.tolerance_of(vertex)?.map_or(0.0, |r| r.get());
                if node.distance(end) > PARAM_SNAP
                    && !on_collapsed_row(&face.surface, node, radius, tol)
                    && face.surface.point_at(node.x, node.y, tol)?.distance(at)
                        < face.surface.point_at(end.x, end.y, tol)?.distance(at)
                {
                    onto[k] = Some(node);
                }
            }
            let shifted = if onto.iter().any(Option::is_some) {
                pcurve_onto_ends(&shifted, (f0, f1), &face.surface, onto, tol)?
            } else {
                shifted
            };
            ogeom_algo::attach_pcurve(
                model,
                &built,
                shifted,
                surface_id,
                Location::identity(),
                (f0, f1),
            )?;
            // The section's image was fitted through samples and may have
            // been bent onto its welded ends; lifted, it stands off the
            // curve by what is measured along the whole piece, and the
            // piece and its ends state that.
            if let Some(gap) = ogeom_algo::edge_pcurve_gap(model, &built, tol)?
                && let Some(data) = model.node(&built).and_then(|n| n.data().as_edge())
                && gap > data.tolerance.get()
            {
                let widened = ogeom_core::Tolerance::new(gap * (1.0 + 1e-6))?;
                if let Some(node) = model.node_mut(&built)
                    && let ogeom_topo::NodeData::Edge(data) = node.data_mut()
                {
                    data.tolerance = data.tolerance.widen(widened);
                }
                for v in [&v0, &v1] {
                    rebuild.widen(v, widened.get())?;
                }
            }
            Ok(built)
        }
    }
}

/// The point of `surface`'s chart nearest `end` that lifts to the foot of
/// `target` on the surface: the foot may land a turn away from `end` on a
/// periodic chart, whether or not the surface's wrapper says it is
/// periodic, and a shifted candidate counts where the surface agrees it is
/// the foot.
fn chart_foot(
    surface: &SurfaceGeometry,
    target: Point,
    end: Point2,
    tol: Tolerances,
) -> OgeomResult<Point2> {
    let foot = ogeom_algo::project_on_surface_from(surface, target, (end.x, end.y), tol)?;
    let raw = Point2::new(foot.parameters.0, foot.parameters.1);
    let turn = core::f64::consts::TAU;
    let mut shifts = period_shifts(surface, tol);
    for du in [-turn, 0.0, turn] {
        for dv in [-turn, 0.0, turn] {
            shifts.push((du, dv));
        }
    }
    Ok(shifts
        .into_iter()
        .map(|(du, dv)| Point2::new(raw.x + du, raw.y + dv))
        .filter(|c| {
            surface
                .point_at(c.x, c.y, tol)
                .is_ok_and(|q| q.distance(foot.point) <= tol.confusion() * 1e2)
        })
        .min_by(|a, b| {
            a.distance(end)
                .partial_cmp(&b.distance(end))
                .unwrap_or(core::cmp::Ordering::Equal)
        })
        .unwrap_or(raw))
}

/// Whether the chart row or column through `at` lies, across the chart's
/// whole width that way, within `radius` of one point in space: a pole's
/// row or an apex's, along which a point moves nowhere, so a pcurve's end
/// is placed on it by the way it arrives and not by a node there.
fn on_collapsed_row(surface: &SurfaceGeometry, at: Point2, radius: f64, tol: Tolerances) -> bool {
    let ((u0, u1), (v0, v1)) = surface.domain();
    let Ok((du, dv)) = surface.d1_at(at.x, at.y, tol) else {
        return true;
    };
    du.magnitude() * (u1 - u0).abs() <= radius || dv.magnitude() * (v1 - v0).abs() <= radius
}

/// A pcurve over `range` bent at its ends onto the chart points `targets`,
/// where given, and refitted at the same parameters, at every span of the
/// image, so the image stays same-parameter with its edge to the
/// correction's size.
///
/// Each end's correction fades linearly to nothing at the other end, and,
/// read on the surface's first derivatives, nowhere moves the image
/// further in space than it moves the end: where a chart step costs more
/// in space than it does at the end (away from a pole the end stands
/// beside), the step is scaled down by as much. A ten-thousandth of a
/// radian round a ball's axis is a few microns beside its pole and a
/// ten-thousandth of its radius at its equator.
fn pcurve_onto_ends(
    pcurve: &PlanarCurve,
    range: (f64, f64),
    surface: &SurfaceGeometry,
    targets: [Option<Point2>; 2],
    tol: Tolerances,
) -> OgeomResult<PlanarCurve> {
    const SAMPLES: usize = 32;
    let ends = [
        pcurve.point_at(range.0, tol)?,
        pcurve.point_at(range.1, tol)?,
    ];
    // The length in space of a chart step `by` taken at `at`.
    let cost = |at: Point2, by: ogeom_math::Vector2| -> Option<f64> {
        let (du, dv) = surface.d1_at(at.x, at.y, tol).ok()?;
        Some((du * by.x + dv * by.y).magnitude())
    };
    let mut deltas = [ogeom_math::Vector2::new(0.0, 0.0); 2];
    let mut at_end = [None; 2];
    for (k, target) in targets.iter().enumerate() {
        let Some(target) = target else {
            continue;
        };
        deltas[k] = *target - ends[k];
        at_end[k] = cost(ends[k], deltas[k]);
    }
    // How much of an end's correction a point of the image takes, its
    // linear share scaled so the point moves no further in space than the
    // end does.
    let share = |k: usize, p: Point2, linear: f64| -> f64 {
        let (Some(end), Some(here)) = (at_end[k], cost(p, deltas[k])) else {
            return linear;
        };
        if here > end {
            linear * end / here
        } else {
            linear
        }
    };
    // Refitted at every span of the image and held to the target between
    // the samples as well as at them; the edge states what the bend and
    // the fit leave once the image is attached.
    let (lo, hi) = (range.0.min(range.1), range.0.max(range.1));
    let stations = ogeom_algo::traced::stations_2d(pcurve, (lo, hi), SAMPLES);
    let fitted = ogeom_algo::traced::fit_traced_2d(
        |t| {
            let along = if hi > lo {
                (t - range.0) / (range.1 - range.0)
            } else {
                0.0
            };
            let p = pcurve.point_at(t, tol)?;
            Ok(p + deltas[0] * share(0, p, 1.0 - along) + deltas[1] * share(1, p, along))
        },
        &stations,
        3,
        tol.confusion() * 10.0,
        tol,
    )?;
    Ok(PlanarCurve::BSpline(fitted.curve))
}

/// Sew kept pieces, demand closure, and nest shells into solids and voids.
///
/// The faces each solid set aside come through as they are where
/// `keep_aside` keeps that solid's outside, and are deleted where it does
/// not.
fn assemble_result(
    model: &mut Model,
    fused: &GeneralFused,
    kept: &[(usize, bool)],
    keep_aside: [bool; 2],
    a: &Shape,
    b: &Shape,
    tol: Tolerances,
) -> OgeomResult<Built> {
    ogeom_core::progress::stage("boolean: assemble");
    let local = !fused.a.aside.is_empty() || !fused.b.aside.is_empty();
    let mut history = History::new();
    let source_face = |piece: &FacePiece| -> Shape {
        if piece.from_a {
            fused.a.faces[piece.face].face.clone()
        } else {
            fused.b.faces[piece.face].face.clone()
        }
    };

    if kept.is_empty() {
        if (keep_aside[0] && !fused.a.aside.is_empty())
            || (keep_aside[1] && !fused.b.aside.is_empty())
        {
            ogeom_bail!(NotDone, "no piece is kept beside the faces set aside");
        }
        // A legitimate answer: cutting a solid away entirely leaves nothing.
        let empty = model.add_compound(&[])?;
        for piece in &fused.pieces {
            history.delete(&source_face(piece));
        }
        for (face, _) in fused.a.aside.iter().chain(&fused.b.aside) {
            history.delete(face);
        }
        history.modify(a, empty.clone());
        history.modify(b, empty.clone());
        return Ok(Built::new(empty, history));
    }

    let Rebuilt {
        faces,
        settled,
        weld: floor,
        holes,
        kept: built_from,
    } = rebuilt_pieces(model, fused, kept, &mut history, tol)?;
    let sewn = sew_around_within(model, &faces, &settled, SEW_ACROSS.get(), tol)?;
    // Sewing rebuilds the pieces onto shared edges: the result's faces are
    // its faces, reached from the inputs through both steps.
    history = history.followed_by(&sewn.history);
    // What the sew and the passes after it made of each rebuilt face, where
    // faces set aside are put back beside them.
    let mut after = if local {
        sewn.history.clone()
    } else {
        History::new()
    };
    let mut sewn = sewn;
    let dropped = without_membranes(model, &mut sewn.shells, floor, tol)?;
    history = history.followed_by(&dropped);
    let held: ogeom_core::FastSet<ogeom_topo::TShapeId> = fused
        .a
        .shared
        .values()
        .chain(fused.b.shared.values())
        .map(Shape::node)
        .collect();
    let joined = seam_join::join_across_seams(model, &mut sewn.shells, &held, tol)?;
    history = history.followed_by(&joined).without_repeated_images();
    let mut closed = None;
    let mut made = None;
    if local {
        after = after.followed_by(&dropped).followed_by(&joined);
        let (shells, shut, new) = with_aside(
            model,
            fused,
            &built_from,
            &faces,
            &holes,
            &after,
            &sewn.shells,
            keep_aside,
            &mut history,
        )?;
        sewn.shells = shells;
        closed = Some(shut);
        made = Some(new);
    }
    if sewn.shells.is_empty() {
        // Membranes all through: what was kept encloses nothing.
        let empty = model.add_compound(&[])?;
        history.modify(a, empty.clone());
        history.modify(b, empty.clone());
        return Ok(Built::new(empty, history));
    }
    for (i, shell) in sewn.shells.iter().enumerate() {
        let shut = match &closed {
            Some(closed) => closed[i],
            None => is_shell_closed(model, shell)?,
        };
        if !shut {
            // Env-gated forensics: the open shell's unshared edges, the
            // question every failure here starts from.
            if *ARRANGE_DEBUG {
                use ogeom_geom::Curve3d as _;
                for edge in ogeom_topo::explore_unique(model, shell, ShapeType::Edge)? {
                    let users = ogeom_topo::explore(model, shell, Filter::OfType(ShapeType::Face))?
                        .iter()
                        .filter(|f| {
                            ogeom_topo::explore_unique(model, f, ShapeType::Edge)
                                .map(|es| es.iter().any(|e2| e2.node() == edge.node()))
                                .unwrap_or(false)
                        })
                        .count();
                    let mut occurrences = 0_usize;
                    for f in ogeom_topo::explore(model, shell, Filter::OfType(ShapeType::Face))? {
                        for wire in model.children_of(&f)? {
                            for e2 in model.children_of(&wire)? {
                                if e2.node() == edge.node() {
                                    occurrences += 1;
                                }
                            }
                        }
                    }
                    if occurrences % 2 == 1
                        && let Some(data) = model.node(&edge).and_then(|n| n.data().as_edge())
                        && let Some(ogeom_topo::EdgeRepr::Curve3d { curve, range, .. }) =
                            data.curve3d()
                        && let Some(g) = model.geometry().curve(*curve)
                    {
                        let a = g.point_at(range.0, tol)?;
                        let b = g.point_at(range.1, tol)?;
                        eprintln!(
                            "  open edge uses={occurrences} faces={users} {:?} range={range:?}: {a:?} -> {b:?}",
                            core::mem::discriminant(g)
                        );
                        // Twins: other edges of the shell with the same ends,
                        // which the sew should have found to be this edge.
                        for other in ogeom_topo::explore_unique(model, shell, ShapeType::Edge)? {
                            if other.node() == edge.node() {
                                continue;
                            }
                            let Some(od) = model.node(&other).and_then(|n| n.data().as_edge())
                            else {
                                continue;
                            };
                            let Some(ogeom_topo::EdgeRepr::Curve3d {
                                curve: oc,
                                range: orange,
                                ..
                            }) = od.curve3d()
                            else {
                                continue;
                            };
                            let Some(og) = model.geometry().curve(*oc) else {
                                continue;
                            };
                            let oa = og.point_at(orange.0, tol)?;
                            let ob = og.point_at(orange.1, tol)?;
                            let same = (oa.distance(a) <= 1e-3 && ob.distance(b) <= 1e-3)
                                || (oa.distance(b) <= 1e-3 && ob.distance(a) <= 1e-3);
                            if same {
                                let om = og.point_at(f64::midpoint(orange.0, orange.1), tol)?;
                                let m = g.point_at(f64::midpoint(range.0, range.1), tol)?;
                                eprintln!(
                                    "    twin {:?} range={orange:?} mid gap {:.2e} tol {:.2e} vs {:.2e}",
                                    core::mem::discriminant(og),
                                    om.distance(m),
                                    od.tolerance.get(),
                                    data.tolerance.get()
                                );
                            }
                        }
                        for f in ogeom_topo::explore(model, shell, Filter::OfType(ShapeType::Face))?
                        {
                            let uses_it = ogeom_topo::explore_unique(model, &f, ShapeType::Edge)
                                .map(|es| es.iter().any(|e2| e2.node() == edge.node()))
                                .unwrap_or(false);
                            if !uses_it {
                                continue;
                            }
                            if let Some(ogeom_topo::NodeData::Face(fd)) =
                                model.node(&f).map(|n| n.data())
                                && let Some(sg) = model.geometry().surface(fd.surface)
                            {
                                let bound = shape_bounds(model, &f, tol)?;
                                eprintln!(
                                    "    used by face on {:?} bound {:?}",
                                    core::mem::discriminant(sg),
                                    bound
                                );
                            }
                        }
                    }
                }
            }
            if *ARRANGE_DEBUG {
                use ogeom_geom::Curve3d as _;
                for f in ogeom_topo::explore(model, shell, Filter::OfType(ShapeType::Face))? {
                    let Some(ogeom_topo::NodeData::Face(fd)) = model.node(&f).map(|n| n.data())
                    else {
                        continue;
                    };
                    let Some(sg) = model.geometry().surface(fd.surface) else {
                        continue;
                    };
                    let edges = ogeom_topo::explore_unique(model, &f, ShapeType::Edge)?;
                    eprintln!(
                        "  face {:?} with {} edges",
                        core::mem::discriminant(sg),
                        edges.len()
                    );
                    if matches!(sg, SurfaceGeometry::Sphere(_)) {
                        for e in &edges {
                            if let Some(ed) = model.node(e).and_then(|n| n.data().as_edge())
                                && let Some(ogeom_topo::EdgeRepr::Curve3d { curve, range, .. }) =
                                    ed.curve3d()
                                && let Some(g) = model.geometry().curve(*curve)
                            {
                                let a = g.point_at(range.0, tol)?;
                                let b = g.point_at(range.1, tol)?;
                                eprintln!(
                                    "    sphere edge {:?} ({:.4},{:.4},{:.4}) -> ({:.4},{:.4},{:.4})",
                                    core::mem::discriminant(g),
                                    a.x,
                                    a.y,
                                    a.z,
                                    b.x,
                                    b.y,
                                    b.z
                                );
                            }
                        }
                    }
                }
            }
            ogeom_bail!(
                NotDone,
                "the kept pieces did not close into a shell; the configuration \
                 is beyond what the boolean currently resolves"
            );
        }
    }

    // Nest: a shell inside another is that solid's void, and a shell inside
    // a void is a solid of its own. The kept pieces are already oriented
    // as the material's boundary, so a void's faces face into it as they
    // are.
    let mut solids = Vec::new();
    for (outer, voids) in nest_shells(model, &sewn.shells, tol)? {
        let mut group = vec![sewn.shells[outer].clone()];
        group.extend(voids.iter().map(|&j| sewn.shells[j].clone()));
        solids.push(model.add_solid(&group)?);
    }
    let result = if solids.len() == 1 {
        solids.remove(0)
    } else {
        model.add_compound(&solids)?
    };
    // A face made here whose boundary does not close in its surface's chart
    // (a section stopped short of where its neighbour starts, at a contact
    // the marcher did not follow through) holds a strand that dangles, and
    // the result would check broken. It is refused instead, for the retries
    // to take another way.
    // Set aside, the faces made are known; otherwise they are the result's
    // faces that are not the operands'.
    let built_faces = match &made {
        Some(made) => made.clone(),
        None => {
            let given: ogeom_core::FastSet<ogeom_topo::TShapeId> = [a, b]
                .into_iter()
                .map(|operand| explore_unique(model, operand, ShapeType::Face))
                .collect::<OgeomResult<Vec<_>>>()?
                .into_iter()
                .flatten()
                .map(|face| face.node())
                .collect();
            explore_unique(model, &result, ShapeType::Face)?
                .into_iter()
                .filter(|f| !given.contains(&f.node()))
                .collect()
        }
    };
    // A wire of a face the boolean gathered that comes through as the same
    // wire (a hole clear of the other solid, put back into the piece that
    // holds it) closes as it did.
    let given_wires: ogeom_core::FastSet<ogeom_topo::TShapeId> = fused
        .a
        .faces
        .iter()
        .chain(&fused.b.faces)
        .map(|gathered| model.ordered_children_of(&gathered.face))
        .collect::<OgeomResult<Vec<_>>>()?
        .into_iter()
        .flatten()
        .map(|wire| wire.node())
        .collect();
    let taken = |wire: &Shape| given_wires.contains(&wire.node());
    for face in &built_faces {
        if !ogeom_algo::chart_breaks(model, face, &taken, tol)?.is_empty() {
            ogeom_bail!(
                NotDone,
                "a face the boolean made does not close in its surface's chart; the \
                 configuration is beyond what the boolean currently resolves"
            );
        }
    }
    // The faces set aside keep the boxes they had: only the faces made
    // are looked at.
    match &made {
        Some(made) => keep_face_boxes(model, made)?,
        None => keep_face_boxes(model, &explore_unique(model, &result, ShapeType::Face)?)?,
    }
    history.modify(a, result.clone());
    history.modify(b, result.clone());
    Ok(Built::new(result, history))
}

/// Each of `faces` on a ruled surface (a plane, a drum, a cone) keeps its
/// box, found from its edges alone: the next boolean on the result reads
/// every face's box to find the faces it can set aside.
fn keep_face_boxes(model: &Model, faces: &[Shape]) -> OgeomResult<()> {
    for face in faces {
        if model.face_bounds(face).is_some() {
            continue;
        }
        let ruled = model
            .node(face)
            .and_then(|n| n.data().as_face())
            .and_then(|d| model.geometry().surface(d.surface))
            .is_some_and(|s| {
                matches!(
                    s,
                    SurfaceGeometry::Plane(_)
                        | SurfaceGeometry::Cylinder(_)
                        | SurfaceGeometry::Cone(_)
                )
            });
        if ruled {
            ogeom_algo::face_bounds(model, face)?;
        }
    }
    Ok(())
}

/// The kept pieces of a sheet sewn along the edges they share: one shell,
/// or a compound of shells where they fall apart. Nothing is asked of the
/// shells' closure. A sheet that is one face has its history in its
/// pieces; a shell or a compound also becomes the result.
fn assemble_sheet(
    model: &mut Model,
    fused: &GeneralFused,
    kept: &[usize],
    sheet: &Shape,
    tol: Tolerances,
) -> OgeomResult<Built> {
    ogeom_core::progress::stage("boolean: assemble");
    let mut history = History::new();
    let whole = model.kind_of(sheet)? != ShapeType::Face;
    if kept.is_empty() {
        let empty = model.add_compound(&[])?;
        for piece in &fused.pieces {
            history.delete(&fused.a.faces[piece.face].face);
        }
        if whole {
            history.modify(sheet, empty.clone());
        }
        return Ok(Built::new(empty, history));
    }
    let kept: Vec<(usize, bool)> = kept.iter().map(|&i| (i, false)).collect();
    let Rebuilt { faces, settled, .. } = rebuilt_pieces(model, fused, &kept, &mut history, tol)?;
    let mut sewn = sew_around(model, &faces, &settled, tol)?;
    history = history.followed_by(&sewn.history);
    let joined = seam_join::join_across_seams(
        model,
        &mut sewn.shells,
        &ogeom_core::FastSet::default(),
        tol,
    )?;
    history = history.followed_by(&joined).without_repeated_images();
    let result = if sewn.shells.len() == 1 {
        sewn.shells.remove(0)
    } else {
        model.add_compound(&sewn.shells)?
    };
    if whole {
        history.modify(sheet, result.clone());
    }
    Ok(Built::new(result, history))
}

/// The kept pieces rebuilt as faces, each recorded in `history` against the
/// face it came from and every face no piece is kept of deleted, whether
/// each is a copy already sewn to all its neighbours, and the distance the
/// rebuild welds their ends within.
fn rebuilt_pieces(
    model: &mut Model,
    fused: &GeneralFused,
    kept: &[(usize, bool)],
    history: &mut History,
    tol: Tolerances,
) -> OgeomResult<Rebuilt> {
    let source_face = |piece: &FacePiece| -> Shape {
        if piece.from_a {
            fused.a.faces[piece.face].face.clone()
        } else {
            fused.b.faces[piece.face].face.clone()
        }
    };
    let weld = fused
        .contacts
        .iter()
        .map(|c| c.tolerance)
        .chain(fused.sections.iter().map(|s| s.tolerance))
        .fold(0.0_f64, |acc, t| acc.max(honest(t, tol) * 3.0));
    let floor = weld.max(tol.confusion() * 1e2);
    let junction_reach = fused
        .junctions
        .iter()
        .fold(0.0_f64, |acc, j| acc.max(j.reach));
    let mut junction_bins = bins::Bins::new(junction_reach + floor);
    for (index, j) in fused.junctions.iter().enumerate() {
        junction_bins.insert(j.at, index);
    }
    // The vertices' cells are sized to the loosest tolerance a strand
    // brings to its ends, so an end is compared across a few cells, not
    // every vertex.
    let loosest = fused
        .a
        .faces
        .iter()
        .chain(fused.b.faces.iter())
        .flat_map(|f| f.edges.iter().map(|e| e.tolerance))
        .chain(fused.contacts.iter().map(|c| c.tolerance))
        .chain(fused.sections.iter().map(|s| s.tolerance))
        .fold(junction_reach, f64::max);
    let mut rebuild = Rebuild {
        model,
        surfaces_a: vec![None; fused.a.faces.len()],
        surfaces_b: vec![None; fused.b.faces.len()],
        vertices: Vec::new(),
        vertex_bins: bins::Bins::new(floor + loosest),
        near: Vec::new(),
        widest: 0.0,
        weld,
        junctions: fused.junctions.iter().map(|j| (*j, None)).collect(),
        junction_bins,
        junction_reach,
        onto_vertex: ogeom_core::FastSet::default(),
        whole_edges: ogeom_core::FastMap::default(),
        kept: ogeom_core::FastMap::default(),
        strained: false,
    };
    for (at, vertex) in fused
        .a
        .shared_vertices
        .iter()
        .chain(&fused.b.shared_vertices)
    {
        rebuild.remember(*at, vertex);
        rebuild.kept.insert(vertex.node(), *at);
    }
    // A face the operation never touched (nothing crosses it, no edge of it
    // is split, no junction lands at its corners) is rebuilt as an exact
    // copy of itself. Its neighbours across its unsplit edges build those
    // edges from the same curves, so whichever twin the sew keeps is its
    // own boundary.
    let clean = |piece: &FacePiece, model: &Model| -> OgeomResult<bool> {
        if !piece.whole {
            return Ok(false);
        }
        let face = &source_face(piece);
        for vertex in explore_unique(model, face, ShapeType::Vertex)? {
            let Some(data) = model.node(&vertex).and_then(|n| n.data().as_vertex()) else {
                continue;
            };
            let at = vertex.transform(model.datums())?.apply(data.point);
            if fused
                .junctions
                .iter()
                .any(|j| j.at.distance(at) <= j.reach + floor)
            {
                return Ok(false);
            }
        }
        Ok(true)
    };
    // Each kept piece built first: one whose boundary closes on a point is
    // dust, and none of what follows sees it.
    let mut pieces_built: Vec<(usize, bool, Shape)> = Vec::with_capacity(kept.len());
    for &(index, flip) in kept {
        if let Some(built) = build_piece(&mut rebuild, fused, &fused.pieces[index], tol)? {
            pieces_built.push((index, flip, built));
        }
    }
    let kept: Vec<(usize, bool)> = pieces_built.iter().map(|&(i, f, _)| (i, f)).collect();
    let kept = kept.as_slice();
    // One kept turned over (a tool's face lining the cavity a cut leaves)
    // faces the other way, which no copy does.
    let mut copies = Vec::with_capacity(kept.len());
    for &(index, flip) in kept {
        copies.push(!flip && clean(&fused.pieces[index], rebuild.model)?);
    }
    let mut faces = Vec::new();
    let mut kept_sources: ogeom_core::FastSet<Shape> = ogeom_core::FastSet::default();
    let mut built_of: ogeom_core::FastMap<usize, usize> = ogeom_core::FastMap::default();
    for (slot, (index, flip, built)) in pieces_built.into_iter().enumerate() {
        built_of.insert(index, slot);
        let piece = &fused.pieces[index];
        let mut built = built;
        if flip {
            built = built.reversed();
        }
        if copies[slot] {
            history.copy(&source_face(piece), built.clone());
        } else {
            history.modify(&source_face(piece), built.clone());
        }
        kept_sources.insert(source_face(piece));
        faces.push(built);
    }
    if rebuild.strained {
        ogeom_bail!(
            NotDone,
            "a strand ends further from a vertex shared with a face set aside \
             than the vertex reaches"
        );
    }
    let holes = holes_put_back(rebuild.model, fused, kept, tol)?;
    // A piece dropped because the other argument's coincident piece is
    // kept for the same patch: its face became that piece's face.
    let mut stood_for: ogeom_core::FastSet<Shape> = ogeom_core::FastSet::default();
    for &(index_a, index_b) in &fused.coincident {
        let (dropped, standing) = match (built_of.get(&index_a), built_of.get(&index_b)) {
            (Some(&slot), None) => (index_b, slot),
            (None, Some(&slot)) => (index_a, slot),
            _ => continue,
        };
        let source = source_face(&fused.pieces[dropped]);
        if !history
            .modified(&source)
            .iter()
            .any(|f| f.is_same(&faces[standing]))
        {
            history.modify(&source, faces[standing].clone());
        }
        stood_for.insert(source);
    }
    for piece in &fused.pieces {
        let source = source_face(piece);
        if !kept_sources.contains(&source) && !stood_for.contains(&source) {
            history.delete(&source);
        }
    }

    // A copy shares each edge with the face of its own solid across it,
    // built once for both: no edge a copy holds has a twin in its own
    // solid. Where it meets a face of the other solid, its edges may have
    // twins only the sew can find, so only a copy all of whose vertices are
    // held by faces of its own solid alone comes through the sew as it
    // stands.
    let class = |slot: usize| -> u8 {
        match (copies[slot], fused.pieces[kept[slot].0].from_a) {
            (true, true) => 1,
            (true, false) => 2,
            (false, true) => 4,
            (false, false) => 8,
        }
    };
    let mut held: ogeom_core::FastMap<ogeom_topo::TShapeId, u8> = ogeom_core::FastMap::default();
    let mut corners = Vec::with_capacity(faces.len());
    for (slot, face) in faces.iter().enumerate() {
        let vertices = explore_unique(rebuild.model, face, ShapeType::Vertex)?;
        for vertex in &vertices {
            *held.entry(vertex.node()).or_default() |= class(slot);
        }
        corners.push(vertices);
    }
    let settled = corners
        .iter()
        .enumerate()
        .map(|(slot, vertices)| {
            let own = if fused.pieces[kept[slot].0].from_a {
                1 | 4
            } else {
                2 | 8
            };
            copies[slot]
                && vertices
                    .iter()
                    .all(|v| held.get(&v.node()).is_some_and(|by| by & !own == 0))
        })
        .collect();

    Ok(Rebuilt {
        faces,
        settled,
        weld: floor,
        holes,
        kept: kept.to_vec(),
    })
}

/// The shells the result is bounded by, with the faces set aside put back:
/// each face taking back holes left out of its arrangement is made again
/// with them, the faces set aside join the faces sewn where `keep_aside`
/// keeps them, and the shells are found again from the edges they all
/// share. `history` records the faces set aside and the faces made again.
#[allow(
    clippy::too_many_arguments,
    reason = "the assembly's own state, read once"
)]
fn with_aside(
    model: &mut Model,
    fused: &GeneralFused,
    kept: &[(usize, bool)],
    faces: &[Shape],
    holes: &[Vec<usize>],
    after: &History,
    shells: &[Shape],
    keep_aside: [bool; 2],
    history: &mut History,
) -> OgeomResult<(Vec<Shape>, Vec<bool>, Vec<Shape>)> {
    if kept.len() != faces.len() {
        ogeom_bail!(
            Construction,
            "{} kept pieces for {} rebuilt faces; each face is read with its own piece",
            kept.len(),
            faces.len()
        );
    }
    // Each face made again with its holes, with the wires it walks itself
    // and the faces set aside beside its holes.
    let mut remade: ogeom_core::FastMap<ogeom_topo::TShapeId, Remade> =
        ogeom_core::FastMap::default();
    let mut put_back = History::new();
    // Each face's place: its solid, the place there of the face it came
    // from, and its piece's.
    let mut rank: ogeom_core::FastMap<ogeom_topo::TShapeId, (bool, usize, usize)> =
        ogeom_core::FastMap::default();
    for (slot, built) in faces.iter().enumerate() {
        let piece = &fused.pieces[kept[slot].0];
        let own = if piece.from_a { &fused.a } else { &fused.b };
        let source = &own.faces[piece.face].face;
        let place = (
            !piece.from_a,
            own.order
                .get(&ogeom_topo::SameKey(source.clone()))
                .copied()
                .unwrap_or(usize::MAX),
            slot,
        );
        rank.insert(built.node(), place);
        for image in after.modified(built) {
            rank.insert(image.node(), place);
        }
    }
    for (slot, (built, holes)) in faces.iter().zip(holes).enumerate() {
        if holes.is_empty() {
            continue;
        }
        let image = match after.modified(built) {
            [] if !after.is_deleted(built) => built.clone(),
            [image] => image.clone(),
            _ => ogeom_bail!(NotDone, "a face taking back its holes was split or dropped"),
        };
        let piece = &fused.pieces[kept[slot].0];
        let own = if piece.from_a { &fused.a } else { &fused.b };
        let source = &own.faces[piece.face];
        let side = usize::from(!piece.from_a);
        let wires: Vec<Shape> = holes
            .iter()
            .map(|&h| source.holes_aside[h].wire.clone())
            .collect();
        let joins: Vec<(usize, u32)> = holes
            .iter()
            .flat_map(|&h| source.holes_aside[h].beside.iter().map(move |&j| (side, j)))
            .collect();
        let walk = model.node(&image).map_or(0, |n| n.children().len());
        let made = with_holes(model, &image, &wires)?;
        // A plane's holes lie inside its outer boundary, which alone sets
        // its box: the face with its holes back keeps the box of the face
        // without them.
        ogeom_algo::face_bounds(model, &image)?;
        let found = model.kept_face_box(&image, |_| {
            Err(ogeom_core::ogeom_err!(
                NotDone,
                "the face's box was not kept"
            ))
        });
        if let Ok(found) = found {
            model.kept_face_box(&made, |_| Ok(found))?;
        }
        let copied = after.copy_of(built).is_some() || after.modified(built).is_empty();
        if copied {
            put_back.copy(&image, made.clone());
        } else {
            put_back.modify(&image, made.clone());
        }
        remade.insert(image.node(), (made, walk, joins));
    }
    // Each face with its place: its solid, the place there of the face it
    // came from, and its piece's.
    let mut all = Vec::new();
    for shell in shells {
        for face in model.children_of(shell)? {
            let place = rank
                .get(&face.node())
                .copied()
                .unwrap_or((true, usize::MAX, usize::MAX));
            all.push(match remade.remove(&face.node()) {
                Some((made, walk, joins)) => (
                    place,
                    aside::Member {
                        face: made,
                        aside: None,
                        walk,
                        joins,
                    },
                ),
                None => (
                    place,
                    aside::Member {
                        face,
                        aside: None,
                        walk: usize::MAX,
                        joins: Vec::new(),
                    },
                ),
            });
        }
    }
    *history = core::mem::take(history).followed_by(&put_back);
    // The faces set aside are no image of anything the history holds so
    // far, so they are recorded as they stand.
    for (g, keep, from_b) in [
        (&fused.a, keep_aside[0], false),
        (&fused.b, keep_aside[1], true),
    ] {
        for (face, place) in &g.aside {
            if keep {
                history.copy(face, face.clone());
                all.push((
                    (from_b, *place, 0),
                    aside::Member {
                        face: face.clone(),
                        aside: Some((usize::from(from_b), *place)),
                        walk: 0,
                        joins: Vec::new(),
                    },
                ));
            } else {
                history.delete(face);
            }
        }
    }
    // In the order the solids list the faces they came from, as the
    // general fuse of every face lists them.
    all.sort_by_key(|(place, _)| *place);
    let all: Vec<aside::Member> = all.into_iter().map(|(_, member)| member).collect();
    if all.is_empty() {
        return Ok((Vec::new(), Vec::new(), Vec::new()));
    }
    let made = all
        .iter()
        .filter(|member| member.aside.is_none())
        .map(|member| member.face.clone())
        .collect();
    let (shells, closed) = aside::shells_of(model, &all, [&fused.a.beside, &fused.b.beside])?;
    Ok((shells, closed, made))
}

/// A face made again with its holes, how many of its wires it walks
/// itself, and the faces set aside beside its holes.
type Remade = (Shape, usize, Vec<(usize, u32)>);

/// What [`rebuilt_pieces`] makes of the kept pieces.
struct Rebuilt {
    /// One face per kept piece, in order.
    faces: Vec<Shape>,
    /// Whether each comes through the sew as it stands.
    settled: Vec<bool>,
    /// The distance the rebuild welds ends within.
    weld: f64,
    /// The holes left out of the arrangement each face takes back, by
    /// their place among its source face's.
    holes: Vec<Vec<usize>>,
    /// The kept pieces each face is built from, in order: those given, less
    /// any whose boundary closed on one point.
    kept: Vec<(usize, bool)>,
}

/// The holes left out of each face's arrangement, given to the kept piece
/// holding each.
///
/// A hole left out stands clear of the other solid, so the piece holding it
/// lies outside the other solid. Where the operation keeps what lies
/// outside, the face's one kept piece holds it, or of several the one whose
/// outline it lies within. Where it keeps what lies inside, no kept piece
/// holds one.
fn holes_put_back(
    model: &Model,
    fused: &GeneralFused,
    kept: &[(usize, bool)],
    tol: Tolerances,
) -> OgeomResult<Vec<Vec<usize>>> {
    let mut holes = vec![Vec::new(); kept.len()];
    let mut by_face: std::collections::BTreeMap<(bool, usize), Vec<usize>> =
        std::collections::BTreeMap::new();
    for (slot, &(index, _)) in kept.iter().enumerate() {
        let piece = &fused.pieces[index];
        let own = if piece.from_a { &fused.a } else { &fused.b };
        if !own.faces[piece.face].holes_aside.is_empty() {
            by_face
                .entry((piece.from_a, piece.face))
                .or_default()
                .push(slot);
        }
    }
    for ((from_a, fi), slots) in by_face {
        let face = if from_a {
            &fused.a.faces[fi]
        } else {
            &fused.b.faces[fi]
        };
        let outside = slots
            .iter()
            .any(|&slot| fused.pieces[kept[slot].0].state == PieceState::Out);
        if let [slot] = slots.as_slice()
            && outside
        {
            holes[*slot] = (0..face.holes_aside.len()).collect();
            continue;
        }
        for (h, hole) in face.holes_aside.iter().enumerate() {
            let Some(at) = hole_point(model, face, &hole.wire, tol)? else {
                ogeom_bail!(NotDone, "a hole set aside has no point in its face's chart");
            };
            let mut within = slots
                .iter()
                .filter(|&&slot| inside_rings(&fused.pieces[kept[slot].0].outlines, at));
            match (within.next(), within.next()) {
                (Some(&slot), None) if fused.pieces[kept[slot].0].state == PieceState::Out => {
                    holes[slot].push(h);
                }
                (None, _) if !outside => {}
                _ => ogeom_bail!(
                    NotDone,
                    "a hole set aside lies in no one piece standing outside the other solid"
                ),
            }
        }
    }
    Ok(holes)
}

/// A point of a hole's first edge in its face's chart.
fn hole_point(
    model: &Model,
    face: &GFace,
    hole: &Shape,
    tol: Tolerances,
) -> OgeomResult<Option<Point2>> {
    let Some(surface) = face.own_surface else {
        return Ok(None);
    };
    let Some(edge) = model.children_of(hole)?.into_iter().next() else {
        return Ok(None);
    };
    let Some(data) = model.node(&edge).and_then(|n| n.data().as_edge()) else {
        return Ok(None);
    };
    let (pc, range) = match data.pcurve_for(surface, edge.location()) {
        Some(EdgeRepr::PCurve { curve, range, .. }) => (*curve, *range),
        Some(EdgeRepr::Seam { forward, range, .. }) => (*forward, *range),
        _ => return Ok(None),
    };
    let Some(pcurve) = model.geometry().pcurve(pc) else {
        return Ok(None);
    };
    Ok(Some(pcurve.point_at(f64::midpoint(range.0, range.1), tol)?))
}

/// `image` with the holes `holes` added: a new face on the same surface,
/// facing the same way.
fn with_holes(model: &mut Model, image: &Shape, holes: &[Shape]) -> OgeomResult<Shape> {
    if !image.location().is_identity() {
        ogeom_bail!(
            NotDone,
            "a face taking back its holes stands under a placement"
        );
    }
    let Some(NodeData::Face(data)) = model.node(image).map(|n| n.data().clone()) else {
        ogeom_bail!(Dangling, "face is not in this model");
    };
    let mut data = *data;
    data.triangulation = None;
    // The holes' edges are the solid's own and are not widened: a face
    // looser than one of them takes none back. No edge is tighter than the
    // least tolerance.
    if data.tolerance.get() > ogeom_core::Tolerance::MIN.get() {
        for hole in holes {
            for edge in model.children_of(hole)? {
                if model
                    .node(&edge)
                    .and_then(|n| n.data().as_edge())
                    .is_none_or(|e| e.tolerance.get() < data.tolerance.get())
                {
                    ogeom_bail!(NotDone, "a face is looser than a hole it takes back");
                }
            }
        }
    }
    let mut wires = model.children_of(&Shape::of(image.node()))?;
    wires.extend(holes.iter().cloned());
    Ok(model.add_face(data, &wires)?.oriented(image.orientation()))
}

/// Each shell without its membranes, and the history of their removal.
///
/// Two faces standing apart by less than the weld (two boxes stacked a few
/// microns apart) have their corners welded into one vertex each, and their
/// edges sewn into one: the two faces then bound one shell along the same
/// edges, lying on each other and facing apart, a wall of no thickness with
/// material on both sides. That is the opposed pair the boolean drops where
/// the contact is exact, and it is dropped here the same way. A pair bounded
/// by the same edges but standing apart (a lens's two caps on their one
/// rim) is a solid's own boundary and stays. A shell that is membranes
/// through (a sliver thinner than the weld) encloses nothing and goes.
/// The faces of a pair stand within [`MEMBRANE_WITHIN`] of each other too.
fn without_membranes(
    model: &mut Model,
    shells: &mut Vec<Shape>,
    weld: f64,
    tol: Tolerances,
) -> OgeomResult<History> {
    use ogeom_geom::Transformable as _;
    let mut dropped = History::new();
    let within = MEMBRANE_WITHIN.get();
    let bounding = |model: &Model, face: &Shape| -> OgeomResult<Vec<ogeom_topo::TShapeId>> {
        let mut edges: Vec<ogeom_topo::TShapeId> = explore_unique(model, face, ShapeType::Edge)?
            .iter()
            .filter(|e| {
                model
                    .node(e)
                    .and_then(|n| n.data().as_edge())
                    .is_some_and(|d| !d.degenerate)
            })
            .map(Shape::node)
            .collect();
        edges.sort_unstable();
        Ok(edges)
    };
    // Whether `second` lies on `first`, facing away from it.
    let membrane = |model: &Model, first: &Shape, second: &Shape| -> OgeomResult<bool> {
        let (at, n) = ogeom_algo::face_normal(model, first, tol)?;
        let (_, m) = ogeom_algo::face_normal(model, second, tol)?;
        if n.dot(m) > -0.99 * n.magnitude() * m.magnitude() {
            return Ok(false);
        }
        // The first's inner points, every one on the second's surface: a
        // thin lens (a tube's tip poking through a cap, cut off by it) is
        // two faces on the same loop facing apart too, as thin as a weld
        // only near its rim.
        let mesh =
            ogeom_mesh::triangulate_face(model, first, ogeom_mesh::Deflection::default(), tol)?;
        let mut probes: Vec<Point> = mesh
            .triangles
            .iter()
            .map(|t| {
                let [p, q, r] = t.map(|i| mesh.positions[i as usize]);
                Point::from_vector((p.to_vector() + q.to_vector() + r.to_vector()) / 3.0)
            })
            .collect();
        if probes.is_empty() {
            probes.push(at);
        }
        let Some(NodeData::Face(data)) = model.node(second).map(|n| n.data()) else {
            return Ok(false);
        };
        let Some(surface) = model.geometry().surface(data.surface) else {
            return Ok(false);
        };
        let placed = surface.transformed(&second.transform(model.datums())?, tol)?;
        // As far as the weld that joined their corners reached: its floor
        // past what the corners themselves own.
        let owned = explore_unique(model, first, ShapeType::Vertex)?
            .iter()
            .filter_map(|v| model.node(v).and_then(|n| n.data().as_vertex()))
            .fold(0.0_f64, |acc, d| acc.max(d.tolerance.get()));
        let reach = (weld + owned).min(within);
        for probe in probes {
            let foot = ogeom_algo::project_on_surface(&placed, probe, 16, tol)?;
            if foot.point.distance(probe) > reach {
                return Ok(false);
            }
        }
        Ok(true)
    };
    let mut emptied = Vec::new();
    for (index, shell) in shells.iter_mut().enumerate() {
        let faces = ogeom_topo::explore(model, shell, Filter::OfType(ShapeType::Face))?;
        let edges = faces
            .iter()
            .map(|f| bounding(model, f))
            .collect::<OgeomResult<Vec<_>>>()?;
        // Only faces bounded by the same edges can be a membrane's pair, so
        // the pairs are taken within each such group, in face order.
        let mut alike: ogeom_core::FastMap<&[ogeom_topo::TShapeId], Vec<usize>> =
            ogeom_core::FastMap::default();
        for (i, bounded_by) in edges.iter().enumerate() {
            if !bounded_by.is_empty() {
                alike.entry(bounded_by.as_slice()).or_default().push(i);
            }
        }
        let mut groups: Vec<Vec<usize>> = alike.into_values().filter(|g| g.len() > 1).collect();
        groups.sort_unstable();
        let mut gone = vec![false; faces.len()];
        for group in &groups {
            for (k, &i) in group.iter().enumerate() {
                for &j in &group[k + 1..] {
                    if gone[i] || gone[j] {
                        continue;
                    }
                    if membrane(model, &faces[i], &faces[j])? {
                        gone[i] = true;
                        gone[j] = true;
                    }
                }
            }
        }
        if !gone.contains(&true) {
            continue;
        }
        let mut kept = Vec::new();
        for (face, gone) in faces.iter().zip(&gone) {
            if *gone {
                dropped.delete(face);
            } else {
                kept.push(face.clone());
            }
        }
        if kept.is_empty() {
            emptied.push(index);
        } else {
            *shell = model.add_shell(&kept)?;
        }
    }
    for index in emptied.into_iter().rev() {
        shells.remove(index);
    }
    Ok(dropped)
}

/// Closed shells grouped into solids: each outer shell with the voids
/// directly inside it, as indices into `shells`.
///
/// A shell's depth is how many others enclose it. Even depth is a solid's
/// outer boundary (a free shell, or an island standing in another's
/// cavity), odd depth a void, belonging to the enclosing shell one level
/// out. Enclosure is decided by classifying the inner shell's vertices,
/// not by bounding boxes: a part standing in another's notch sits inside
/// its box and outside its material. A pair whose vertices all lie on the
/// other (shells touching everywhere they could be tested) falls back to
/// the boxes.
fn nest_shells(
    model: &Model,
    shells: &[Shape],
    tol: Tolerances,
) -> OgeomResult<Vec<(usize, Vec<usize>)>> {
    if shells.len() == 1 {
        return Ok(vec![(0, Vec::new())]);
    }
    let mut bounds = Vec::with_capacity(shells.len());
    for shell in shells {
        bounds.push(shape_bounds(model, shell, tol)?);
    }
    // A container's box widened by the tolerance a touch is read within: a
    // void meeting its outer shell at a point (a ball resting against the
    // inside of a wall) may reach a hair past it, and is still within it.
    let reach = tol.confusion() * 1e2;
    let mut boundaries: Vec<Option<ogeom_algo::SolidBoundary>> =
        (0..shells.len()).map(|_| None).collect();
    let mut encloses = vec![vec![false; shells.len()]; shells.len()];
    for i in 0..shells.len() {
        for j in 0..shells.len() {
            if i == j || !bounds[i].expanded(reach).contains_box(&bounds[j]) {
                continue;
            }
            if boundaries[i].is_none() {
                boundaries[i] = Some(ogeom_algo::SolidBoundary::of(
                    model,
                    &shells[i],
                    tol.confusion() * 1e4,
                    tol,
                )?);
            }
            let Some(boundary) = boundaries[i].as_ref() else {
                continue;
            };
            let mut verdict = None;
            for vertex in explore_unique(model, &shells[j], ShapeType::Vertex)? {
                let Some(data) = model.node(&vertex).and_then(|n| n.data().as_vertex()) else {
                    continue;
                };
                let at = vertex.transform(model.datums())?.apply(data.point);
                match boundary.holds(model, at, tol)? {
                    Containment::In => verdict = Some(true),
                    Containment::Out => verdict = Some(false),
                    Containment::On => continue,
                }
                break;
            }
            encloses[i][j] = verdict.unwrap_or(true);
        }
    }
    let depth: Vec<usize> = (0..shells.len())
        .map(|j| (0..shells.len()).filter(|&i| encloses[i][j]).count())
        .collect();
    let mut out: Vec<(usize, Vec<usize>)> = (0..shells.len())
        .filter(|&i| depth[i].is_multiple_of(2))
        .map(|i| (i, Vec::new()))
        .collect();
    for j in (0..shells.len()).filter(|&j| !depth[j].is_multiple_of(2)) {
        let parent = (0..shells.len()).find(|&i| encloses[i][j] && depth[i] + 1 == depth[j]);
        if let Some(parent) = parent
            && let Some(slot) = out.iter_mut().find(|(i, _)| *i == parent)
        {
            slot.1.push(j);
        }
    }
    Ok(out)
}

/// Solids from an unordered soup of faces: sew, demand closure, nest
/// shells into solids and voids: the pipeline's own final stages offered
/// as a builder.
///
/// # Errors
///
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) if a
/// shell fails to close; an open soup encloses no volume, and saying so
/// beats guessing.
pub fn make_volume(model: &mut Model, faces: &[Shape], tol: Tolerances) -> OgeomResult<Built> {
    let sewn = ogeom_algo::sew(model, faces, tol)?;
    for shell in &sewn.shells {
        if !ogeom_algo::is_shell_closed(model, shell)? {
            ogeom_bail!(
                Construction,
                "the faces do not close into shells; an open soup encloses no volume"
            );
        }
    }
    let mut solids = Vec::new();
    for (outer, voids) in nest_shells(model, &sewn.shells, tol)? {
        let mut group = vec![sewn.shells[outer].clone()];
        // A void bounds its solid from inside: material lies outside it,
        // so the sewn outward orientation reverses.
        group.extend(voids.iter().map(|&j| sewn.shells[j].reversed()));
        solids.push(model.add_solid(&group)?);
    }
    let mut history = History::new();
    let result = if solids.len() == 1 {
        solids.remove(0)
    } else {
        model.add_compound(&solids)?
    };
    for face in faces {
        history.modify(face, result.clone());
    }
    Ok(Built::new(result, history))
}

/// The three cells two solids cut space into, each one boolean's answer:
/// what is only in `a`, what is only in `b`, and what is in both. Arbitrary
/// set expressions compose by fusing a selection of these.
#[derive(Debug)]
pub struct Cells {
    /// `a` with `b` removed.
    pub a_not_b: Built,
    /// `b` with `a` removed.
    pub b_not_a: Built,
    /// The overlap.
    pub common: Built,
}

/// Split two solids into their three cells.
///
/// # Errors
///
/// As the operations themselves.
pub fn cells(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Cells> {
    let (a, b) = (
        &resolved_half_space(model, a, b, tol)?,
        &resolved_half_space(model, b, a, tol)?,
    );
    let (a, b) = (
        &baked_if_scaled(model, a, tol)?,
        &baked_if_scaled(model, b, tol)?,
    );
    // One arrangement answers all three: each cell is a different choice
    // of the same classified pieces, the choices `cut` and `common` make,
    // and the cut the other way round with the arguments' roles swapped.
    let fused = general_fuse_classified(model, a, b, None, tol)?;
    let keep = |choose: &dyn Fn(&FacePiece) -> Option<bool>| -> Vec<(usize, bool)> {
        fused
            .pieces
            .iter()
            .enumerate()
            .filter_map(|(i, p)| choose(p).map(|flip| (i, flip)))
            .collect()
    };
    let cut_from = |first: bool| {
        move |p: &FacePiece| match (p.from_a == first, p.state) {
            (true, PieceState::Out | PieceState::OnOpposed) => Some(false),
            (false, PieceState::In) => Some(true),
            _ => None,
        }
    };
    let a_only = keep(&cut_from(true));
    let b_only = keep(&cut_from(false));
    let both = keep(&|p: &FacePiece| {
        (p.state == PieceState::In || (p.state == PieceState::OnAligned && !p.covered))
            .then_some(false)
    });
    Ok(Cells {
        a_not_b: assemble_result(model, &fused, &a_only, [true, false], a, b, tol)?,
        b_not_a: assemble_result(model, &fused, &b_only, [false, true], a, b, tol)?,
        common: assemble_result(model, &fused, &both, [false, false], a, b, tol)?,
    })
}

/// A tolerance whose confusion *is* the stated fuzz: every gap, pave and
/// weld decision inherits it coherently, which is what a fuzzy boolean
/// means.
fn fuzzed(fuzz: f64, tol: Tolerances) -> OgeomResult<Tolerances> {
    if !fuzz.is_finite() || fuzz <= 0.0 {
        ogeom_bail!(Construction, "a fuzz of {fuzz} is not a distance");
    }
    if fuzz <= tol.confusion() {
        return Ok(tol);
    }
    Tolerances::with_scale(ogeom_core::tolerance::CONFUSION / fuzz)
}

/// [`fuse`] with geometry within `fuzz` of touching counted as touching.
///
/// The fuzz loosens every decision the boolean makes, its welds and probes
/// included, and those reach well past the fuzz itself: at a fuzz near a
/// hundredth of the operands' size they can swallow a face. A result is
/// kept only where its volume agrees, within the fuzz over the operands'
/// area, with what the exact operation finds, or with what any union of
/// the two can hold where the exact one is refused; otherwise the fuzz is
/// taken a tenth smaller, down to the exact operation itself.
///
/// # Errors
///
/// As [`fuse`], plus a non-positive fuzz.
pub fn fuse_fuzzy(
    model: &mut Model,
    a: &Shape,
    b: &Shape,
    fuzz: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    at_a_fuzz(model, a, b, fuzz, tol, fuse, |va, vb| (va.max(vb), va + vb))
}

/// [`cut`] at a stated fuzz.
///
/// # Errors
///
/// As [`fuse_fuzzy`].
pub fn cut_fuzzy(
    model: &mut Model,
    a: &Shape,
    b: &Shape,
    fuzz: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    at_a_fuzz(model, a, b, fuzz, tol, cut, |va, vb| {
        ((va - vb).max(0.0), va)
    })
}

/// [`common`] at a stated fuzz.
///
/// # Errors
///
/// As [`fuse_fuzzy`].
pub fn common_fuzzy(
    model: &mut Model,
    a: &Shape,
    b: &Shape,
    fuzz: f64,
    tol: Tolerances,
) -> OgeomResult<Built> {
    at_a_fuzz(model, a, b, fuzz, tol, common, |va, vb| (0.0, va.min(vb)))
}

/// One boolean at a fuzz, as [`fuse_fuzzy`] says: the largest fuzz up to
/// `fuzz`, a tenth smaller at a time, whose result holds the volume the
/// exact `operation` finds, or lies within `span` of the operands'
/// volumes where the exact one is refused.
fn at_a_fuzz(
    model: &mut Model,
    a: &Shape,
    b: &Shape,
    fuzz: f64,
    tol: Tolerances,
    operation: fn(&mut Model, &Shape, &Shape, Tolerances) -> OgeomResult<Built>,
    span: fn(f64, f64) -> (f64, f64),
) -> OgeomResult<Built> {
    let loosened = fuzzed(fuzz, tol)?;
    if loosened.confusion() <= tol.confusion() {
        return operation(model, a, b, tol);
    }
    let measure = |model: &Model, shape: &Shape| -> Option<(f64, f64)> {
        let found =
            ogeom_algo::volume_properties(model, shape, ogeom_mesh::Deflection::default(), tol)
                .ok()?;
        Some((found.mass, found.deflection))
    };
    // Where the operands cannot be measured there is nothing to hold a
    // result to, and the fuzz is taken as asked.
    let (Some((va, da)), Some((vb, db))) = (measure(model, a), measure(model, b)) else {
        return operation(model, a, b, loosened);
    };
    let area = box_area(model, a, tol) + box_area(model, b, tol);
    let exact = operation(model, a, b, tol);
    let held = match &exact {
        Ok(built) => measure(model, &built.shape).map(|(v, _)| (v, v)),
        Err(_) => Some(span(va, vb)),
    };
    let Some((low, high)) = held else {
        return exact;
    };
    let mut first_error = None;
    let mut f = fuzz;
    while f > tol.confusion() {
        let at = fuzzed(f, tol)?;
        match operation(model, a, b, at) {
            Ok(built) => {
                // A meshed measure stands off by its chord over the area.
                let slack = (f + da.max(db)) * area + (va + vb) * 1e-9;
                if let Some((v, dv)) = measure(model, &built.shape)
                    && v >= low - slack - dv * area
                    && v <= high + slack + dv * area
                {
                    return Ok(built);
                }
            }
            Err(e) => {
                first_error.get_or_insert(e);
            }
        }
        f /= 10.0;
    }
    match (exact, first_error) {
        (Ok(built), _) => Ok(built),
        (Err(_), Some(e)) => Err(e),
        (Err(e), None) => Err(e),
    }
}

/// The area of a shape's bounding box: what the fuzz moves its faces over,
/// at most, for a shape that is not a sponge.
fn box_area(model: &Model, shape: &Shape, tol: Tolerances) -> f64 {
    let Ok(bound) = ogeom_algo::tight_bounds(model, shape, tol) else {
        return 0.0;
    };
    let (Some(lo), Some(hi)) = (bound.low(), bound.high()) else {
        return 0.0;
    };
    let (x, y, z) = (hi.x - lo.x, hi.y - lo.y, hi.z - lo.z);
    2.0 * (x * y + y * z + z * x)
}

/// A shape repeated `count` times along a direction at a period and fused
/// into one: the periodic pattern as a composition of what exists.
///
/// # Errors
///
/// As [`fuse`], plus an unusable count or period.
pub fn make_periodic(
    model: &mut Model,
    shape: &Shape,
    step: ogeom_math::Vector,
    count: usize,
    tol: Tolerances,
) -> OgeomResult<Built> {
    if count == 0 {
        ogeom_bail!(Construction, "a pattern of zero copies is nothing");
    }
    if step.magnitude() <= tol.confusion() {
        ogeom_bail!(Construction, "a zero period stacks every copy on the first");
    }
    // Each face and edge of the input traces to its own image in the
    // pattern and generates its copies' images, through every fuse.
    let mut parts: Vec<Shape> = Vec::new();
    for kind in [ShapeType::Face, ShapeType::Edge] {
        parts.extend(ogeom_topo::explore_unique(model, shape, kind)?);
    }
    let mut history = History::new();
    // The pattern so far as disjoint solids: a copy is fused into each piece
    // it joins, and stands as a piece of its own where a gap parts it from
    // the rest.
    let mut pieces: Vec<Shape> = vec![shape.clone()];
    for i in 1..count {
        #[allow(clippy::cast_precision_loss, reason = "pattern counts are small")]
        let offset = step * i as f64;
        let moved =
            ogeom_algo::transformed(model, shape, ogeom_math::Transform::translation(offset))?
                .shape;
        // A placement moves every part with the whole: the copy's parts are
        // the input's, placed as the copy is.
        let placement = moved.location().then(&shape.location().inverted());
        let mut images: Vec<(usize, Vec<Shape>)> = parts
            .iter()
            .enumerate()
            .map(|(k, part)| (k, vec![part.moved(&placement)]))
            .collect();
        let mut current = moved;
        let mut apart: Vec<Shape> = Vec::new();
        for piece in pieces {
            let joined = fuse(model, &piece, &current, tol)?;
            if model.kind_of(&joined.shape)? != ShapeType::Solid {
                apart.push(piece);
                continue;
            }
            history = history.then(&joined.history);
            for (_, traced) in &mut images {
                *traced = traced
                    .iter()
                    .flat_map(|image| joined.history.trace(image).to_vec())
                    .collect();
            }
            current = joined.shape;
        }
        for (k, traced) in images {
            for image in traced {
                history.generate(&parts[k], image);
            }
        }
        apart.push(current);
        pieces = apart;
    }
    let result = if let [one] = pieces.as_slice() {
        one.clone()
    } else {
        ogeom_algo::build::make_compound(model, &pieces)?.shape
    };
    history.generate(shape, result.clone());
    Ok(Built::new(result, history))
}

// --- the operations ----------------------------------------------------------

/// A shape whose placements carry scale, rebuilt with the scale baked
/// into its geometry before the pipeline runs.
///
/// A scale changes a surface's parameterization out from under its
/// pcurves (the refusal the gather makes), so the bake is the whole-shape
/// conversion:
/// surfaces restated in world space, edges moved exactly, pcurves
/// re-derived against the new parameterizations. Unscaled shapes pass
/// through untouched.
fn baked_if_scaled(model: &mut Model, shape: &Shape, tol: Tolerances) -> OgeomResult<Shape> {
    let mut restate = false;
    for face in ogeom_topo::explore(model, shape, Filter::OfType(ShapeType::Face))? {
        if face.location().is_identity() {
            continue;
        }
        let placement = face.transform(model.datums())?;
        // A scale changes lengths the melt compares. A reflection flips
        // every chart's natural normal against its face's flag. Either way
        // the operand is restated in world coordinates first, where both
        // effects are already folded in.
        if (placement.scale_factor().abs() - 1.0).abs() > 1e-9 || !placement.preserves_handedness()
        {
            restate = true;
            break;
        }
    }
    if !restate {
        return Ok(shape.clone());
    }
    Ok(ogeom_algo::baked_shape(model, shape, tol)?.shape)
}

/// Whether a shape is a half space: one shell of one face, open by
/// construction or closed inside out.
fn is_half_space(model: &Model, shape: &Shape, tol: Tolerances) -> OgeomResult<bool> {
    Ok(half_space::half_space_face(model, shape, tol)?.is_some())
}

/// A half space resolved into the solid the operation can act on.
///
/// A planar boundary becomes a box filling the material side, sized past
/// the other argument's whole reach. The box's plane-side face is
/// *coplanar with the boundary itself*, so the cut the caller sees is the
/// exact plane. Its far faces stand outside everything the other shape
/// reaches and never appear in the result. A curved boundary is resolved
/// by [`half_space::resolved`]. A shape that is not a half space passes
/// through untouched.
fn resolved_half_space(
    model: &mut Model,
    shape: &Shape,
    other: &Shape,
    tol: Tolerances,
) -> OgeomResult<Shape> {
    let Some(face) = half_space::half_space_face(model, shape, tol)? else {
        return Ok(shape.clone());
    };
    let planar = model
        .node(&face)
        .and_then(|n| n.data().as_face())
        .and_then(|d| model.geometry().surface(d.surface))
        .is_some_and(|s| matches!(s, SurfaceGeometry::Plane(_)));
    if !planar {
        return half_space::resolved(model, &face, other, tol);
    }
    // The boundary's outward normal points away from the material.
    let (at, outward) = ogeom_algo::face_normal(model, &face, tol)?;
    let bound = ogeom_algo::shape_bounds(model, other, tol)?;
    let Some(centre) = bound.centre() else {
        ogeom_bail!(
            Construction,
            "the other argument has no bound to fill against"
        );
    };
    let reach = bound.diagonal().max(tol.confusion() * 1e3) * 2.0;
    let into = ogeom_math::Direction::new(-outward, tol)?;
    let foot = centre - outward * outward.dot(centre - at);
    let seed = if into.vector().x.abs() < 0.9 {
        ogeom_math::Vector::new(1.0, 0.0, 0.0)
    } else {
        ogeom_math::Vector::new(0.0, 1.0, 0.0)
    };
    let frame_x = ogeom_math::Direction::from_cross(into.vector(), seed, tol)?;
    let oriented = ogeom_math::Frame::new(foot, into, frame_x, tol)?;
    let corner =
        foot - oriented.x().vector() * (reach / 2.0) - oriented.y().vector() * (reach / 2.0);
    let placed = ogeom_math::Frame::new(corner, into, frame_x, tol)?;
    // Deep enough to pass the other shape's far side however far the
    // plane stands from it: a stand-in whose far face fell inside the
    // shape would cut it there, where the half space cuts nothing.
    let depth = reach + (centre - at).dot(into.vector()).max(0.0);
    Ok(ogeom_algo::make_box(model, placed, (reach, reach, depth), tol)?.shape)
}

/// The plane bounding a half space, where `shape` is one and its boundary
/// is planar.
fn half_space_plane(
    model: &Model,
    shape: &Shape,
    tol: Tolerances,
) -> OgeomResult<Option<ogeom_math::Plane>> {
    let Some(face) = half_space::half_space_face(model, shape, tol)? else {
        return Ok(None);
    };
    let Some(surface) = model
        .node(&face)
        .and_then(|n| n.data().as_face())
        .and_then(|d| model.geometry().surface(d.surface))
        .cloned()
    else {
        return Ok(None);
    };
    use ogeom_geom::Transformable as _;
    match surface.transformed(&face.transform(model.datums())?, tol)? {
        SurfaceGeometry::Plane(p) => Ok(Some(p.plane())),
        _ => Ok(None),
    }
}

/// The union of two solids.
///
/// # Errors
///
/// [`OgeomError::NotDone`](ogeom_core::OgeomError::NotDone) for configurations the
/// boolean refuses: tangential or same-domain contact, scaled placements;
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) for arguments
/// that are not closed solids.
pub fn fuse(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    if is_sheet(model, a)? || is_sheet(model, b)? {
        ogeom_bail!(
            Construction,
            "a union takes solids; common and cut trim a sheet, and split_sheet \
             splits one"
        );
    }
    let built = noting_held(model, |model| {
        ball_chart::with_poles_clear(model, a, b, tol, |model, a, b| {
            settled(model, tol, |model, tol| fuse_once(model, a, b, tol))
        })
    })?;
    sub_shapes::with_sub_shapes(model, [a, b], built, tol)
}

/// What `run` makes, with the nodes it passed through from the shapes it
/// was given noted as held by those shapes as well
/// ([`Model::note_held`]): an operation editing the result in place
/// copies them first ([`Model::unshare`]).
fn noting_held(
    model: &mut Model,
    run: impl FnOnce(&mut Model) -> OgeomResult<Built>,
) -> OgeomResult<Built> {
    let since = model.node_count();
    let built = run(model)?;
    model.note_held(&built.shape, since)?;
    Ok(built)
}

fn fuse_once(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    if is_half_space(model, a, tol)? || is_half_space(model, b, tol)? {
        ogeom_bail!(
            Construction,
            "the union with a half space is unbounded; a half space serves cut, \
             common and section"
        );
    }
    let (a, b) = (
        &baked_if_scaled(model, a, tol)?,
        &baked_if_scaled(model, b, tol)?,
    );
    // Outward pieces bound the union. A same-domain pair with aligned
    // material keeps one copy, and one with opposed material is interior to
    // the union and vanishes.
    let built = fused_and_assembled(model, a, b, [true, true], tol, |p| {
        (p.state == PieceState::Out || (p.state == PieceState::OnAligned && !p.covered))
            .then_some(false)
    });
    // A union of two solids is never empty.
    let built = match built {
        Ok(built) if holds_nothing(model, &built.shape)? => {
            Err(ogeom_core::ogeom_err!(NotDone, "the union came out empty"))
        }
        other => other,
    };
    // The union of a solid and one lying within it is the outer one,
    // whatever contact their boundaries make.
    or_nested(model, built, a, b, true, tol)
}

/// Which of two solids lies within the other, where one does: every sample
/// of the inner one's boundary in or on the outer, none of the outer's
/// strictly inside the inner. `Some(true)` for `b` within `a`, `Some(false)`
/// for `a` within `b`.
///
/// Asked only once the general boolean has refused: boundaries that run
/// along each other within their tolerances (a pad sketched on a converted
/// part's own outline, its sides chords of the part's walls) defeat the
/// arrangement, and a solid within the other is what they usually are.
fn nested(model: &Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Option<bool>> {
    sampled_relation(model, a, b, Relation::Nested, tol)
}

/// Whether two solids share no volume: no sample of either's boundary
/// strictly inside the other. Boxes apart settle it without sampling.
fn apart(model: &Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<bool> {
    let (box_a, box_b) = (
        ogeom_algo::shape_bounds(model, a, tol)?,
        ogeom_algo::shape_bounds(model, b, tol)?,
    );
    if !box_a.expanded(tol.confusion()).intersects(&box_b) {
        return Ok(true);
    }
    Ok(sampled_relation(model, a, b, Relation::Apart, tol)? == Some(true))
}

/// What [`sampled_relation`] reads of two boundaries.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Relation {
    /// Which solid lies within the other, as [`nested`] answers.
    Nested,
    /// Whether neither boundary enters the other solid: `Some(true)` when
    /// none does.
    Apart,
    /// Whether the first solid's boundary stands nowhere outside the
    /// second: `Some(true)` when no sample of it reads out.
    Covered,
}

/// Two solids' boundaries sampled and read against each other.
fn sampled_relation(
    model: &Model,
    a: &Shape,
    b: &Shape,
    relation: Relation,
    tol: Tolerances,
) -> OgeomResult<Option<bool>> {
    // The boundary's samples, each on its face's exact surface: the face
    // mesh's vertices, and its triangles' middles taken in the chart and
    // lifted, since a middle taken in space stands off a curved face by the
    // mesh's own sag. A triangle along a trim bending into the face reaches
    // past it by its chord's sag, and so may its middle: a middle is kept
    // only where it reads inside the trim drawn at `fine`.
    let samples = |shape: &Shape, fine: f64| -> OgeomResult<Vec<Point>> {
        let mut out = Vec::new();
        for face in explore_unique(model, shape, ShapeType::Face)? {
            let Some(NodeData::Face(data)) = model.node(&face).map(|n| n.data()) else {
                continue;
            };
            let Some(surface) = model.geometry().surface(data.surface) else {
                ogeom_bail!(Dangling, "surface is not in this model");
            };
            let placement = face.transform(model.datums())?;
            let mesh =
                ogeom_mesh::triangulate_face(model, &face, ogeom_mesh::Deflection::default(), tol)?;
            out.extend(mesh.positions.iter().copied());
            if mesh.parameters.len() != mesh.positions.len() {
                continue;
            }
            let trim = ogeom_algo::classify::FaceTrim::of(
                model,
                &face,
                ogeom_mesh::Deflection {
                    chord: fine,
                    ..ogeom_mesh::Deflection::default()
                },
                tol,
            )?;
            for t in &mesh.triangles {
                let [p, q, r] = t.map(|i| mesh.parameters[i as usize]);
                let (u, v) = ((p.0 + q.0 + r.0) / 3.0, (p.1 + q.1 + r.1) / 3.0);
                if trim.holds(model, (u, v), 0.0, tol)? == Containment::In {
                    out.push(placement.apply(surface.point_at(u, v, tol)?));
                }
            }
        }
        Ok(out)
    };
    // Every sample on the right side: `allowed` names the containments that
    // fit. An ambiguous sample says nothing. A boundary most of whose
    // samples say nothing is not settled.
    let all_read = |points: &[Point],
                    boundary: &ogeom_algo::SolidBoundary,
                    allowed: &dyn Fn(Containment) -> bool|
     -> OgeomResult<bool> {
        let mut unread = 0_usize;
        for p in points {
            ogeom_core::progress::checkpoint()?;
            match boundary.holds(model, *p, tol) {
                Ok(says) if allowed(says) => {}
                Ok(_) => return Ok(false),
                Err(ogeom_core::OgeomError::NotDone(_)) => unread += 1,
                Err(e) => return Err(e),
            }
        }
        Ok(unread * 10 <= points.len())
    };
    // Read at the looseness the solids state: a converted part's walls are
    // fits standing off its mesh's points, and a solid drawn on those
    // points lies on the walls only to that.
    let mut loosest = tol.confusion();
    for shape in [a, b] {
        for kind in [ShapeType::Edge, ShapeType::Vertex] {
            for sub in explore_unique(model, shape, kind)? {
                let stated = match model.node(&sub).map(|n| n.data()) {
                    Some(NodeData::Edge(d)) => d.tolerance.get(),
                    Some(NodeData::Vertex(d)) => d.tolerance.get(),
                    _ => continue,
                };
                loosest = loosest.max(stated);
            }
        }
    }
    // The rings are polylined at the band the caller's tolerance sets, or
    // at the solids' own looseness where that is coarser. Taken from the
    // loosened tolerance instead, a few microns of slop would polyline the
    // rings at tens of millimetres, and every ray would land within that of
    // some trim and read nothing.
    let band = (tol.confusion() * 1e4).max(loosest);
    let tol = if loosest > tol.confusion() {
        fuzzed(loosest, tol)?
    } else {
        tol
    };
    let (of_a, of_b) = (
        ogeom_algo::SolidBoundary::of(model, a, band, tol)?,
        ogeom_algo::SolidBoundary::of(model, b, band, tol)?,
    );
    let (on_a, on_b) = (samples(a, band)?, samples(b, band)?);
    if relation == Relation::Apart {
        let clear = all_read(&on_a, &of_b, &|c| c != Containment::In)?
            && all_read(&on_b, &of_a, &|c| c != Containment::In)?;
        return Ok(Some(clear));
    }
    if relation == Relation::Covered {
        return Ok(Some(all_read(&on_a, &of_b, &|c| c != Containment::Out)?));
    }
    let within = |inner: &[Point],
                  outer_boundary: &ogeom_algo::SolidBoundary,
                  outer: &[Point],
                  inner_boundary: &ogeom_algo::SolidBoundary|
     -> OgeomResult<bool> {
        Ok(all_read(inner, outer_boundary, &|c| c != Containment::Out)?
            && all_read(outer, inner_boundary, &|c| c != Containment::In)?)
    };
    if within(&on_b, &of_a, &on_a, &of_b)? && !pokes_out(model, b, a, &of_a, tol)? {
        return Ok(Some(true));
    }
    if within(&on_a, &of_b, &on_b, &of_a)? && !pokes_out(model, a, b, &of_b, tol)? {
        return Ok(Some(false));
    }
    Ok(None)
}

/// Whether `inner`'s boundary pokes out through `outer`'s between the
/// samples [`nested`] reads.
///
/// A drum a few microns wider than the box it stands in bulges out of each
/// wall along a strip a fraction of a millimetre wide, and samples a mesh's
/// chord apart step over it. So each inner face climbs its own chart from
/// the samples standing nearest each outer face, toward that face's outside,
/// and the furthest point reached is asked of the outer boundary: out there,
/// and on the inner face, the inner solid is not within the outer.
fn pokes_out(
    model: &Model,
    inner: &Shape,
    outer: &Shape,
    outer_boundary: &ogeom_algo::SolidBoundary,
    tol: Tolerances,
) -> OgeomResult<bool> {
    use ogeom_geom::Surface as _;
    use ogeom_geom::Transformable as _;
    // A start this close to a wall, inside it, may sit beside a bulge the
    // samples straddle: a chord's sag, a few times over.
    let deflection = ogeom_mesh::Deflection::default();
    let reach = deflection.chord * 4.0;
    // The starts climbed per inner face and wall: the nearest few, which
    // stand beside the bulges if there are any.
    const STARTS: usize = 6;
    let placed = |face: &Shape| -> OgeomResult<SurfaceGeometry> {
        let Some(NodeData::Face(data)) = model.node(face).map(|n| n.data()) else {
            ogeom_bail!(Dangling, "face is not in this model");
        };
        let Some(surface) = model.geometry().surface(data.surface) else {
            ogeom_bail!(Dangling, "surface is not in this model");
        };
        surface.transformed(&face.transform(model.datums())?, tol)
    };
    // Each outer face: its surface placed, which way its outside lies, and
    // the box a near start stands in.
    let mut walls = Vec::new();
    for face in explore_unique(model, outer, ShapeType::Face)? {
        let outward = if face.orientation() == ogeom_topo::Orientation::Reversed {
            -1.0
        } else {
            1.0
        };
        let bound = ogeom_algo::shape_bounds(model, &face, tol)?.expanded(reach);
        walls.push((placed(&face)?, outward, bound));
    }
    // How far a point stands outside a wall's surface, along its normal.
    let outside = |p: Point, wall: &(SurfaceGeometry, f64, ogeom_math::Aabb)| -> Option<f64> {
        let found = ogeom_algo::project_on_surface(&wall.0, p, 8, tol).ok()?;
        let (u, v) = found.parameters;
        let n = wall.0.normal_at(u, v, tol).ok()?;
        Some((p - found.point).dot(n.vector()) * wall.1)
    };
    for face in explore_unique(model, inner, ShapeType::Face)? {
        ogeom_core::progress::checkpoint()?;
        let surface = placed(&face)?;
        let mesh = ogeom_mesh::triangulate_face(model, &face, deflection, tol)?;
        if mesh.parameters.len() != mesh.positions.len() || mesh.parameters.is_empty() {
            continue;
        }
        let (mut lo, mut hi) = (mesh.parameters[0], mesh.parameters[0]);
        for &(u, v) in &mesh.parameters {
            lo = (lo.0.min(u), lo.1.min(v));
            hi = (hi.0.max(u), hi.1.max(v));
        }
        let span = (hi.0 - lo.0).max(hi.1 - lo.1);
        if span <= 0.0 {
            continue;
        }
        let lift = |at: (f64, f64)| surface.point_at(at.0, at.1, tol);
        let mut starts: Vec<(f64, f64)> = mesh.parameters.clone();
        for t in &mesh.triangles {
            let [p, q, r] = t.map(|i| mesh.parameters[i as usize]);
            starts.push(((p.0 + q.0 + r.0) / 3.0, (p.1 + q.1 + r.1) / 3.0));
        }
        for wall in &walls {
            let mut near: Vec<((f64, f64), f64)> = Vec::new();
            for &at in &starts {
                let p = lift(at)?;
                if !wall.2.contains(p) {
                    continue;
                }
                if let Some(d) = outside(p, wall)
                    && d >= -reach
                {
                    near.push((at, d));
                }
            }
            near.sort_by(|x, y| y.1.total_cmp(&x.1));
            near.truncate(STARTS);
            for (start, d) in near {
                // A pattern search in the chart, held to the face's own
                // parameter box: a step each way along u and v, halved
                // where none climbs.
                let (mut at, mut best, mut step) = (start, d, span * 0.05);
                let mut rounds = 0;
                while step > span * 1e-7 && rounds < 400 {
                    rounds += 1;
                    let mut climbed = false;
                    for (du, dv) in [(step, 0.0), (-step, 0.0), (0.0, step), (0.0, -step)] {
                        let next = ((at.0 + du).clamp(lo.0, hi.0), (at.1 + dv).clamp(lo.1, hi.1));
                        if let Ok(q) = lift(next)
                            && let Some(g) = outside(q, wall)
                            && g > best
                        {
                            (at, best) = (next, g);
                            climbed = true;
                        }
                    }
                    if !climbed {
                        step *= 0.5;
                    }
                }
                if best <= tol.confusion() {
                    continue;
                }
                let q = lift(at)?;
                if ogeom_algo::classify_on_face(model, &face, q, deflection, tol)?
                    != Containment::Out
                    && outer_boundary
                        .holds(model, q, tol)
                        .is_ok_and(|c| c == Containment::Out)
                {
                    return Ok(true);
                }
            }
        }
    }
    Ok(false)
}

/// A boolean's result, or where the general boolean refused and one solid
/// lies within the other, the answer that nesting gives: the outer one for
/// a union (`outer` true), the inner one for an intersection. The solid
/// returned is that argument itself, the other's faces deleted.
fn or_nested(
    model: &mut Model,
    built: OgeomResult<Built>,
    a: &Shape,
    b: &Shape,
    outer: bool,
    tol: Tolerances,
) -> OgeomResult<Built> {
    let refusal = match built {
        Ok(built) => return Ok(built),
        Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
            return Err(e);
        }
        Err(e) => e,
    };
    let Some(b_in_a) = nested(model, a, b, tol)? else {
        return Err(refusal);
    };
    // For the union the container stands. For the intersection, what it
    // contains.
    let (kept, gone) = if b_in_a == outer { (a, b) } else { (b, a) };
    let mut history = ogeom_algo::History::new();
    for face in explore_unique(model, gone, ShapeType::Face)? {
        history.delete(&face);
    }
    Ok(Built::new(kept.clone(), history))
}

/// The intersection of two solids.
///
/// Either argument may instead be a sheet (a face, a shell or a compound of
/// those) when the other is a solid or a half space: the result is then the
/// part of the sheet inside the other. Each face of the sheet is split where
/// the other's boundary crosses it, and the pieces inside are sewn along the
/// edges they share into one shell, or a compound of shells where they fall
/// apart, or an empty compound where none is inside. Each piece lies on its
/// face's surface, and the history records each against the face it came
/// from and every face nothing is kept of as deleted.
///
/// # Errors
///
/// As [`fuse`].
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) for two
/// sheets, which share no volume.
/// [`OgeomError::NotDone`](ogeom_core::OgeomError::NotDone) where a piece of
/// a sheet lies on the other's boundary, which keeps it on neither side.
pub fn common(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    match (is_sheet(model, a)?, is_sheet(model, b)?) {
        (true, true) => ogeom_bail!(
            Construction,
            "two sheets share no volume to keep; split_sheet splits one by the other"
        ),
        (true, false) => trimmed_sheet(model, a, b, true, tol),
        (false, true) => trimmed_sheet(model, b, a, true, tol),
        (false, false) => {
            let built = noting_held(model, |model| {
                ball_chart::with_poles_clear(model, a, b, tol, |model, a, b| {
                    settled(model, tol, |model, tol| common_once(model, a, b, tol))
                })
            })?;
            sub_shapes::with_sub_shapes(model, [a, b], built, tol)
        }
    }
}

fn common_once(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    let (a, b) = (
        &resolved_half_space(model, a, b, tol)?,
        &resolved_half_space(model, b, a, tol)?,
    );
    let (a, b) = (
        &baked_if_scaled(model, a, tol)?,
        &baked_if_scaled(model, b, tol)?,
    );
    // Inward pieces bound the intersection. An aligned same-domain pair
    // bounds it too, once. An opposed pair encloses no volume between them.
    let built = fused_and_assembled(model, a, b, [false, false], tol, |p| {
        (p.state == PieceState::In || (p.state == PieceState::OnAligned && !p.covered))
            .then_some(false)
    });
    // Nothing in common is an answer only where the two share no volume.
    let built = match built {
        Ok(built) if holds_nothing(model, &built.shape)? && !apart(model, a, b, tol)? => {
            Err(ogeom_core::ogeom_err!(
                NotDone,
                "the intersection came out empty though the solids overlap"
            ))
        }
        other => other,
    };
    // The intersection of a solid and one lying within it is the inner one.
    or_nested(model, built, a, b, false, tol)
}

/// Two solids fused generally and the pieces `keep` takes assembled, each
/// with whether it is turned over; `keep_aside` says, per solid, whether
/// its faces outside the other are kept.
///
/// The faces each solid has clear of the other are set aside first and
/// come through untouched. Where that cannot be assembled (an edge the
/// faces set aside share would have to move), every face is taken.
fn fused_and_assembled(
    model: &mut Model,
    a: &Shape,
    b: &Shape,
    keep_aside: [bool; 2],
    tol: Tolerances,
    keep: impl Fn(&FacePiece) -> Option<bool>,
) -> OgeomResult<Built> {
    let attempt = |model: &mut Model, aside: Option<&[aside::Aside; 2]>| {
        let fused = general_fuse_classified(model, a, b, aside, tol)?;
        let kept: Vec<(usize, bool)> = fused
            .pieces
            .iter()
            .enumerate()
            .filter_map(|(i, p)| keep(p).map(|flip| (i, flip)))
            .collect();
        assemble_result(model, &fused, &kept, keep_aside, a, b, tol)
    };
    if let Ok(Some(aside)) = aside::set_aside(model, a, b, tol) {
        // The faces set aside keep the solids' own edges and vertices, and
        // what the attempt widens of those is put back where it fails: the
        // solids are given back as they came, and taking every face starts
        // from them.
        let mark = model.note_widened();
        match attempt(model, Some(&aside)) {
            Ok(built) => {
                model.keep_widened(mark);
                return Ok(built);
            }
            Err(e) => {
                model.undo_widened(mark);
                if matches!(e, ogeom_core::OgeomError::Cancelled) {
                    return Err(e);
                }
            }
        }
    }
    attempt(model, None)
}

/// Whether a boolean's result has no face: an empty compound, or one of
/// empty shells.
fn holds_nothing(model: &Model, shape: &Shape) -> OgeomResult<bool> {
    // Down from the shape until the first face, which settles it.
    let mut stack = vec![shape.clone()];
    while let Some(at) = stack.pop() {
        let Some(node) = model.node(&at) else {
            ogeom_bail!(Dangling, "shape refers to a node not in this model");
        };
        match node.kind() {
            ShapeType::Face => return Ok(false),
            ShapeType::Compound | ShapeType::CompSolid | ShapeType::Solid | ShapeType::Shell => {
                stack.extend(node.children().iter().cloned());
            }
            _ => {}
        }
    }
    Ok(true)
}

/// The first solid with the second removed.
///
/// The pieces of `b` that close the cut into `a`'s material bound the removed
/// volume from `b`'s side, so they join the result with their material side
/// flipped.
///
/// `a` may instead be a sheet (a face, a shell or a compound of those) when
/// `b` is a solid or a half space: the result is then the part of the sheet
/// outside `b`, made as [`common`] makes the part inside.
///
/// # Errors
///
/// As [`common`].
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) where
/// `b` is a sheet, which bounds no volume to remove.
pub fn cut(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    if is_sheet(model, b)? {
        ogeom_bail!(
            Construction,
            "a sheet bounds no volume to cut away; split_sheet splits by a sheet"
        );
    }
    if is_sheet(model, a)? {
        return trimmed_sheet(model, a, b, false, tol);
    }
    let built = noting_held(model, |model| {
        ball_chart::with_poles_clear(model, a, b, tol, |model, a, b| {
            settled(model, tol, |model, tol| cut_once(model, a, b, tol))
        })
    })?;
    sub_shapes::with_sub_shapes(model, [a, b], built, tol)
}

/// [`cut`], where `b` is a blend's wedge, or a compound of wedges standing
/// apart, that sits flush on `a`: each wedge bounded by planar seats lying
/// on faces of `a` and one strip of a cylinder, the blend; or each a rim's
/// wedge, an annulus of a plane and a band of a cylinder about one axis
/// lying on faces of `a`, and the quarter of a torus's tube between them;
/// or a piece of a rim's wedge between two planar ends through its axis,
/// at most half a turn, each seat and end lying on a face of `a`.
/// Where every seat lies within the face it is on, facing its way, and no
/// other face of `a` reaches into the wedge, the faces the seats lie on are
/// trimmed along the wedge's own edges and the blends close what is left:
/// the general fuse is not run, and the result and its history are those
/// it gives. A straight band's wedge whose end runs, at a block's corner,
/// into a blend of `a` of its radius rounding the face it rounds is trimmed
/// so as its part inside `a`, cut back at the mitre where the two blends
/// cross. Where `b` mixes rims' wedges with other lumps, each rim's box
/// standing further from every other lump's than the boolean welds, the
/// rims are trimmed out so and the other lumps cut from what is left, to
/// the solid and history the general fuse gives cutting all of `b`.
/// Otherwise, and where `a` or `b` is anything else, this is [`cut`].
///
/// # Errors
///
/// As [`cut`].
pub fn cut_seated(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    if is_sheet(model, a)? || is_sheet(model, b)? {
        return cut(model, a, b, tol);
    }
    let built = noting_held(model, |model| {
        ball_chart::with_poles_clear(model, a, b, tol, |model, a, b| {
            match seated::seated_cut(model, a, b, false, tol) {
                Ok(Some(built)) => return Ok(built),
                Err(
                    e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_)),
                ) => {
                    return Err(e);
                }
                Ok(None) | Err(_) => {}
            }
            let rest = |model: &mut Model, a: &Shape, b: &Shape| {
                settled(model, tol, |model, tol| cut_once(model, a, b, tol))
            };
            match seated::rings_first(model, a, b, false, tol, rest) {
                Ok(Some(built)) => return Ok(built),
                Err(
                    e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_)),
                ) => {
                    return Err(e);
                }
                Ok(None) | Err(_) => {}
            }
            settled(model, tol, |model, tol| cut_once(model, a, b, tol))
        })
    })?;
    sub_shapes::with_sub_shapes(model, [a, b], built, tol)
}

/// [`fuse`], where `b` is a concave rim's blend wedge, or a compound of
/// such wedges standing apart, that sits flush on `a`: each an annulus of a
/// plane and a band of a cylinder about one axis lying on faces of `a`,
/// facing against them, and the quarter of a torus's tube between them; or
/// a concave straight band's wedge or a piece of a rim's, as [`cut_seated`]
/// reads them, its seats lying on faces of `a` facing against them.
/// Where every seat lies within the face it is on and no other face of `a`
/// reaches into the region the wedge lies in, the faces the seats lie on are
/// trimmed along the wedge's own edges and the blends close what is left:
/// the general fuse is not run, and the result and its history are those
/// it gives. Where `b` mixes such wedges with other lumps, each rim's box
/// standing further from every other lump's than the boolean welds, the
/// rims are filled so and the other lumps fused on to what is left, to the
/// solid and history the general fuse gives fusing all of `b`. Otherwise,
/// and where `a` or `b` is anything else, this is [`fuse`].
///
/// # Errors
///
/// As [`fuse`].
pub fn fuse_seated(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    if is_sheet(model, a)? || is_sheet(model, b)? {
        return fuse(model, a, b, tol);
    }
    let built = noting_held(model, |model| {
        ball_chart::with_poles_clear(model, a, b, tol, |model, a, b| {
            match seated::seated_cut(model, a, b, true, tol) {
                Ok(Some(built)) => return Ok(built),
                Err(
                    e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_)),
                ) => {
                    return Err(e);
                }
                Ok(None) | Err(_) => {}
            }
            let rest = |model: &mut Model, a: &Shape, b: &Shape| {
                settled(model, tol, |model, tol| fuse_once(model, a, b, tol))
            };
            match seated::rings_first(model, a, b, true, tol, rest) {
                Ok(Some(built)) => return Ok(built),
                Err(
                    e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_)),
                ) => {
                    return Err(e);
                }
                Ok(None) | Err(_) => {}
            }
            settled(model, tol, |model, tol| fuse_once(model, a, b, tol))
        })
    })?;
    sub_shapes::with_sub_shapes(model, [a, b], built, tol)
}

/// What of a sheet lies inside `tool` (`inside` true) or outside it, as a
/// sheet: [`common`] and [`cut`] with a sheet.
fn trimmed_sheet(
    model: &mut Model,
    sheet: &Shape,
    tool: &Shape,
    inside: bool,
    tol: Tolerances,
) -> OgeomResult<Built> {
    if !is_sheet(model, sheet)? {
        ogeom_bail!(
            Construction,
            "the sheet to trim is a face, a shell or a compound of those"
        );
    }
    trim_sheet_edges(model, sheet, tol)?;
    let built = noting_held(model, |model| {
        settled(model, tol, |model, tol| {
            let tool = &resolved_half_space(model, tool, sheet, tol)?;
            let (sheet, tool) = (
                &baked_if_scaled(model, sheet, tol)?,
                &baked_if_scaled(model, tool, tol)?,
            );
            let fused = general_fuse_as(model, sheet, tool, Operands::SheetBySolid, None, tol)?;
            let mut kept = Vec::new();
            for (index, piece) in fused.pieces.iter().enumerate() {
                match piece.state {
                    PieceState::In if inside => kept.push(index),
                    PieceState::Out if !inside => kept.push(index),
                    PieceState::In | PieceState::Out => {}
                    PieceState::OnAligned | PieceState::OnOpposed => ogeom_bail!(
                        NotDone,
                        "a piece of the sheet lies on the tool's boundary, which \
                     keeps it on neither side"
                    ),
                    PieceState::Unread => ogeom_bail!(
                        Construction,
                        "a piece of the sheet was not classified against the tool"
                    ),
                }
            }
            assemble_sheet(model, &fused, &kept, sheet, tol)
        })
    })?;
    sub_shapes::with_sub_shapes(model, [sheet, tool], built, tol)
}

/// A sheet split where another sheet crosses it: the pieces, with history.
///
/// `sheet` and `by` are each a face, a shell or a compound of those. Each
/// face of `sheet` is split along the curves where `by`'s faces cross it,
/// and along `by`'s edges where they lie in it. Only `sheet` is split: two
/// sheets are split by each other in two calls, each sheet by the other.
/// The pieces are sewn along the edges they share into one shell, or a
/// compound of shells where they fall apart. Each piece lies on its face's
/// surface, and the history records each against the face it came from;
/// a face nothing crosses is its own copy. A piece reaching across the seam
/// of a face on a surface of revolution is one face, on that surface turned
/// about its axis so the chart's join falls outside the piece.
///
/// # Errors
///
/// [`OgeomError::Construction`](ogeom_core::OgeomError::Construction) where
/// either argument is not a sheet; a solid or a half space trims a sheet
/// through [`common`] and [`cut`].
/// [`OgeomError::NotDone`](ogeom_core::OgeomError::NotDone) where the two
/// sheets overlap on one surface, and as [`fuse`] for configurations the
/// splitting refuses.
pub fn split_sheet(
    model: &mut Model,
    sheet: &Shape,
    by: &Shape,
    tol: Tolerances,
) -> OgeomResult<Built> {
    for shape in [sheet, by] {
        if !is_sheet(model, shape)? {
            ogeom_bail!(
                Construction,
                "split_sheet splits a sheet by a sheet, each a face, a shell or \
                 a compound of those; common and cut trim a sheet by a solid"
            );
        }
        trim_sheet_edges(model, shape, tol)?;
    }
    let built = noting_held(model, |model| {
        settled(model, tol, |model, tol| {
            let (sheet, by) = (
                &baked_if_scaled(model, sheet, tol)?,
                &baked_if_scaled(model, by, tol)?,
            );
            let fused = general_fuse_as(model, sheet, by, Operands::SheetBySheet, None, tol)?;
            let kept: Vec<usize> = (0..fused.pieces.len()).collect();
            assemble_sheet(model, &fused, &kept, sheet, tol)
        })
    })?;
    sub_shapes::with_sub_shapes(model, [sheet, by], built, tol)
}

fn cut_once(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    let (a, b) = (
        &resolved_half_space(model, a, b, tol)?,
        &resolved_half_space(model, b, a, tol)?,
    );
    let (a, b) = (
        &baked_if_scaled(model, a, tol)?,
        &baked_if_scaled(model, b, tol)?,
    );
    // The first argument's outward pieces stay. The tool's inward pieces
    // close the cut with their material side flipped. On the shared
    // surface: an opposed pair means the tool's material is entirely on the
    // other side, so the first argument's face survives untouched; an
    // aligned pair means the tool's material backs the same wall, which the
    // cut removes.
    let built = fused_and_assembled(model, a, b, [true, false], tol, |p| {
        match (p.from_a, p.state) {
            (true, PieceState::Out | PieceState::OnOpposed) => Some(false),
            (false, PieceState::In) => Some(true),
            _ => None,
        }
    });
    let refusal = match built {
        // Nothing left is an answer only where no part of the solid's
        // boundary stands outside the tool.
        Ok(built)
            if !holds_nothing(model, &built.shape)?
                || sampled_relation(model, a, b, Relation::Covered, tol)? == Some(true) =>
        {
            return Ok(built);
        }
        Ok(_) => ogeom_core::ogeom_err!(
            NotDone,
            "the cut left nothing of a solid that does not lie within the tool"
        ),
        Err(e @ (ogeom_core::OgeomError::Cancelled | ogeom_core::OgeomError::Dangling(_))) => {
            return Err(e);
        }
        Err(e) => e,
    };
    // A solid lying within the tool, whatever contact their boundaries
    // make (the same solid twice among them), is cut away entirely.
    if nested(model, b, a, tol)? != Some(true) {
        return Err(refusal);
    }
    let empty = model.add_compound(&[])?;
    let mut history = ogeom_algo::History::new();
    for face in explore_unique(model, a, ShapeType::Face)? {
        history.delete(&face);
    }
    history.modify(a, empty.clone());
    Ok(Built::new(empty, history))
}

/// Refused where `section`'s image on `face`, a sphere face, leaves the
/// chart at a pole: past the pole row by more than the section's
/// tolerance, or through one of the face's poles between its ends. An
/// image past the pole row stands for the point half a turn round on the
/// near side, and a curve through a pole leaves it half a turn round the
/// chart from where it came, which no one image can follow; the
/// arrangement would read either where the section is not. Each is read
/// at its worst among evenly spaced samples, refined by golden section
/// between their neighbours.
fn past_a_pole(
    section: &SectionRec,
    pcurve: &PlanarCurve,
    face: &GFace,
    tol: Tolerances,
) -> OgeomResult<()> {
    const SAMPLES: usize = 256;
    let SurfaceGeometry::Sphere(sphere) = &face.surface else {
        return Ok(());
    };
    let radius = sphere.sphere().radius();
    let reach = section.tolerance.max(tol.confusion());
    let range = section.curve.domain();
    let worst = |measure: &dyn Fn(f64) -> OgeomResult<f64>| -> OgeomResult<f64> {
        #[allow(clippy::cast_precision_loss)]
        let step = |k: usize| range.0 + (range.1 - range.0) * k as f64 / SAMPLES as f64;
        let mut top = (f64::NEG_INFINITY, 0);
        for k in 0..=SAMPLES {
            let m = measure(step(k))?;
            if m > top.0 {
                top = (m, k);
            }
        }
        let (mut lo, mut hi) = (
            step(top.1.saturating_sub(1)),
            step((top.1 + 1).min(SAMPLES)),
        );
        let golden = (5.0_f64.sqrt() - 1.0) / 2.0;
        for _ in 0..100 {
            let (a, b) = (hi - golden * (hi - lo), lo + golden * (hi - lo));
            if measure(a)? > measure(b)? {
                hi = b;
            } else {
                lo = a;
            }
        }
        Ok(measure(f64::midpoint(lo, hi))?.max(top.0))
    };
    let past =
        worst(&|t| Ok((pcurve.point_at(t, tol)?.y.abs() - core::f64::consts::FRAC_PI_2) * radius))?;
    if past > reach {
        ogeom_bail!(
            NotDone,
            "a section's image on a sphere runs {past} past the chart's pole, beyond \
             its tolerance of {reach}; a section through a sphere chart's pole is not \
             resolved; see docs/CAPABILITIES.md, bool.booleans"
        );
    }
    let (start, end) = (
        section.curve.point_at(range.0, tol)?,
        section.curve.point_at(range.1, tol)?,
    );
    for pole in &face.poles {
        if start.distance(pole.point) <= reach || end.distance(pole.point) <= reach {
            continue;
        }
        let near = -worst(&|t| Ok(-section.curve.point_at(t, tol)?.distance(pole.point)))?;
        if near <= reach {
            ogeom_bail!(
                NotDone,
                "a section passes within {near} of a sphere chart's pole between its \
                 ends, inside its tolerance of {reach}; a section through a sphere \
                 chart's pole is not resolved; see docs/CAPABILITIES.md, bool.booleans"
            );
        }
    }
    Ok(())
}

/// The edges where the two solids' boundaries cross.
///
/// Either argument may instead be a face, a shell or a compound of faces
/// with no solid behind it, when the other is a half space bounded by a
/// plane: the section is then [`section_face`]'s, the curves where its
/// faces cross the plane.
///
/// # Errors
///
/// As [`fuse`].
pub fn section(model: &mut Model, a: &Shape, b: &Shape, tol: Tolerances) -> OgeomResult<Built> {
    // A face, shell or compound with no solid behind it, against a half
    // space bounded by a plane: the curves where its faces cross the plane.
    for (sheet, other) in [(a, b), (b, a)] {
        if model.kind_of(sheet)? != ShapeType::Solid
            && let Some(plane) = half_space_plane(model, other, tol)?
        {
            return section_face(model, sheet, &plane, tol);
        }
    }
    let (a, b) = (
        &resolved_half_space(model, a, b, tol)?,
        &resolved_half_space(model, b, a, tol)?,
    );
    let (a, b) = (
        &baked_if_scaled(model, a, tol)?,
        &baked_if_scaled(model, b, tol)?,
    );
    let fused = general_fuse(model, a, b, None, tol)?;
    // Every section sub-edge that survived into some piece's ring, built
    // once per distinct sub-range.
    let mut wanted: Vec<(usize, (f64, f64))> = Vec::new();
    for piece in &fused.pieces {
        for ring in &piece.rings {
            for traversal in ring {
                if let Tag::Section { section, range } = &traversal.tag {
                    let near = |a: (f64, f64), b: (f64, f64)| {
                        (a.0 - b.0).abs() <= tol.parametric()
                            && (a.1 - b.1).abs() <= tol.parametric()
                    };
                    if !wanted.iter().any(|(s, r)| s == section && near(*r, *range)) {
                        wanted.push((*section, *range));
                    }
                }
            }
        }
    }
    let mut history = History::new();
    let mut edges = Vec::new();
    // Consecutive pieces of the section meet end to end, and there they
    // share one vertex: the section is a wire's worth of edges, not a
    // scatter of segments each with vertices of its own.
    let mut vertices: Vec<(Point, Shape)> = Vec::new();
    for (si, range) in wanted {
        let s = &fused.sections[si];
        let domain = s.curve.domain();
        let (f0, f1) = folded_range(range, domain, s.closed);
        let from = s.curve.point_at(at_param(f0, domain, s.closed), tol)?;
        let to = s.curve.point_at(at_param(f1, domain, s.closed), tol)?;
        let v0 = section_face::vertex(model, &mut vertices, from, tol)?;
        let v1 = section_face::vertex(model, &mut vertices, to, tol)?;
        edges.push(make_edge_between(model, s.curve.clone(), (f0, f1), &v0, &v1, tol)?.shape);
    }
    // Contacts are not crossings, so no piece's ring carries them and the
    // loop above cannot see them, but a section through a tangency has a
    // curve in it, and this is where it comes from.
    for contact in &fused.tangents {
        for (lo, hi) in contact_intervals(&fused, contact, tol)? {
            let from = contact.curve.point_at(lo, tol)?;
            let to = contact.curve.point_at(hi, tol)?;
            let v0 = section_face::vertex(model, &mut vertices, from, tol)?;
            let v1 = section_face::vertex(model, &mut vertices, to, tol)?;
            edges.push(
                make_edge_between(model, contact.curve.clone(), (lo, hi), &v0, &v1, tol)?.shape,
            );
        }
    }
    let result = model.add_compound(&edges)?;
    history.modify(a, result.clone());
    history.modify(b, result.clone());
    Ok(Built::new(result, history))
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use super::*;
    use ogeom_algo::{check, make_box, make_cylinder, volume_properties};
    use ogeom_math::{Direction, Frame};
    use ogeom_mesh::Deflection;

    const T: Tolerances = Tolerances::millimetres();
    const PI: f64 = core::f64::consts::PI;

    /// One cylinder, one cone and one torus, each spelled on frames turned
    /// about the axis, slid along it (the cylinder's and the cone's), with
    /// the axis reversed and on
    /// either handedness: every pair's chart map carries a point of the
    /// owner's chart to the target's point at the same place in space.
    /// A frame of the other handedness turns its angle the other way
    /// round, which the map must mirror rather than turn.
    #[test]
    fn a_coaxial_chart_map_lands_on_the_same_point_across_handedness() {
        let frames = |slide: f64| -> Vec<Frame> {
            let mut out = Vec::new();
            for up in [Direction::Z, -Direction::Z] {
                let x = Direction::new(ogeom_math::Vector::new(0.6, 0.8, 0.0), T).unwrap();
                let frame = Frame::new(Point::new(0.0, 0.0, slide), up, x, T).unwrap();
                out.extend([frame, frame.mirrored()]);
            }
            out
        };
        let cylinder = |f: Frame| -> SurfaceGeometry {
            ogeom_geom::CylinderSurface::new(
                ogeom_math::Cylinder::new(f, 2.0, T).unwrap(),
                (-5.0, 5.0),
            )
            .unwrap()
            .into()
        };
        let torus = |f: Frame| -> SurfaceGeometry {
            ogeom_geom::TorusSurface::new(ogeom_math::Torus::new(f, 2.0, 0.5, T).unwrap()).into()
        };
        // One cone, its radius 2 + z / 4 at a height z on the world's axis,
        // spelled from each frame's origin with the half angle signed by
        // which way the frame's axis runs.
        let cone = |f: Frame| -> SurfaceGeometry {
            let up = f.z().vector().z;
            let height = f.origin().z;
            ogeom_geom::ConeSurface::new(
                ogeom_math::Cone::new(f, 0.25_f64.mul_add(height, 2.0), up * 0.25_f64.atan(), T)
                    .unwrap(),
                (-5.0, 5.0),
            )
            .unwrap()
            .into()
        };
        let kinds: [(&dyn Fn(Frame) -> SurfaceGeometry, f64); 3] =
            [(&cylinder, 1.5), (&cone, 1.5), (&torus, 0.0)];
        for (make, slide) in kinds {
            for target_frame in [Frame::WORLD, Frame::WORLD.mirrored()] {
                let target = make(target_frame);
                for owner_frame in frames(slide) {
                    let owner = make(owner_frame);
                    let map = coaxial_chart_map(&owner, &target, 0.0, T).unwrap();
                    for (u, v) in [(0.3, 0.2), (2.0, -1.0), (5.0, 1.1)] {
                        let at = owner.point_at(u, v, T).unwrap();
                        let uv = map.apply(Point2::new(u, v));
                        let tau = core::f64::consts::TAU;
                        let lifted = target
                            .point_at(uv.x.rem_euclid(tau), uv.y, T)
                            .or_else(|_| {
                                target.point_at(uv.x.rem_euclid(tau), uv.y.rem_euclid(tau), T)
                            })
                            .unwrap();
                        // Two closed forms of one point: rounding only.
                        assert!(
                            at.distance(lifted) < 1e-12,
                            "{:?} owner on {:?} target, ({u}, {v}): {at:?} against {lifted:?}",
                            owner_frame.handedness(),
                            target_frame.handedness()
                        );
                    }
                }
            }
        }
    }

    /// An L-shaped prism across `y` whose step's underside lies on
    /// `z = 0` over `1 <= x <= 2`: past its edge at `x = 1` the plane runs
    /// into the leg below (a concave edge), past its edge at `x = 2` out of
    /// the solid (a convex one). A thin piece of a face on that plane,
    /// lying past each edge, reads inside past the first, outside past the
    /// second, and between both it is dust whose strands disagree.
    #[test]
    fn a_thin_piece_reads_the_other_solid_s_wedge_at_its_edges() {
        let mut model = Model::new();
        let profile = [
            (0.0, -1.0),
            (1.0, -1.0),
            (1.0, 0.0),
            (2.0, 0.0),
            (2.0, 1.0),
            (0.0, 1.0),
        ]
        .map(|(x, z)| Point::new(x, 0.0, z));
        let wire = ogeom_algo::make_polygon(&mut model, &profile, true, T)
            .unwrap()
            .shape;
        let plane = ogeom_geom::PlaneSurface::over(
            ogeom_math::Plane::new(
                Frame::new(Point::ORIGIN, Direction::Y, Direction::X, T).unwrap(),
            ),
            (-5.0, 5.0),
            (-5.0, 5.0),
        )
        .unwrap();
        let section = ogeom_algo::make_face(&mut model, plane.into(), &[wire], T)
            .unwrap()
            .shape;
        let step = ogeom_algo::make_prism(
            &mut model,
            &section,
            ogeom_math::Vector::new(0.0, 1.0, 0.0),
            T,
        )
        .unwrap()
        .shape;
        let floor = make_box(
            &mut model,
            Frame::new(Point::new(-1.0, -1.0, -3.0), Direction::Z, Direction::X, T).unwrap(),
            (4.0, 3.0, 3.0),
            T,
        )
        .unwrap()
        .shape;
        let theirs = gather(&model, &step, false, None, T).unwrap();
        let ours = gather(&model, &floor, false, None, T).unwrap();
        let top = ours
            .faces
            .iter()
            .find(|f| {
                matches!(f.surface, SurfaceGeometry::Plane(_))
                    && f.edges
                        .iter()
                        .all(|e| e.curve.point_at(e.crange.0, T).unwrap().z.abs() < 1e-9)
            })
            .unwrap();
        // The step's edge along `y` at `x`, on `z = 0`, as a contact on
        // the floor's top, with the way the ring walks it so the piece lies
        // on the side `x` grows towards when `beyond` is positive.
        let contact = |x: f64, beyond: f64| -> (ContactRec, (f64, f64), bool) {
            let e = theirs
                .faces
                .iter()
                .flat_map(|f| f.edges.iter())
                .find(|e| {
                    [e.crange.0, e.crange.1].iter().all(|&t| {
                        let p = e.curve.point_at(t, T).unwrap();
                        (p.x - x).abs() < 1e-9 && p.z.abs() < 1e-9
                    })
                })
                .unwrap();
            let ends = [e.crange.0, e.crange.1].map(|t| {
                chart_point_within(top, e.curve.point_at(t, T).unwrap(), 1e-6, T).unwrap()
            });
            let line = ogeom_geom::Line2d::segment(ends[0], ends[1], T).unwrap();
            let prange = ogeom_geom::Curve2d::domain(&line);
            let rec = ContactRec {
                curve: (*e.curve).clone(),
                crange: e.crange,
                pcurve: line.into(),
                prange,
                node: e.node,
                tolerance: e.tolerance,
                target_from_a: true,
                target_face: 0,
                bound: ogeom_math::Aabb::EMPTY,
                crossed: false,
            };
            // The piece is on the left of its ring about the chart's
            // normal, which is `+z` or `-z`.
            let t = f64::midpoint(e.crange.0, e.crange.1);
            let along = e.curve.d1_at(t, T).unwrap();
            let uv = ends[0];
            let normal = top.surface.normal_at(uv.x, uv.y, T).unwrap().vector();
            let left = normal.cross(along);
            (rec, e.crange, left.x * beyond < 0.0)
        };
        let thin = vec![
            Point2::new(0.0, 0.0),
            Point2::new(1.0, 0.0),
            Point2::new(1.0, 1e-6),
            Point2::new(0.0, 1e-6),
        ];
        let read = |strands: &[(f64, f64)]| -> Thin {
            let mut contacts = Vec::new();
            let mut ring = Vec::new();
            for (k, &(x, beyond)) in strands.iter().enumerate() {
                let (rec, range, reversed) = contact(x, beyond);
                contacts.push(rec);
                ring.push(Traversal {
                    tag: Tag::Contact { contact: k, range },
                    reversed,
                    nodes: None,
                });
            }
            thin_by_strands(
                top,
                &[ring],
                std::slice::from_ref(&thin),
                &contacts,
                &theirs,
                T,
            )
            .unwrap()
        };
        assert!(matches!(read(&[(1.0, -1.0)]), Thin::Reads(PieceState::In)));
        assert!(matches!(read(&[(2.0, 1.0)]), Thin::Reads(PieceState::Out)));
        assert!(matches!(read(&[(1.0, -1.0), (2.0, 1.0)]), Thin::Disagree));
        // On the step's side of either edge the piece lies on its face: a
        // coincidence the partner reads, and the strand says nothing.
        assert!(matches!(read(&[(2.0, -1.0)]), Thin::Undecided));
    }

    /// A quarter of a cylinder wall of radius 0.002, its edges and vertices
    /// widened to 0.003, its seam turned away from the quarter, one of its
    /// rulings restated a period off. Where that ruling meets the arcs, its
    /// ends stand a period from theirs, and that whole turn lifts within
    /// the edges' radii, yet the surface moves along it: the joint is a
    /// jump of branch, not one across an apex. Gathered, every pcurve of
    /// the wall stands where it stands when the ruling is not restated.
    #[test]
    fn a_period_jump_on_a_wall_smaller_than_its_radii_is_folded_back() {
        let wall = |restate: f64| -> (Model, Vec<(EdgeKey, Point2)>) {
            let mut model = Model::new();
            let x = Direction::new(ogeom_math::Vector::new(-1.0, -1.0, 0.0), T).unwrap();
            let whole = make_cylinder(
                &mut model,
                Frame::new(Point::ORIGIN, Direction::Z, x, T).unwrap(),
                0.002,
                0.01,
                T,
            )
            .unwrap()
            .shape;
            let quadrant = make_box(
                &mut model,
                Frame::new(Point::new(0.0, 0.0, -1.0), Direction::Z, Direction::X, T).unwrap(),
                (1.0, 1.0, 2.0),
                T,
            )
            .unwrap()
            .shape;
            let part = common(&mut model, &whole, &quadrant, T).unwrap().shape;
            let face = explore_unique(&model, &part, ShapeType::Face).unwrap()[0].clone();
            let surface = model.node(&face).unwrap().data().as_face().unwrap().surface;
            let mut restated = false;
            for edge in explore_unique(&model, &face, ShapeType::Edge).unwrap() {
                model
                    .widen(&edge, ogeom_core::Tolerance::new(0.003).unwrap())
                    .unwrap();
                let Some(EdgeRepr::PCurve { curve, range, .. }) = model
                    .node(&edge)
                    .unwrap()
                    .data()
                    .as_edge()
                    .unwrap()
                    .pcurve_for(surface, edge.location())
                    .cloned()
                else {
                    continue;
                };
                let stated = model.geometry().pcurve(curve).unwrap().clone();
                let (a, b) = (
                    stated.point_at(range.0, T).unwrap(),
                    stated.point_at(range.1, T).unwrap(),
                );
                if restate == 0.0 || restated || (a.x - b.x).abs() > 1e-9 {
                    continue;
                }
                let moved = stated
                    .transformed(
                        &ogeom_math::Transform2::translation(ogeom_math::Vector2::new(
                            restate, 0.0,
                        )),
                        T,
                    )
                    .unwrap();
                let moved = model.geometry_mut().add_pcurve(moved);
                if let Some(node) = model.node_mut(&edge)
                    && let NodeData::Edge(data) = node.data_mut()
                {
                    for repr in &mut data.representations {
                        if let EdgeRepr::PCurve {
                            curve, surface: s, ..
                        } = repr
                            && *s == surface
                        {
                            *curve = moved;
                        }
                    }
                }
                restated = true;
            }
            assert!(restate == 0.0 || restated);
            let gathered = gather(&model, &part, false, None, T).unwrap();
            let starts = gathered
                .faces
                .iter()
                .find(|f| matches!(f.surface, SurfaceGeometry::Cylinder(_)))
                .unwrap()
                .edges
                .iter()
                .map(|e| (e.node, e.pcurve.point_at(e.prange.0, T).unwrap()))
                .collect();
            (model, starts)
        };
        let (_, want) = wall(0.0);
        for by in [core::f64::consts::TAU, -core::f64::consts::TAU] {
            let (_, got) = wall(by);
            assert_eq!(got.len(), want.len());
            for ((_, g), (_, w)) in got.iter().zip(&want) {
                assert!(
                    g.distance(*w) < 1e-9,
                    "moved {by}: {got:?} against {want:?}"
                );
            }
        }
    }

    /// An edge passing under a drill of radius 23.6 at right angles,
    /// tangent to it a few microns off at the middle of the edge, is
    /// crossed by the sections on the drill either side of the touch
    /// 0.03 apart: the stretch between stays within five microns of the
    /// drill. The two crossings are one junction at the touch, whether the
    /// sections state a fit error of a micron's quarter or of a micron.
    #[test]
    fn a_graze_s_crossings_are_one_junction_however_tightly_fitted() {
        let radius = 23.6;
        let curve = Curve::Line(
            ogeom_geom::LineCurve::segment(
                Point::new(-10.0, 0.0, 0.0),
                Point::new(10.0, 0.0, 0.0),
                T,
            )
            .unwrap(),
        );
        let crange = ogeom_geom::Curve3d::domain(&curve);
        let off_drill = |_: (bool, usize), p: Point| -> OgeomResult<f64> {
            Ok(p.x.hypot(p.z - radius) - radius + 4.6e-6)
        };
        let half = 0.0148;
        for honesty in [2.6e-4, 1e-3] {
            let paves: Vec<Pave> = [-half, half]
                .into_iter()
                .map(|x| Pave {
                    t: x + 10.0,
                    honesty,
                    across: Some((false, 0)),
                    spread: 0.0,
                })
                .collect();
            let clusters =
                cluster_paves(&curve, crange, 1e-7, &paves, Some(&off_drill), &[], T).unwrap();
            assert_eq!(clusters.len(), 1, "honesty {honesty}: {clusters:?}");
            assert!(clusters[0].at.x.abs() < half, "{clusters:?}");
        }
    }

    /// A box whose front top edge, y = 0 at z = 10, is drawn on the top
    /// face `shift` inside where it runs, and states `loose`: the edge's
    /// tolerance owed to the top face alone, as a chord beside a drum owes
    /// its sag to the drum.
    fn box_with_an_edge_drawn_off_its_top(model: &mut Model, shift: f64, loose: f64) -> Shape {
        let solid = make_box(model, Frame::WORLD, (20.0, 20.0, 10.0), T)
            .unwrap()
            .shape;
        let top = explore_unique(model, &solid, ShapeType::Face)
            .unwrap()
            .into_iter()
            .find(|f| {
                let b = shape_bounds(model, f, T).unwrap();
                b.low().unwrap().z > 9.9
            })
            .unwrap();
        let top_surface = model.node(&top).unwrap().data().as_face().unwrap().surface;
        let edge = explore_unique(model, &top, ShapeType::Edge)
            .unwrap()
            .into_iter()
            .find(|e| {
                let b = shape_bounds(model, e, T).unwrap();
                b.high().unwrap().y.abs() < 1e-6
            })
            .unwrap();
        let (old, range) = match model
            .node(&edge)
            .unwrap()
            .data()
            .as_edge()
            .unwrap()
            .pcurve_on(top_surface)
        {
            Some(EdgeRepr::PCurve { curve, range, .. }) => (*curve, *range),
            _ => unreachable!("a box's edge has a plain pcurve on its top"),
        };
        let pcurve = model.geometry().pcurve(old).unwrap().clone();
        let (from, to) = (
            pcurve.point_at(range.0, T).unwrap(),
            pcurve.point_at(range.1, T).unwrap(),
        );
        // Square to the edge in the chart, toward the face's middle.
        let along = (to - from) / (to - from).magnitude();
        let mut across = ogeom_math::Vector2::new(-along.y, along.x);
        let middle = Point2::new(f64::midpoint(from.x, to.x), f64::midpoint(from.y, to.y));
        let lift = |p: Point2| {
            let SurfaceGeometry::Plane(plane) = model.geometry().surface(top_surface).unwrap()
            else {
                unreachable!("a box's top is a plane")
            };
            plane.point_at(p.x, p.y, T).unwrap()
        };
        if lift(middle + across).y < 0.0 {
            across = -across;
        }
        let line =
            ogeom_geom::Line2d::segment(from + across * shift, to + across * shift, T).unwrap();
        let domain = (0.0, from.distance(to));
        let id = model.geometry_mut().add_pcurve(PlanarCurve::Line(line));
        let Some(NodeData::Edge(data)) = model.node_mut(&edge).map(|n| n.data_mut()) else {
            unreachable!("an edge")
        };
        for repr in &mut data.representations {
            if let EdgeRepr::PCurve {
                curve,
                surface,
                range,
                ..
            } = repr
                && *surface == top_surface
            {
                *curve = id;
                *range = domain;
            }
        }
        data.tolerance = data.tolerance.widen_to(loose);
        solid
    }

    /// Each face reads an edge as far as it stands off that face: the top
    /// face draws its edge as its own pcurve on its plane, the front face
    /// reads the same edge exactly. An edge stated loose that stands off
    /// no face of it is read to its tolerance on both.
    #[test]
    fn a_face_reads_an_edge_as_far_as_it_stands_off_that_face() {
        let mut model = Model::new();
        let solid = box_with_an_edge_drawn_off_its_top(&mut model, 0.004, 0.005);
        let gathered = gather(&model, &solid, false, None, T).unwrap();
        let mut read = 0;
        for face in &gathered.faces {
            for e in &face.edges {
                if e.tolerance < 1e-3 {
                    continue;
                }
                read += 1;
                let normal = face.surface.normal_at(0.0, 0.0, T).unwrap().vector();
                let (drawn, range, off) = e.drawn();
                let middle = drawn.point_at(f64::midpoint(range.0, range.1), T).unwrap();
                if normal.z.abs() > 0.5 {
                    assert!((e.standoff - 0.004).abs() < 1e-6, "top: {}", e.standoff);
                    assert!(e.image.is_some() && off == 0.0);
                    assert!((middle.y - 0.004).abs() < 1e-6, "top drawn at {middle:?}");
                } else {
                    assert!(e.standoff < 1e-9, "front: {}", e.standoff);
                    assert!(e.image.is_none());
                    assert!(middle.y.abs() < 1e-9, "front drawn at {middle:?}");
                }
            }
        }
        assert_eq!(read, 2);

        let mut model = Model::new();
        let solid = box_with_an_edge_drawn_off_its_top(&mut model, 1e-4, 0.005);
        let gathered = gather(&model, &solid, false, None, T).unwrap();
        for e in gathered.faces.iter().flat_map(|f| f.edges.iter()) {
            if e.tolerance >= 1e-3 {
                assert_eq!(e.standoff, e.tolerance);
                assert!(e.image.is_none());
            }
        }
    }

    /// The crossings either face of a loose edge finds, a lean apart along
    /// it, are one cluster; tight, they stay two. A run of such crossings,
    /// each within its spread of the last, makes no cluster longer than
    /// two spreads.
    #[test]
    fn a_loose_edge_s_crossings_join_across_their_spread_and_no_further() {
        let curve = Curve::Line(
            ogeom_geom::LineCurve::segment(Point::new(0.0, 0.0, 0.0), Point::new(2.0, 0.0, 0.0), T)
                .unwrap(),
        );
        let crange = ogeom_geom::Curve3d::domain(&curve);
        let pave = |t: f64, spread: f64| Pave {
            t,
            honesty: 0.0,
            across: None,
            spread,
        };
        let two = [pave(1.0, 0.03), pave(1.05, 0.03)];
        let clusters = cluster_paves(&curve, crange, 0.0096, &two, None, &[], T).unwrap();
        assert_eq!(clusters.len(), 1, "{clusters:?}");
        assert!((clusters[0].span - 0.05).abs() < 1e-9, "{clusters:?}");
        let tight = [pave(1.0, 0.0), pave(1.05, 0.0)];
        assert_eq!(
            cluster_paves(&curve, crange, 0.0096, &tight, None, &[], T)
                .unwrap()
                .len(),
            2
        );
        let run: Vec<Pave> = (0..8)
            .map(|k| pave(0.5 + 0.05 * f64::from(k), 0.03))
            .collect();
        let clusters = cluster_paves(&curve, crange, 0.0096, &run, None, &[], T).unwrap();
        assert!(clusters.len() > 1, "{clusters:?}");
        for c in &clusters {
            assert!(c.span <= 0.06 + 1e-9, "{clusters:?}");
        }
    }

    /// A line touching a cylinder of radius 2 parts from it as `s^2 / 4`
    /// along it. A crossing on the line found at the touch, by a section a
    /// micron off the cylinder, may stand `sqrt(2 * 1e-6 * 2)` from the
    /// true one either way; found `d` = 1e-3 along the line, the valley
    /// reaches past the touch to `d + sqrt(d^2 + 4e-6)`.
    /// A line crossing the cylinder at an angle, and an exact section,
    /// spread nothing.
    #[test]
    fn a_crossing_where_the_edge_touches_the_other_surface_spreads_across_its_valley() {
        let cylinder: SurfaceGeometry = ogeom_geom::CylinderSurface::new(
            ogeom_math::Cylinder::new(Frame::WORLD, 2.0, T).unwrap(),
            (-5.0, 5.0),
        )
        .unwrap()
        .into();
        let line = |x: f64| {
            Curve::Line(
                ogeom_geom::LineCurve::segment(
                    Point::new(x, -3.0, 0.0),
                    Point::new(x, 3.0, 0.0),
                    T,
                )
                .unwrap(),
            )
        };
        let touching = line(2.0);
        let spread_at = |curve: &Curve, y: f64, honesty: f64| {
            let t = y + 3.0;
            let at = curve.point_at(t, T).unwrap();
            touch_spread((curve, t), &cylinder, at, honesty, T)
        };
        let at_touch = spread_at(&touching, 0.0, 1e-6);
        assert!((at_touch - 2e-3).abs() < 1e-9, "{at_touch}");
        let d = 1e-3;
        let beside = spread_at(&touching, d, 1e-6);
        let want = d + d.mul_add(d, 4e-6).sqrt();
        assert!((beside - want).abs() < 1e-6, "{beside} against {want}");
        assert_eq!(spread_at(&touching, 0.0, 0.0), 0.0);
        assert_eq!(spread_at(&line(1.0), 3.0_f64.sqrt(), 1e-6), 0.0);
    }

    /// A crossing of a loose edge spreads along it as its tolerance over
    /// the sine of its lean out of the crossing face, held to ten
    /// tolerances; a tight edge's does not; and where the face's normal
    /// cannot be read, at a cone's apex, the spread is none.
    #[test]
    fn a_crossing_spreads_along_a_loose_edge_by_its_lean() {
        let mut model = Model::new();
        let solid = make_box(&mut model, Frame::WORLD, (20.0, 20.0, 10.0), T)
            .unwrap()
            .shape;
        let mut gathered = gather(&model, &solid, false, None, T).unwrap();
        let e = gathered
            .faces
            .iter_mut()
            .flat_map(|f| f.edges.iter_mut())
            .find(|e| matches!(&*e.curve, Curve::Line(_)))
            .unwrap();
        let t = f64::midpoint(e.crange.0, e.crange.1);
        let at = e.curve.point_at(t, T).unwrap();
        let along = e.curve.d1_at(t, T).unwrap();
        let along = along / along.magnitude();
        let square = if along.z.abs() < 0.9 {
            along.cross(ogeom_math::Vector::Z)
        } else {
            along.cross(ogeom_math::Vector::X)
        };
        let square = square / square.magnitude();
        let plane_leaning = |lean: f64| -> SurfaceGeometry {
            let normal = square * lean.cos() + along * lean.sin();
            let frame = Frame::new(
                at,
                Direction::new(normal, T).unwrap(),
                Direction::new(normal.cross(square).cross(normal), T)
                    .or_else(|_| Direction::new(along, T))
                    .unwrap(),
                T,
            )
            .unwrap();
            ogeom_geom::PlaneSurface::new(ogeom_math::Plane::new(frame)).into()
        };
        assert_eq!(lean_spread(e, t, &plane_leaning(0.3), at, T), 0.0);
        e.tolerance = 0.01;
        for lean in [0.3_f64, 1.2] {
            let spread = lean_spread(e, t, &plane_leaning(lean), at, T);
            assert!(
                (spread - 0.01 / lean.sin()).abs() < 1e-9,
                "{lean}: {spread}"
            );
        }
        let spread = lean_spread(e, t, &plane_leaning(0.01), at, T);
        assert!((spread - 0.1).abs() < 1e-12, "{spread}");
        let apex = ogeom_geom::ConeSurface::new(
            ogeom_math::Cone::new(
                Frame::new(
                    at,
                    Direction::new(square, T).unwrap(),
                    Direction::new(along, T).unwrap(),
                    T,
                )
                .unwrap(),
                0.0,
                0.5,
                T,
            )
            .unwrap(),
            (0.0, 5.0),
        )
        .unwrap();
        let spread = lean_spread(e, t, &SurfaceGeometry::Cone(apex), at, T);
        assert!(spread.is_finite() && spread >= 0.0, "{spread}");
    }

    /// A point on a face's surface inside its trim lies within it; one
    /// beyond its boundary lies within it only to the margin asked.
    #[test]
    fn a_point_beside_a_face_lies_within_it_only_to_the_margin() {
        let mut model = Model::new();
        let solid = make_box(&mut model, Frame::WORLD, (20.0, 20.0, 10.0), T)
            .unwrap()
            .shape;
        let gathered = gather(&model, &solid, false, None, T).unwrap();
        let top = gathered
            .faces
            .iter()
            .find(|f| f.bound.low().unwrap().z > 9.9)
            .unwrap();
        assert!(within_face(top, Point::new(10.0, 10.0, 10.0), 1e-7, T).unwrap());
        let beside = Point::new(10.0, -0.05, 10.0);
        assert!(!within_face(top, beside, 1e-4, T).unwrap());
        assert!(within_face(top, beside, 0.06, T).unwrap());
    }

    /// A circle's count from its sag in closed form stands its chords within
    /// the strand sag, short of the cap both counts share, and never above
    /// the count measuring the chords reaches.
    #[test]
    fn a_circle_is_sampled_to_the_strand_sag_in_closed_form() {
        for radius in [0.01, 1.0, 40.0] {
            let circle = ogeom_math::Circle2::new(ogeom_math::Frame2::WORLD, radius, T).unwrap();
            let pcurve = PlanarCurve::Circle(ogeom_geom::Circle2d::new(circle));
            for (lo, hi) in [(0.0, 2.0 * PI), (1.0, 2.5)] {
                let count = circle_sag_count(&pcurve, lo, hi, 8).unwrap();
                let step = (hi - lo) / f64::from(u32::try_from(count).unwrap());
                assert!(
                    count == 512
                        || radius * (1.0 - (step / 2.0).cos()) <= STRAND_SAG * (1.0 + 1e-9)
                );
                let (measured, _) = sag_count(&|t| pcurve.point_at(t, T), lo, hi, 8).unwrap();
                assert!(count <= measured, "{count} against {measured}");
            }
        }
    }

    /// A narrow wedge whose last edge stops short of the column it meets,
    /// once by more than the weld and once by less than the snap: closed,
    /// a point level with the opening and outside the wedge reads outside,
    /// and one inside still reads inside.
    #[test]
    fn an_outline_closes_across_the_openings_its_ends_leave() {
        let top = PI / 2.0;
        for short in [4e-4, 2.6e-8] {
            let mut lines = vec![
                vec![Point2::new(0.0, 0.0), Point2::new(0.06, 0.0)],
                vec![Point2::new(0.06, 0.0), Point2::new(0.06, top)],
                vec![Point2::new(0.06, top - short), Point2::new(0.0, 0.0)],
            ];
            bridge_outline_gaps(&mut lines);
            let lines: Vec<&[Point2]> = lines.iter().map(Vec::as_slice).collect();
            // Level with the opening, a turn round from the wedge, so its
            // ray runs across the wedge.
            let level = Point2::new(-5.298, top - short / 2.0);
            assert!(!arrange::inside_many(&lines, level), "{short}");
            assert!(
                arrange::inside_many(&lines, Point2::new(0.05, 0.5)),
                "{short}"
            );
        }
    }

    fn frame_at(origin: Point) -> Frame {
        Frame::new(origin, Direction::Z, Direction::X, T).unwrap()
    }

    fn boxes(model: &mut Model) -> (Shape, Shape) {
        // Overlapping in the corner cube [1,2]^3.
        let a = make_box(model, Frame::WORLD, (2.0, 2.0, 2.0), T).unwrap();
        let b = make_box(
            model,
            frame_at(Point::new(1.0, 1.0, 1.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        (a.shape, b.shape)
    }

    fn volume(model: &Model, shape: &Shape) -> f64 {
        let fine = Deflection {
            chord: 1e-3,
            ..Deflection::default()
        };
        volume_properties(model, shape, fine, T).unwrap().mass
    }

    fn assert_valid(model: &Model, shape: &Shape) {
        let diagnosis = check(model, shape, T).unwrap();
        assert!(
            diagnosis.is_valid(),
            "the result fails validity: {:?}",
            diagnosis.problems
        );
    }

    #[test]
    fn fuse_of_overlapping_boxes_has_the_inclusion_exclusion_volume() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let fused = fuse(&mut model, &a, &b, T).unwrap();
        assert_valid(&model, &fused.shape);
        assert!((volume(&model, &fused.shape) - 15.0).abs() < 1e-9);
        assert_eq!(
            fused.history.modified(&a),
            std::slice::from_ref(&fused.shape)
        );
    }

    #[test]
    fn common_of_overlapping_boxes_is_the_overlap_cube() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let result = common(&mut model, &a, &b, T).unwrap();
        assert_valid(&model, &result.shape);
        assert!((volume(&model, &result.shape) - 1.0).abs() < 1e-9);
    }

    #[test]
    fn cut_removes_the_overlap_from_the_first_argument() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let result = cut(&mut model, &a, &b, T).unwrap();
        assert_valid(&model, &result.shape);
        assert!((volume(&model, &result.shape) - 7.0).abs() < 1e-9);
    }

    #[test]
    fn section_of_overlapping_boxes_is_the_six_segment_seam() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let result = section(&mut model, &a, &b, T).unwrap();
        let edges = explore(&model, &result.shape, Filter::OfType(ShapeType::Edge)).unwrap();
        assert_eq!(edges.len(), 6);
        // One closed loop: six edges end to end on six shared vertices.
        let vertices =
            ogeom_topo::explore_unique(&model, &result.shape, ShapeType::Vertex).unwrap();
        assert_eq!(vertices.len(), 6);
    }

    #[test]
    fn fuse_of_disjoint_boxes_is_a_compound_of_both() {
        let mut model = Model::new();
        let a = make_box(&mut model, Frame::WORLD, (2.0, 2.0, 2.0), T).unwrap();
        let b = make_box(
            &mut model,
            frame_at(Point::new(5.0, 0.0, 0.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let fused = fuse(&mut model, &a.shape, &b.shape, T).unwrap();
        assert_eq!(model.kind_of(&fused.shape).unwrap(), ShapeType::Compound);
        assert!((volume(&model, &fused.shape) - 16.0).abs() < 1e-9);
    }

    #[test]
    fn cutting_a_through_post_leaves_a_slab_with_a_hole() {
        let mut model = Model::new();
        let slab = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let post = make_box(
            &mut model,
            frame_at(Point::new(1.5, 1.5, -1.0)),
            (1.0, 1.0, 3.0),
            T,
        )
        .unwrap();
        let result = cut(&mut model, &slab.shape, &post.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        assert!((volume(&model, &result.shape) - 15.0).abs() < 1e-9);
    }

    #[test]
    fn common_with_a_contained_box_is_that_box() {
        let mut model = Model::new();
        let outer = make_box(&mut model, Frame::WORLD, (6.0, 6.0, 6.0), T).unwrap();
        let inner = make_box(
            &mut model,
            frame_at(Point::new(2.0, 2.0, 2.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let result = common(&mut model, &outer.shape, &inner.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        assert!((volume(&model, &result.shape) - 8.0).abs() < 1e-9);
    }

    #[test]
    fn cutting_everything_away_leaves_an_empty_compound() {
        let mut model = Model::new();
        let outer = make_box(&mut model, Frame::WORLD, (6.0, 6.0, 6.0), T).unwrap();
        let inner = make_box(
            &mut model,
            frame_at(Point::new(2.0, 2.0, 2.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let result = cut(&mut model, &inner.shape, &outer.shape, T).unwrap();
        assert_eq!(model.kind_of(&result.shape).unwrap(), ShapeType::Compound);
        assert!(
            explore(&model, &result.shape, Filter::OfType(ShapeType::Face))
                .unwrap()
                .is_empty()
        );
    }

    #[test]
    fn drilling_a_box_leaves_a_cylindrical_hole() {
        // Box minus a through-post cylinder: the box's top and bottom faces
        // come back with *circular* holes, the hole's wall is the cylinder's
        // own surface with its material side flipped, and the cylinder's
        // seam and both section circles all split and sew for the shell to
        // close.
        let mut model = Model::new();
        let block = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let drill = make_cylinder(
            &mut model,
            frame_at(Point::new(2.0, 2.0, -1.0)),
            0.5,
            3.0,
            T,
        )
        .unwrap();
        let result = cut(&mut model, &block.shape, &drill.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        let exact = 16.0 - PI * 0.25;
        let got = volume(&model, &result.shape);
        assert!(
            (got - exact).abs() / exact < 2e-3,
            "volume {got} against {exact}"
        );
    }

    /// A long rod of radius 5 at right angles to a long drill of radius 56,
    /// the axes 46 apart, runs in through the drill's wall and out again:
    /// its side meets the drill in two loops 64 apart. Both cut the rod, and
    /// what the drill holds of it is the integral of the rod's slices below
    /// the drill's wall.
    #[test]
    fn a_rod_through_a_long_drill_s_wall_is_cut_on_both_sides() {
        let (big, small, offset) = (56.0, 5.0, 46.0);
        let mut model = Model::new();
        let rod = make_cylinder(
            &mut model,
            Frame::new(
                Point::new(5.0, -1000.0, offset),
                Direction::Y,
                Direction::X,
                T,
            )
            .unwrap(),
            small,
            2000.0,
            T,
        )
        .unwrap();
        let drill = make_cylinder(
            &mut model,
            Frame::new(Point::new(-900.0, 0.0, 0.0), Direction::X, Direction::Z, T).unwrap(),
            big,
            1800.0,
            T,
        )
        .unwrap();
        // The slice of the rod at `y` lies in the drill below z = h(y): a
        // disc's segment, integrated by Simpson's rule.
        let segment = |y: f64| -> f64 {
            let d = (big * big - y * y).max(0.0).sqrt() - offset;
            if d <= -small {
                0.0
            } else if d >= small {
                PI * small * small
            } else {
                small * small * (-d / small).acos() + d * (small * small - d * d).sqrt()
            }
        };
        let reach = (big * big - (offset - small).powi(2)).sqrt();
        let steps = 20_000_u32;
        let h = 2.0 * reach / f64::from(steps);
        let held = (0..=steps)
            .map(|i| {
                let w = if i == 0 || i == steps {
                    1.0
                } else if i % 2 == 1 {
                    4.0
                } else {
                    2.0
                };
                w * segment(-reach + h * f64::from(i))
            })
            .sum::<f64>()
            * h
            / 3.0;
        let whole = PI * small * small * 2000.0;
        let kept = cut(&mut model, &rod.shape, &drill.shape, T).unwrap();
        assert_valid(&model, &kept.shape);
        let inside = common(&mut model, &rod.shape, &drill.shape, T).unwrap();
        assert_valid(&model, &inside.shape);
        let got = volume(&model, &inside.shape);
        assert!(
            (got - held).abs() / held < 2e-3,
            "common {got} against {held}"
        );
        let got = volume(&model, &kept.shape);
        let exact = whole - held;
        assert!(
            (got - exact).abs() / exact < 2e-3,
            "cut {got} against {exact}"
        );
    }

    #[test]
    fn common_of_a_box_and_a_cylinder_is_the_post_inside_it() {
        let mut model = Model::new();
        let block = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let post = make_cylinder(
            &mut model,
            frame_at(Point::new(2.0, 2.0, -1.0)),
            0.5,
            3.0,
            T,
        )
        .unwrap();
        let result = common(&mut model, &block.shape, &post.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        let exact = PI * 0.25;
        let got = volume(&model, &result.shape);
        assert!(
            (got - exact).abs() / exact < 2e-3,
            "volume {got} against {exact}"
        );
    }

    #[test]
    fn fusing_a_post_onto_a_slab_adds_what_stands_proud() {
        let mut model = Model::new();
        let slab = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let post = make_cylinder(
            &mut model,
            frame_at(Point::new(2.0, 2.0, -1.0)),
            0.5,
            3.0,
            T,
        )
        .unwrap();
        let result = fuse(&mut model, &slab.shape, &post.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        let exact = PI.mul_add(0.25 * 3.0, 16.0) - PI * 0.25;
        let got = volume(&model, &result.shape);
        assert!(
            (got - exact).abs() / exact < 2e-3,
            "volume {got} against {exact}"
        );
    }

    #[test]
    fn crossed_cylinders_run_through_the_marched_sections() {
        // No closed form exists for cylinder/cylinder: the sections are
        // marched and fitted, and every stage downstream (paves against
        // seams on both charts, splitting, classification, rebuilding with
        // fitted pcurves, sewing, meshing) has to work within the fit's
        // stated budget. Unequal radii keep the tangential branch points
        // away. The volumes have no easy closed form, so the operations are
        // held to each other: fuse = A + B - common and cut = A - common are
        // identities whatever the shapes.
        let mut model = Model::new();
        let upright = make_cylinder(&mut model, Frame::WORLD, 1.0, 4.0, T).unwrap();
        let across_frame =
            Frame::new(Point::new(-2.0, 0.0, 2.0), Direction::X, Direction::Y, T).unwrap();
        let across = make_cylinder(&mut model, across_frame, 0.6, 4.0, T).unwrap();

        let both = fuse(&mut model, &upright.shape, &across.shape, T).unwrap();
        assert_valid(&model, &both.shape);
        let shared = common(&mut model, &upright.shape, &across.shape, T).unwrap();
        assert_valid(&model, &shared.shape);
        let pierced = cut(&mut model, &upright.shape, &across.shape, T).unwrap();
        assert_valid(&model, &pierced.shape);

        let va = volume(&model, &upright.shape);
        let vb = volume(&model, &across.shape);
        let vf = volume(&model, &both.shape);
        let vc = volume(&model, &shared.shape);
        let vx = volume(&model, &pierced.shape);

        assert!(vc > 0.0 && vc < vb, "the overlap is real and partial: {vc}");
        assert!(
            (vf - (va + vb - vc)).abs() / vf < 2e-3,
            "fuse {vf} against A + B - common {}",
            va + vb - vc
        );
        assert!(
            (vx - (va - vc)).abs() / vx < 2e-3,
            "cut {vx} against A - common {}",
            va - vc
        );
    }

    #[test]
    fn stacked_boxes_fuse_into_one_solid_and_the_contact_vanishes() {
        // Same-domain contact with opposed materials: the shared rectangle is
        // interior to the union and no face of the result may carry it.
        let mut model = Model::new();
        let lower = make_box(&mut model, Frame::WORLD, (2.0, 2.0, 1.0), T).unwrap();
        let upper = make_box(
            &mut model,
            frame_at(Point::new(0.0, 0.0, 1.0)),
            (2.0, 2.0, 1.0),
            T,
        )
        .unwrap();
        let fused = fuse(&mut model, &lower.shape, &upper.shape, T).unwrap();
        assert_valid(&model, &fused.shape);
        assert_eq!(model.kind_of(&fused.shape).unwrap(), ShapeType::Solid);
        assert!((volume(&model, &fused.shape) - 8.0).abs() < 1e-9);
    }

    #[test]
    fn a_small_box_on_a_big_one_fuses_with_a_partial_contact() {
        // The big top face splits into the contact rectangle (swallowed)
        // and the surround, which stays and must sew to the small box's
        // walls along the contact's edges.
        let mut model = Model::new();
        let big = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let small = make_box(
            &mut model,
            frame_at(Point::new(1.0, 1.0, 1.0)),
            (2.0, 2.0, 1.0),
            T,
        )
        .unwrap();
        let fused = fuse(&mut model, &big.shape, &small.shape, T).unwrap();
        assert_valid(&model, &fused.shape);
        assert!((volume(&model, &fused.shape) - 20.0).abs() < 1e-9);

        // Cutting the same pair removes nothing but the measure-zero contact:
        // the big box survives whole, its top face's contact piece intact.
        let mut model = Model::new();
        let big = make_box(&mut model, Frame::WORLD, (4.0, 4.0, 1.0), T).unwrap();
        let small = make_box(
            &mut model,
            frame_at(Point::new(1.0, 1.0, 1.0)),
            (2.0, 2.0, 1.0),
            T,
        )
        .unwrap();
        let result = cut(&mut model, &big.shape, &small.shape, T).unwrap();
        assert_valid(&model, &result.shape);
        assert!((volume(&model, &result.shape) - 16.0).abs() < 1e-9);
    }

    #[test]
    fn flush_walls_fuse_cut_and_meet_with_aligned_contact() {
        // Overlapping boxes sharing flush walls: same-domain contact with
        // *aligned* materials. A = [0,2]^3, B = [1,3]x[0,2]x[0,2]: the y and
        // z walls of the overlap are coplanar with aligned outward normals.
        let mut model = Model::new();
        let a = make_box(&mut model, Frame::WORLD, (2.0, 2.0, 2.0), T).unwrap();
        let b = make_box(
            &mut model,
            frame_at(Point::new(1.0, 0.0, 0.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let fused = fuse(&mut model, &a.shape, &b.shape, T).unwrap();
        assert_valid(&model, &fused.shape);
        assert!((volume(&model, &fused.shape) - 12.0).abs() < 1e-9);

        let mut model = Model::new();
        let a = make_box(&mut model, Frame::WORLD, (2.0, 2.0, 2.0), T).unwrap();
        let b = make_box(
            &mut model,
            frame_at(Point::new(1.0, 0.0, 0.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let shared = common(&mut model, &a.shape, &b.shape, T).unwrap();
        assert_valid(&model, &shared.shape);
        assert!((volume(&model, &shared.shape) - 4.0).abs() < 1e-9);

        let mut model = Model::new();
        let a = make_box(&mut model, Frame::WORLD, (2.0, 2.0, 2.0), T).unwrap();
        let b = make_box(
            &mut model,
            frame_at(Point::new(1.0, 0.0, 0.0)),
            (2.0, 2.0, 2.0),
            T,
        )
        .unwrap();
        let cut_result = cut(&mut model, &a.shape, &b.shape, T).unwrap();
        assert_valid(&model, &cut_result.shape);
        assert!((volume(&model, &cut_result.shape) - 4.0).abs() < 1e-9);
    }

    #[test]
    fn every_source_face_is_accounted_for_in_the_history() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let result = cut(&mut model, &a, &b, T).unwrap();
        for face in explore(&model, &a, Filter::OfType(ShapeType::Face)).unwrap() {
            assert!(
                result.history.is_affected(&face),
                "a face of the first argument vanished from the history"
            );
        }
    }

    /// A plate 10 thick, `rows` by `rows` holes of radius 1.5 drilled
    /// through it 10 apart and 10 from its sides.
    fn drilled_plate(model: &mut Model, rows: u32) -> Shape {
        let size = 10.0 * f64::from(rows) + 10.0;
        let block = make_box(model, Frame::WORLD, (size, size, 10.0), T)
            .unwrap()
            .shape;
        let mut pins = Vec::new();
        for i in 0..rows {
            for j in 0..rows {
                let at = Point::new(10.0 + 10.0 * f64::from(i), 10.0 + 10.0 * f64::from(j), -5.0);
                pins.push(
                    make_cylinder(model, frame_at(at), 1.5, 20.0, T)
                        .unwrap()
                        .shape,
                );
            }
        }
        let pins = model.add_compound(&pins).unwrap();
        cut(model, &block, &pins, T).unwrap().shape
    }

    /// The operation with every face of both solids taken into the fuse.
    fn with_every_face(
        model: &mut Model,
        a: &Shape,
        b: &Shape,
        keep_aside: [bool; 2],
        keep: impl Fn(&FacePiece) -> Option<bool>,
    ) -> Built {
        let fused = general_fuse_classified(model, a, b, None, T).unwrap();
        let kept: Vec<(usize, bool)> = fused
            .pieces
            .iter()
            .enumerate()
            .filter_map(|(i, p)| keep(p).map(|flip| (i, flip)))
            .collect();
        assemble_result(model, &fused, &kept, keep_aside, a, b, T).unwrap()
    }

    fn cut_keeps(p: &FacePiece) -> Option<bool> {
        match (p.from_a, p.state) {
            (true, PieceState::Out | PieceState::OnOpposed) => Some(false),
            (false, PieceState::In) => Some(true),
            _ => None,
        }
    }

    /// Whether `face`'s box stands clear of each of `tool`'s lumps' by a
    /// millimetre.
    fn clear_of(model: &Model, face: &Shape, tool: &Shape) -> bool {
        let face = ogeom_algo::face_bounds(model, face).unwrap().expanded(1.0);
        explore_unique(model, tool, ShapeType::Solid)
            .unwrap()
            .iter()
            .all(|lump| !face.intersects(&ogeom_algo::tight_bounds(model, lump, T).unwrap()))
    }

    /// The result with faces set aside against the one with every face
    /// taken: the same volume and face count, valid, and every face of `a`
    /// clear of `b` passed through as itself.
    fn same_as_with_every_face(model: &Model, a: &Shape, b: &Shape, local: &Built, whole: &Built) {
        assert_valid(model, &local.shape);
        assert_valid(model, &whole.shape);
        let (v_local, v_whole) = (volume(model, &local.shape), volume(model, &whole.shape));
        assert!(
            (v_local - v_whole).abs() <= 1e-9 * v_whole.abs(),
            "{v_local} against {v_whole}"
        );
        let count = |shape: &Shape| explore_unique(model, shape, ShapeType::Face).unwrap().len();
        assert_eq!(count(&local.shape), count(&whole.shape));
        let mut passed = 0;
        for face in explore_unique(model, a, ShapeType::Face).unwrap() {
            if clear_of(model, &face, b) {
                let copy = local.history.copy_of(&face);
                assert!(
                    copy.is_some_and(|c| c.is_same(&face)),
                    "a face clear of the tool was not passed through"
                );
                passed += 1;
            }
        }
        assert!(passed > 0);
    }

    /// A tool of one lump along two edges of a drilled plate, its box
    /// spanning the plate while its faces reach only the edges: the hole
    /// walls miss every face of it and stand outside it, so they are set
    /// aside and passed through as they were, the result the one with every
    /// face taken.
    #[test]
    fn a_one_lump_tool_spanning_a_plate_leaves_the_holes_it_misses_as_they_were() {
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 3);
        let along_y = make_box(
            &mut model,
            frame_at(Point::new(-1.0, -1.0, 8.0)),
            (5.0, 42.0, 3.0),
            T,
        )
        .unwrap()
        .shape;
        let along_x = make_box(
            &mut model,
            frame_at(Point::new(-1.0, -1.0, 9.0)),
            (42.0, 5.0, 2.0),
            T,
        )
        .unwrap()
        .shape;
        let corner = fuse(&mut model, &along_y, &along_x, T).unwrap().shape;
        assert_eq!(
            explore_unique(&model, &corner, ShapeType::Solid)
                .unwrap()
                .len(),
            1
        );
        let local = cut(&mut model, &plate, &corner, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &corner, [true, false], cut_keeps);
        assert_valid(&model, &local.shape);
        let (v_local, v_whole) = (volume(&model, &local.shape), volume(&model, &whole.shape));
        assert!(
            (v_local - v_whole).abs() <= 1e-9 * v_whole,
            "{v_local} against {v_whole}"
        );
        let walls: Vec<Shape> = explore_unique(&model, &plate, ShapeType::Face)
            .unwrap()
            .into_iter()
            .filter(|f| {
                let data = model.node(f).unwrap().data().as_face().unwrap();
                matches!(
                    model.geometry().surface(data.surface),
                    Some(SurfaceGeometry::Cylinder(_))
                )
            })
            .collect();
        assert_eq!(walls.len(), 9);
        for wall in &walls {
            let copy = local.history.copy_of(wall);
            assert!(
                copy.is_some_and(|c| c.is_same(wall)),
                "a hole wall clear of the tool was not passed through"
            );
        }
    }

    #[test]
    fn a_hole_drilled_at_a_plates_corner_leaves_the_rest_as_it_was() {
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 3);
        let corner = make_cylinder(
            &mut model,
            frame_at(Point::new(5.0, 5.0, -5.0)),
            1.5,
            20.0,
            T,
        )
        .unwrap()
        .shape;
        assert!(
            aside::set_aside(&model, &plate, &corner, T)
                .unwrap()
                .is_some()
        );
        let local = cut(&mut model, &plate, &corner, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &corner, [true, false], cut_keeps);
        same_as_with_every_face(&model, &plate, &corner, &local, &whole);
        let holed = 40.0 * 40.0 * 10.0 - 10.0 * PI * 1.5 * 1.5 * 10.0;
        assert!((volume(&model, &local.shape) - holed).abs() < 1e-6 * holed);
    }

    /// Two pins at opposite corners, cut as one compound whose box spans
    /// the plate: the faces clear of both pins are set aside all the same.
    #[test]
    fn holes_at_opposite_corners_leave_the_faces_between_them_as_they_were() {
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 3);
        let mut pins = Vec::new();
        for at in [5.0, 35.0] {
            pins.push(
                make_cylinder(&mut model, frame_at(Point::new(at, at, -5.0)), 1.5, 20.0, T)
                    .unwrap()
                    .shape,
            );
        }
        let pins = model.add_compound(&pins).unwrap();
        let local = cut(&mut model, &plate, &pins, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &pins, [true, false], cut_keeps);
        same_as_with_every_face(&model, &plate, &pins, &local, &whole);
        let holed = 40.0 * 40.0 * 10.0 - 11.0 * PI * 1.5 * 1.5 * 10.0;
        assert!((volume(&model, &local.shape) - holed).abs() < 1e-6 * holed);
    }

    /// Four bars along a box's top edges, fused into a frame whose top
    /// stays split where the bars met: each edge between two of its pieces
    /// lies on the box's top and is laid there once, and the cut leaves the
    /// box less the frame.
    #[test]
    fn a_frame_fused_from_bars_cuts_the_rim_off_a_box() {
        let mut model = Model::new();
        let block = make_box(&mut model, Frame::WORLD, (10.0, 10.0, 10.0), T)
            .unwrap()
            .shape;
        let bars = [
            ((0.0, 0.0), (10.0, 1.0)),
            ((0.0, 9.0), (10.0, 1.0)),
            ((0.0, 0.0), (1.0, 10.0)),
            ((9.0, 0.0), (1.0, 10.0)),
        ];
        let mut frame: Option<Shape> = None;
        for ((x, y), (dx, dy)) in bars {
            let bar = make_box(
                &mut model,
                frame_at(Point::new(x, y, 9.0)),
                (dx, dy, 1.0),
                T,
            )
            .unwrap()
            .shape;
            frame = Some(match frame {
                None => bar,
                Some(held) => fuse(&mut model, &held, &bar, T).unwrap().shape,
            });
        }
        let frame = frame.unwrap();
        let rimmed = cut(&mut model, &block, &frame, T).unwrap();
        assert_valid(&model, &rimmed.shape);
        let want = 1000.0 - (100.0 - 64.0);
        let got = volume(&model, &rimmed.shape);
        assert!((got - want).abs() < 1e-9 * want, "{got} against {want}");
    }

    #[test]
    fn a_notch_through_a_plates_edge_meets_the_faces_left_as_they_were() {
        // A box notching the corner through two sides, the top and the
        // bottom: the outer rings of all four are split, and the edges
        // they share with the faces set aside stay as they were.
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 3);
        let notch = make_box(
            &mut model,
            frame_at(Point::new(-1.0, -1.0, -1.0)),
            (5.0, 4.0, 12.0),
            T,
        )
        .unwrap()
        .shape;
        let local = cut(&mut model, &plate, &notch, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &notch, [true, false], cut_keeps);
        same_as_with_every_face(&model, &plate, &notch, &local, &whole);
    }

    #[test]
    fn a_boss_fused_and_kept_in_common_beside_faces_set_aside() {
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 3);
        let boss = make_cylinder(
            &mut model,
            frame_at(Point::new(5.0, 5.0, 5.0)),
            3.0,
            10.0,
            T,
        )
        .unwrap()
        .shape;
        let local = fuse(&mut model, &plate, &boss, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &boss, [true, true], |p| {
            (p.state == PieceState::Out || (p.state == PieceState::OnAligned && !p.covered))
                .then_some(false)
        });
        same_as_with_every_face(&model, &plate, &boss, &local, &whole);

        let local = common(&mut model, &plate, &boss, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &boss, [false, false], |p| {
            (p.state == PieceState::In || (p.state == PieceState::OnAligned && !p.covered))
                .then_some(false)
        });
        assert_valid(&model, &local.shape);
        let (v_local, v_whole) = (volume(&model, &local.shape), volume(&model, &whole.shape));
        assert!(
            (v_local - v_whole).abs() <= 1e-9 * v_whole,
            "{v_local} against {v_whole}"
        );
        for face in explore_unique(&model, &plate, ShapeType::Face).unwrap() {
            if clear_of(&model, &face, &boss) {
                assert!(local.history.is_deleted(&face));
            }
        }
    }

    /// The corner hole into a plate of 582 faces, with every face but the
    /// top, the bottom and the tool's set aside, comes out the solid the fuse
    /// of every face makes, and passes every face it leaves alone through as
    /// itself.
    #[test]
    #[ignore = "heavy"]
    fn a_corner_hole_in_a_large_plate_is_the_solid_every_face_makes() {
        let mut model = Model::new();
        let plate = drilled_plate(&mut model, 24);
        assert_eq!(
            explore_unique(&model, &plate, ShapeType::Face)
                .unwrap()
                .len(),
            582
        );
        let corner = make_cylinder(
            &mut model,
            frame_at(Point::new(5.0, 5.0, -5.0)),
            1.5,
            20.0,
            T,
        )
        .unwrap()
        .shape;
        let local = cut(&mut model, &plate, &corner, T).unwrap();
        let whole = with_every_face(&mut model, &plate, &corner, [true, false], cut_keeps);
        same_as_with_every_face(&model, &plate, &corner, &local, &whole);
        // The top and the bottom take the new hole; every other face is
        // untouched.
        let copied = explore_unique(&model, &plate, ShapeType::Face)
            .unwrap()
            .iter()
            .filter(|face| local.history.copy_of(face).is_some())
            .count();
        assert_eq!(copied, 580);
    }

    /// The face a primitive builder gave `role`.
    fn face_with_role(model: &Model, solid: &Shape, role: ogeom_core::Role) -> Shape {
        explore_unique(model, solid, ShapeType::Face)
            .unwrap()
            .into_iter()
            .find(|f| {
                matches!(
                    model.provenance_of(f),
                    Some(
                        ogeom_core::Provenance::Primitive { role: r, .. }
                            | ogeom_core::Provenance::Derived { role: r, .. }
                    ) if *r == role
                )
            })
            .unwrap()
    }

    /// The faces of `result` that `history` traces from `source`.
    fn traced_into(model: &Model, result: &Shape, history: &History, source: &Shape) -> Vec<Shape> {
        explore_unique(model, result, ShapeType::Face)
            .unwrap()
            .into_iter()
            .filter(|r| history.trace(source).iter().any(|t| t.is_same(r)))
            .collect()
    }

    /// A cylinder's caps lying in a cube's faces: the common keeps the
    /// cube's piece of each, and each cap traces to that face; the fuse
    /// keeps one face per cap plane too, which both trace to. The
    /// cylinder's side, half outside the cube, is not lost in the common.
    #[test]
    fn a_coincident_piece_dropped_for_the_others_traces_to_it() {
        use ogeom_algo::primitive::roles::{FACE_MAX_Z, FACE_MIN_Z};
        let mut model = Model::new();
        let cube = make_box(&mut model, Frame::WORLD, (100.0, 100.0, 100.0), T)
            .unwrap()
            .shape;
        let cylinder = make_cylinder(&mut model, Frame::WORLD, 50.0, 100.0, T)
            .unwrap()
            .shape;
        for keep_in in [true, false] {
            let built = if keep_in {
                common(&mut model, &cube, &cylinder, T).unwrap()
            } else {
                fuse(&mut model, &cube, &cylinder, T).unwrap()
            };
            let expected = if keep_in {
                PI * 50.0 * 50.0 * 100.0 / 4.0
            } else {
                1e6 + PI * 50.0 * 50.0 * 100.0 * 3.0 / 4.0
            };
            assert_valid(&model, &built.shape);
            let v = volume(&model, &built.shape);
            assert!(
                (v - expected).abs() <= 1e-3 * expected,
                "{v} against {expected}"
            );
            for role in [FACE_MIN_Z, FACE_MAX_Z] {
                let (side, cap) = (
                    face_with_role(&model, &cube, role),
                    face_with_role(&model, &cylinder, role),
                );
                assert!(!built.history.is_deleted(&cap));
                let from_cap = traced_into(&model, &built.shape, &built.history, &cap);
                let from_side = traced_into(&model, &built.shape, &built.history, &side);
                if keep_in {
                    // The common keeps one face per cap plane, the one both
                    // sources trace to and nothing else.
                    assert_eq!(from_cap.len(), 1, "{role:?}: the cap");
                    assert_eq!(from_side.len(), 1, "{role:?}: the cube's face");
                }
                let shared = from_cap
                    .iter()
                    .filter(|f| from_side.iter().any(|g| g.is_same(f)))
                    .count();
                assert_eq!(shared, 1, "common {keep_in}");
            }
        }
    }

    /// A slot cut into a step already cut, its floor partly on the step's
    /// floor: the cut keeps the step's floor there and the slot's floor
    /// traces to it as well as to its own piece; the slot's ends, which lie
    /// in the block's sides with the material on the same side, are cut
    /// away and stay deleted.
    #[test]
    fn a_tool_face_on_a_floor_a_cut_left_traces_to_that_floor() {
        use ogeom_algo::primitive::roles::{FACE_MAX_Z, FACE_MIN_X, FACE_MIN_Z};
        let mut model = Model::new();
        let block = make_box(&mut model, Frame::WORLD, (100.0, 100.0, 50.0), T)
            .unwrap()
            .shape;
        let step = make_box(
            &mut model,
            frame_at(Point::new(50.0, -10.0, 30.0)),
            (60.0, 120.0, 20.0),
            T,
        )
        .unwrap()
        .shape;
        let slot = make_box(
            &mut model,
            frame_at(Point::new(-10.0, 40.0, 30.0)),
            (120.0, 20.0, 30.0),
            T,
        )
        .unwrap()
        .shape;
        let (step_floor, slot_floor) = (
            face_with_role(&model, &step, FACE_MIN_Z),
            face_with_role(&model, &slot, FACE_MIN_Z),
        );
        let stepped = cut(&mut model, &block, &step, T).unwrap();
        let slotted = cut(&mut model, &stepped.shape, &slot, T).unwrap();
        assert_valid(&model, &slotted.shape);
        let history = stepped.history.then(&slotted.history);
        let v = volume(&model, &slotted.shape);
        assert!((v - 380_000.0).abs() <= 1e-6 * 380_000.0, "{v}");
        let from_slot = traced_into(&model, &slotted.shape, &history, &slot_floor);
        let from_step = traced_into(&model, &slotted.shape, &history, &step_floor);
        assert_eq!(from_slot.len(), 2);
        let shared = from_slot
            .iter()
            .filter(|f| from_step.iter().any(|g| g.is_same(f)))
            .count();
        assert_eq!(shared, 1);
        // Faces whose material is gone stay gone: the slot's top and its
        // end outside the block.
        for role in [FACE_MAX_Z, FACE_MIN_X] {
            assert!(history.is_deleted(&face_with_role(&model, &slot, role)));
        }
    }

    /// A cut followed by a move: each face of the cut's inputs that is not
    /// deleted traces to faces of the moved result, and to nothing else.
    #[test]
    fn a_cut_then_a_move_traces_its_inputs_to_the_moved_result() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let cut_out = cut(&mut model, &a, &b, T).unwrap();
        let moved = ogeom_algo::transformed(
            &mut model,
            &cut_out.shape,
            ogeom_math::Transform::translation(ogeom_math::Vector::new(100.0, 0.0, 0.0)),
        )
        .unwrap();
        let history = cut_out.history.then(&moved.history);
        let result = explore_unique(&model, &moved.shape, ShapeType::Face).unwrap();
        let mut traced = 0;
        for face in explore_unique(&model, &a, ShapeType::Face)
            .unwrap()
            .into_iter()
            .chain(explore_unique(&model, &b, ShapeType::Face).unwrap())
        {
            if history.is_deleted(&face) {
                continue;
            }
            let images = history.trace(&face);
            assert!(!images.is_empty());
            for image in images {
                assert!(result.iter().any(|r| r.is_same(image)));
            }
            traced += 1;
        }
        assert_eq!(traced, 9);
    }

    /// A cut followed by a shear: each face, edge and vertex of the cut's
    /// inputs that the cut carries into its result traces through the
    /// composed history to as many sub-shapes of its kind in the sheared
    /// result, and to nothing else.
    #[test]
    fn a_cut_then_a_shear_traces_its_inputs_to_the_sheared_result() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let cut_out = cut(&mut model, &a, &b, T).unwrap();
        let shear = ogeom_math::GeneralTransform::new(
            ogeom_math::Matrix3 {
                rows: [[1.0, 0.5, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
            },
            ogeom_math::Vector::ZERO,
        );
        let sheared =
            ogeom_algo::general_transformed_shape(&mut model, &cut_out.shape, &shear, T).unwrap();
        let history = cut_out.history.then(&sheared.history);
        for (kind, expected) in [
            (ShapeType::Face, 9),
            (ShapeType::Edge, 15),
            (ShapeType::Vertex, 8),
        ] {
            let between = explore_unique(&model, &cut_out.shape, kind).unwrap();
            let result = explore_unique(&model, &sheared.shape, kind).unwrap();
            let mut traced = 0;
            for part in explore_unique(&model, &a, kind)
                .unwrap()
                .into_iter()
                .chain(explore_unique(&model, &b, kind).unwrap())
            {
                let carried = cut_out.history.trace(&part);
                if carried.is_empty()
                    || !carried.iter().all(|c| between.iter().any(|r| r.is_same(c)))
                {
                    continue;
                }
                let images = history.trace(&part);
                assert_eq!(images.len(), carried.len(), "{kind:?}");
                assert!(history.is_affected(&part), "{kind:?}");
                for image in images {
                    assert!(result.iter().any(|r| r.is_same(image)), "{kind:?}");
                }
                traced += 1;
            }
            assert_eq!(traced, expected, "{kind:?}");
        }
    }

    /// Each edge and vertex of `argument` traced through `history`: deleted,
    /// or traced to shapes of its kind that `result` holds. The counts of
    /// those deleted, unchanged (held by the result as they stand, or
    /// copied) and modified, by kind.
    fn sub_shapes_traced(
        model: &Model,
        argument: &Shape,
        result: &Shape,
        history: &History,
    ) -> [(usize, usize, usize); 2] {
        let mut counts = [(0, 0, 0); 2];
        for (slot, kind) in [ShapeType::Edge, ShapeType::Vertex].into_iter().enumerate() {
            let held = explore_unique(model, result, kind).unwrap();
            for part in explore_unique(model, argument, kind).unwrap() {
                if history.is_deleted(&part) {
                    counts[slot].0 += 1;
                    continue;
                }
                let images = history.trace(&part);
                assert!(!images.is_empty(), "{kind:?}");
                for image in images {
                    assert!(
                        held.iter().any(|h| h.is_same(image)),
                        "a {kind:?} traces to a shape the result does not hold"
                    );
                }
                if history.copy_of(&part).is_some() || !history.is_affected(&part) {
                    counts[slot].1 += 1;
                } else {
                    counts[slot].2 += 1;
                }
            }
        }
        counts
    }

    fn vertex_point(model: &Model, vertex: &Shape) -> Point {
        let data = model.node(vertex).unwrap().data().as_vertex().unwrap();
        vertex.transform(model.datums()).unwrap().apply(data.point)
    }

    /// A drill through a block whose top line, its seam, stands a hair
    /// above the block's top face: the face is cut along two lines either
    /// side of the seam, closer than the weld, which sew into one line the
    /// drill's face meets on both sides. That line is the drill's seam, and
    /// the result is valid with the volume the drill exactly tangent to the
    /// top cuts.
    #[test]
    fn a_drill_whose_seam_grazes_a_face_keeps_it_a_seam() {
        let chord = Deflection::with_chord(0.01).unwrap();
        let volume_at = |rise: f64| {
            let mut model = Model::new();
            let block = make_box(
                &mut model,
                frame_at(Point::new(-20.0, 0.0, 0.0)),
                (40.0, 30.0, 10.0),
                T,
            )
            .unwrap()
            .shape;
            let up = ogeom_math::Direction::Y;
            let seam = ogeom_math::Direction::Z;
            let drill = make_cylinder(
                &mut model,
                Frame::new(Point::new(0.0, -5.0, 7.0 + rise), up, seam, T).unwrap(),
                3.0,
                40.0,
                T,
            )
            .unwrap()
            .shape;
            let out = cut(&mut model, &block, &drill, T).unwrap();
            let d = check(&model, &out.shape, T).unwrap();
            assert!(d.is_valid(), "rise {rise}: {d}");
            volume_properties(&model, &out.shape, chord, T)
                .unwrap()
                .mass
        };
        let tangent = volume_at(0.0);
        for rise in [1e-9, 1e-8, 1e-7, 2e-7] {
            let v = volume_at(rise);
            assert!(
                (v - tangent).abs() < 1e-6 * tangent,
                "rise {rise}: {v} against {tangent}"
            );
        }
    }

    /// A drill tangent to a wall along the edge where a concave round
    /// leaves it, the drill flatter than the round: the drill touches the
    /// wall from the empty side and cuts into the material behind the
    /// round, so its wall lines the cut from the tangent line to where it
    /// leaves the solid. The material is a slab with a notch whose inner
    /// corner is rounded, and the volume removed is the drill's disc over
    /// the material's section, in closed form.
    #[test]
    fn a_drill_tangent_to_a_wall_along_a_rounds_edge_cuts_the_sliver_behind_it() {
        let mut model = Model::new();
        let slab = make_box(&mut model, Frame::WORLD, (40.0, 40.0, 10.0), T)
            .unwrap()
            .shape;
        let notch = make_box(
            &mut model,
            frame_at(Point::new(20.0, 20.0, -1.0)),
            (21.0, 21.0, 12.0),
            T,
        )
        .unwrap()
        .shape;
        let notched = cut(&mut model, &slab, &notch, T).unwrap().shape;
        // The round: the corner square less a cylinder of radius 2 about
        // (22, 22), tangent to the walls y = 20 and x = 20 at (22, 20) and
        // (20, 22).
        let square = make_box(
            &mut model,
            frame_at(Point::new(20.0, 20.0, 0.0)),
            (2.0, 2.0, 10.0),
            T,
        )
        .unwrap()
        .shape;
        let bore = make_cylinder(
            &mut model,
            frame_at(Point::new(22.0, 22.0, -1.0)),
            2.0,
            12.0,
            T,
        )
        .unwrap()
        .shape;
        let round = cut(&mut model, &square, &bore, T).unwrap().shape;
        let part = fuse(&mut model, &notched, &round, T).unwrap().shape;
        let chord = Deflection::with_chord(0.01).unwrap();
        let before = volume_properties(&model, &part, chord, T).unwrap().mass;
        for seam in [
            Direction::X,
            Direction::new(ogeom_math::Vector::new(-1.0, 0.0, 0.0), T).unwrap(),
        ] {
            let drill = make_cylinder(
                &mut model,
                Frame::new(Point::new(22.0, 50.0, -1.0), Direction::Z, seam, T).unwrap(),
                30.0,
                12.0,
                T,
            )
            .unwrap()
            .shape;
            let out = cut(&mut model, &part, &drill, T).unwrap();
            check(&model, &out.shape, T).unwrap();
            // The integral of sqrt(r^2 - u^2).
            let seg = |u: f64, r: f64| 0.5 * (u * (r * r - u * u).sqrt() + r * r * (u / r).asin());
            // Over the block x in [0, 20]: between y = 40 and the drill's
            // lower arc, y = 50 - sqrt(900 - (x - 22)^2).
            let block = (seg(-2.0, 30.0) - seg(-22.0, 30.0)) - 10.0 * 20.0;
            // Over the corner square x in [20, 22]: the square less its
            // quarter disc, less what lies below the drill's arc.
            let corner = (4.0 - (seg(0.0, 2.0) - seg(-2.0, 2.0)))
                - (60.0 - (seg(0.0, 30.0) - seg(-2.0, 30.0)));
            let expected = before - 10.0 * (block + corner);
            let after = volume_properties(&model, &out.shape, chord, T)
                .unwrap()
                .mass;
            assert!(
                (after - expected).abs() < 1e-6 * expected,
                "seam {seam:?}: {after} against {expected}"
            );
        }
    }

    /// A box cut by one overlapping its corner: the target's three edges
    /// through the corner are shortened and the corner deleted; the tool's
    /// three edges through its corner inside the target line the cavity,
    /// cut short, and the rest of the tool is deleted.
    #[test]
    fn a_cut_records_every_edge_and_vertex_of_both_boxes() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let out = cut(&mut model, &a, &b, T).unwrap();
        let h = &out.history;
        // Edges (deleted, copied, modified), then vertices.
        assert_eq!(
            sub_shapes_traced(&model, &a, &out.shape, h),
            [(0, 9, 3), (1, 7, 0)]
        );
        assert_eq!(
            sub_shapes_traced(&model, &b, &out.shape, h),
            [(9, 0, 3), (7, 0, 1)]
        );
        for vertex in explore_unique(&model, &a, ShapeType::Vertex).unwrap() {
            let at = vertex_point(&model, &vertex);
            assert_eq!(
                h.is_deleted(&vertex),
                at.distance(Point::new(2.0, 2.0, 2.0)) < 1e-9
            );
        }
        // Each shortened edge is one edge of length one.
        for edge in explore_unique(&model, &a, ShapeType::Edge).unwrap() {
            if h.copy_of(&edge).is_some() || !h.is_affected(&edge) {
                continue;
            }
            let [image] = h.modified(&edge) else {
                panic!("a shortened edge is one edge");
            };
            let ends: Vec<Point> = explore_unique(&model, image, ShapeType::Vertex)
                .unwrap()
                .iter()
                .map(|v| vertex_point(&model, v))
                .collect();
            assert_eq!(ends.len(), 2);
            assert!((ends[0].distance(ends[1]) - 1.0).abs() < 1e-9);
        }
    }

    /// A plate drilled through: its edges and vertices come through as
    /// copies, the drill's side seam is cut down to the plate's thickness,
    /// and its rims and their vertices, outside the plate, are deleted.
    #[test]
    fn a_drill_records_every_edge_and_vertex_of_plate_and_drill() {
        let mut model = Model::new();
        let plate = make_box(&mut model, Frame::WORLD, (20.0, 20.0, 10.0), T)
            .unwrap()
            .shape;
        let drill = make_cylinder(
            &mut model,
            frame_at(Point::new(10.0, 10.0, -1.0)),
            3.0,
            12.0,
            T,
        )
        .unwrap()
        .shape;
        let out = cut(&mut model, &plate, &drill, T).unwrap();
        let h = &out.history;
        assert_eq!(
            sub_shapes_traced(&model, &plate, &out.shape, h),
            [(0, 12, 0), (0, 8, 0)]
        );
        assert_eq!(
            sub_shapes_traced(&model, &drill, &out.shape, h),
            [(2, 0, 1), (2, 0, 0)]
        );
    }

    /// A cut composed with a move: what the cut records of each edge and
    /// vertex is carried to the moved result, and a deletion stays one.
    #[test]
    fn a_cut_then_a_move_traces_every_edge_and_vertex() {
        let mut model = Model::new();
        let (a, b) = boxes(&mut model);
        let out = cut(&mut model, &a, &b, T).unwrap();
        let moved = ogeom_algo::transformed(
            &mut model,
            &out.shape,
            ogeom_math::Transform::translation(ogeom_math::Vector::new(5.0, 0.0, 0.0)),
        )
        .unwrap();
        let composed = out.history.then(&moved.history);
        // A move modifies what it moves: the cut's copies are modified
        // in the composed history, and the cut's deletions stay deleted.
        let carried = |counts: [(usize, usize, usize); 2]| counts.map(|(d, c, m)| (d, c + m));
        for argument in [&a, &b] {
            let composed_counts = sub_shapes_traced(&model, argument, &moved.shape, &composed);
            assert!(composed_counts.iter().all(|&(_, copied, _)| copied == 0));
            assert_eq!(
                carried(composed_counts),
                carried(sub_shapes_traced(
                    &model,
                    argument,
                    &out.shape,
                    &out.history
                )),
            );
            for kind in [ShapeType::Edge, ShapeType::Vertex] {
                for part in explore_unique(&model, argument, kind).unwrap() {
                    assert_eq!(composed.trace(&part).len(), out.history.trace(&part).len());
                }
            }
        }
    }
}