Enum BoolFailureReason 

pub enum BoolFailureReason {
    OperandTooLarge {
        polys_a: usize,
        polys_b: usize,
    },
    EmptyOperand,
    DegenerateOperand,
    NoBoundsOverlap,
    KernelOutputInvalid,
    SolidSolidDifferenceSkipped,
    PolygonalBoundedHalfSpaceFallback,
    CutterUnionUnavailable,
    UnknownBooleanOperator(String),
    OperandBudgetExhausted,
    ManifoldOutputDegenerate {
        host_tris: usize,
        result_tris: usize,
    },
    KernelError(String),
    DifferenceEmptiedHost,
    UnsupportedOperand(String),
    OpenTopologyRejected,
    NonManifoldRejected {
        over_used: usize,
        same_direction: usize,
    },
}

Why a boolean operation failed or was skipped.

Variants

OperandTooLarge

HISTORICAL: at least one operand exceeded the deleted legacy BSP CSG polygon cap. The pure-Rust exact kernel has no operand cap, so this is no longer emitted by the boolean ops; the variant (and its JSON label) is kept for the frozen diagnostics surface and void-router plumbing.

Fields

polys_a: usize

polys_b: usize

EmptyOperand

One or both operand meshes were empty before polygon extraction.

DegenerateOperand

Polygon extraction yielded an empty list (degenerate / non-finite vertices).

NoBoundsOverlap

Operand bounding boxes don’t overlap. Informational — host returned unchanged.

KernelOutputInvalid

The CSG kernel returned malformed polygons (NaN / non-finite).

SolidSolidDifferenceSkipped

HISTORICAL: solid-vs-solid IfcBooleanResult.DIFFERENCE was not attempted because the deleted legacy BSP could stack-overflow on arbitrary solid combinations. No longer emitted — the exact kernel always attempts the cut. Variant kept for the frozen label surface.

PolygonalBoundedHalfSpaceFallback

IfcPolygonalBoundedHalfSpace prism-subtraction failed; the kernel fell back to an unbounded plane clip, silently dropping the polygonal boundary. The clip is applied but is a strict superset of the requested cut.

CutterUnionUnavailable

The chained-clip cutter prisms couldn’t be unioned into one watertight solid, so the single batched subtract (issue #960) was skipped and the chain fell back to sequential per-cutter subtraction. The cuts are applied, but abutting cutters may leave zero-thickness seam fins that the batched path would have eliminated.

UnknownBooleanOperator(String)

IfcBooleanResult operator string didn’t match any known op.

OperandBudgetExhausted

The operand walk under one representation item entered more boolean/CSG nodes than processors::boolean::MAX_OPERAND_VISITS allows and was stopped. The item is dropped (the walk returns Err), so this is the only trace of why. A shared SecondOperand re-meshed down m^levels paths is the shape that gets here; a real item does not.

ManifoldOutputDegenerate

HISTORICAL: the deleted Manifold C++ kernel’s difference returned output implausibly small relative to the host (a Linux-x86_64-only pathology). No longer emitted — the deterministic exact kernel replaced Manifold. Variant kept for the frozen label surface.

Fields

host_tris: usize

result_tris: usize

KernelError(String)

Catch-all for kernel-specific errors (free-form string).

DifferenceEmptiedHost

IfcBooleanResult.DIFFERENCE produced an empty mesh from a non-empty host. Almost always a buggy export — a clip plane authored AT the wall’s top with AgreementFlag = .T. (issue #821, Revit IFC2x3 TallBuilding.ifc) makes the half-space material region exactly cover the wall body, so the strict-spec subtract yields nothing. The caller falls back to the un-cut host (matching what BIMVision and similar viewers do in practice) and records this so the loss surfaces in diagnostics rather than as a silently missing element.

UnsupportedOperand(String)

A boolean operand’s IfcRepresentationItem type has no meshing branch in BooleanClippingProcessor::process_operand_checked, so the operand resolved to an EMPTY mesh. Carries the operand’s IFC type name.

As a FIRST operand this is a real element-geometry loss: the base solid is empty, the whole boolean result is empty, and the element renders nothing from that item. As a SECOND operand it means “unsupported cutter” — the host renders un-cut, and the pre-existing EmptyOperand record for the same step is also emitted (one record for the cause, one for the consequence).

OpenTopologyRejected

#3440 step 2: the kernel result passed validate_mesh (finite, in-bounds) but failed the directed-edge closure audit (topology_gate_reject — same predicate KernelError’s step-1 informational record already checks) and was REJECTED rather than merely flagged. Only ever constructed when this crate is built with the csg_topology_gate feature, which is off by default and enabled by nothing downstream — so this variant exists in every build (a stable thing for consumers to match on, per the crate’s convention for its other rarely-emitted variants above) but is only ever actually recorded in a --features csg_topology_gate build.

NonManifoldRejected

#3440 step 3: the kernel result passed validate_mesh AND the signed closure audit, but carries an edge-multiplicity defect that audit cannot express — an undirected edge used by more than two triangles, or used twice the same way round (edge_multiplicity_defects). Rejected, and the caller falls back exactly as it does for KernelOutputInvalid.

Like Self::OpenTopologyRejected, only ever constructed under a feature — its own csg_manifold_gate, kept separate from csg_topology_gate so a census can attribute a flip to one defect class rather than to whichever gate fired first. The variant exists in every build, per this enum’s convention for its other rarely-emitted reasons.

The gate reads a defect class benign tessellation cannot produce, so it was tried as a default; the fallback a rejection reaches turned out to be worse than the tear it replaces. The numbers behind that live in one place — csg_manifold_gate in Cargo.toml — with the corpus sweep in tests/issue_3440_manifold_gate_census.rs.

Carries the two counts (as OperandTooLarge carries its operand sizes) so the census can break the flip set down by defect class without a second sweep: the two say different things about the kernel, and a bare variant would force anyone measuring to re-derive them.

Fields

over_used: usize

Undirected edges used by more than two triangles.

same_direction: usize

Undirected edges used twice, both uses the same way round.

Implementations

impl BoolFailureReason

pub fn label(&self) -> &'static str

Stable short label for per-reason aggregation. Single home shared by the wasm console diagnostics and the server tracing summary so the two surfaces cannot drift (Rust-first).

Trait Implementations

impl Clone for BoolFailureReason

fn clone(&self) -> BoolFailureReason

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BoolFailureReason

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for BoolFailureReason

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for BoolFailureReason

fn eq(&self, other: &BoolFailureReason) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for BoolFailureReason

impl StructuralPartialEq for BoolFailureReason