# Reference-Guided Performance Notes

These measurements retain only changes that preserve exact rows, output size,
and benchmark checksums. They were collected on 15, 17, 18, 20, and 28 July 2026 with
the release benchmark profile. Times are medians after two warmup batches.

| Workload | Before | After | Change | Preserved evidence |
|---|---:|---:|---:|---|
| `mesh_queries/graphics_buffers` | 1.170 ms/op | 0.139 ms/op | 88.1% faster | 1,584 indices and exact position/normal regression |
| `adapter_graphics_export/f32_48384` | 59.4 ms/op | 1.04 ms/op | 98.2% faster | Same finite row/index contract and strict overflow error |
| `adapter_graphics_export/f64_48384` (split-buffer control) | 1.16 ms/op | 0.52 ms/op | 55.2% faster | Same 48,384 interleaved rows and indices with no temporary split buffers |
| `mesh_io/all_exporters` | 87.602 ms | 81.581 ms | 6.9% faster | 385,166 output bytes and checksum |
| `mesh_boolean/immediate_four` | 0.596–0.659 ms | operation-scoped | N/A | Four independently closure-certified outputs, 120 polygons/corners, stable checksum |
| `mesh_queries/ray_intersections` | 32.851 ms/op | 30.819 ms/op | 6.2% faster | Same exact ordered hit points, distances, and checksum |
| `kernel/construct_box/unit` (cold) | 36.157 us/op | 28.308 us/op | 21.7% faster | Same 12-facet checksum; 1.338x faster than CGAL EPECK |
| `kernel/center/translated_box` (cold) | 23.768 us/op | 3.400 us/op | 85.7% faster | Same 12-coordinate checksum; 1.991x faster than CGAL EPECK |
| `kernel/translate/sphere_medium` (cold) | 0.2513 ms/op | 0.1865 ms/op | 25.8% faster | Same 960-coordinate checksum; 2.095x faster than CGAL EPECK |
| `kernel/affine_transform/sphere_shear` (cold) | 0.1288 ms/op | 0.1069 ms/op | 17.0% faster | Same 960-coordinate checksum; 5.125x faster than CGAL EPECK |
| `profile_primitives/constructor/circle_with_keyway` | 4.72 ms/op | 0.209 ms/op | 95.6% faster | Same contour roles, area, exact containment oracle, and checksum |
| `profile_primitives/constructor/keyhole` | 5.58 ms/op | 0.161 ms/op | 97.1% faster | Same contour roles, area, exact containment oracle, and checksum |
| `profile_primitives/constructor/crescent` | 10.9 ms/op | 1.42 ms/op | 87.0% faster | Same contour roles, area, 605 exact containment oracle decisions, and checksum |
| `profile_primitives/constructor/circle` | 0.129 ms/op | 0.0791 ms/op | 38.7% faster | Exact former `Region2`, point cache, and symbolic unit-normal cache at five tessellations |
| `profile_primitives/constructor/ellipse` | 0.171 ms/op | 0.0452 ms/op | 73.6% faster | Exact former `Region2` equality across five aspect-ratio/tessellation cases |
| `profile_primitives/constructor/star` | 0.128 ms/op | 0.0539 ms/op | 57.8% faster | Exact former `Region2` equality across five point-count/radius-ratio cases |
| `profile_primitives/constructor/regular_ngon` | 0.0368 ms/op | 0.0201 ms/op | 45.3% faster | Exact former `Region2` equality at six side counts |
| `profile_primitives/constructor/teardrop` | 0.170 ms/op | 0.0606 ms/op | 64.4% faster | Exact former `Region2` equality across five dimension/tessellation cases |
| `profile_primitives/constructor/egg` | 0.118 ms/op | 0.0628 ms/op | 46.9% faster | Legacy finite coordinates within 1e-12 plus exact requested bounds |
| `profile_primitives/constructor/squircle` | 0.138 ms/op | 0.0634 ms/op | 54.0% faster | Exact former `Region2` equality across six aspect-ratio/tessellation cases |
| `profile_primitives/constructor/ring` | 0.263 ms/op | 0.0868 ms/op | 66.9% faster | Exact former annular `Region2` equality across six dimension/tessellation cases |
| `profile_primitives/constructor/supershape` | 0.0280 ms/op | 0.0692 ms/op | 147.5% exactness cost | Legacy finite coordinates within 1e-11; no internal binary64 demotion |
| `profile_primitives/constructor/airfoil_naca4` | 1.686 ms/op | 1.184 ms/op | 29.8% faster | Exact former-region equality at three tessellations and same checksum |
| `profile_primitives/constructor/involute_gear` | 0.637 ms/op | 0.389 ms/op | 38.9% faster | Legacy coordinates within 2e-12, symbolic samples, and exact beyond-binary64 module retention |
| `profile_primitives/constructor/cycloidal_gear` | 0.391 ms/op | 0.202 ms/op | 48.3% faster | Legacy coordinates within 2e-12, symbolic samples, and exact beyond-binary64 module retention |
| `profile_primitives/constructor/cycloidal_rack` | 0.170 ms/op | 0.0419 ms/op | 75.4% faster | Exact former `Region2` equality across three parameter sets |
| `profile_primitives/constructor/involute_rack` | 0.0809 ms/op | 0.0309 ms/op | 61.8% faster | Exact former `Region2` equality plus zero-root-space boundary oracle |
| `profile_primitives/constructor/reuleaux` | 12.409 ms/op | 0.0650 ms/op | 99.5% faster | Exact former Boolean boundary and same contour checksum |
| `profile_primitives/constructor/heart` | 0.3378 ms/op | 0.3130 ms/op | 7.3% faster | Legacy finite coordinates within 1e-12; exact requested bounds and symbolic samples |

## Retained changes

TriangleMesh broad-phase disjoint and point-outside tests now consume Hyperlimit's
canonical exact AABB predicates instead of rebuilding six scalar comparisons.
A serialized 20-sample disjoint-box competitive gate preserved every output and
checksum. CSGRS measured 25.132 us for union, 0.253 us for intersection, and
1.083 us for difference. The corresponding fresh pre-lift run measured
22.568/0.240/1.005 us, while the unchanged competitors drifted by comparable
amounts in the same runs (roughly 4--19%); normalized results show no attributable
regression. Hyperlimit's direct ordered full-axis predicate takes 24.50 ns, and
the exact intersection cascade improved 23.56%.

The primitive-scalar adapter now benchmarks its public graphics export on a
48,384-vertex sphere. It traverses the core's retained exact HyperMesh rows once
and writes directly into the requested interleaved layout; the benchmark keeps
the separate-position/normal GPU route plus a merge as a regression control.
The binary32 path consumes Hyperreal's rational/retained-binary64 fast path;
its first warmup now publishes each rational proposal in the existing cache,
while overflow still returns `NotFiniteApproximation`. Exact `RawReal` and
integer adapters retain their generic conversions. The same audit made the raw
carrier accessors `const`, named the indexed-buffer return type, and removed the
now-unnecessary forwarding layer from `TriangleMesh::graphics_mesh`.

Lazy cuboid pools now store exact minimum and maximum coordinates per axis, so
translation and centering can construct the final cuboid carrier directly from
shifted exact bounds. This avoids rebuilding eight exact position
representatives and 24 face vertices, and avoids nesting symbolic translation
recipes. A six-coordinate binary64 view is retained only for measurement,
rendering, and export boundaries; predicates and materialized vertices continue
to consume the exact coordinate bounds. Translation-cache hits also restore the
cuboid carrier so chained operations retain the same path. Regression coverage
checks exact round-trip positions, eight shared position identities, two shared
coordinate identities per axis, centering, chained translation, and cache hits.

The cold translated-box center counter fell from 35,902,952 to 35,379,545
instructions, 1.46%. In the complete 47-workload, 15-cold/9-warm native sweep,
the center median fell from the prior approximately 6.9 us to 3.400 us, versus
6.770 us for CGAL EPECK and 0.783 ms for tight OpenCascade. Warm CSGRS measured
1.154 us versus CGAL's 5.462 us. Every warm row beat both comparison engines;
the only cold non-win remained the timer-scale identical-box intersection at
110 ns versus CGAL's 100 ns.

Exactly disjoint mesh concatenation now sums the two retained topology tuples
instead of rescanning every cloned output face to rediscover facet, corner,
and triangle-only counts. Triangle order, exact positions, provenance, and set
semantics are unchanged; the disjoint-set regression now also checks the
retained 24-facet/48-corner output. A matched cold Callgrind A/B fell from
35,474,450 to 35,011,530 instructions, 1.30%. In the complete native sweep,
`boolean_union/disjoint_boxes` fell from the prior 11.389 us to 1.880 us versus
CGAL EPECK's 11.869 us, widening the cold margin from 1.034x to 6.313x. Warm
CSGRS measured 0.666 us versus CGAL's 1.140 us. All 47 cold rows beat both
comparison engines; the only non-win was the timer-scale warm identical-box
intersection at 24 ns versus approximately 23 ns.

Original cuboid pools now defer their six-coordinate binary64 boundary view
until rendering, measurement, or export first requests it. Topology-only cube
and cuboid construction therefore retains exact coordinate bounds without
paying for an unused finite adapter. Translated cuboids still precompute their
final finite bounds because translated centering consumes that view in the
timed path. `OnceLock` publishes the original pool's boundary once, so later
finite traversal does not materialize exact face vertices or repeat conversion.
Exact shared-identity and direct-export regressions cover both access modes.

Across 31 focused cold samples, `construct_box/unit` fell from 32.238 us to
24.938 us (22.6%) and changed from 0.957x to 1.310x versus CGAL EPECK. In the
complete native sweep it fell from 36.157 us to 28.308 us (21.7%), versus
37.876 us for CGAL. The translated-center row remained ahead at 3.580 us versus
CGAL's 6.810 us. Every cold and warm row beat or tied both comparison engines;
the only tie was the timer-scale identical-box intersection at 100 ns cold.

The indexed adapter omits its position-ID lookup unless the connectivity API
requests it, so Boolean input does not materialize lazy sphere corners solely
to build an unused map.

On the cold sphere/box union trace, the direct Boolean subtree fell
from 16,718,295 to 16,655,056 instructions (0.38%), while the setup-heavy whole
process fell from 54,481,865 to 54,413,625 instructions (0.13%). The complete
15-cold/9-warm cross-kernel sweep retained all output sizes and checksums;
union fell from 1.885881 ms to 1.878861 ms and widened its CGAL EPECK margin
from 1.076x to 1.080x. Every substantive cold and warm row remained ahead of
both comparison engines. The only measured non-win was the timer-resolution
identical-box intersection at 120 ns versus CGAL's 110 ns; its warm result was
21 ns versus 24 ns.

`TriangleMesh::build_graphics_mesh` previously called `TriangleMesh::triangulate`, which built
temporary triangle polygons, recomputed support planes, allocated metadata and
IDs, and then discarded that intermediate mesh. The renderer boundary now
streams the same certified triangle indices directly from each source polygon
into exact `Real` position/normal rows. A regression test compares every row and
the sequential index buffer with the former materialized path.

`TriangleMesh::indexed_triangles` now reserves position, normal, face, and lookup
storage from source topology bounds before exporters populate it. Deduplication
still uses retained position and plane identities; output order and serialized
bytes are unchanged.

TriangleMesh Booleans now have one immediate path. `try_union`, `try_difference`,
`try_intersection`, and `try_xor` select one operation, apply exact
empty/disjoint/identical/axis-aligned-box shortcuts when certified, and
otherwise request HyperMesh's direct certified triangle soup. CSGRS restores
source metadata while materializing the result. There is no public retained
Boolean carrier, thread-local arrangement cache, compatibility alias, or
build-once/extract-many benchmark.

The previous multi-result measurements are historical evidence for machinery
that is intentionally no longer supported, so those benchmark rows and
claims have been removed. `mesh_boolean/immediate_four` remains as the
independent-operation workload; the kernel comparison measures the same
public calls. Future optimization is evaluated on cold immediate latency,
allocation count, exact output rows, source metadata, and closure.

Three warm release samples of the overlapping-box sentinel measured
0.596–0.659 ms for all four immediate calls together, with 120 output
polygons/corners and the same checksum in every sample. The certified
axis-aligned-box shortcuts dominate that fixture; non-box workloads remain
covered by the direct HyperMesh triangle-soup path.

Matrix transforms now use Hyperlattice's immediate scalar and batch APIs; no
caller-managed matrix cache, prepared divisor, or transform handle remains.
The retained-layout path batches point and normal rows so structural facts are
computed once inside each operation. The serialized
`kernel/affine_transform/sphere_shear` gate moved from 208.278 us/op to
206.997 us/op (0.62% faster), with all 960 output coordinates and checksum
`5925854529696364912` unchanged.

Cold HyperMesh output materialization now appends all triangle vertices to one
preallocated buffer and gives each CSGRS polygon an exact shared range. Source
metadata, fresh plane identities, flat shading normals, and independent
copy-on-write mutation are unchanged. This replaces a three-vertex `Vec` and
its separate `Arc` allocation for every emitted triangle with one result-wide
buffer.

Across 30 counter runs of 500 alternating-input sphere/box operations, union
instructions fell from 10,034,937,171 to 9,950,943,190 (0.84%) and cycles fell
0.55%. Difference instructions fell from 7,935,683,222 to 7,872,306,550
(0.80%) and cycles fell 0.36%. A 50-union heap trace recorded 1,060,054
allocations versus 1,084,445, eliminating 24,391 allocations, or about 488 per
union. A direct regression verifies that every materialized output polygon
shares the retained vertex buffer while the existing exact-output and metadata
oracles remain unchanged.

`TriangleMesh::ray_intersections` now streams triangle position references from
the native index buffer instead of cloning a temporary `[Point3; 3]` for every
ray test. The HyperLimit ray/triangle predicate, exact
hit ordering, and exact deduplication are unchanged. A differential test replays
the former materialized enumeration against the streaming result.

The exact translation path now materializes its complete finite position view
once, shares that retained allocation with both the coordinate cache and the
result layout, and skips construction of an indexed vertex pool unless the
already-known triangle, normal, and coordinate-layout preconditions can accept
it. Face corner counts survive the generic translated fallback because
translation changes neither triangle order nor arity. That retained fact also
lets the HyperMesh adapter triangulate translated cuboids directly from their
canonical position slots instead of requiring the triangle-only pool. A
differential regression compares every exact triangle coordinate row, source
polygon row, and position-ID mapping against generic triangulation.
Independently cached constructors may assign different canonical slot numbers
to the same triangle rows, so the identical-input shortcut now compares those
exact indexed coordinate rows instead of treating raw local indices as global
geometry identity. Seven cold
cross-kernel samples put translated-box centering at 6.339 us, medium-sphere
translation at 0.1865 ms, and sphere shear at 0.1069 ms; all three beat both
CGAL EPECK and OpenCascade while preserving their prior checksums.

AddressSanitizer completed 10,000 transform-matrix executions and 2,000
HyperMesh-adapter executions with leak detection disabled for the ptrace-hosted
runner. The adapter campaign exposed two stale harness assumptions rather than
production faults: the native mesh-buffer view intentionally expands triangle
corners while connectivity canonicalizes exact positions, and an open or
otherwise Boolean-invalid triangle stream can still have valid native buffers
and partial connectivity. The corrected oracle now checks bidirectional exact
position coverage and reserves closed-manifold claims for successful HyperMesh
imports.

`CurveRegion2::circle_with_keyway` now recognizes the exactly certified case where
both left cutter corners lie in the convex sampled circle. It constructs that
single attached notch with one ring traversal and a logarithmic convex-point
certificate instead of invoking the general region Boolean. Deep or wide
cutters whose topology is not covered by that certificate retain the former
Boolean path. Four fast-path geometries match the Boolean oracle's contour
roles, signed area, and 484 exact-rational containment classifications; a
separate deep/wide regression proves the fallback remains selected.

`CurveRegion2::keyhole` applies the dual construction when a centered rectangular
handle reaches at least the sampled circle radius and its bottom corner is
certified inside the convex ring. The height proof ensures the rectangle covers
the complete replaced upper arc; a logarithmic convex-point query and two exact
line intersections then build the union boundary in one traversal. Short and
overly wide handles retain the general Boolean. Four direct geometries match
the Boolean oracle's contour roles, signed area, and 572 exact-rational
containment classifications; two fallback regressions cover both excluded
topology classes.

`CurveRegion2::crescent` now classifies the complete topology before invoking a
general Boolean. Properly crossing homothetic regular polygons are joined from
their two exactly certified boundary transitions: the outer outside arc is
spliced to the reversed inner inside arc. X-axis reflection reuses lower-half
membership decisions. Exact radius/offset identities handle containment as an
explicit material-plus-hole region and disjointness as the unchanged outer
ring, including internal and external tangency. This removes the former
`RealSign` panic at internal tangency. Five crossing geometries, including odd
segments and negative offset, match the Boolean oracle's contour roles, signed
area, and 605 exact-rational containment classifications; contained and
disjoint identities have separate regressions.

`CurveRegion2::circle` now materializes its regular sampled polygon from the
constructor's own topology certificate. Positive radius and at least three
cyclic samples prove distinct neighboring vertices, nonzero chords, simple
closure, and consistent winding, so the generic exact distance predicates do
not need to rediscover those properties. The convex tessellation cache remains
the exact authored point sequence. A differential regression compares both the
complete former `Region2` and point cache at 3, 4, 5, 16, and 31 segments.
The retained side-normal cache now also samples exact half-step angles instead
of promoting binary64 sine/cosine values; the same differential proves every
normal against its symbolic construction. Matched 30-sample medians fell from
0.129 to 0.0791 ms/op (38.7%), with non-overlapping 0.125--0.155 and
0.0788--0.0799 ms interquartile ranges. A one-call trace moved from 1,752 to
2,068 dispatch events because the formerly invisible normal sampling is now
exact and recorded. Unknown and fallback/abort events each fell from 88 to
zero, with no approximation or refinement events before or after.

`CurveRegion2::ellipse` applies the same certified materialization after its positive
width and height admission. Independent positive axis scaling is an
orientation-preserving affine map of the regular sampled polygon, so it
preserves distinct neighboring vertices, nonzero edges, simplicity, closure,
and winding. A differential regression compares the complete former exact
`Region2` at five portrait, landscape, and strongly eccentric tessellations.
Matched 30-sample medians fell from 0.171 to 0.0452 ms/op (73.6%), with
0.136--0.179 and 0.0441--0.0455 ms interquartile ranges. A one-call trace fell
from 1,647 to 1,175 dispatch events (28.7%); unknown and fallback/abort events
each fell from 88 to zero, with no approximation or refinement events before
or after.

`CurveRegion2::star` now uses the direct line-ring path after its strict positive
inner-radius and larger-outer-radius admission. Alternating samples lie on
strictly increasing rays; each chord is contained in its own angular wedge, so
nonadjacent chords cannot cross and every authored edge is nonzero with
consistent winding. A differential regression compares the complete former
exact `Region2` at five point counts and radius ratios, including nearly equal
radii and strong contrast. Matched 30-sample medians fell from 0.128 to 0.0539
ms/op (57.8%), with 0.121--0.143 and 0.0519--0.0571 ms interquartile ranges. A
one-call trace fell from 1,658 to 1,190 dispatch events (28.2%); unknown and
fallback/abort events each fell from 88 to zero, with no approximation or
refinement events before or after.

`CurveRegion2::regular_ngon` reuses the same positive-radius regular-polygon proof
as `CurveRegion2::circle`, without adding the circle-only convex-normal cache. A
differential regression compares the complete former exact `Region2` at 3, 4,
5, 7, 16, and 31 sides. Matched 30-sample medians fell from 0.0368 to 0.0201
ms/op (45.3%), with 0.0360--0.0431 and 0.0174--0.0211 ms interquartile ranges.
A one-call trace fell from 723 to 589 dispatch events (18.5%); unknown and
fallback/abort events each fell from 26 to zero, with no approximation or
refinement events before or after.

`CurveRegion2::teardrop` now materializes its sampled semicircle-and-tip boundary
from the constructor's existing strict `length > width / 2` certificate. The
positive cap-center height places the entire semicircle on or above its
endpoint chord while both tip edges stay below it except at shared endpoints,
proving nonzero edges, simple closure, and consistent winding. A differential
regression compares the complete former exact `Region2` across five dimension
and tessellation regimes, including the minimum two-segment cap. Matched
30-sample medians fell from 0.170 to 0.0606 ms/op (64.4%), with 0.166--0.177
and 0.0566--0.0672 ms interquartile ranges. A one-call trace fell from 2,112
to 1,436 dispatch events (32.0%); unknown and fallback/abort events each fell
from 92 to zero, with no approximation or refinement events before or after.

`CurveRegion2::egg` no longer demotes every symbolic sine/cosine sample to binary64
for internal normalization. The discrete extrema are known from uniform sample
indices: x extrema are nearest the quarter turns, while
`d(c + c^2/5)/dc = 1 + 2c/5` is strictly positive on `[-1, 1]`, so y extrema
are nearest 0 and pi. Two exact span divisions are hoisted outside the point
loop, and analytically tied extrema are canonicalized to the exact requested
half-dimensions. The raw curve's signed curvature
`1 + (2/5) cos(theta)^3 >= 3/5` certifies the normalized sampled ring as
distinct, convex, simple, and consistently wound. Across seven tessellations,
the new path stays within `1e-12` of every legacy finite coordinate, preserves
non-rational exact coordinates, and proves the requested width and length
exactly. Matched 30-sample medians fell from 0.118 to 0.0628 ms/op (46.9%),
with 0.100--0.121 and 0.0618--0.0644 ms interquartile ranges. A one-call trace
fell from 2,083 to 1,377 dispatch events (33.9%); approximation, refinement,
fallback, and unknown events remained zero.

`CurveRegion2::squircle` now materializes its exact signed-square-root samples from
the constructor's Lamé topology certificate. Positive width and height scale
the strictly convex boundary `x^4/rx^4 + y^4/ry^4 = 1`, so cyclic samples are
distinct and form a simple, consistently wound convex polygon without generic
edge validation. A differential regression compares the complete former exact
`Region2` across six aspect-ratio and tessellation cases. Matched 30-sample
medians fell from 0.138 to 0.0634 ms/op (54.0%), with 0.126--0.156 and
0.0587--0.0683 ms interquartile ranges. A one-call trace fell from 2,135 to
1,711 dispatch events (19.9%); unknown events fell from 96 to zero and
fallback/abort events from 160 to 64, with approximation and refinement events
remaining zero. The retained 64 fallback events belong to the intrinsic
signed-square-root classification, not ring topology validation.

`CurveRegion2::ring` now applies the same analytic topology certificate separately
to its two concentric regular polygons. Positive input dimensions and at least
three samples make both boundaries simple and consistently wound; the larger
outer radius makes the inner polygon a strict positive homothety inside it, so
the material and hole roles need no generic ring validation. A differential
regression compares the complete former exact annular `Region2` across six
diameter, thickness, and tessellation cases. Matched 30-sample medians fell
from 0.263 to 0.0868 ms/op (66.9%), with 0.260--0.265 and 0.0858--0.0885 ms
interquartile ranges. A one-call trace fell from 3,646 to 2,174 dispatch events
(40.4%); unknown and fallback/abort events both fell from 176 to zero, while
approximation and refinement events remained zero.

`CurveRegion2::supershape` no longer demotes its six parameters, symbolic sample
angles, powered superformula terms, radius, and final coordinates to binary64.
General exponents now use Hyperreal powers throughout. The common
`a = b = 1`, `n2 = n3 = 2` identity is reduced exactly through
`cos(theta)^2 + sin(theta)^2 = 1`, avoiding the general power graph while
retaining exact circle samples. Positive radii and uniform angular wedges
certify the resulting polygon directly. Symmetric and asymmetric differential
cases retain every legacy finite coordinate within `1e-11` and preserve
non-rational exact coordinates. Removing the internal approximation raises the
matched 30-sample median from 0.0280 to 0.0692 ms/op (2.48x), with
0.0266--0.0327 and 0.0688--0.0702 ms interquartile ranges. The one-call trace
rises from 788 to 1,999 events because the exact sine/cosine path is now
observable; fallback, approximation, and refinement events remain zero.

`CurveRegion2::airfoil_naca4` previously evaluated every interior chord station
twice: once while constructing the upper surface and again while traversing the
lower surface in reverse. It now evaluates each exact station once, appends the
upper point immediately, and retains the corresponding lower point for the
same reverse-order assembly. Matched 15-sample medians fell from 1.686 to 1.184
ms/op (29.8%). A one-call trace fell from 22,928 to 14,441 dispatch events;
generic sine, cosine, and arctangent evaluations each fell from 158 to 80 and
refinements remained zero. A differential oracle reconstructs the former
two-pass algorithm and compares the complete exact `Region2` for symmetric and
cambered airfoils at 10, 24, and 80 samples. The shared curve-constructor fuzz
target completed 1,000 AddressSanitizer-instrumented executions after the
change with no failure.

`CurveRegion2::involute_gear` no longer demotes module, pressure angle, clearance,
backlash, analytic radii, or sampled angles to binary64. Hyperreal square root,
inverse tangent, and trigonometry retain the analytic samples directly. The
constructor evaluates each radial flank sample once for one local tooth, reuses
that retained sequence in reverse for the opposite flank, and assembles the
gear with exact pitch rotations. Even tooth counts reuse half-turn symmetry;
multiples of four reuse exact coordinate swaps and sign changes for three
quadrants. The admitted analytic ranges also certify the line ring without a
second generic validation pass. A differential oracle compares every boundary
coordinate with the former finite implementation within 2e-12 across three
pressure-angle, clearance, backlash, tooth-count, and tessellation cases; an
adversarial module one unit beyond binary64 integer resolution remains exactly
distinguishable after construction. Matched 30-sample medians are 0.389 ms/op
with a 0.384--0.396 ms interquartile range: 38.9% faster than the original
0.637 ms generic path, while paying a documented 125% exactness cost against
the intermediate 0.173 ms finite sampler. The optimized exact one-call trace
emits 1,213 events versus 24,619 originally and 943 for the invisible finite
sampler, with six arctangent and five generic square-root evaluations and no
unknown or approximation events.

`CurveRegion2::cycloidal_gear` now obtains its first-lobe tip and root parameters
from exact closed-form radial-square identities and retained inverse cosine
nodes, replacing the former binary64 conversion and 64-step floating bisection.
It samples one oriented epicycloid and hypocycloid per tooth shape, reuses those
samples for both flanks, and assembles repeated teeth through shared exact
rotational symmetry. Tip and root arcs remain exact `Real` polar samples. A
differential oracle compares every boundary coordinate with the former finite
implementation within 2e-12 across three lobe and symmetry cases; a module one
unit beyond binary64 integer resolution remains distinguishable after complete
construction. Matched 30-sample release medians are 0.202 ms/op with a
0.201--0.205 ms interquartile range: 48.3% faster than the original 0.391 ms
path, while paying a documented 71% exactness cost against the intermediate
0.118 ms finite sampler. Its one-call trace fell from 12,839 to 3,292 dispatch
events (74.4%), with zero approximation, refinement, fallback, unknown-fact,
or rational-GCD events.

`CurveRegion2::cycloidal_rack` now evaluates its exact cycloid lobe once and reuses
that symbolic `Real` boundary under pitch translations for every tooth. Its
constructor also owns a direct topology certificate: positive admitted radius
gives `x'(theta) = r(1 - cos(theta))`, so every positive sample interval is
strictly x-monotone; positive pitch proves the bottom edge nonzero, and the
strictly negative root line proves both side edges nonzero. The shared endpoint
assembly is therefore connected, closed, simple, and consistently wound without
repeating generic exact distance predicates. A copied former implementation
matches the complete exact `Region2` across three tooth/resolution/clearance
sets. Matched 30-sample medians fell from 0.170 to 0.0419 ms/op (75.4%), with
non-overlapping 0.162--0.185 and 0.0325--0.0469 ms interquartile ranges. The
one-call trace fell from 1,848 to 667 events (63.9%); sine and cosine calls each
fell from 33 to 9, while 128 unknown/fallback events fell to zero.

`CurveRegion2::involute_rack` uses the same certified line-ring materialization when
its already-computed tip width and root space are strictly positive. Those
inequalities, together with positive module, dedendum, and pressure-angle
tangent, make each authored x coordinate strictly increase and every tooth
slope nonzero; the closing root edge spans the complete rack width. Exact zero
root space formerly authored one duplicate edge and returned empty, so it is
still rejected before the certified path. The complete exact `Region2` matches
the former generic constructor across three valid parameter sets, and a
symbolically constructed zero-root-space case matches its empty result. Matched
30-sample medians fell from 0.0809 to 0.0309 ms/op (61.8%), with non-overlapping
0.0796--0.0834 and 0.0305--0.0318 ms interquartile ranges. The one-call trace
fell from 1,003 to 499 events (50.2%); unknown events fell from 92 to zero and
fallback/abort events from 93 to one.

`CurveRegion2::reuleaux` now recognizes the exact sampling alignment
`circle_segments % (4 * sides) == 0`. Under that certificate, every analytic
arc endpoint is already one of the regular-polygon centers, so the intersection
boundary is assembled directly from those shared centers and the intervening
source-circle samples. This visits the retained half-circle boundary once and
does not ask the general arrangement engine to rediscover known arc topology;
unaligned tessellations retain the former fallible Boolean path. The canonical
3-sided, 24-segment boundary matches the former Boolean's exact segment cycle.
An aligned 5-sided regression checks its single 10-segment material ring and
width. Across 30 samples, the median fell from the retained 12.409 ms/op
baseline to 0.0650 ms/op (99.5%), with a 0.0643--0.0685 ms interquartile range
and the same checksum. A one-call trace fell from 117,970 to 797 dispatch events
(99.3%); approximations and refinements remained zero.

`CurveRegion2::heart` no longer evaluates five exact trigonometric expressions per
sample, demotes them to binary64 for normalization, and promotes the results
back into `Real`. The multiple-angle terms are the exact polynomial
`y(c) = 4 + 19c - 2c^2 - 8c^3 - 8c^4`, so each station now evaluates one sine
and one cosine. Quarter-turn symmetry supplies the sampled x extrema, the
sample nearest pi supplies y-min, and the single derivative sign change makes
y-max an exact logarithmic unimodal search rather than a linear four-comparison
scan. Across 30 samples, the median fell from 0.3378 to 0.3130 ms/op (7.3%),
with non-overlapping 0.3366--0.3387 and 0.3068--0.3302 ms interquartile ranges.
The one-call trace fell from 3,857 to 2,742 events (28.9%), and cosine calls
from 128 to 32. Seven tessellation counts from 8 through 63 retain every legacy
finite coordinate within 1e-12 while now proving exact requested width and
height and retaining symbolic sample dependencies.

The shared curve-constructor target then completed 1,000
AddressSanitizer-instrumented executions (350 coverage points and 573 feature
edges). Supershape inputs retain negative, zero, and positive exact powers in
the bounded integer range -4 through 4 so fuzz throughput cannot be dominated
by arbitrarily large symbolic exponent expansion; this is a harness-only bound,
and the public constructor remains unrestricted. Its generated corpus exposed
exact-Boolean uncertainty in the legacy
fallbacks for a 3-segment keyhole and a 15-sided Reuleaux polygon. Those public
constructors now use the fallible Boolean surfaces and fail closed instead of
reaching the panic-based convenience methods; both minimized four-byte inputs
have permanent unit regressions and replay cleanly.

### Lazy cuboid topology and translated distributions

Cuboids now author six lazy indexed quads over one retained vertex pool. The
constructor reserves the exact eight position identities and two coordinate
identities per axis immediately, but it materializes none of the 24
face-corner vertices until geometry is read. TriangleMesh storage retains that cuboid
fact and initializes the shared topology-only transform layout only on its
first consumer. Eight separate lazy representative vertices let transform
layout traversal read unique positions without expanding the pool's 24-corner
index space. A dedicated cube cache key also validates its one extent once
instead of rebuilding and comparing a three-scalar cuboid key.

Linear and grid distribution now retain lazy translated copies rather than
constructing every output coordinate and face vertex before returning. The
pool preserves exact translation, face normals, plane identities, eight
positions per copy, and the authored two coordinate identities per axis per
copy. Materialization regressions force every lazy vertex, verify exact linear
and grid bounds, and check 64 position identities plus 16 coordinate
identities per axis for eight distributed cubes. Cache-hit cuboids, cubes, and
their translated results retain the same provenance checks.

In a matched 15-cold/9-warm focused sweep, box construction measured 26.45 us
versus CGAL EPECK's 36.90 us (1.40x faster), cuboid construction 6.56 us versus
14.90 us (2.27x), linear distribution 32.38 us versus 40.24 us (1.24x), and
grid distribution 23.26 us versus 70.59 us (3.04x). The subsequent full
47-workload sweep measured linear distribution at 13.56 us versus 39.89 us
(2.94x) and grid distribution at 11.29 us versus 67.90 us (6.01x); their warm
rows were 9.48x and 9.91x faster than CGAL. Every warm row remained at or
above native-kernel parity. Whole-suite cold box construction initially varied
to 35.27 us versus CGAL's 32.68 us. Focused and whole-suite results are both
retained because first-use code/data placement is substantially more variable
than repeated work.

Octahedra subsequently adopted the same lazy topology boundary: eight indexed
triangles reserve six exact position identities but defer their 24 face
vertices and eight sampled unit normals. A focused cold sweep measured 9.97 us
versus CGAL's 11.10 us (1.11x faster). In the following full sweep, octahedron
construction measured 1.89 us versus 8.63 us (4.57x), and box construction
returned to 26.69 us versus 33.73 us (1.26x). The only cold reversals were then
the noise-scale sphere/box union and translated-box center rows, at 0.994x and
0.990x CGAL parity respectively; their warm rows remained 19.79x and 5.33x
faster.

Constructor fuzzing also exposed an ellipsoid-only validation mismatch:
`segments = 1, stacks = 1` reached the shared sphere recipe even though the
sphere entry point rejects fewer than three segments or two stacks. Ellipsoid
now enforces the same tessellation contract before cache lookup, with a unit
regression for each underspecified dimension. The minimized four-byte artifact
replays cleanly, followed by 511 primitive-catalog ASAN executions and 14,082
transform-matrix ASAN executions without another failure.

## End-to-end dispatch evidence

Dispatch recording now occurs inside each selected benchmark closure, so setup
for unselected feature rows cannot contaminate a trace. The
`mesh_boolean/immediate_four` sentinel records four independent public Boolean
calls and four output-closure certifications. The former retained-state
comparison is intentionally absent; there is no cache or alternate extraction
surface to benchmark.

The public free writer surfaces now have their own in-memory benchmark rather
than inheriting evidence only from the `TriangleMesh` string-returning wrappers. The
nine-sample `mesh_io/public_writer_exporters` median is 45.934 ms for 314,636
materialized OBJ, PLY, plain AMF, colored AMF, and glTF bytes. Its isolated
trace records 151,935 dispatch events and one benchmark-entry marker, with zero
approximation, refinement, or unknown-fact events and checksum 314,636. Direct
writer-versus-string equality tests cover each format; the export-name fuzz
target completed 1,010 AddressSanitizer-instrumented nightly executions with
leak detection disabled for the ptrace-hosted runner. Separate nine-sample rows
retain format-level baselines: OBJ 8.996 ms for 44,308 bytes, PLY 10.647 ms for
137,970 bytes, AMF 8.621 ms, and glTF 8.838 ms for 41,659 bytes.

Replay the focused measurements with:

```sh
CSGRS_BENCH_FILTER=mesh_queries/graphics_buffers \
CSGRS_BENCH_SAMPLES=9 \
CSGRS_BENCH_WARMUP=2 \
cargo bench --bench feature_pipeline --features offset,bevymesh

CSGRS_BENCH_FILTER=mesh_io/all_exporters \
CSGRS_BENCH_SAMPLES=7 \
CSGRS_BENCH_WARMUP=2 \
cargo bench --bench feature_pipeline --features offset,bevymesh

CSGRS_BENCH_FILTER=mesh_boolean \
CSGRS_BENCH_SAMPLES=9 \
CSGRS_BENCH_WARMUP=2 \
cargo bench --bench feature_pipeline --features offset,bevymesh

CSGRS_BENCH_FILTER=mesh_queries/ray_intersections \
CSGRS_BENCH_SAMPLES=9 \
CSGRS_BENCH_WARMUP=2 \
cargo bench --bench feature_pipeline --features offset,bevymesh
```

## Audited non-adoptions

The reference section's cubic Bezier GPU distance algorithm is a finite
nearest-distance technique. It is not substituted for exact/adaptive topology
predicates, and `csgrs` has no current public curve-distance API that would
justify adding a rendering-specific approximation. Likewise, the CAD/CAM
hyperbook's interval, subdivision, and offset methods are not claimed as
certificates where the current implementation explicitly crosses a finite
adapter boundary.

Taubin's two-pass smoothing filter and the uniform Laplacian formulation in
Botsch et al. keep topology and per-valence weights fixed across iterations. An
experiment therefore retained the lambda/mu stencils and alternated two reusable
position buffers instead of rebuilding scale divisions and allocating each
pass. On `mesh_refinement/subdivide_and_smooth`, nine-sample medians were
113.870 ms for the existing implementation and 113.933 ms for the experiment;
the identical 276,830,400 checksum confirmed output preservation, but the timing
was indistinguishable and slightly worse. The production change was removed.
The existing end-to-end benchmark remains the regression sentinel; exact `Real`
neighbor accumulation, not vector allocation or valence-scale division, dominates
this workload.

The single-pointer linear convex-polygon intersection algorithm of O'Rourke,
Chien, Olson, and Naddor
(<https://asignatura.us.es/fgcitig/Articulos/09-A%20New%20Linear%20Algorithm%20for%20Intersecting%20Convex%20Polygons.pdf>)
was also evaluated as a shared Hypercurve specialization for the sampled
Reuleaux constructor. The retained general-Boolean baseline is 12.409 ms/op.
Exact strict-convexity certificates based on all half planes, prepared
self-contact plus local turns, and local turns plus a rotation index measured
26.32, 21.30, and 19.66 ms/op respectively. A final translated-source
provenance experiment reached 18.25 ms/op but still could not certify later
symbolic trigonometric edge-head relations, so it paid the specialization and
fell back. Its one-call trace remained effectively the general path (119,927
dispatch events and 1,930 AABB overlaps versus 117,970 and 1,930 at baseline),
with the same one-contour checksum. All variants and temporary provenance code
were removed. The retained aligned-arc optimization above succeeds by proving
the constructor's endpoint indices before any clipping and therefore does not
solve—or pay for—the shared predicate gap. Unaligned convex intersections still
need an algebraic trigonometric zero/sign certificate or source-direction facts
that survive emitted intersection fragments.

The glTF public writer was also changed experimentally from serializing a
pretty JSON string and copying its bytes to calling `serde_json`'s pretty
writer directly. Across 15 samples, its median moved from 8.838 ms to 8.791 ms
(0.5%); the baseline and experiment interquartile ranges overlapped, while the
direct path required an extra document-builder layer and writer-error mapping.
The experiment was removed. The format-level writer benchmark and byte-equality
test remain, so a future retry must demonstrate a material improvement while
preserving byte-identical output.

The isolated feature traces also keep the remaining large rows visible without
weakening their contracts. Symbolic profile offsets recorded 24,005 refinement
events because many trigonometric segment bounds cannot be decided structurally;
TPMS sampling recorded 22,784 refinements before its documented Surface Nets
preview boundary; smoothing recorded 68,074 rational reductions and 102,010
GCDs. Replacing these with primitive-float topology decisions, skipping offset
self-contact validation, or changing the smoothing stencil would change quality
or exactness rather than optimize the same result, so those substitutions were
not attempted.

## 2026-07-28: thin retained-evidence handoff and historical corpus gate

The corpus rows below were measured before the fixture moved to the optional
target-directory benchmark download. The timings remain as a historical
baseline.

CSGRS now forwards transform-derived exact support planes only when they are
already retained. An ordinary first Boolean no longer scans every polygon to
construct a complete Hypermesh `InputTrianglePlanes` array. If exactly one
operand has retained plane evidence, the missing aligned side is derived so
the plane-aware Hypermesh contract remains complete; if neither does, CSGRS
calls the ordinary certified-convex Hypermesh entry point.

The competitive YeahRight row also now constructs the exact 4,512-triangle
subdivision from the certified 1,128-triangle hull. The former harness parsed a
serialized subdivided mesh and rebuilt a convex hull from rounded coordinates,
creating a much harder arrangement than the native Hypermesh row. Output
conversion now exports positions and indices directly instead of computing
exact unit normals that no peer output contract required.

These staged fixes changed the false 18.3-second CSGRS row to:

| operation | fresh first call | repeated CSGRS | native Hypermesh |
| --- | ---: | ---: | ---: |
| union | 21.20 ms | 13.79 ms | 10.30--10.70 ms |
| intersection | 11.43 ms | - | - |
| difference | 12.84 ms | - | - |

Before the lazy plane-evidence handoff, the corrected fixture still measured
77.66/28.34/29.44 ms for union/intersection/difference. After that handoff and
before the output-contract change it measured 39.17/21.15/23.13 ms.

The final full serialized competitive run covered 54 portable workloads in
each of CSGRS, CGAL EPECK, and tight-tolerance OpenCascade. CSGRS won 46/54
against CGAL and 53/54 against OpenCascade. Across the 125 CSGRS rows shared
with the pre-change full run, geometric-mean runtime was 0.789x baseline. The
final one-sample 4,512-triangle rows were 20.45/11.89/12.58 ms for
union/intersection/difference, versus 18.50/17.72/18.00 seconds before the
fixture and handoff corrections.

The Rust competitive matrix exposes the scale crossover. CSGRS won all three
3,072-triangle subdivided-box Booleans at 3.32/2.95/2.92 ms, but lost the
4,512-triangle YeahRight Booleans to boolmesh and manifold-rust, whose rows
were 2.70--3.70 ms. On the 12 small Boolean cases, CSGRS won only the three
disjoint-box operations; the exact general path remains the principal
small-overlap deficit.

The original genus-131 control mesh was an always-on hard carrier/import row
for this run. CSGRS import measured 16.72 ms
versus 5.75 ms for boolmesh, 5.17 ms for manifold-rust, and 1.54 ms for
tri-mesh. Both layers also
retain an ignored rotated-copy intersection as the explicit memory-ceiling
test; it is not run routinely because the earlier CSGRS workload reached about
116 GiB RSS.