Union of two pieces sharing a full face returns two components instead of one solid

[GeneralPawz]

The new exactness suite scores (A-B) u (A^B) = A and it fails on
topology while volume is exact:

reconstruction   2.0e0 euler   (axiolid)

Probe output for the two sides:

lhs  vol=4.800000000  euler=4  comps=2  manifold=true
rhs  vol=4.800000000  euler=2  comps=1  manifold=true

What this means

Splitting A by B and re-uniting the two pieces returns them as TWO
separate closed solids instead of re-welding them into one. chi=4
with comps=2 is exactly two closed shells (2 each); A itself is one
shell with chi=2.

The volume is right to 9 decimals because the two pieces partition A
exactly, and each piece is individually a closed manifold, so
manifold=true on both sides.

Why it went unnoticed

The previous suite scored volume only, and volume is exact here. A
manifold audit alone would also pass, since each shell is closed and
two-manifold on its own. Only the component count and the Euler
characteristic separate "one solid" from "two solids that happen to
touch", which is why this surfaced the moment those metrics were
added to the scoring.

Reproduce with --only=exactness; the reconstruction row is the
one that fails.

[GeneralPawz]

Investigated. Reporting findings before attempting a fix, because the
obvious fix is wrong and the cause is not where the title suggests.

This is upstream behaviour, not absorption damage

Ran the same reconstruction through crates.io boolmesh directly and
through our absorbed provider:

UPSTREAM  (A-B)u(A^B): tris=32  chi=4  comps=2
OURS      (A-B)u(A^B): tris=32  chi=4  comps=2

Identical. ADR 0047 absorbed this code faithfully; the limitation
came with it.

Three hypotheses tested and disproven

1. Vertex-merge tolerance. The duplicated seam vertices are
separated by EXACTLY 0.000e0 -- bit-identical. No epsilon affects
this.

2. Missing vertex weld. Manifold::from_pos welds duplicate
positions by exact bit pattern, but compute_boolean no longer ends
by rebuilding a Manifold, so that weld stopped running on boolean
output. Restoring it as a post-pass gives:

before weld:  chi=4  comps=2  nonmanifold=0
after weld:   chi=3  comps=1  nonmanifold=1

chi=3 is impossible for a closed orientable surface. The weld joins
the index graph but leaves interior faces in place, producing a
non-manifold edge. That is strictly worse: it converts an honest
two-shell result into a corrupt one-shell result that still passes a
volume check. Reverted, not shipped.

3. Coincident-face cancellation. Expected the union to cancel a
coplanar face pair (equal geometry, opposite winding). Measured the
faces A-B and A^B actually share:

shared seam faces = 0
shared seam area  = 0.000000

None. There is no face pair to cancel.

Where the defect actually is

area(A)       = 29.600000
area(A-B)     = 28.795099
area(A^B)     =  5.874893
sum           = 34.669992
area(union)   = 30.353368   <- removed 4.3166
excess over A =  0.753368   <- should be 0

The union IS doing seam removal -- it discarded 4.3166 of area -- but
stops 0.7534 short. Combined with zero shared faces, that means the
two operands were RETRIANGULATED differently along their common
surface: the seam is geometrically identical but combinatorially
distinct. Face-pair cancellation cannot apply; the union has to
re-cut the shared region, and it does so incompletely.

Requires rotation: the axis-aligned through-hole reconstruction is
correct (chi=2 comps=1 area=29.600000, exactly area(A)). Rotated
coordinates are not exactly representable, so the two retriangulations
diverge.

Assessment

A correct fix belongs in the coplanar-region handling inside
boolean03/boolean45, not in a post-pass. That is real surgery on
absorbed upstream CSG code and should be its own scoped decision
rather than folded into a quick fix.

Severity is lower than the title implies: both shells are
individually closed and two-manifold, volume is exact to 1e-16, and
nothing downstream consumes component count from a boolean result
today. The new exactness suite is what surfaced it and will keep it
visible.

[GeneralPawz]

Scoped as ADR 0048 — Coplanar seam merging across chained booleans
(docs/adr/0048-coplanar-seam-merging.md, commit b2767f4).

Root cause

Coplanar merging is keyed on Tref { mid, pid }:

• mid — which INPUT manifold a face came from
• pid — coplanar group id WITHIN that input, from
  compute_coplanar_idx, which runs only in Manifold::new_impl

In (A-B) u (A^B) both sides of the seam originate from A, but they
arrive as operands of a SEPARATE boolean call and were retriangulated
independently. pid is local to the call that produced it, so the two
sides are never recognised as the same plane.

Evidence: zero exactly-shared faces between A-B and A^B, and the
union removes 4.3166 of seam area but stops 0.7534 short of
area(A).

Planned fix

Make coplanar identity GEOMETRIC rather than provenance-based, so
faces in the same plane merge regardless of which call produced them.
Four independently-gated steps, in order:

1. Fixture first (done)
2. Recompute plane groups on boolean output
3. Key is_coplanar on the geometric plane id, keeping mid only for
   the sharp-edge and normal-flip guards that genuinely need it
4. Re-gate the full suite for volume accuracy and determinism

Step 1 landed

crates/providers/mesh/boolmesh/tests/reconstruction.rs:

reconstruction_preserves_topology ... ignored (ADR 0048)
axis_aligned_reconstruction_preserves_topology ... ok

Run with --ignored, the rotated case fails with exactly this defect:

reconstruction changed the shape: expected chi=2 comps=1, got chi=4 comps=2

So the fix has a real gate to turn green rather than prose. The
axis-aligned case runs by default and passes, guarding the claim that
the defect is specific to inexactly-representable coordinates -- if it
ever fails, the diagnosis is wrong.

Main risk recorded in the ADR: a geometric plane key needs a
quantisation tolerance, which is a new way to merge faces that should
NOT merge. That is why the fixture landed first.

[GeneralPawz]

Investigated and measured. Landed d37fabe on main with the
evidence and two new regression tests. The fix itself is not in, and
I want to flag why before spending the budget it needs.

The part that changes the priority

This was scored as a topology-only defect: volume exact, both shells
closed, only chi and component count wrong. That reads as cosmetic.

It is not. The damaged result is refused by the next boolean:

NotManifold("subject: edge (1, 3) has 4 incident faces; "
            "a half-edge mesh admits at most two")

The axis-aligned control reconstructs correctly and chains fine, so
the refusal is caused by the defect, not by the workload. Chained
booleans are the primary CAD path, so this is a hard stop rather
than a cosmetic score.

A measurement that narrows the target

By VERTEX INDEX the rebuilt mesh is a clean two-manifold: every edge
has exactly two incident faces, which is why it passes a manifold
audit in isolation. The damage is visible only by COORDINATE:

edge incidence by index       {2: 48}          <- looks clean
edge incidence by coordinate  {2: 46, 4: 1}    <- one bad edge
distinct positions 20, distinct coordinates 18

So it is not two fully doubled shells. Exactly two vertices are
duplicated and one edge is four-incident. The overlap is small and
local, which is more tractable than the earlier framing suggested.

Re-confirmed independently, not taken on trust

ADR 0048's diagnosis holds. I re-measured rather than assuming:

• 0 exactly-shared triangles between the two shells, so there is no
  coincident face PAIR to cancel.
• 30 OPPOSED-facing coplanar triangle pairs: that is the interior
  interface, present geometrically but combinatorially disjoint.
• The windings are CORRECT, not buggy: w03=0 for all 18 A-B
  vertices and w30=1 for all 10 A^B vertices. For union
  i03 = 1 - w03 = 1, so every A-B face is retained by rule.
• Welding by coordinate gives chi=3. An odd Euler characteristic
  is impossible for a closed surface, so that alternative converts
  an honest two-shell result into a corrupt one-shell result.
  Re-confirmed, still rejected.

Where the fix has to go, and why I stopped short of it

intersect12 finds edge-face CROSSINGS. A face lying exactly in
another face crosses nothing, so it generates no intersection
record and the classifier never learns the two surfaces coincide.
The windings do not need correcting; the coincidence needs
DETECTING, which is a capability the algorithm does not have.

That lands in kernel12.rs / kernel03.rs / boolean45.rs — the
layer that defines what a boolean MEANS. Changing what counts as
interior moves volumes, not just triangle counts. Kernel12::op
also carries assert_eq!(k, 2) invariants that assume transversal
contact, so admitting coplanar contact changes the geometric model
the projection kernel is built on.

I am not landing a speculative change there between a green gate
and a release. It needs its own sprint with the full exactness,
drift and determinism tables as the acceptance bar, plus the
upstream differential test staying green.

Landed now

• a_damaged_reconstruction_blocks_the_next_boolean — ignored,
  fails today, records the propagation cost.
• an_axis_aligned_reconstruction_stays_usable_as_an_operand —
  passes today, the control that proves causation.
• ADR 0048 gains both measurement sections.

The two failing tests stay #[ignore]d next to the existing
fixture: they record the defect and give the fix a gate to turn
green. Default cargo test stays clean; --include-ignored
shows the four-test picture.

Issue stays OPEN. What is closed is the question of how much it
costs to leave it open: more than the original score implied.

[GeneralPawz]

Fixed in 411fa0e.

Root cause

Coplanar merging asked the wrong question. The test gating edge
collapse was:

t0.mid == t1.mid && t0.pid == t1.pid

That is PROVENANCE, not geometry. mid is which operand a face came
from; pid indexes the coplanar set within that one operand, and is
recomputed per call.

So two faces genuinely on one plane compared unequal whenever they
arrived from different operands. A reconstructed seam is exactly
that case, so it never welded and the result stayed two shells.

Measured, not inferred: instrumenting the rejected pairs on the
failing case gave 996 rejections, and 89% were cross-operand
(710 with both fields differing, 181 with the same pid but a
different mid). Only 11% were same-operand.

The fix

is_coplanar_at keeps provenance as a fast path and falls back to
the face normals when it disagrees: same plane means parallel
normals, and antiparallel counts because a seam between two solids
has opposed windings by construction.

Being a fallback, it cannot stop previously-merged faces from
merging. It only admits pairs provenance wrongly rejected.

Evidence

Both #[ignore]d tests from d37fabe now run by default and pass:
the rotated reconstruction returns chi=2 comps=1, and the result
is accepted as an operand by the next boolean instead of being
refused NotManifold.

The exactness suite the issue said to reproduce with now reports
reconstruction 0.0e0 and all identities match ground truth.
The scorer still computes euler, so that is the strict metric, not
a weakened one.

Mutation evidence

The epsilon is pinned from both sides, so it is not a magic number:

• remove the normal fallback (revert to provenance only) -> both
  reconstruction tests FAIL, reproducing this issue exactly
• open the epsilon wide (everything counts as coplanar) -> a
  different test FAILS

Too strict brings #100 back; too loose breaks something else.

Full gate passes, main = 411fa0e.