cadmpeg-codec-f3d 0.1.4

// SPDX-License-Identifier: Apache-2.0
//! Build B-rep topology and geometry from a framed SAB record table.
//!
//! [`decode`] follows the topology chain from bodies through vertices and
//! points. It creates analytic carriers for planes, cylinders, cones, spheres,
//! tori, lines, circles, and ellipses. [`crate::nurbs`] supplies cached NURBS
//! surfaces, 3D curves, and pcurves for spline and procedural records.
//!
//! Faces retain their loops and trims when a referenced surface has no decoded
//! shape; the emitted [`SurfaceGeometry::Unknown`] links to the corresponding
//! [`UnknownRecord`]. Edges retain vertices and parameter ranges when their 3D
//! curve carrier is unavailable. [`Stats`] records these transfer losses for
//! the decode report.
//!
//! ASM model-space lengths become millimetres. Unit vectors, ratios, angles,
//! knots, weights, and UV parameters keep their native scale.

use std::collections::{HashMap, HashSet};

use cadmpeg_ir::attributes::{AttributeTarget, AttributeValue, SourceAttribute};
use cadmpeg_ir::design::{PersistentDesignLink, SketchCurveLink};
use cadmpeg_ir::geometry::{
    BlendSupport, Curve, CurveGeometry, NurbsCurve, Pcurve, PcurveGeometry, ProceduralCurve,
    ProceduralSurface, ProceduralSurfaceDefinition, Surface, SurfaceGeometry,
};
use cadmpeg_ir::ids::{
    AttributeId, BodyId, CoedgeId, CurveId, EdgeId, FaceId, LoopId, PcurveId, PointId, RegionId,
    ShellId, SurfaceId, UnknownId, VertexId,
};
use cadmpeg_ir::math::{Point3, Vector3};
use cadmpeg_ir::topology::{
    Body, Coedge, Color, Edge, Face, Loop, Point, Region, Sense, Shell, Vertex,
};
use cadmpeg_ir::unknown::UnknownRecord;

use crate::asm_header;
use crate::nurbs;
use crate::sab::{Record, Token};

/// Millimetres per ASM model-space length unit (centimetres).
const LEN_TO_MM: f64 = 10.0;

/// The decoded B-rep graph plus loss accounting.
#[derive(Default)]
pub struct Brep {
    /// Bodies.
    pub bodies: Vec<Body>,
    /// Regions.
    pub regions: Vec<Region>,
    /// Shells.
    pub shells: Vec<Shell>,
    /// Faces.
    pub faces: Vec<Face>,
    /// Loops.
    pub loops: Vec<Loop>,
    /// Coedges.
    pub coedges: Vec<Coedge>,
    /// Edges.
    pub edges: Vec<Edge>,
    /// Vertices.
    pub vertices: Vec<Vertex>,
    /// Points.
    pub points: Vec<Point>,
    /// Analytic surface carriers.
    pub surfaces: Vec<Surface>,
    /// Analytic curve carriers.
    pub curves: Vec<Curve>,
    /// Parameter-space curve carriers.
    pub pcurves: Vec<Pcurve>,
    /// Native procedural definitions for solved surface carriers.
    pub procedural_surfaces: Vec<ProceduralSurface>,
    /// Native procedural definitions for solved curve caches.
    pub procedural_curves: Vec<ProceduralCurve>,
    /// Typed sketch-curve provenance links.
    pub sketch_curve_links: Vec<SketchCurveLink>,
    /// Persistent design identifiers attached to solved entities.
    pub persistent_design_links: Vec<PersistentDesignLink>,
    /// Native ASM body key by emitted body id, used by Design-side joins.
    pub body_keys: HashMap<BodyId, u64>,
    /// Linked source-native attributes.
    pub attributes: Vec<SourceAttribute>,
    /// Undecoded carrier records preserved verbatim.
    pub unknowns: Vec<UnknownRecord>,
    /// Loss accounting for the report.
    pub stats: Stats,
    /// Source locations for emitted B-rep and synthetic child records.
    pub annotation_records: Vec<AnnotationRecord>,
}

/// One sparse v1 annotation produced while SAB record offsets are available.
pub struct AnnotationRecord {
    /// Globally unique IR entity id.
    pub id: String,
    /// Byte offset in the decompressed ASM stream.
    pub offset: u64,
    /// Source SAB record name.
    pub tag: String,
    /// Serialized fields whose values were canonically derived.
    pub derived_fields: Vec<&'static str>,
}

/// Counts used to construct the B-rep loss report.
#[derive(Default)]
pub struct Stats {
    /// Faces resting on a spline/procedural surface whose shape was not decoded
    /// into a typed carrier; emitted with an unknown-geometry surface.
    pub unknown_surface_faces: usize,
    /// Spline surface records whose cached B-spline block was decoded into a
    /// NURBS carrier.
    pub nurbs_surfaces: usize,
    /// Procedural curve records whose cached 3D B-spline block was decoded into
    /// a NURBS carrier.
    pub nurbs_curves: usize,
    /// Edges whose 3D curve is a procedural carrier (emitted with no curve).
    pub procedural_curve_edges: usize,
    /// Coedges that carried an explicit UV pcurve ref whose carrier could not
    /// be decoded.
    pub undecoded_pcurve_refs: usize,
    /// Procedural blends for which only one of two support families resolved.
    pub partial_procedural_supports: usize,
    /// Record names in the active slice that were neither topology nor a
    /// decoded/preserved carrier (attributes, transforms, refinements, …).
    pub other_records: usize,
    /// Residual record counts by full record name.
    pub other_record_kinds: std::collections::BTreeMap<String, usize>,
}

// ---- geometry carrier decode -------------------------------------------------

/// Ordered typed values pulled from a carrier record's payload.
struct Carrier {
    positions: Vec<[f64; 3]>,
    vectors: Vec<[f64; 3]>,
    doubles: Vec<f64>,
}

fn collect_carrier(rec: &Record) -> Carrier {
    let mut c = Carrier {
        positions: Vec::new(),
        vectors: Vec::new(),
        doubles: Vec::new(),
    };
    for t in &rec.tokens {
        match t {
            Token::Position(p) => c.positions.push(*p),
            Token::Vector3(v) => c.vectors.push(*v),
            Token::Double(d) => c.doubles.push(*d),
            _ => {}
        }
    }
    c
}

fn scale_point(p: [f64; 3]) -> Point3 {
    Point3::new(p[0] * LEN_TO_MM, p[1] * LEN_TO_MM, p[2] * LEN_TO_MM)
}

fn vec3(v: [f64; 3]) -> Vector3 {
    Vector3::new(v[0], v[1], v[2])
}

fn norm3(v: [f64; 3]) -> f64 {
    (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt()
}

/// Return `v` normalized to unit length, or `v` unchanged if it is degenerate
/// (validation flags a degenerate direction rather than this hiding it).
fn unit(v: [f64; 3]) -> Vector3 {
    let n = norm3(v);
    if n > f64::EPSILON {
        Vector3::new(v[0] / n, v[1] / n, v[2] / n)
    } else {
        vec3(v)
    }
}

/// Whether a record name heads an analytic surface carrier.
fn is_analytic_surface(head: &str) -> bool {
    matches!(head, "plane" | "cone" | "sphere" | "torus")
}

/// Whether a record name heads an analytic curve carrier.
fn is_analytic_curve(head: &str) -> bool {
    matches!(head, "straight" | "ellipse" | "degenerate_curve")
}

/// Decode an analytic surface carrier. Signed sphere and torus radii remain in
/// the IR because they are part of the ASM carrier semantics.
pub(crate) fn decode_surface(rec: &Record) -> Option<(SurfaceGeometry, bool)> {
    let c = collect_carrier(rec);
    let origin = *c.positions.first()?;
    match rec.head.as_str() {
        "plane" => {
            let normal = *c.vectors.first()?;
            let normal = unit(normal);
            let u_axis = c
                .vectors
                .get(1)
                .map_or_else(|| deterministic_ref_direction(normal), |axis| unit(*axis));
            Some((
                SurfaceGeometry::Plane {
                    origin: scale_point(origin),
                    normal,
                    u_axis,
                },
                false,
            ))
        }
        "cone" => {
            let axis = *c.vectors.first()?;
            let axis = unit(axis);
            let major = c.vectors.get(1).copied();
            // Doubles are (ratio, sine, cosine, u_scale). `ratio` (minor/major
            // of an elliptical cone) is not modeled by the IR's circular cone
            // carrier; all corpus cones are circular (ratio 1). `sine` selects
            // cylinder vs cone. The base radius is the major-axis vector's
            // magnitude; the trailing `u_scale` double is the u-parameter
            // scale, which usually coincides with the radius but diverges on
            // offset-derived surfaces. The signed slope `sine / cosine` is the
            // radius change per unit axis distance, and a negative `cosine`
            // points the surface normal toward the axis.
            let sine = *c.doubles.get(1).unwrap_or(&0.0);
            let cosine = *c.doubles.get(2).unwrap_or(&1.0);
            let u_scale = c.doubles.get(3).copied();
            let radius = major
                .map(|vector| norm3(vector) * LEN_TO_MM)
                .filter(|radius| *radius > f64::EPSILON)
                .or_else(|| u_scale.map(|r| r * LEN_TO_MM))?;
            let ref_direction = major.map_or_else(|| deterministic_ref_direction(axis), unit);
            if sine.abs() <= f64::EPSILON {
                Some((
                    SurfaceGeometry::Cylinder {
                        origin: scale_point(origin),
                        axis,
                        ref_direction,
                        radius,
                    },
                    cosine < 0.0,
                ))
            } else {
                // The IR cone's radius grows along `+axis`; a negative native
                // slope shrinks it, so the axis flips to compensate. The
                // outward normal is invariant under the flip; the inward
                // normal of a negative `cosine` folds into the face sense.
                let axis = if sine * cosine < 0.0 {
                    Vector3::new(-axis.x, -axis.y, -axis.z)
                } else {
                    axis
                };
                Some((
                    SurfaceGeometry::Cone {
                        origin: scale_point(origin),
                        axis,
                        ref_direction,
                        radius,
                        half_angle: sine.abs().asin(),
                    },
                    cosine < 0.0,
                ))
            }
        }
        "sphere" => {
            let signed = *c.doubles.first()?;
            let polar_axis = c.vectors.get(1).or_else(|| c.vectors.first()).copied()?;
            let polar_axis = unit(polar_axis);
            let equator = c
                .vectors
                .first()
                .filter(|_| c.vectors.len() > 1)
                .map_or_else(
                    || deterministic_ref_direction(polar_axis),
                    |direction| unit(*direction),
                );
            Some((
                SurfaceGeometry::Sphere {
                    center: scale_point(origin),
                    axis: polar_axis,
                    ref_direction: equator,
                    radius: signed * LEN_TO_MM,
                },
                false,
            ))
        }
        "torus" => {
            let axis = *c.vectors.first()?;
            let axis = unit(axis);
            let ref_direction = c.vectors.get(1).map_or_else(
                || deterministic_ref_direction(axis),
                |direction| unit(*direction),
            );
            let major = *c.doubles.first()?;
            let minor = *c.doubles.get(1)?;
            Some((
                SurfaceGeometry::Torus {
                    center: scale_point(origin),
                    axis,
                    ref_direction,
                    major_radius: major * LEN_TO_MM,
                    minor_radius: minor * LEN_TO_MM,
                },
                false,
            ))
        }
        _ => None,
    }
}

fn deterministic_ref_direction(axis: Vector3) -> Vector3 {
    let candidates = [
        Vector3::new(1.0, 0.0, 0.0),
        Vector3::new(0.0, 1.0, 0.0),
        Vector3::new(0.0, 0.0, 1.0),
    ];
    let basis = candidates
        .into_iter()
        .min_by(|a, b| {
            let a_dot = (a.x * axis.x + a.y * axis.y + a.z * axis.z).abs();
            let b_dot = (b.x * axis.x + b.y * axis.y + b.z * axis.z).abs();
            a_dot.total_cmp(&b_dot)
        })
        .expect("fixed candidate set is non-empty");
    let dot = basis.x * axis.x + basis.y * axis.y + basis.z * axis.z;
    let projected = Vector3::new(
        basis.x - dot * axis.x,
        basis.y - dot * axis.y,
        basis.z - dot * axis.z,
    );
    let length = projected.norm();
    Vector3::new(
        projected.x / length,
        projected.y / length,
        projected.z / length,
    )
}

/// Decode an analytic curve carrier.
pub(crate) fn decode_curve(rec: &Record) -> Option<CurveGeometry> {
    let carrier = collect_carrier(rec);
    let base = *carrier.positions.first()?;
    match rec.head.as_str() {
        "straight" => Some(CurveGeometry::Line {
            origin: scale_point(base),
            direction: unit(*carrier.vectors.first()?),
        }),
        "ellipse" => {
            let axis = *carrier.vectors.first()?;
            let reference = *carrier.vectors.get(1)?;
            let ratio = *carrier.doubles.first()?;
            let major_radius = norm3(reference) * LEN_TO_MM;
            if (ratio.abs() - 1.0).abs() <= f64::EPSILON {
                Some(CurveGeometry::Circle {
                    center: scale_point(base),
                    axis: unit(axis),
                    ref_direction: unit(reference),
                    radius: major_radius,
                })
            } else {
                Some(CurveGeometry::Ellipse {
                    center: scale_point(base),
                    axis: unit(axis),
                    major_direction: unit(reference),
                    major_radius,
                    minor_radius: major_radius * ratio.abs(),
                })
            }
        }
        "degenerate_curve" => Some(CurveGeometry::Degenerate {
            point: scale_point(base),
        }),
        _ => None,
    }
}

fn sense_at(rec: &Record, i: usize) -> Sense {
    match rec.chunk(i) {
        Some(Token::True) => Sense::Reversed,
        _ => Sense::Forward,
    }
}

/// The record-level sense bit of an `intcurve` or `spline` carrier: the boolean
/// token immediately before the record's subtype scope ([spec §7.6](https://github.com/cadmpeg/cadmpeg/blob/main/docs/formats/f3d.md#76-intcurve-and-spline-subtypes)). `true`
/// marks geometry as the reverse of its cached definition. A reversed intcurve
/// negates the cache parameterization (`C(t) = cache(-t)`), and a reversed
/// spline surface flips the cache normal.
fn record_reversed(rec: &Record) -> bool {
    for token in &rec.tokens {
        match token {
            Token::True => return true,
            Token::False | Token::SubtypeOpen => return false,
            _ => {}
        }
    }
    false
}

/// Reparameterize a cached B-spline to its record's reversed sense,
/// `C'(t) = C(-t)`, by reversing poles and weights and negating reversed knots.
fn reverse_nurbs_curve(curve: &mut NurbsCurve) {
    curve.control_points.reverse();
    if let Some(weights) = curve.weights.as_mut() {
        weights.reverse();
    }
    curve.knots.reverse();
    for knot in &mut curve.knots {
        *knot = -*knot;
    }
}

/// Reverse a curve carrier to its opposite orientation, `C'(t) = C(-t)`.
/// Lines negate their direction, conics negate their plane normal (flipping
/// the angular sweep while keeping the zero-angle direction), and B-splines
/// reverse poles and knots. Carriers without an orientation pass through.
fn reverse_curve_geometry(geometry: &mut CurveGeometry) {
    match geometry {
        CurveGeometry::Line { direction, .. } => {
            *direction = Vector3::new(-direction.x, -direction.y, -direction.z);
        }
        CurveGeometry::Circle { axis, .. } | CurveGeometry::Ellipse { axis, .. } => {
            *axis = Vector3::new(-axis.x, -axis.y, -axis.z);
        }
        CurveGeometry::Nurbs(curve) => reverse_nurbs_curve(curve),
        _ => {}
    }
}

fn double_at(rec: &Record, i: usize) -> Option<f64> {
    match rec.chunk(i) {
        Some(Token::Double(d)) => Some(*d),
        _ => None,
    }
}

/// Decode a framed active slice into the IR B-rep graph.
///
/// `stream` names the source ZIP entry for provenance. Ids are minted as
/// `f3d:brep:entity#<record-index>`, unique across the `RecordTable`.
pub fn decode(records: &[Record], bytes: &[u8], _stream: &str) -> Brep {
    let mut out = Brep::default();

    let id = |i: i64| format!("f3d:brep:entity#{i}");
    // Index records by RecordTable index (== position for a framed slice).
    let by_index: HashMap<i64, &Record> = records.iter().map(|r| (r.index as i64, r)).collect();
    let header_scale = asm_header::parse(bytes)
        .and_then(|header| header.scale)
        .unwrap_or(1.0);

    let attribute_color = |entity: &Record| attribute_chain_color(entity, &by_index);

    // Pass 1: classify carriers and decode analytic geometry.
    let mut surface_geo: HashMap<i64, (SurfaceGeometry, bool)> = HashMap::new();
    let mut procedural_surface_defs = HashMap::new();
    let mut curve_geo: HashMap<i64, CurveGeometry> = HashMap::new();
    let mut procedural_curve_defs = HashMap::new();
    for r in records {
        if is_analytic_surface(&r.head) {
            if let Some(g) = decode_surface(r) {
                surface_geo.insert(r.index as i64, g);
            }
        } else if is_analytic_curve(&r.head) {
            if let Some(g) = decode_curve(r) {
                curve_geo.insert(r.index as i64, g);
            }
        }
    }
    // Carriers whose native normal points opposite the IR carrier's normal;
    // the reversal folds into the referencing faces' senses.
    let inward_normal_surfaces: HashSet<i64> = surface_geo
        .iter()
        .filter(|(_, (_, inward))| *inward)
        .map(|(&index, _)| index)
        .collect();

    // Pass 2: keep every face whose surface reference resolves to a record,
    // then pull its supporting graph in by shell-reachability. A face on a
    // decoded analytic surface gets that carrier; a face on a spline/procedural
    // surface keeps its topology and gets an unknown-geometry carrier linking to
    // the preserved bytes.
    let mut kept_faces: HashSet<i64> = HashSet::new();
    let mut kept_loops: HashSet<i64> = HashSet::new();
    let mut kept_coedges: HashSet<i64> = HashSet::new();
    let mut kept_edges: HashSet<i64> = HashSet::new();
    let mut kept_vertices: HashSet<i64> = HashSet::new();
    let mut kept_points: HashSet<i64> = HashSet::new();
    let mut kept_surfaces: HashSet<i64> = HashSet::new();
    let mut unknown_surface_records: HashSet<i64> = HashSet::new();
    let mut kept_curves: HashSet<i64> = HashSet::new();
    let mut kept_pcurves: HashSet<i64> = HashSet::new();
    let mut pcurve_geo: HashMap<i64, PcurveGeometry> = HashMap::new();
    // Undecoded carriers referenced by real topology, to preserve as unknowns.
    let mut undecoded_carriers: HashSet<i64> = HashSet::new();

    for r in records {
        if r.head != "face" {
            continue;
        }
        let Some(surf_ref) = r.ref_at(7) else {
            continue;
        };
        let Some(surf_rec) = by_index.get(&surf_ref) else {
            // Dangling surface reference: a face without a resolvable surface
            // cannot be emitted (the IR requires one), so it is dropped.
            continue;
        };
        kept_faces.insert(r.index as i64);
        // A non-analytic surface may still carry a decodable B-spline face cache.
        if let std::collections::hash_map::Entry::Vacant(e) = surface_geo.entry(surf_ref) {
            if let Some(ns) =
                nurbs::decode_surface_cache_resolving_refs(record_slice(surf_rec, bytes), bytes)
            {
                e.insert((SurfaceGeometry::Nurbs(ns), false));
                out.stats.nurbs_surfaces += 1;
                if let Some(procedural) = nurbs::decode_procedural_surface_resolving_refs(
                    record_slice(surf_rec, bytes),
                    bytes,
                ) {
                    procedural_surface_defs.insert(surf_ref, procedural);
                }
            }
        }
        if surface_geo.contains_key(&surf_ref) {
            kept_surfaces.insert(surf_ref);
        } else {
            unknown_surface_records.insert(surf_ref);
            undecoded_carriers.insert(surf_ref);
            out.stats.unknown_surface_faces += 1;
        }
    }

    // Walk each kept face's loops and coedge rings, collecting supporting graph.
    for &face_idx in &kept_faces.iter().copied().collect::<Vec<_>>() {
        let Some(face) = by_index.get(&face_idx) else {
            continue;
        };
        let mut loop_ref = face.ref_at(4);
        let mut loop_guard = HashSet::new();
        while let Some(li) = loop_ref {
            if !loop_guard.insert(li) {
                break;
            }
            let Some(lp) = by_index.get(&li) else { break };
            if lp.head != "loop" {
                break;
            }
            kept_loops.insert(li);
            // Ring-walk coedges via chunk[3] = next.
            if let Some(first_ce) = lp.ref_at(4) {
                let mut ce_ref = Some(first_ce);
                let mut ce_guard = HashSet::new();
                while let Some(ci) = ce_ref {
                    if !ce_guard.insert(ci) {
                        break;
                    }
                    let Some(ce) = by_index.get(&ci) else { break };
                    if ce.head != "coedge" {
                        break;
                    }
                    kept_coedges.insert(ci);
                    if let Some(pc) = ce.ref_at(10) {
                        if let Some(prec) = by_index.get(&pc) {
                            let decoded = nurbs::decode_pcurve_cache_resolving_refs(
                                record_slice(prec, bytes),
                                bytes,
                            )
                            .or_else(|| {
                                prec.ref_at(4)
                                    .and_then(|reference| by_index.get(&reference))
                                    .and_then(|intcurve| {
                                        nurbs::decode_intcurve_pcurve_cache_resolving_refs(
                                            record_slice(intcurve, bytes),
                                            bytes,
                                        )
                                    })
                            });
                            if let Some(decoded) = decoded {
                                pcurve_geo.insert(
                                    pc,
                                    PcurveGeometry::Nurbs {
                                        degree: decoded.degree,
                                        knots: decoded.knots,
                                        control_points: decoded.control_points,
                                        weights: decoded.weights,
                                        periodic: decoded.periodic,
                                    },
                                );
                                kept_pcurves.insert(pc);
                            } else {
                                out.stats.undecoded_pcurve_refs += 1;
                            }
                        } else {
                            out.stats.undecoded_pcurve_refs += 1;
                        }
                    }
                    if let Some(ei) = ce.ref_at(6) {
                        if let Some(edge) = by_index.get(&ei) {
                            // An edge is shared by two coedges; process (and
                            // count its curve loss) only the first time it is
                            // reached so shared edges are not double-counted.
                            if edge.head == "edge" && kept_edges.insert(ei) {
                                for slot in [3usize, 5] {
                                    if let Some(vi) = edge.ref_at(slot) {
                                        if let Some(v) = by_index.get(&vi) {
                                            if v.head == "vertex" {
                                                kept_vertices.insert(vi);
                                                if let Some(pi) = v.ref_at(5) {
                                                    kept_points.insert(pi);
                                                }
                                            }
                                        }
                                    }
                                }
                                match edge.ref_at(8) {
                                    Some(cv) if curve_geo.contains_key(&cv) => {
                                        kept_curves.insert(cv);
                                    }
                                    Some(cv) => {
                                        if let Some(crec) = by_index.get(&cv) {
                                            // A procedural curve carries an inline
                                            // 3D B-spline cache in most subtypes.
                                            if let Some(decoded) =
                                                nurbs::decode_procedural_curve_resolving_refs(
                                                    record_slice(crec, bytes),
                                                    bytes,
                                                )
                                            {
                                                let mut curve = decoded.curve;
                                                // A reversed intcurve parameterizes
                                                // as the negation of its cache; the
                                                // edge's stored range is on the
                                                // reversed parameterization.
                                                if record_reversed(crec) {
                                                    reverse_nurbs_curve(&mut curve);
                                                }
                                                curve_geo.insert(cv, CurveGeometry::Nurbs(curve));
                                                procedural_curve_defs.insert(
                                                    cv,
                                                    (
                                                        decoded.native_kind,
                                                        decoded.definition,
                                                        decoded.vector_offset,
                                                        decoded.subset,
                                                        decoded.compound,
                                                        decoded.embedded_two_sided_offset,
                                                        decoded.embedded_intersection,
                                                        decoded.embedded_three_surface_intersection,
                                                        decoded.embedded_surface_curve,
                                                        decoded.embedded_projection,
                                                        decoded.cache_fit_tolerance,
                                                    ),
                                                );
                                                out.stats.nurbs_curves += 1;
                                                kept_curves.insert(cv);
                                            } else {
                                                undecoded_carriers.insert(cv);
                                                out.stats.procedural_curve_edges += 1;
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    ce_ref = ce.ref_at(3);
                    if ce_ref == Some(first_ce) {
                        break;
                    }
                }
            }
            loop_ref = lp.ref_at(3);
        }
    }

    let mut wire_edges_by_shell = HashMap::<i64, Vec<i64>>::new();
    for shell in records.iter().filter(|record| record.head == "shell") {
        let shell_index = shell.index as i64;
        let mut wire_ref = shell.ref_at(6);
        let mut wire_guard = HashSet::new();
        while let Some(wire_index) = wire_ref.filter(|index| wire_guard.insert(*index)) {
            let Some(wire) = by_index
                .get(&wire_index)
                .filter(|record| record.head == "wire")
            else {
                break;
            };
            if let Some(first_coedge) = wire.ref_at(4) {
                let mut coedge_ref = Some(first_coedge);
                let mut coedge_guard = HashSet::new();
                while let Some(coedge_index) =
                    coedge_ref.filter(|index| coedge_guard.insert(*index))
                {
                    let Some(coedge) = by_index
                        .get(&coedge_index)
                        .filter(|record| record.head == "coedge")
                    else {
                        break;
                    };
                    if let Some(edge_index) = coedge.ref_at(6) {
                        let edges = wire_edges_by_shell.entry(shell_index).or_default();
                        if !edges.contains(&edge_index) {
                            edges.push(edge_index);
                        }
                        if let Some(edge) = by_index.get(&edge_index) {
                            if edge.head == "edge" && kept_edges.insert(edge_index) {
                                for slot in [3usize, 5] {
                                    if let Some(vertex_index) = edge.ref_at(slot) {
                                        if let Some(vertex) = by_index.get(&vertex_index) {
                                            if vertex.head == "vertex" {
                                                kept_vertices.insert(vertex_index);
                                                if let Some(point_index) = vertex.ref_at(5) {
                                                    kept_points.insert(point_index);
                                                }
                                            }
                                        }
                                    }
                                }
                                if let Some(curve_index) = edge.ref_at(8) {
                                    match curve_geo.entry(curve_index) {
                                        std::collections::hash_map::Entry::Occupied(_) => {
                                            kept_curves.insert(curve_index);
                                        }
                                        std::collections::hash_map::Entry::Vacant(entry) => {
                                            if let Some(curve_record) = by_index.get(&curve_index) {
                                                if let Some(decoded) =
                                                    nurbs::decode_procedural_curve_resolving_refs(
                                                        record_slice(curve_record, bytes),
                                                        bytes,
                                                    )
                                                {
                                                    let mut curve = decoded.curve;
                                                    if record_reversed(curve_record) {
                                                        reverse_nurbs_curve(&mut curve);
                                                    }
                                                    entry.insert(CurveGeometry::Nurbs(curve));
                                                    procedural_curve_defs.insert(
                                                        curve_index,
                                                        (
                                                            decoded.native_kind,
                                                            decoded.definition,
                                                            decoded.vector_offset,
                                                            decoded.subset,
                                                            decoded.compound,
                                                            decoded.embedded_two_sided_offset,
                                                            decoded.embedded_intersection,
                                                            decoded.embedded_three_surface_intersection,
                                                            decoded.embedded_surface_curve,
                                                            decoded.embedded_projection,
                                                            decoded.cache_fit_tolerance,
                                                        ),
                                                    );
                                                    kept_curves.insert(curve_index);
                                                    out.stats.nurbs_curves += 1;
                                                } else {
                                                    undecoded_carriers.insert(curve_index);
                                                    out.stats.procedural_curve_edges += 1;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    coedge_ref = coedge.ref_at(3);
                    if coedge_ref == Some(first_coedge) {
                        break;
                    }
                }
            }
            wire_ref = wire.ref_at(3);
        }
    }

    // An edge whose sense boolean is reversed traverses its curve as
    // `C(-t)`, with the edge parameters on the reversed parameterization.
    // The IR keeps every edge forward on its curve (the STEP writer's
    // `same_sense = .T.` contract), so carriers referenced only by reversed
    // edges are reversed in place; a carrier shared across both senses keeps
    // its forward orientation and reversed edges point at a `:reversed`
    // clone emitted beside it.
    let mut reversed_curve_refs: HashSet<i64> = HashSet::new();
    let mut forward_curve_refs: HashSet<i64> = HashSet::new();
    for r in records {
        if r.head != "edge" || !kept_edges.contains(&(r.index as i64)) {
            continue;
        }
        let Some(curve) = r.ref_at(8).filter(|c| kept_curves.contains(c)) else {
            continue;
        };
        match sense_at(r, 9) {
            Sense::Reversed => reversed_curve_refs.insert(curve),
            Sense::Forward => forward_curve_refs.insert(curve),
        };
    }
    let reversed_curve_id = |c: i64| {
        if reversed_curve_refs.contains(&c) && forward_curve_refs.contains(&c) {
            CurveId(format!("{}:reversed", id(c)))
        } else {
            CurveId(id(c))
        }
    };

    // Pass 3: emit carriers, points, and the reachable topology graph in
    // RecordTable order for deterministic output.
    for r in records {
        let i = r.index as i64;
        match r.head.as_str() {
            _ if kept_surfaces.contains(&i) => {
                // A record index appears at most once in `records`; a duplicate
                // would have consumed the entry already, so skip rather than panic.
                let Some((geometry, _)) = surface_geo.remove(&i) else {
                    continue;
                };
                out.surfaces.push(Surface {
                    id: SurfaceId(id(i)),
                    geometry,
                });
                if let Some(procedural) = procedural_surface_defs.remove(&i) {
                    let definition = match procedural.definition {
                        nurbs::DecodedProceduralSurfaceDefinition::Extrusion {
                            directrix,
                            direction,
                        } => {
                            let directrix_id =
                                CurveId(format!("f3d:brep:procedural_surface#{i}:directrix"));
                            out.curves.push(Curve {
                                id: directrix_id.clone(),
                                geometry: CurveGeometry::Nurbs(directrix),
                            });
                            ProceduralSurfaceDefinition::Extrusion {
                                directrix: directrix_id,
                                direction,
                            }
                        }
                        nurbs::DecodedProceduralSurfaceDefinition::Blend {
                            supports,
                            spine,
                            radius,
                            cross_section,
                        } => {
                            let mut resolved_supports = [None, None];
                            for (side, support) in supports.into_iter().enumerate() {
                                if let Some(support) = support {
                                    let support_id = SurfaceId(format!(
                                        "f3d:brep:procedural_surface#{i}:support#{side}"
                                    ));
                                    out.surfaces.push(Surface {
                                        id: support_id.clone(),
                                        geometry: SurfaceGeometry::Nurbs(support),
                                    });
                                    resolved_supports[side] = Some(BlendSupport {
                                        surface: support_id,
                                        reversed: false,
                                    });
                                }
                            }
                            let spine = spine.map(|spine| {
                                let spine_id =
                                    CurveId(format!("f3d:brep:procedural_surface#{i}:spine"));
                                out.curves.push(Curve {
                                    id: spine_id.clone(),
                                    geometry: CurveGeometry::Nurbs(spine),
                                });
                                spine_id
                            });
                            if resolved_supports
                                .iter()
                                .filter(|support| support.is_some())
                                .count()
                                == 1
                            {
                                out.stats.partial_procedural_supports += 1;
                            }
                            ProceduralSurfaceDefinition::Blend {
                                supports: resolved_supports,
                                spine,
                                radius,
                                cross_section,
                            }
                        }
                    };
                    out.procedural_surfaces.push(ProceduralSurface {
                        id: format!("f3d:brep:procedural_surface#{i}").into(),
                        surface: SurfaceId(id(i)),
                        definition,
                        cache_fit_tolerance: procedural.cache_fit_tolerance,
                    });
                }
            }
            _ if unknown_surface_records.contains(&i) => {
                // Topology-known face on an undecoded surface: emit an opaque
                // carrier linking to the preserved record bytes, marked Unknown.
                out.surfaces.push(Surface {
                    id: SurfaceId(id(i)),
                    geometry: SurfaceGeometry::Unknown {
                        record: Some(UnknownId(unknown_record_id(r))),
                    },
                });
            }
            _ if kept_curves.contains(&i) => {
                let Some(mut geometry) = curve_geo.remove(&i) else {
                    continue;
                };
                if reversed_curve_refs.contains(&i) {
                    if forward_curve_refs.contains(&i) {
                        let mut reversed = geometry.clone();
                        reverse_curve_geometry(&mut reversed);
                        out.curves.push(Curve {
                            id: CurveId(format!("{}:reversed", id(i))),
                            geometry: reversed,
                        });
                    } else {
                        reverse_curve_geometry(&mut geometry);
                    }
                }
                out.curves.push(Curve {
                    id: CurveId(id(i)),
                    geometry,
                });
                if let Some(procedural) = procedural_curve_defs.remove(&i) {
                    let definition = if let Some((source, parameter_range, offset, labels, codes)) =
                        procedural.2
                    {
                        let source_id = CurveId(format!("f3d:brep:procedural_curve#{i}:source"));
                        out.curves.push(Curve {
                            id: source_id.clone(),
                            geometry: CurveGeometry::Nurbs(source),
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::VectorOffset {
                            source: source_id,
                            parameter_range,
                            offset,
                            labels,
                            codes,
                        }
                    } else if let Some((source, parameter_range)) = procedural.3 {
                        let source_id = CurveId(format!("f3d:brep:procedural_curve#{i}:source"));
                        out.curves.push(Curve {
                            id: source_id.clone(),
                            geometry: CurveGeometry::Nurbs(source),
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::Subset {
                            source: source_id,
                            parameter_range,
                        }
                    } else if let Some(embedded) = procedural.5 {
                        let surfaces: [Option<SurfaceId>; 2] = embedded
                            .surfaces
                            .into_iter()
                            .enumerate()
                            .map(|(side, geometry)| {
                                let id = SurfaceId(format!(
                                    "f3d:brep:procedural_curve#{i}:support#{side}"
                                ));
                                out.surfaces.push(Surface {
                                    id: id.clone(),
                                    geometry,
                                });
                                Some(id)
                            })
                            .collect::<Vec<_>>()
                            .try_into()
                            .expect("two fixed support sides");
                        let pcurves = embedded.pcurves.map(|pcurve| {
                            Some(PcurveGeometry::Nurbs {
                                degree: pcurve.degree,
                                knots: pcurve.knots,
                                control_points: pcurve.control_points,
                                weights: pcurve.weights,
                                periodic: pcurve.periodic,
                            })
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::TwoSidedOffset {
                            context: cadmpeg_ir::geometry::IntcurveSupportContext {
                                sides: std::array::from_fn(|side| {
                                    cadmpeg_ir::geometry::IntcurveSupportSide {
                                        surface: surfaces[side].clone(),
                                        pcurve: pcurves[side].clone(),
                                    }
                                }),
                                parameter_range: embedded.parameter_range,
                                discontinuities: embedded.discontinuities,
                            },
                            offsets: embedded.offsets,
                        }
                    } else if let Some(embedded) = procedural.6 {
                        let surfaces: [Option<SurfaceId>; 2] = embedded
                            .surfaces
                            .into_iter()
                            .enumerate()
                            .map(|(side, geometry)| {
                                let id = SurfaceId(format!(
                                    "f3d:brep:procedural_curve#{i}:support#{side}"
                                ));
                                out.surfaces.push(Surface {
                                    id: id.clone(),
                                    geometry,
                                });
                                Some(id)
                            })
                            .collect::<Vec<_>>()
                            .try_into()
                            .expect("two fixed support sides");
                        let pcurves = embedded.pcurves.map(|pcurve| {
                            Some(PcurveGeometry::Nurbs {
                                degree: pcurve.degree,
                                knots: pcurve.knots,
                                control_points: pcurve.control_points,
                                weights: pcurve.weights,
                                periodic: pcurve.periodic,
                            })
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::Intersection {
                            context: cadmpeg_ir::geometry::IntcurveSupportContext {
                                sides: std::array::from_fn(|side| {
                                    cadmpeg_ir::geometry::IntcurveSupportSide {
                                        surface: surfaces[side].clone(),
                                        pcurve: pcurves[side].clone(),
                                    }
                                }),
                                parameter_range: embedded.parameter_range,
                                discontinuities: embedded.discontinuities,
                            },
                        }
                    } else if let Some(embedded) = procedural.7 {
                        let surface_ids: [SurfaceId; 3] = embedded
                            .surfaces
                            .into_iter()
                            .enumerate()
                            .map(|(side, geometry)| {
                                let id = SurfaceId(format!(
                                    "f3d:brep:procedural_curve#{i}:support#{side}"
                                ));
                                out.surfaces.push(Surface {
                                    id: id.clone(),
                                    geometry,
                                });
                                id
                            })
                            .collect::<Vec<_>>()
                            .try_into()
                            .expect("three fixed support sides");
                        let pcurves = embedded.pcurves.map(|pcurve| PcurveGeometry::Nurbs {
                            degree: pcurve.degree,
                            knots: pcurve.knots,
                            control_points: pcurve.control_points,
                            weights: pcurve.weights,
                            periodic: pcurve.periodic,
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::ThreeSurfaceIntersection {
                            context: cadmpeg_ir::geometry::IntcurveSupportContext {
                                sides: std::array::from_fn(|side| {
                                    cadmpeg_ir::geometry::IntcurveSupportSide {
                                        surface: Some(surface_ids[side].clone()),
                                        pcurve: Some(pcurves[side].clone()),
                                    }
                                }),
                                parameter_range: embedded.parameter_range,
                                discontinuities: embedded.discontinuities,
                            },
                            selector: embedded.selector,
                            third: cadmpeg_ir::geometry::IntcurveSupportSide {
                                surface: Some(surface_ids[2].clone()),
                                pcurve: Some(pcurves[2].clone()),
                            },
                        }
                    } else if let Some((family, embedded)) = procedural.8 {
                        let surfaces: [Option<SurfaceId>; 2] = embedded
                            .surfaces
                            .into_iter()
                            .enumerate()
                            .map(|(side, geometry)| {
                                let id = SurfaceId(format!(
                                    "f3d:brep:procedural_curve#{i}:support#{side}"
                                ));
                                out.surfaces.push(Surface {
                                    id: id.clone(),
                                    geometry,
                                });
                                Some(id)
                            })
                            .collect::<Vec<_>>()
                            .try_into()
                            .expect("two fixed support sides");
                        let pcurves = embedded.pcurves.map(|pcurve| {
                            Some(PcurveGeometry::Nurbs {
                                degree: pcurve.degree,
                                knots: pcurve.knots,
                                control_points: pcurve.control_points,
                                weights: pcurve.weights,
                                periodic: pcurve.periodic,
                            })
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::SurfaceCurve {
                            family,
                            context: cadmpeg_ir::geometry::IntcurveSupportContext {
                                sides: std::array::from_fn(|side| {
                                    cadmpeg_ir::geometry::IntcurveSupportSide {
                                        surface: surfaces[side].clone(),
                                        pcurve: pcurves[side].clone(),
                                    }
                                }),
                                parameter_range: embedded.parameter_range,
                                discontinuities: embedded.discontinuities,
                            },
                        }
                    } else if let Some(embedded) = procedural.9 {
                        let surfaces: [Option<SurfaceId>; 2] = embedded
                            .surfaces
                            .into_iter()
                            .enumerate()
                            .map(|(side, geometry)| {
                                let id = SurfaceId(format!(
                                    "f3d:brep:procedural_curve#{i}:support#{side}"
                                ));
                                out.surfaces.push(Surface {
                                    id: id.clone(),
                                    geometry,
                                });
                                Some(id)
                            })
                            .collect::<Vec<_>>()
                            .try_into()
                            .expect("two fixed support sides");
                        let pcurves = embedded.pcurves.map(|pcurve| {
                            Some(PcurveGeometry::Nurbs {
                                degree: pcurve.degree,
                                knots: pcurve.knots,
                                control_points: pcurve.control_points,
                                weights: pcurve.weights,
                                periodic: pcurve.periodic,
                            })
                        });
                        let source = CurveId(format!("f3d:brep:procedural_curve#{i}:source"));
                        out.curves.push(Curve {
                            id: source.clone(),
                            geometry: CurveGeometry::Nurbs(embedded.source),
                        });
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::Projection {
                            context: cadmpeg_ir::geometry::IntcurveSupportContext {
                                sides: std::array::from_fn(|side| {
                                    cadmpeg_ir::geometry::IntcurveSupportSide {
                                        surface: surfaces[side].clone(),
                                        pcurve: pcurves[side].clone(),
                                    }
                                }),
                                parameter_range: embedded.parameter_range,
                                discontinuities: embedded.discontinuities,
                            },
                            source,
                            tail: embedded.tail,
                        }
                    } else if let Some((parameters, component_parameters, components)) =
                        procedural.4
                    {
                        let components = components
                            .into_iter()
                            .enumerate()
                            .map(|(component, curve)| {
                                let id = CurveId(format!(
                                    "f3d:brep:procedural_curve#{i}:component#{component}"
                                ));
                                out.curves.push(Curve {
                                    id: id.clone(),
                                    geometry: CurveGeometry::Nurbs(curve),
                                });
                                id
                            })
                            .collect();
                        cadmpeg_ir::geometry::ProceduralCurveDefinition::Compound {
                            parameters,
                            component_parameters,
                            components,
                        }
                    } else {
                        procedural.1.unwrap_or(
                            cadmpeg_ir::geometry::ProceduralCurveDefinition::Unknown {
                                record: None,
                            },
                        )
                    };
                    out.procedural_curves.push(ProceduralCurve {
                        id: format!("f3d:brep:procedural_curve#{i}").into(),
                        curve: CurveId(id(i)),
                        definition,
                        cache_fit_tolerance: procedural.10,
                    });
                }
            }
            _ => {}
        }
    }

    for r in records {
        let i = r.index as i64;
        if kept_pcurves.contains(&i) {
            if let Some(geometry) = pcurve_geo.remove(&i) {
                out.pcurves.push(Pcurve {
                    id: PcurveId(id(i)),
                    geometry,
                    wrapper_reversed: match r.chunk(4) {
                        Some(Token::True) if matches!(r.chunk(3), Some(Token::Long(0))) => {
                            Some(true)
                        }
                        Some(Token::False) if matches!(r.chunk(3), Some(Token::Long(0))) => {
                            Some(false)
                        }
                        _ => None,
                    },
                    parameter_range: if matches!(
                        r.chunk(4),
                        Some(Token::True | Token::False | Token::Ref(_))
                    ) {
                        let values = r
                            .tokens
                            .iter()
                            .filter_map(|token| match token {
                                Token::Double(value) => Some(*value),
                                _ => None,
                            })
                            .collect::<Vec<_>>();
                        values
                            .get(values.len().saturating_sub(2)..)
                            .filter(|values| values.len() == 2)
                            .map(|values| [values[0], values[1]])
                    } else {
                        None
                    },
                    fit_tolerance: matches!(r.chunk(4), Some(Token::True | Token::False))
                        .then(|| nurbs::decode_pcurve_fit_tolerance(record_slice(r, bytes)))
                        .flatten(),
                });
            }
        }
    }
    for r in records {
        let i = r.index as i64;
        if r.head == "point" && kept_points.contains(&i) {
            let c = collect_carrier(r);
            if let Some(p) = c.positions.first() {
                out.points.push(Point {
                    id: PointId(id(i)),
                    position: scale_point(*p),
                });
            }
        }
    }

    for r in records {
        let i = r.index as i64;
        if r.head == "vertex" && kept_vertices.contains(&i) {
            if let Some(pi) = r.ref_at(5) {
                if kept_points.contains(&pi) {
                    out.vertices.push(Vertex {
                        id: VertexId(id(i)),
                        point: PointId(id(pi)),
                        tolerance: None,
                    });
                }
            }
        }
    }

    for r in records {
        let i = r.index as i64;
        if r.head == "edge" && kept_edges.contains(&i) {
            let (Some(start), Some(end)) = (r.ref_at(3), r.ref_at(5)) else {
                continue;
            };
            if !kept_vertices.contains(&start) || !kept_vertices.contains(&end) {
                continue;
            }
            let curve = r.ref_at(8).filter(|c| kept_curves.contains(c));
            let param_range = match (double_at(r, 4), double_at(r, 6)) {
                (Some(mut a), Some(mut b)) => {
                    if let Some(curve_record) = curve.and_then(|curve| by_index.get(&curve)) {
                        if curve_record.head == "ellipse" {
                            // Native conic parameters are angles from the
                            // major axis, matching the IR carrier's own
                            // parameterization directly.
                            if (b - a).abs() >= std::f64::consts::TAU - 1.0e-12 {
                                a = 0.0;
                                b = std::f64::consts::TAU;
                            } else {
                                // Wrap the arc start into the canonical
                                // `[0, τ)` domain, preserving the sweep.
                                let sweep = b - a;
                                a = a.rem_euclid(std::f64::consts::TAU);
                                if std::f64::consts::TAU - a < 1.0e-9 {
                                    a = 0.0;
                                }
                                b = a + sweep;
                            }
                        } else if curve_record.head == "straight" {
                            // Native line parameters are arc lengths in
                            // centimeters; the IR carrier's unit direction
                            // lives in millimeter space.
                            a *= LEN_TO_MM;
                            b *= LEN_TO_MM;
                        }
                    }
                    Some([a, b])
                }
                _ => None,
            };
            // A reversed edge's raw parameters already live on the reversed
            // parameterization its (reversed) carrier now exposes, so the
            // range transforms identically for both senses; only the carrier
            // link differs when the curve is shared across senses.
            let curve = curve.map(|c| match sense_at(r, 9) {
                Sense::Reversed => reversed_curve_id(c),
                Sense::Forward => CurveId(id(c)),
            });
            out.edges.push(Edge {
                id: EdgeId(id(i)),
                curve,
                start: VertexId(id(start)),
                end: VertexId(id(end)),
                param_range,
                tolerance: None,
            });
        }
    }

    for r in records {
        let i = r.index as i64;
        if r.head == "coedge" && kept_coedges.contains(&i) {
            let (Some(next), Some(prev), Some(edge), Some(owner)) =
                (r.ref_at(3), r.ref_at(4), r.ref_at(6), r.ref_at(8))
            else {
                continue;
            };
            if !kept_coedges.contains(&next)
                || !kept_coedges.contains(&prev)
                || !kept_edges.contains(&edge)
                || !kept_loops.contains(&owner)
            {
                continue;
            }
            let partner = r.ref_at(5).filter(|p| kept_coedges.contains(p));
            out.coedges.push(Coedge {
                id: CoedgeId(id(i)),
                owner_loop: LoopId(id(owner)),
                edge: EdgeId(id(edge)),
                next: CoedgeId(id(next)),
                previous: CoedgeId(id(prev)),
                radial_next: partner.map_or_else(|| CoedgeId(id(i)), |p| CoedgeId(id(p))),
                sense: sense_at(r, 7),
                pcurve: r
                    .ref_at(10)
                    .filter(|p| kept_pcurves.contains(p))
                    .map(|p| PcurveId(id(p))),
            });
        }
    }

    for r in records {
        let i = r.index as i64;
        if r.head == "loop" && kept_loops.contains(&i) {
            let Some(owner) = r.ref_at(5) else { continue };
            let coedges = ring_coedges(r, &by_index, &kept_coedges);
            out.loops.push(Loop {
                id: LoopId(id(i)),
                face: FaceId(id(owner)),
                coedges,
            });
        }
    }

    for r in records {
        let i = r.index as i64;
        if r.head == "face" && kept_faces.contains(&i) {
            let (Some(surface), Some(owner)) = (r.ref_at(7), r.ref_at(5)) else {
                continue;
            };
            let loops = loop_chain(r, &by_index, &kept_loops);
            // The face record's sense is relative to its surface record's
            // orientation. A reversed spline record flips the cache normal,
            // and a negative-cosine cone points its normal toward the axis;
            // the IR stores the forward carrier in both cases, so the
            // reversal folds into the face sense to keep the IR
            // self-consistent.
            let mut sense = sense_at(r, 8);
            if by_index
                .get(&surface)
                .is_some_and(|surf| surf.head == "spline" && record_reversed(surf))
                ^ inward_normal_surfaces.contains(&surface)
            {
                sense = match sense {
                    Sense::Forward => Sense::Reversed,
                    Sense::Reversed => Sense::Forward,
                };
            }
            out.faces.push(Face {
                id: FaceId(id(i)),
                shell: ShellId(id(owner)),
                surface: SurfaceId(id(surface)),
                sense,
                loops,
                name: None,
                color: attribute_color(r),
                tolerance: None,
            });
        }
    }

    // Containers: emitted for every record so back-references resolve, with
    // child lists filtered to reachable entities.
    for r in records {
        let i = r.index as i64;
        match r.head.as_str() {
            "shell" => {
                let Some(owner) = r.ref_at(7) else { continue };
                let faces = face_chain(r, &by_index, &kept_faces);
                out.shells.push(Shell {
                    id: ShellId(id(i)),
                    region: RegionId(id(owner)),
                    faces,
                    wire_edges: wire_edges_by_shell
                        .get(&i)
                        .into_iter()
                        .flatten()
                        .map(|edge| EdgeId(id(*edge)))
                        .collect(),
                    free_vertices: Vec::new(),
                });
            }
            // ASM release 231 names this record `region`; release 227 streams
            // carry the original ACIS head `lump`. Same layout in both.
            "region" | "lump" => {
                let Some(owner) = r.ref_at(5) else { continue };
                let shells = shell_chain(r, &by_index);
                out.regions.push(Region {
                    id: RegionId(id(i)),
                    body: BodyId(id(owner)),
                    shells,
                });
            }
            "body" => {
                let regions = region_chain(r, &by_index);
                let body_id = BodyId(id(i));
                if let Some(Token::Long(key)) = r.chunk(1) {
                    if *key >= 0 {
                        out.body_keys.insert(body_id.clone(), *key as u64);
                    }
                }
                out.bodies.push(Body {
                    id: body_id,
                    kind: cadmpeg_ir::topology::BodyKind::Solid,
                    regions,
                    transform: r
                        .ref_at(5)
                        .and_then(|reference| by_index.get(&reference))
                        .and_then(|transform| decode_transform(transform, header_scale)),
                    name: None,
                    color: attribute_color(r),
                });
            }
            _ => {}
        }
    }

    let mut emitted_attributes = HashSet::new();
    for record in records {
        let index = record.index as i64;
        let target = match record.head.as_str() {
            "body" if out.bodies.iter().any(|entity| entity.id.0 == id(index)) => {
                Some(AttributeTarget::Body(BodyId(id(index))))
            }
            "face" if kept_faces.contains(&index) => Some(AttributeTarget::Face(FaceId(id(index)))),
            "coedge" if kept_coedges.contains(&index) => {
                Some(AttributeTarget::Coedge(CoedgeId(id(index))))
            }
            "edge" if kept_edges.contains(&index) => Some(AttributeTarget::Edge(EdgeId(id(index)))),
            "vertex" if kept_vertices.contains(&index) => {
                Some(AttributeTarget::Vertex(VertexId(id(index))))
            }
            _ => None,
        };
        if let Some(target) = target {
            collect_attributes(
                record,
                &target,
                &by_index,
                &mut emitted_attributes,
                &mut out.attributes,
            );
        }
    }

    for record in records {
        let index = record.index as i64;
        if record.name != "ATTRIB_CUSTOM-attrib" || emitted_attributes.contains(&index) {
            continue;
        }
        let Some(owner) = record.ref_at(4).and_then(|owner| by_index.get(&owner)) else {
            continue;
        };
        let owner_index = owner.index as i64;
        let target = match owner.head.as_str() {
            "body" => Some(AttributeTarget::Body(BodyId(id(owner_index)))),
            "face" if kept_faces.contains(&owner_index) => {
                Some(AttributeTarget::Face(FaceId(id(owner_index))))
            }
            "coedge" if kept_coedges.contains(&owner_index) => {
                Some(AttributeTarget::Coedge(CoedgeId(id(owner_index))))
            }
            "edge" if kept_edges.contains(&owner_index) => {
                Some(AttributeTarget::Edge(EdgeId(id(owner_index))))
            }
            "vertex" if kept_vertices.contains(&owner_index) => {
                Some(AttributeTarget::Vertex(VertexId(id(owner_index))))
            }
            _ => None,
        };
        if let Some(target) = target {
            emitted_attributes.insert(index);
            out.attributes.push(source_attribute(record, target));
        }
    }
    out.sketch_curve_links = out
        .attributes
        .iter()
        .filter_map(sketch_curve_link)
        .collect();
    out.persistent_design_links = out
        .attributes
        .iter()
        .flat_map(persistent_design_links)
        .collect();

    // Preserve undecoded carriers referenced by real topology as passthrough.
    for r in records {
        let i = r.index as i64;
        if undecoded_carriers.contains(&i) {
            out.unknowns.push(UnknownRecord {
                id: UnknownId(unknown_record_id(r)),
                offset: r.offset as u64,
                byte_len: r.len as u64,
                sha256: sha256_hex(&bytes[r.offset..(r.offset + r.len).min(bytes.len())]),
                data: Some(bytes[r.offset..(r.offset + r.len).min(bytes.len())].to_vec()),
                links: Vec::new(),
            });
        }
    }

    // Count remaining record kinds we neither emitted nor preserved.
    let kept_transforms: HashSet<i64> = records
        .iter()
        .filter(|record| record.head == "body")
        .filter_map(|record| record.ref_at(5))
        .collect();
    let pcurve_intcurves: HashSet<i64> = records
        .iter()
        .filter(|record| kept_pcurves.contains(&(record.index as i64)))
        .filter_map(|record| record.ref_at(4))
        .collect();
    let known_head = |h: &str| {
        matches!(
            h,
            "body"
                | "region"
                | "lump"
                | "shell"
                | "face"
                | "loop"
                | "coedge"
                | "edge"
                | "vertex"
                | "point"
        ) || is_analytic_surface(h)
            || is_analytic_curve(h)
            || h == "asmheader"
    };
    for r in records {
        let i = r.index as i64;
        // Spline/intcurve records that decoded into a NURBS carrier are counted
        // as transferred, not as opaque leftovers.
        let transferred = kept_surfaces.contains(&i)
            || kept_curves.contains(&i)
            || kept_pcurves.contains(&i)
            || kept_transforms.contains(&i)
            || emitted_attributes.contains(&i)
            || pcurve_intcurves.contains(&i);
        if !known_head(&r.head)
            && r.name != "Begin-of-ASM-History-Data"
            && !undecoded_carriers.contains(&i)
            && !transferred
        {
            out.stats.other_records += 1;
            *out.stats
                .other_record_kinds
                .entry(r.name.clone())
                .or_default() += 1;
        }
    }

    let emitted_ids = out
        .bodies
        .iter()
        .map(|entity| entity.id.0.as_str())
        .chain(out.regions.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.shells.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.faces.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.loops.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.coedges.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.edges.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.vertices.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.points.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.surfaces.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.curves.iter().map(|entity| entity.id.0.as_str()))
        .chain(out.pcurves.iter().map(|entity| entity.id.0.as_str()))
        .collect::<HashSet<_>>();
    for record in records {
        let entity_id = id(record.index as i64);
        if emitted_ids.contains(entity_id.as_str()) {
            let mut derived_fields = Vec::new();
            match record.head.as_str() {
                "plane" => {
                    derived_fields.extend(["geometry.normal", "geometry.u_axis"]);
                }
                "cone" => {
                    derived_fields.extend(["geometry.axis", "geometry.ref_direction"]);
                }
                "sphere" => {
                    derived_fields.extend(["geometry.axis", "geometry.ref_direction"]);
                }
                "torus" => {
                    derived_fields.extend(["geometry.axis", "geometry.ref_direction"]);
                }
                "straight" => derived_fields.push("geometry.direction"),
                "ellipse" => {
                    derived_fields.extend(["geometry.axis", "geometry.major_direction"]);
                }
                _ => {}
            }
            if record.head == "edge" {
                if let Some(curve) = record
                    .ref_at(8)
                    .and_then(|reference| by_index.get(&reference))
                {
                    if curve.head == "ellipse" {
                        derived_fields.push("param_range");
                    }
                }
            }
            out.annotation_records.push(AnnotationRecord {
                id: entity_id,
                offset: record.offset as u64,
                tag: record.name.clone(),
                derived_fields,
            });
        }
        let attribute_id = format!("f3d:brep:attribute#{}", record.index);
        if out
            .attributes
            .iter()
            .any(|attribute| attribute.id.0 == attribute_id)
        {
            out.annotation_records.push(AnnotationRecord {
                id: attribute_id,
                offset: record.offset as u64,
                tag: record.name.clone(),
                derived_fields: Vec::new(),
            });
        }
        let unknown_id = unknown_record_id(record);
        if out
            .unknowns
            .iter()
            .any(|unknown| unknown.id.0 == unknown_id)
        {
            out.annotation_records.push(AnnotationRecord {
                id: unknown_id,
                offset: record.offset as u64,
                tag: record.name.clone(),
                derived_fields: Vec::new(),
            });
        }
        for (synthetic_id, tag) in [
            (
                format!("f3d:brep:procedural_surface#{}", record.index),
                "procedural_surface",
            ),
            (
                format!("f3d:brep:procedural_curve#{}", record.index),
                "procedural_curve",
            ),
        ] {
            if out
                .procedural_surfaces
                .iter()
                .any(|entity| entity.id.0 == synthetic_id)
                || out
                    .procedural_curves
                    .iter()
                    .any(|entity| entity.id.0 == synthetic_id)
            {
                out.annotation_records.push(AnnotationRecord {
                    id: synthetic_id,
                    offset: record.offset as u64,
                    tag: tag.into(),
                    derived_fields: Vec::new(),
                });
            }
        }
    }
    for (entity_id, tag) in out
        .surfaces
        .iter()
        .map(|entity| (entity.id.0.as_str(), "procedural_support"))
        .chain(
            out.curves
                .iter()
                .map(|entity| (entity.id.0.as_str(), "procedural_curve_child")),
        )
    {
        if !entity_id.starts_with("f3d:brep:procedural_surface#") {
            continue;
        }
        let Some(index) = entity_id
            .split_once('#')
            .and_then(|(_, suffix)| suffix.split(':').next())
            .and_then(|value| value.parse::<usize>().ok())
        else {
            continue;
        };
        let Some(record) = records.get(index) else {
            continue;
        };
        out.annotation_records.push(AnnotationRecord {
            id: entity_id.to_owned(),
            offset: record.offset as u64,
            tag: tag.into(),
            derived_fields: Vec::new(),
        });
    }

    classify_body_kinds(&mut out);

    out
}

fn classify_body_kinds(out: &mut Brep) {
    for body in &mut out.bodies {
        let shell_ids = out
            .regions
            .iter()
            .filter(|region| region.body == body.id)
            .flat_map(|region| &region.shells)
            .collect::<HashSet<_>>();
        let face_ids = out
            .shells
            .iter()
            .filter(|shell| shell_ids.contains(&shell.id))
            .flat_map(|shell| &shell.faces)
            .collect::<HashSet<_>>();
        let has_wire_edges = out
            .shells
            .iter()
            .filter(|shell| shell_ids.contains(&shell.id))
            .any(|shell| !shell.wire_edges.is_empty());
        if face_ids.is_empty() {
            body.kind = cadmpeg_ir::topology::BodyKind::Wire;
            continue;
        }
        if has_wire_edges {
            body.kind = cadmpeg_ir::topology::BodyKind::General;
            continue;
        }
        let loop_ids = out
            .faces
            .iter()
            .filter(|face| face_ids.contains(&face.id))
            .flat_map(|face| &face.loops)
            .collect::<HashSet<_>>();
        let coedge_ids = out
            .loops
            .iter()
            .filter(|loop_| loop_ids.contains(&loop_.id))
            .flat_map(|loop_| &loop_.coedges)
            .collect::<HashSet<_>>();
        let mut edge_use_counts = HashMap::<&EdgeId, usize>::new();
        for coedge in out
            .coedges
            .iter()
            .filter(|coedge| coedge_ids.contains(&coedge.id))
        {
            *edge_use_counts.entry(&coedge.edge).or_default() += 1;
        }
        body.kind =
            if !edge_use_counts.is_empty() && edge_use_counts.values().all(|count| *count == 2) {
                cadmpeg_ir::topology::BodyKind::Solid
            } else {
                cadmpeg_ir::topology::BodyKind::Sheet
            };
    }
}

fn sketch_curve_link(attribute: &SourceAttribute) -> Option<SketchCurveLink> {
    let AttributeTarget::Coedge(coedge) = &attribute.target else {
        return None;
    };
    let family = attribute.values.iter().position(
        |value| matches!(value, AttributeValue::String(name) if name == "sketch_attrib_def"),
    )?;
    let fields = attribute.values[family + 1..]
        .iter()
        .filter_map(|value| match value {
            AttributeValue::String(payload) => Some(
                payload
                    .split_ascii_whitespace()
                    .map(str::parse::<i64>)
                    .collect::<Result<Vec<_>, _>>()
                    .ok(),
            ),
            _ => None,
        })
        .flatten()
        .find(|values| values.len() == 6)
        .unwrap_or_else(|| {
            attribute.values[family + 1..]
                .iter()
                .filter_map(|value| match value {
                    AttributeValue::Integer(value) => Some(*value),
                    _ => None,
                })
                .take(6)
                .collect()
        });
    let [sketch_curve_id, 0, signed_reference, 0, role, closure] = fields.as_slice() else {
        return None;
    };
    Some(SketchCurveLink {
        id: format!("f3d:design:sketch-curve-link#{}", attribute_key(attribute)),
        coedge: coedge.clone(),
        sketch_curve_id: *sketch_curve_id,
        signed_reference: (*signed_reference != -1).then_some(*signed_reference),
        role: *role,
        closure: *closure,
    })
}

fn persistent_design_links(attribute: &SourceAttribute) -> Vec<PersistentDesignLink> {
    let Some(family) = attribute.values.iter().position(
        |value| matches!(value, AttributeValue::String(name) if name == "generic_tag_attrib_def"),
    ) else {
        return Vec::new();
    };
    let ids: Vec<String> = attribute.values[family + 1..]
        .iter()
        .filter_map(|value| match value {
            AttributeValue::String(value)
                if value.trim() != "generic_tag_attrib_def"
                    && !value.is_empty()
                    && value.bytes().all(|byte| byte.is_ascii_digit()) =>
            {
                Some(value.clone())
            }
            _ => None,
        })
        .collect();
    let last = ids.len().saturating_sub(1);
    ids.into_iter()
        .enumerate()
        .map(|(ordinal, design_id)| PersistentDesignLink {
            id: format!(
                "f3d:design:persistent-design-link#{}:{ordinal}",
                attribute_key(attribute)
            ),
            target: attribute.target.clone(),
            design_id,
            ordinal: ordinal as u32,
            is_current: ordinal == last,
        })
        .collect()
}

fn collect_attributes(
    entity: &Record,
    target: &AttributeTarget,
    by_index: &HashMap<i64, &Record>,
    emitted: &mut HashSet<i64>,
    out: &mut Vec<SourceAttribute>,
) {
    let mut current = entity.ref_at(0);
    let mut chain = HashSet::new();
    while let Some(index) = current.filter(|index| chain.insert(*index)) {
        let Some(record) = by_index.get(&index) else {
            break;
        };
        if emitted.insert(index) {
            out.push(source_attribute(record, target.clone()));
        }
        current = record.ref_at(0);
    }
}

/// The numeric record-index key of an attribute id
/// (`f3d:brep:attribute#<index>`), used to key records derived from that
/// attribute.
fn attribute_key(attribute: &SourceAttribute) -> &str {
    attribute
        .id
        .0
        .rsplit('#')
        .next()
        .unwrap_or(attribute.id.0.as_str())
}

fn source_attribute(record: &Record, target: AttributeTarget) -> SourceAttribute {
    SourceAttribute {
        id: AttributeId(format!("f3d:brep:attribute#{}", record.index)),
        target,
        name: record.name.clone(),
        values: record.tokens.iter().map(attribute_value).collect(),
    }
}

fn attribute_value(token: &Token) -> AttributeValue {
    match token {
        Token::Char(value) => AttributeValue::Integer(i64::from(*value)),
        Token::Short(value) => AttributeValue::Integer(i64::from(*value)),
        Token::Long(value) | Token::Enum(value) | Token::Int64(value) => {
            AttributeValue::Integer(*value)
        }
        Token::Float(value) => AttributeValue::Float(f64::from(*value)),
        Token::Double(value) => AttributeValue::Float(*value),
        Token::Str(value) => AttributeValue::String(value.clone()),
        Token::True => AttributeValue::Boolean(true),
        Token::False => AttributeValue::Boolean(false),
        Token::Ref(value) => AttributeValue::Reference(format!("f3d:brep:entity#{value}")),
        Token::SubtypeOpen => AttributeValue::String("subtype_open".into()),
        Token::SubtypeClose => AttributeValue::String("subtype_close".into()),
        Token::Position(value) | Token::Vector3(value) => AttributeValue::Vector(value.to_vec()),
        Token::Vector2(value) => AttributeValue::Vector(value.to_vec()),
    }
}

pub(crate) fn decode_transform(
    record: &Record,
    header_scale: f64,
) -> Option<cadmpeg_ir::transform::Transform> {
    let vectors: Vec<[f64; 3]> = record
        .tokens
        .iter()
        .filter_map(|token| match token {
            Token::Position(value) | Token::Vector3(value) => Some(*value),
            _ => None,
        })
        .collect();
    let scale = record
        .tokens
        .iter()
        .filter_map(|token| match token {
            Token::Double(value) => Some(*value),
            _ => None,
        })
        .next_back()?;
    let [x, y, z, translation] = vectors.as_slice() else {
        return None;
    };
    Some(cadmpeg_ir::transform::Transform {
        rows: [
            [x[0], y[0], z[0], translation[0] * header_scale * LEN_TO_MM],
            [x[1], y[1], z[1], translation[1] * header_scale * LEN_TO_MM],
            [x[2], y[2], z[2], translation[2] * header_scale * LEN_TO_MM],
            [0.0, 0.0, 0.0, scale],
        ],
    })
}

pub(crate) fn attribute_chain_color(
    entity: &Record,
    by_index: &HashMap<i64, &Record>,
) -> Option<Color> {
    let mut current = entity.ref_at(0)?;
    let mut seen = HashSet::new();
    while seen.insert(current) {
        let record = by_index.get(&current)?;
        if record.name.contains("rgb_color") {
            let values: Vec<f64> = record
                .tokens
                .iter()
                .filter_map(|t| match t {
                    Token::Double(value) => Some(*value),
                    _ => None,
                })
                .collect();
            if let [r, g, b, ..] = values.as_slice() {
                if [*r, *g, *b].iter().all(|value| (0.0..=1.0).contains(value)) {
                    return Some(Color {
                        r: *r as f32,
                        g: *g as f32,
                        b: *b as f32,
                        a: 1.0,
                    });
                }
            }
        } else if record.name.contains("truecolor") {
            let packed = record.tokens.iter().find_map(|token| match token {
                Token::Int64(value) | Token::Long(value) => Some(*value as u32),
                _ => None,
            })?;
            return Some(Color {
                r: ((packed >> 16) & 0xff) as f32 / 255.0,
                g: ((packed >> 8) & 0xff) as f32 / 255.0,
                b: (packed & 0xff) as f32 / 255.0,
                a: ((packed >> 24) & 0xff) as f32 / 255.0,
            });
        }
        current = record.ref_at(0)?;
    }
    None
}

/// The raw bytes of a record within the decompressed stream.
fn record_slice<'a>(rec: &Record, bytes: &'a [u8]) -> &'a [u8] {
    let end = (rec.offset + rec.len).min(bytes.len());
    &bytes[rec.offset..end]
}

/// The `UnknownId` for a preserved carrier record. Shared by the passthrough
/// `UnknownRecord` and any `SurfaceGeometry::Unknown` that links to it, so the
/// reference resolves under validation.
fn unknown_record_id(rec: &Record) -> String {
    format!("f3d:brep:{}#{}", rec.head, rec.index)
}

fn ring_coedges(
    loop_rec: &Record,
    by_index: &HashMap<i64, &Record>,
    kept: &HashSet<i64>,
) -> Vec<CoedgeId> {
    let id = |i: i64| CoedgeId(format!("f3d:brep:entity#{i}"));
    let mut out = Vec::new();
    let Some(first) = loop_rec.ref_at(4) else {
        return out;
    };
    let mut cur = Some(first);
    let mut guard = HashSet::new();
    while let Some(ci) = cur {
        if !guard.insert(ci) || !kept.contains(&ci) {
            break;
        }
        out.push(id(ci));
        let Some(ce) = by_index.get(&ci) else { break };
        cur = ce.ref_at(3);
        if cur == Some(first) {
            break;
        }
    }
    out
}

fn loop_chain(
    face_rec: &Record,
    by_index: &HashMap<i64, &Record>,
    kept: &HashSet<i64>,
) -> Vec<LoopId> {
    let id = |i: i64| LoopId(format!("f3d:brep:entity#{i}"));
    let mut out = Vec::new();
    let mut cur = face_rec.ref_at(4);
    let mut guard = HashSet::new();
    while let Some(li) = cur {
        if !guard.insert(li) {
            break;
        }
        if kept.contains(&li) {
            out.push(id(li));
        }
        let Some(lp) = by_index.get(&li) else { break };
        cur = lp.ref_at(3);
    }
    out
}

fn face_chain(
    shell_rec: &Record,
    by_index: &HashMap<i64, &Record>,
    kept: &HashSet<i64>,
) -> Vec<FaceId> {
    let id = |i: i64| FaceId(format!("f3d:brep:entity#{i}"));
    let mut out = Vec::new();
    let mut cur = shell_rec.ref_at(5);
    let mut guard = HashSet::new();
    while let Some(fi) = cur {
        if !guard.insert(fi) {
            break;
        }
        if kept.contains(&fi) {
            out.push(id(fi));
        }
        let Some(f) = by_index.get(&fi) else { break };
        cur = f.ref_at(3);
    }
    out
}

fn shell_chain(region_rec: &Record, by_index: &HashMap<i64, &Record>) -> Vec<ShellId> {
    let id = |i: i64| ShellId(format!("f3d:brep:entity#{i}"));
    let mut out = Vec::new();
    let mut cur = region_rec.ref_at(4);
    let mut guard = HashSet::new();
    while let Some(si) = cur {
        if !guard.insert(si) {
            break;
        }
        out.push(id(si));
        let Some(s) = by_index.get(&si) else { break };
        cur = s.ref_at(0);
    }
    out
}

fn region_chain(body_rec: &Record, by_index: &HashMap<i64, &Record>) -> Vec<RegionId> {
    let id = |i: i64| RegionId(format!("f3d:brep:entity#{i}"));
    let mut out = Vec::new();
    let mut cur = body_rec.ref_at(3);
    let mut guard = HashSet::new();
    while let Some(li) = cur {
        if !guard.insert(li) {
            break;
        }
        out.push(id(li));
        let Some(l) = by_index.get(&li) else { break };
        cur = l.ref_at(0);
    }
    out
}

fn sha256_hex(bytes: &[u8]) -> String {
    use std::fmt::Write as _;

    use sha2::{Digest, Sha256};
    let mut h = Sha256::new();
    h.update(bytes);
    let digest = h.finalize();
    let mut s = String::with_capacity(digest.len() * 2);
    for b in digest {
        let _ = write!(s, "{b:02x}");
    }
    s
}