brep_render/sketch/

spline.rs

//! Spline anchor insertion (S3) — refine an existing spline by subdividing it.
//!
//! A sketch spline is geometry `type: "bezier"` (`"spline"` is the kernel's accepted
//! alias): a CHAINED cubic Bézier control polygon of `3n + 1` point ids, on-curve
//! anchors at indices 0, 3, 6, … and two off-curve handles between each pair. Every
//! id is an ordinary sketch point, so it constrains and solves like any other.
//!
//! The bezier TOOL authors one span per invocation (4 clicks). This module is the
//! other half: while that tool is idle, a click along an existing spline inserts a
//! new anchor there. The user is REFINING a curve they already like, so the
//! insertion must not move the curve by a pixel — which is why this is de Casteljau
//! subdivision and not an append. Splitting span `P0 P1 P2 P3` at parameter `t`:
//!
//! ```text
//! A = lerp(P0,P1,t)  B = lerp(P1,P2,t)  C = lerp(P2,P3,t)
//! D = lerp(A,B,t)    E = lerp(B,C,t)    S = lerp(D,E,t)
//! ```
//!
//! gives the two cubics `P0 A D S` and `S E C P3`, which together trace exactly the
//! original curve. In the chained polygon that is `P0, A, D, S, E, C, P3` — three
//! ids longer, so the `3n + 1` invariant is preserved and the span count grows by one.
//!
//! ## Point-id policy
//! Constraints reference point IDS, so subdivision keeps as many as it can: `P0` and
//! `P3` are untouched, and `P1`/`P2` are REUSED for `A`/`C` — they remain the handles
//! flanking the same two anchors and merely slide inward, so a tangent, guide line or
//! dimension hung on them survives and still means what it meant. `A` stays on the
//! ray `P0→P1` (it is `lerp(P0,P1,t)`), so even the solver's end-tangent convention
//! (`B'(0) = 3(P1 − P0)`, see the kernel's `spline_end_info`) reads the same direction
//! after the insert as before. Only `D`, `S` and `E` are freshly minted.
//!
//! The interior anchor the split creates is exactly collinear with its two handles
//! (`S = lerp(D, E, t)`), which is precisely the implied G1 join the kernel solver
//! pushes for every interior anchor (a temporary `⏛` over `prev_handle, next_handle,
//! anchor`). The insert therefore lands on a zero-residual configuration and the
//! following solve has nothing to correct.

use serde_json::Value;

use super::doc::{id_key, SketchDoc, SketchPoint};

/// Per-span sampling resolution used to locate the click along a spline — the same
/// 64 the overlay tessellator draws a span with, so "where the curve looks like it
/// is" and "where the click lands on it" agree. The chord projection inside each
/// sample interval recovers the parameter to far better than the sample spacing.
const SPAN_SAMPLES: usize = 64;

/// Refuse a subdivision within this much of either end of the clicked SPAN (in that
/// span's own `0..1` parameter). Splitting at the very end mints a zero-length span,
/// which is a degenerate control polygon, not a refinement. In practice the
/// point-priority rule in [`insert_anchor`] catches these clicks first — an anchor is
/// a point, and points win the pick — so this is the backstop for the sliver between
/// the two radii.
const MIN_SPAN_PARAM: f64 = 1e-3;

/// Whether `geom_type` names a spline. Mirrors the kernel solver's
/// `is_spline_geometry_type`: `"bezier"` is what the tools author, `"spline"` is the
/// accepted alias. Defined here rather than imported because the sketch module is
/// deliberately kernel-free.
pub fn is_spline_type(geom_type: &str) -> bool {
    geom_type == "bezier" || geom_type == "spline"
}

/// The ids [`insert_anchor`] minted: the new on-curve `anchor` and the two off-curve
/// handles flanking it (`before` precedes it in the polygon, `after` follows it). The
/// caller decides what to hang on them — the tool draws each anchor's handle guides.
#[derive(Clone, Debug)]
pub struct InsertedAnchor {
    /// The new on-curve anchor (`S`).
    pub anchor: Value,
    /// The handle immediately BEFORE the anchor (`D`) — it ends the first half-span.
    pub before: Value,
    /// The handle immediately AFTER the anchor (`E`) — it starts the second half-span.
    pub after: Value,
}

/// Insert an anchor into the spline under the plane click `(u, v)`, or `None` when
/// the click should mean something else. Shape-preserving: the curve through the
/// grown control polygon is the curve that was there before.
///
/// The picking rules, in order:
/// * A POINT within `radius` wins — the whole sketcher gives points priority over
///   geometry, and a click on an anchor or handle would split at a span end anyway.
/// * Otherwise the nearest SPLINE within `radius` is the target. Only splines are
///   candidates, deliberately: the bezier tool hangs a dashed construction guide off
///   each end handle, and on a shallow spline (near-collinear handles) those guides
///   hug the curve along its whole length. Ranking all geometry together would let a
///   spline's own guides shadow it and make the very splines a user most wants to
///   refine the ones that cannot be refined.
/// * The clicked span must have four DISTINCT ids and the click must land clear of
///   the span's ends ([`MIN_SPAN_PARAM`]) — a cusp built by repeating an id cannot be
///   subdivided without corrupting the other role, and a split at a span end is
///   degenerate.
///
/// Does NOT solve, refresh or record undo — the engine wrapper owns that.
pub fn insert_anchor(doc: &mut SketchDoc, u: f64, v: f64, radius: f64) -> Option<InsertedAnchor> {
    // Points win the pick, exactly as they do for hover, select, drag and trim — the
    // sketcher has ONE priority rule and a spline click does not get to break it.
    if doc
        .points
        .iter()
        .any(|p| (p.x - u).hypot(p.y - v) <= radius)
    {
        return None;
    }

    let (geo_id, span, t) = nearest_spline_span(doc, u, v, radius)?;
    if !(MIN_SPAN_PARAM..=1.0 - MIN_SPAN_PARAM).contains(&t) {
        return None;
    }

    // Resolve the clicked span's four ids + coordinates BEFORE any mutation: the
    // splice below shifts every id after the split point.
    let ids = {
        let geo = doc.geometry(&geo_id)?;
        let i0 = span * 3;
        [
            geo.points.get(i0)?.clone(),
            geo.points.get(i0 + 1)?.clone(),
            geo.points.get(i0 + 2)?.clone(),
            geo.points.get(i0 + 3)?.clone(),
        ]
    };
    let keys: Vec<String> = ids.iter().map(id_key).collect();
    for i in 0..keys.len() {
        for j in (i + 1)..keys.len() {
            if keys[i] == keys[j] {
                return None; // a repeated id plays two roles — subdividing would corrupt one.
            }
        }
    }
    let controls = span_controls(doc, &ids)?;

    // de Casteljau at `t` — the two halves' control polygons.
    let [p0, p1, p2, p3] = controls;
    let a = lerp(p0, p1, t);
    let b = lerp(p1, p2, t);
    let c = lerp(p2, p3, t);
    let d = lerp(a, b, t);
    let e = lerp(b, c, t);
    let s = lerp(d, e, t);

    // The old handles slide inward onto the new half-spans' outer handles, keeping
    // their ids (and everything constrained to them) attached to the same curve ends.
    // Both resolved a moment ago through `span_controls`, so neither move can miss.
    move_point(doc, &ids[1], a)?;
    move_point(doc, &ids[2], c)?;
    // Minted in polygon order so the ids read left-to-right along the curve.
    let d_id = add_point(doc, d);
    let s_id = add_point(doc, s);
    let e_id = add_point(doc, e);

    // `P0 A | P3` → `P0 A D S E C P3`: the three new ids go between the two reused
    // handles, i.e. right after slot `i0 + 1`.
    let geo = doc.geometry_mut(&geo_id)?;
    let at = span * 3 + 2;
    geo.points
        .splice(at..at, [d_id.clone(), s_id.clone(), e_id.clone()]);

    Some(InsertedAnchor { anchor: s_id, before: d_id, after: e_id })
}

/// The `(geometry id, span index, span parameter)` of the point nearest `(u, v)` over
/// every spline in `doc`, or `None` when none passes within `radius`. Splines whose
/// control count violates `3n + 1` are skipped — they are corrupt, not pickable.
fn nearest_spline_span(doc: &SketchDoc, u: f64, v: f64, radius: f64) -> Option<(Value, usize, f64)> {
    let mut best: Option<(f64, Value, usize, f64)> = None;
    for geo in &doc.geometries {
        if !is_spline_type(&geo.geom_type) {
            continue;
        }
        let ids = &geo.points;
        if ids.len() < 4 || (ids.len() - 1) % 3 != 0 {
            continue;
        }
        for span in 0..(ids.len() - 1) / 3 {
            let i0 = span * 3;
            let Some(controls) = span_controls(
                doc,
                &[
                    ids[i0].clone(),
                    ids[i0 + 1].clone(),
                    ids[i0 + 2].clone(),
                    ids[i0 + 3].clone(),
                ],
            ) else {
                continue;
            };
            let (dist, t) = closest_on_span(&controls, u, v);
            if dist <= radius && best.as_ref().map_or(true, |(bd, ..)| dist < *bd) {
                best = Some((dist, geo.id.clone(), span, t));
            }
        }
    }
    best.map(|(_, id, span, t)| (id, span, t))
}

/// The `(distance, parameter)` of the point on one cubic span nearest `(u, v)`.
/// Sampled at [`SPAN_SAMPLES`] chords, then the click is projected onto the winning
/// chord — the same sampled-polyline treatment trim gives a curve, and accurate to
/// the chord's sagitta (well under a pixel at overlay resolution).
fn closest_on_span(controls: &[[f64; 2]; 4], u: f64, v: f64) -> (f64, f64) {
    let mut prev = eval_cubic(controls, 0.0);
    let mut best = ((u - prev[0]).hypot(v - prev[1]), 0.0);
    for i in 1..=SPAN_SAMPLES {
        let t1 = i as f64 / SPAN_SAMPLES as f64;
        let next = eval_cubic(controls, t1);
        let (dx, dy) = (next[0] - prev[0], next[1] - prev[1]);
        let len2 = (dx * dx + dy * dy).max(1e-24);
        let s = (((u - prev[0]) * dx + (v - prev[1]) * dy) / len2).clamp(0.0, 1.0);
        let dist = (u - (prev[0] + dx * s)).hypot(v - (prev[1] + dy * s));
        if dist < best.0 {
            let t0 = (i - 1) as f64 / SPAN_SAMPLES as f64;
            best = (dist, t0 + (t1 - t0) * s);
        }
        prev = next;
    }
    best
}

/// Evaluate the cubic Bernstein sum over one span's four control points.
fn eval_cubic(controls: &[[f64; 2]; 4], t: f64) -> [f64; 2] {
    let mt = 1.0 - t;
    let (w0, w1, w2, w3) = (
        mt * mt * mt,
        3.0 * mt * mt * t,
        3.0 * mt * t * t,
        t * t * t,
    );
    [
        w0 * controls[0][0] + w1 * controls[1][0] + w2 * controls[2][0] + w3 * controls[3][0],
        w0 * controls[0][1] + w1 * controls[1][1] + w2 * controls[2][1] + w3 * controls[3][1],
    ]
}

/// Resolve four control-point ids to coordinates, or `None` if any is missing.
fn span_controls(doc: &SketchDoc, ids: &[Value; 4]) -> Option<[[f64; 2]; 4]> {
    let mut out = [[0.0; 2]; 4];
    for (slot, id) in ids.iter().enumerate() {
        let p = doc.point(id)?;
        out[slot] = [p.x, p.y];
    }
    Some(out)
}

fn lerp(a: [f64; 2], b: [f64; 2], t: f64) -> [f64; 2] {
    [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
}

/// Move an existing point to `(x, y)`, or `None` if it vanished.
fn move_point(doc: &mut SketchDoc, id: &Value, at: [f64; 2]) -> Option<()> {
    let p = doc.point_mut(id)?;
    p.x = at[0];
    p.y = at[1];
    Some(())
}

/// Mint a fresh free point at `at` and return its id. Never snaps to a neighbour
/// (unlike [`SketchDoc::snap_or_add_point`]): a subdivision's three new control points
/// are new roles in the polygon even when they land on top of something.
fn add_point(doc: &mut SketchDoc, at: [f64; 2]) -> Value {
    let id = doc.next_point_id();
    doc.points.push(SketchPoint {
        id: id.clone(),
        x: at[0],
        y: at[1],
        fixed: false,
        construction: false,
        external_reference: false,
    });
    id
}

// ---------------------------------------------------------------------------
// Test-only geometry readers.
//
// Shared by this module's unit tests AND the engine-level tool tests
// (`engine_state::sketch_mode_tests`), so "the curve did not move" is measured by
// ONE implementation in both places — analytically, against the control polygons,
// never through a sampled polyline (whose chord gaps run to ~1e-2 at any sane sample
// count and would swallow the deviation these tests exist to catch).
// ---------------------------------------------------------------------------

/// One span of a spline geometry as a control polygon. Panics on a missing point or
/// a short polygon — a test fixture that malformed is a broken test, not a case.
#[cfg(test)]
pub(crate) fn span_controls_at(doc: &SketchDoc, geo_id: &Value, span: usize) -> [[f64; 2]; 4] {
    let geo = doc.geometry(geo_id).expect("geometry");
    let i0 = span * 3;
    let ids = [
        geo.points[i0].clone(),
        geo.points[i0 + 1].clone(),
        geo.points[i0 + 2].clone(),
        geo.points[i0 + 3].clone(),
    ];
    span_controls(doc, &ids).expect("controls")
}

/// Every span of a spline geometry as a control polygon, in chain order.
#[cfg(test)]
pub(crate) fn chain_spans(doc: &SketchDoc, geo_id: &Value) -> Vec<[[f64; 2]; 4]> {
    let count = (doc.geometry(geo_id).expect("geometry").points.len() - 1) / 3;
    (0..count).map(|span| span_controls_at(doc, geo_id, span)).collect()
}

/// The point at parameter `t` on span `span` of a spline geometry — how a test aims a
/// click AT the curve instead of hard-coding a coordinate that a later edit to the
/// fixture would silently move off it.
#[cfg(test)]
pub(crate) fn point_on_span(doc: &SketchDoc, geo_id: &Value, span: usize, t: f64) -> [f64; 2] {
    eval_cubic(&span_controls_at(doc, geo_id, span), t)
}

/// The true distance from `q` to the cubic `controls`: a coarse parameter scan for the
/// bracketing interval, then ternary search inside it (the squared distance is
/// unimodal there). Exact to machine precision, unlike a sampled polyline's
/// nearest-VERTEX distance.
#[cfg(test)]
fn dist_to_cubic(controls: &[[f64; 2]; 4], q: [f64; 2]) -> f64 {
    const SCAN: usize = 256;
    let at = |t: f64| {
        let p = eval_cubic(controls, t);
        (p[0] - q[0]).hypot(p[1] - q[1])
    };
    let mut best = (at(0.0), 0.0);
    for i in 1..=SCAN {
        let t = i as f64 / SCAN as f64;
        let d = at(t);
        if d < best.0 {
            best = (d, t);
        }
    }
    let h = 1.0 / SCAN as f64;
    let (mut lo, mut hi) = ((best.1 - h).max(0.0), (best.1 + h).min(1.0));
    for _ in 0..200 {
        let a = lo + (hi - lo) / 3.0;
        let b = hi - (hi - lo) / 3.0;
        if at(a) < at(b) {
            hi = b;
        } else {
            lo = a;
        }
    }
    at((lo + hi) / 2.0)
}

/// The two-sided Hausdorff distance between the chain `spans` and the single cubic
/// `original` — each walked densely and measured against the OTHER curve
/// analytically. Two-sided because a subdivision could in principle cover only part
/// of the original and still score zero one way.
#[cfg(test)]
pub(crate) fn shape_deviation(spans: &[[[f64; 2]; 4]], original: &[[f64; 2]; 4]) -> f64 {
    const WALK: usize = 400;
    let mut worst: f64 = 0.0;
    for controls in spans {
        for i in 0..=WALK {
            let q = eval_cubic(controls, i as f64 / WALK as f64);
            worst = worst.max(dist_to_cubic(original, q));
        }
    }
    for i in 0..=WALK {
        let q = eval_cubic(original, i as f64 / WALK as f64);
        let near = spans
            .iter()
            .map(|c| dist_to_cubic(c, q))
            .fold(f64::INFINITY, f64::min);
        worst = worst.max(near);
    }
    worst
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn doc_from(value: Value) -> SketchDoc {
        serde_json::from_value(value).expect("sketch doc")
    }

    /// A single-span spline `(0,0) (0,30) (30,30) (30,0)` — a symmetric hump whose
    /// mid-curve point is (15, 22.5), well clear of every control point.
    fn hump_doc() -> SketchDoc {
        doc_from(json!({
            "points": [
                { "id": 0, "x": 0.0,  "y": 0.0 },
                { "id": 1, "x": 0.0,  "y": 30.0 },
                { "id": 2, "x": 30.0, "y": 30.0 },
                { "id": 3, "x": 30.0, "y": 0.0 }
            ],
            "geometries": [{ "id": 10, "type": "bezier", "points": [0, 1, 2, 3] }],
            "constraints": []
        }))
    }

    fn point_ids(doc: &SketchDoc, geo_id: &Value) -> Vec<String> {
        doc.geometry(geo_id)
            .expect("geometry")
            .points
            .iter()
            .map(id_key)
            .collect()
    }

    #[test]
    fn insert_subdivides_without_moving_the_curve() {
        let mut doc = hump_doc();
        let geo = json!(10);
        let before = span_controls_at(&doc, &geo, 0);

        // Click the apex (15, 22.5) — exactly on the curve at t = 0.5.
        let added = insert_anchor(&mut doc, 15.0, 22.5, 1.0).expect("inserted");
        assert_eq!(point_ids(&doc, &geo).len(), 7, "3n+1 grew by one span");

        // The subdivided polygon traces the ORIGINAL cubic. Pure doc math (no solver
        // rounding in the way), so this is floating-point noise, not a tolerance: the
        // observed deviation here and in every other insert test is ~1.6e-14, and the
        // band is set two orders above that so a REAL drift cannot hide under it.
        let dev = shape_deviation(&chain_spans(&doc, &geo), &before);
        assert!(dev < 1e-12, "curve moved by {dev}");

        // The new anchor landed under the click and is collinear with its handles —
        // the implied G1 join the kernel pushes at every interior anchor.
        let s = doc.point(&added.anchor).expect("anchor");
        assert!((s.x - 15.0).abs() < 1e-6 && (s.y - 22.5).abs() < 1e-6, "anchor at {s:?}");
        let d = doc.point(&added.before).expect("before handle");
        let e = doc.point(&added.after).expect("after handle");
        let cross = (s.x - d.x) * (e.y - d.y) - (s.y - d.y) * (e.x - d.x);
        assert!(cross.abs() < 1e-9, "anchor off the handle line: {cross}");
    }

    #[test]
    fn insert_keeps_the_end_ids_and_reuses_the_handle_ids() {
        let mut doc = hump_doc();
        let geo = json!(10);
        insert_anchor(&mut doc, 15.0, 22.5, 1.0).expect("inserted");

        let ids = point_ids(&doc, &geo);
        assert_eq!(ids[0], "0", "start anchor id untouched");
        assert_eq!(ids[6], "3", "end anchor id untouched");
        assert_eq!(ids[1], "1", "P1 reused as the first half-span's handle");
        assert_eq!(ids[5], "2", "P2 reused as the second half-span's handle");
        // The reused handles slid along their own tangent rays, so the end-tangent
        // DIRECTIONS (the kernel's `B'(0) = 3(P1 - P0)` convention) are unchanged.
        let p1 = doc.point(&json!(1)).expect("P1");
        assert!((p1.x - 0.0).abs() < 1e-9 && (p1.y - 15.0).abs() < 1e-9, "A = {p1:?}");
        let p2 = doc.point(&json!(2)).expect("P2");
        assert!((p2.x - 30.0).abs() < 1e-9 && (p2.y - 15.0).abs() < 1e-9, "C = {p2:?}");
        // Exactly three points minted (D, S, E).
        assert_eq!(doc.points.len(), 7);
    }

    #[test]
    fn insert_into_the_second_span_splices_at_the_right_slot() {
        // Two spans sharing anchor 3; insert into the SECOND one. An off-by-3 splice
        // passes every single-span test, so this is the one that catches it.
        let mut doc = doc_from(json!({
            "points": [
                { "id": 0, "x": 0.0,  "y": 0.0 },
                { "id": 1, "x": 0.0,  "y": 20.0 },
                { "id": 2, "x": 20.0, "y": 20.0 },
                { "id": 3, "x": 20.0, "y": 0.0 },
                { "id": 4, "x": 20.0, "y": -20.0 },
                { "id": 5, "x": 40.0, "y": -20.0 },
                { "id": 6, "x": 40.0, "y": 0.0 }
            ],
            "geometries": [{ "id": 10, "type": "bezier", "points": [0, 1, 2, 3, 4, 5, 6] }],
            "constraints": []
        }));
        let geo = json!(10);
        let span0_before = span_controls_at(&doc, &geo, 0);
        let span1_before = span_controls_at(&doc, &geo, 1);
        let mid = eval_cubic(&span1_before, 0.5);

        insert_anchor(&mut doc, mid[0], mid[1], 1.0).expect("inserted");
        let ids = point_ids(&doc, &geo);
        assert_eq!(ids.len(), 10, "3n+1 holds at three spans");
        // The FIRST span's four ids are untouched; the split happened after slot 4.
        assert_eq!(&ids[..4], &["0", "1", "2", "3"], "first span disturbed: {ids:?}");
        assert_eq!(ids[4], "4", "second span's leading handle kept its id");
        assert_eq!(ids[8], "5", "second span's trailing handle kept its id");
        assert_eq!(ids[9], "6", "end anchor untouched");

        // The untouched span kept its control points verbatim, and the subdivided one
        // is reproduced by the two spans that replaced it.
        assert_eq!(span_controls_at(&doc, &geo, 0), span0_before, "first span moved");
        let dev = shape_deviation(&chain_spans(&doc, &geo)[1..=2], &span1_before);
        assert!(dev < 1e-12, "subdivided span moved by {dev}");
    }

    #[test]
    fn a_second_insert_into_a_freshly_made_span_still_holds_the_invariant() {
        let mut doc = hump_doc();
        let geo = json!(10);
        let original = span_controls_at(&doc, &geo, 0);

        insert_anchor(&mut doc, 15.0, 22.5, 1.0).expect("first insert");
        // Halfway along the FIRST half-span (a span that did not exist a moment ago).
        let mid = eval_cubic(&span_controls_at(&doc, &geo, 0), 0.5);
        insert_anchor(&mut doc, mid[0], mid[1], 1.0).expect("second insert");
        assert_eq!(point_ids(&doc, &geo).len(), 10, "3n+1 after two inserts");

        // …and two inserts later the curve is still the curve that was drawn.
        let dev = shape_deviation(&chain_spans(&doc, &geo), &original);
        assert!(dev < 1e-12, "curve moved by {dev} over two inserts");
    }

    #[test]
    fn two_inserts_into_the_same_original_span_both_land() {
        let mut doc = hump_doc();
        let geo = json!(10);
        let original = span_controls_at(&doc, &geo, 0);
        // Quarter and three-quarter points of the ORIGINAL span, in that order: the
        // second click falls in the second half-span the first insert created.
        let first = eval_cubic(&original, 0.25);
        let second = eval_cubic(&original, 0.75);
        insert_anchor(&mut doc, first[0], first[1], 1.0).expect("first insert");
        insert_anchor(&mut doc, second[0], second[1], 1.0).expect("second insert");

        assert_eq!(point_ids(&doc, &geo).len(), 10, "two spans became four");
        let dev = shape_deviation(&chain_spans(&doc, &geo), &original);
        assert!(dev < 1e-12, "curve moved by {dev}");
    }

    #[test]
    fn a_click_off_the_curve_or_on_another_geometry_inserts_nothing() {
        let mut doc = hump_doc();
        // Far from everything.
        assert!(insert_anchor(&mut doc, 15.0, 0.5, 1.0).is_none(), "empty space inserted");
        assert_eq!(doc.points.len(), 4, "nothing minted");

        // A line laid across the sketch, clicked well away from the spline.
        let mut doc = doc_from(json!({
            "points": [
                { "id": 0, "x": 0.0,  "y": 0.0 },
                { "id": 1, "x": 0.0,  "y": 30.0 },
                { "id": 2, "x": 30.0, "y": 30.0 },
                { "id": 3, "x": 30.0, "y": 0.0 },
                { "id": 4, "x": -50.0, "y": -10.0 },
                { "id": 5, "x": 50.0,  "y": -10.0 }
            ],
            "geometries": [
                { "id": 10, "type": "bezier", "points": [0, 1, 2, 3] },
                { "id": 11, "type": "line", "points": [4, 5] }
            ],
            "constraints": []
        }));
        assert!(insert_anchor(&mut doc, 0.0, -10.0, 1.0).is_none(), "the line was subdivided");
        assert_eq!(doc.points.len(), 6, "nothing minted");
    }

    #[test]
    fn a_click_on_a_control_point_or_span_end_inserts_nothing() {
        let mut doc = hump_doc();
        // Points win the pick: a click on the start anchor is not a subdivision.
        assert!(insert_anchor(&mut doc, 0.0, 0.0, 1.0).is_none(), "anchor click inserted");
        // …nor is one on an off-curve handle.
        assert!(insert_anchor(&mut doc, 0.2, 30.0, 1.0).is_none(), "handle click inserted");
        assert_eq!(doc.points.len(), 4, "nothing minted");
    }

    #[test]
    fn a_cusp_span_that_repeats_an_id_is_left_alone() {
        // Handle id 1 doubles as the second handle: subdividing would need to move it
        // to two different places at once, so the click is refused.
        let mut doc = doc_from(json!({
            "points": [
                { "id": 0, "x": 0.0,  "y": 0.0 },
                { "id": 1, "x": 15.0, "y": 30.0 },
                { "id": 3, "x": 30.0, "y": 0.0 }
            ],
            "geometries": [{ "id": 10, "type": "bezier", "points": [0, 1, 1, 3] }],
            "constraints": []
        }));
        let mid = eval_cubic(&span_controls_at(&doc, &json!(10), 0), 0.5);
        assert!(insert_anchor(&mut doc, mid[0], mid[1], 1.0).is_none(), "cusp subdivided");
        assert_eq!(doc.points.len(), 3, "nothing minted");
    }

    #[test]
    fn the_spline_type_alias_is_pickable_too() {
        let mut doc = doc_from(json!({
            "points": [
                { "id": 0, "x": 0.0,  "y": 0.0 },
                { "id": 1, "x": 0.0,  "y": 30.0 },
                { "id": 2, "x": 30.0, "y": 30.0 },
                { "id": 3, "x": 30.0, "y": 0.0 }
            ],
            "geometries": [{ "id": 10, "type": "spline", "points": [0, 1, 2, 3] }],
            "constraints": []
        }));
        assert!(insert_anchor(&mut doc, 15.0, 22.5, 1.0).is_some(), "alias not subdivided");
        assert_eq!(point_ids(&doc, &json!(10)).len(), 7);
    }
}