Commit Graph
3609 Commits
Author SHA1 Message Date
Brett LawsonandClaude Opus 5.5 2d84f8a172 smlib: solidcore's new opt-in fixes are on: sliver iso curves degenerate, Coons corner patches tangent to their sides, a fillet's own edge kept at a corner patch, the corner ball centred where the axes meet, one solution for a seam point, 2D boolean covers of far faces, area only between solid and void, a coincident definition split across the split point, the tight box from the interval's knots, overlapping bands refused, and the SSI tangent-curve tracer
Each is in the fork at develop's SMLIB_REV 1ccd4612 (tangency-labs/smlib 8088f5e, cae8618,
1072d1b, bc6ddf9, 577f7be, 67b8a1e, d2d9586, f11d0ac, 02fc29b, c0d74ee, and ef4ab25, e9fde8f,
d8c61db, 1693c9d), so solidcore stays with SolidCraft's C++.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 09:11:35 +01:00
Brett LawsonandClaude Opus 5.5 39adb66ad1 solidcore: move the pin to 55748ecf (main, with solidcore#1648, #1645, #1644, #1641, #1639, #1637, #1636, #1634, #1657, #1656, #1654, #1653, #1652, #1651, #1598, #1622, #1618, #1616, #1603, #1626, #1661, #1658, #1660, #1629, #1663: attributes through offsets, shells, booleans and copies (#1462 P2, P4), the tight box from the interval's knots (#1054), a merge's UV trims named after their edge use (#435), SM_API ordered-point surfaces, exact projection copies, and the fork's WR-562, WR-547, WR-546, WR-541, WR-537, WR-536, WR-535, WR-533, WR-542 and WR-75 opt-ins)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 09:00:08 +01:00
Brett LawsonandClaude Opus 5.5 436fae56a4 smlib: drafting a cylinder's side runs on solidcore (solidcore#1606, fixed by #1611)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 07:21:46 +01:00
Brett LawsonandClaude Opus 5.5 271f0a39ec smlib: a face's planar section runs on solidcore, as the capi's smlib_face_section (solidcore#1534)
SmBrep::CreatePlanarSectionCurves over the body with the 3D, UV and face outputs, the curve
tolerance as the approximation tolerance and bForceUVClassify left FALSE, as the capi calls it;
a face list not one per curve is unsupported, the picked face's curves go out as NURBS, none is
empty. The section of a lofted wall is the line across it, the same on both kernels. As the
capi leaves bForceUVClassify FALSE, a face on an analytic surface (a box's top, a cylinder's
side) has no UV curve and is trimmed away: both kernels report it empty, and the closed-form
circle on a cylinder is ignored on that.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 07:21:46 +01:00
Brett LawsonandClaude Opus 5.5 3346f41721 smlib: solidcore's new opt-in fixes are on: UV trim checks on the surface, loop orientation from the loop's box, cones extended as themselves, the local operation's box, joined drop pieces, exact edges on analytic faces after a shell, and the two SSI trace fixes
Each is in the fork at develop's SMLIB_REV 1ccd4612 (tangency-labs/smlib b4f8c57, 54ca3e0,
b283ea2, a1ee273, e36feb1, cd85d34, 0dbe681, 8d95600), so solidcore stays with SolidCraft's C++.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 07:21:46 +01:00
Brett LawsonandClaude Opus 5.5 9ceddd9d56 solidcore: move the pin to 937a6319 (main, with solidcore#1534, #1537, #1544, #1617, #1608, #1582, #1591, #1625, #1586, #1619, #1620, #1611, #1647, #1646, #1643, #1642, #1638, #1635, #1633: planar section curves, SM_API intersections, cut, HCR silhouettes on solids, UV trim checks on the surface and tiny loops oriented, projection, trimming, tessellated boundaries and knot removal, the fillet refusal that leaves the body unchanged, Cone::lean_cylinder as a cone, and the fork's WR-260, WR-550, WR-545, WR-543, WR-80, WR-534 and WR-532 opt-ins)
CreateParallelProjectionCurves now takes the curve itself (any of the SmBSplineCurve classes),
so smlib_project_curves passes its line, arc or B-spline as the capi's GetRootCurve() does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 07:10:25 +01:00
Brett LawsonandClaude Opus 5.5 1feba5af98 smlib: the bent-path sweep's ignore cites solidcore#1628
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 06:16:04 +01:00
Brett LawsonandClaude Opus 5.5 dd19f817f7 Merge develop ec4eebaa into solidcore (via ws/develop-sync-1030b)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 06:15:10 +01:00
Brett LawsonandClaude Opus 5.5 6a3558a966 smlib: a sweep along lines and arcs goes piece by piece on solidcore, as the capi does
SMLib 90aabff's smlib_sweep_placed sweeps a path of lines and arcs that turns with the path
(not closed, each piece leaving in the direction the one before arrives in) one segment at a
time, exactly: a line by the linear sweep, an arc by the rotational sweep, the profile
carried from each to the next, every piece's faces copied into one B-rep and stitched, the
caps the profile at both ends. The port (from solidcore#1581's head) sent that path to the
curve sweep, whose fitted walls differ from the C++ kernel's cylinder and torus. `segmented`,
`carried` and `piecewise` (with `Rigid` and `Segment`) are ported, ahead of the curve sweep.

On solidcore the second piece's copy fails: copy_faces without the merge into a B-rep that
already has faces finds no notification record for what it makes (solidcore#TBD, repro in
the bug file), so sweep_along_a_bent_path is ignored on solidcore until that is fixed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:59:06 +01:00
Brett Lawson 57dd2e7117 Merge develop ec4eebaa into solidcore 2026-10-30 04:47:38 +01:00
Brett LawsonandClaude Opus 5.5 97d79e3b88 smlib: the solidcore tag test names what still holds it back
solidcore#1568 (#1462 P1) carries a B-rep's attributes through a boolean, but the tags
`Brep::tagged` puts on the C++ body never reach solidcore: the crossing is the capi's flat
arrays, which carry no attributes (smlib.h, smlib_flat.cpp), and the history is read back
on the C++ body after the same crossing. tags_cross_a_solidcore_boolean stays ignored, its
reason now that crossing rather than solidcore.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:44:41 +01:00
Brett LawsonandClaude Opus 5.5 2ad118666f smlib: curvature-continuous rounds and corners left open on solidcore (solidcore#1438, #1439)
Wires solidcore#1597's per-session fillet options into the smlib crate's port of the capi's
round_edges and blend_call:

- solidcore#1438: a curvature-continuous blend runs the blend-curve section
  (SM_FSG_BLEND_CURVE, continuity 2) with `set_blend_curve_at_thirds` on before the edges
  are prepared, as round_edges sets SetBlendCurveAtThirds. The new case
  fillet_curvature_one_edge takes abc - 113/756 r^2 L (the quintic with its inner control
  points at thirds), to 1e-9, on both kernels.
- solidcore#1439: `smlib_blend_setback_open` sets `set_mark_corner_patches` and reads
  `corner_patch_faces` before the session drops; after the stitch each set-back corner's
  patch is the live faces (p1::faces) marked with its index, and any mark left on the body
  is removed (RemoveAttributeFromTopology). The capi's open_corners is ported: each patch's
  rim chained from the faces beside it, the patches deleted with their edges and vertices
  (DeleteFace(f, TRUE)), and the holes listed per corner point in the result's edge and
  face order. The C++ kernel's own test case (60 x 40 x 20 box, r5, set back 8) gives the
  same 9 faces, 30 edges, 22 vertices and the same twelve-edge hole on both kernels.

The module note drops the two refusals; the unsupported test keeps the variable law's
corner and the cliff.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:41:50 +01:00
Brett LawsonandClaude Opus 5.5 dafb25b4b9 smlib: the body check reads a Caller body's recorded keys on solidcore (solidcore#1584)
solidcore#1585 records the caller keys where a NamingScheme::Caller body is built (an array
import through make_topology_from_data, api_brep_copy), and check_brep checks the body
under them. So `check` runs plain check_brep on every body but an Unknown one, and the
keyed path for our own array imports (Keys::Convert, check_brep_with_keys under
convert::key_of) is gone. A Caller body whose maker recorded no keys (check_brep's
InvalidInput) is refused as not supported, as an Unknown body still is, never a failed
check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:36:53 +01:00
Brett LawsonandClaude Opus 5.5 744f7574d9 smlib: drafted extrudes keep their corners and curve sweeps keep the profile where it lies on solidcore (solidcore#1449, #1450)
Wires the two solidcore fixes into the smlib crate's solidcore port of the capi sweeps:

- solidcore#1449: `fixes()` turns on `taper_tangent_corner_planes`. `extrude`'s draft
  no longer refuses a sharp corner under the curvature rule (or the tangent rule with a
  profile of lines and arcs) as not supported: it calls
  `create_taper_extrude_with_corner` with the rule (curvature -> CurveExtension,
  tangent -> LinearExtension, round -> FilletCorner), and a refused corner is the
  capi's `Error::Corner { why, at }` (Apart, WallCloses, NotExact at the corner's
  point), as the C++ path reports `SmTaperCornerRefusal` and `pOptRefusedCorner`.
  The tangent/sharp/has_corner checks that only fed the refusal are gone.
- solidcore#1450: a sweep along a path that is neither straight nor arcs about one
  axis runs `create_curve_sweep_with_placements` with `profile_at_path_start` (and
  `translational_sweep` for a translating frame), and `placed` takes the first,
  middle and last placements. As in the capi's `smlib_sweep_placed`, round a closed
  path the ends are not capped (the caps would lie on each other inside the solid)
  and the faces are stitched, a lamina left being not solid.

The tests the two issues held back run again (extrude_square_drafted_curvature,
extrude_draft_wall_closes, sweep_along_a_bent_path), with a new case round a closed
rounded rectangle (Pappus). The module note drops the two refusals.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:26:40 +01:00
Brett LawsonandClaude Opus 5.5 c8adedaec2 smlib: solidcore's new fixes are on (taper tangent corner planes, holed revolve void, loose tangent edges refused, scaled extrusion origin zero, booleans skip faces apart)
The flags solidcore added since ddfb3895, each a port of a fork commit that SMLIB_REV
(90aabff) already carries, so solidcore and the C++ path agree with them on:

- taper_tangent_corner_planes (WR-521, #1449; tangency-labs/smlib e8f23e0)
- revolve_holed_profile_void (WR-529; 38b4212)
- local_operation_refuses_loose_tangent_edges (WR-530, #402; 23c5b0a)
- extrusion_origin_scaled_zero (WR-511, #1508; tangency-labs/smlib#31)
- boolean_skips_faces_apart (WR-527, #1526/#1527; 60b1c6a)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:26:40 +01:00
Brett LawsonandClaude Opus 5.5 d4cec2ca95 solidcore: move the pin to b2450cbf (main, with solidcore#1568, #1579, #1581, #1585, #1597, #1604, #1600: attributes through booleans, taper corner rules, the curve sweep, check_brep naming, fillet thirds and corner marks, WR-302)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:25:21 +01:00
jyvikoandClaude Opus 5.5 ec4eebaa82 sew: a folded pcurve has no piece shorter than it lifts onto its edge
A folded edge's Hermite pcurve on a bend's form breaks where the edge's angle crosses a
quarter. At the 120 degree corner with flanges at 60 and 90 degrees under a tear, an edge
starts 3.25e-12 of its parameter short of a quarter: the crossing was kept as a break
(breaks within 1e-12 of the parameter merged), the pieces halved to 1.6e-12, and SMLib,
given knots 1.6e-12 apart, handed the pcurve back with 15 equal knots at degree 7 ("SMLib
export: pcurve: loop 0 use 1: given pcurve: portable B-rep: knot multiplicity"). A crossing
whose point on the edge lies within the pcurve's lift accuracy (FOLD_TOL of the edge's size)
of the previous break is that break; the end is never merged into the start.

Fixes sheet::tests::every_pair_of_angles_is_torn_or_keeps_its_notch (torn pairs 37, 37, 27).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:20:47 -04:00
jyvikoandClaude Opus 5.5 ff9ccaf1e8 Sheet tests: the DXF outline and the folded volume as the exact flat pattern and measure give them
Two expectations encoded truck-era output:

- a_flange_bent_inside_keeps_the_base_sketchs_arcs_in_the_flat_pattern_and_the_dxf: the
  DXF has 7 LINEs, 4 ARCs, 11 shapes (was 9, 4, 13). The flat outline is SMLib's exact 2D
  union of the plate, the bend zone and the flange panel; a zone's side and its panel's side
  meet in line, and a region's boundary has no vertex in the middle of a straight run, so
  each flange side is one line: 6 outline lines (plate top, left, right; flange sides and
  end) and the bend's centre line. The same reason as 5d25684a1 gave for
  a_base_trimmed_for_a_flange_keeps_its_arcs (12 to 10 edges). Areas, the bend length and
  the volumes are checked as before and hold.
- hole_beside_two_adjacent_edge_flanges_cuts_and_bends_stay_guarded: the folded volume was
  14057.2 +- 0.1, a faceted measure; since 32ae0cd9c the measure is SMLib's exact integral,
  14057.3837123. Exactly, a folded sheet holds its flat area A times t, less each bend's flat
  strip L·t·(R + K·t)·π/2, plus its sector L·t·(R + t/2)·π/2: t·A + t²·(½ − K)·(π/2)·L. With
  t = R = 2.5, K = 0.44, A = 5597.0353454 (the flat pattern) and L = 75 + 35, that is
  13992.5883635 + 64.7953485 = 14057.3837120, within 2e-11 relative of the measure. The
  test now checks that identity to 1e-9.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:20:47 -04:00
jyvikoandClaude Opus 5.5 909f9a20e9 Sheet face names: a triangle takes a flat face's name only where that face faces its way
A face's sheet name is the name 80% of its mesh triangles' centres agree on. SMLib's
mesher fans a 1 mm rim (30 mm tall) into four triangles about its middle; two of their
centres lie 1/6 mm from the panel's top or bottom face, inside the 0.2·t tolerance, and
took that face's name, so the rim got no name (rim.side0/side1/ext0/ext1 of the tray's
flanges: 6 faces unnamed). A flat face's name now needs its plane to face along the
triangle's normal (within 1e-3); otherwise the point is a rim's, a bend's or an ext rim's.
No face changes name: these faces had none.

sheet::face_names_tests::a_trays_faces_have_readable_sheet_names_that_follow_its_size now
passes its naming checks and fails later, on the point named_face_point gives for a rim
(the roomiest triangle's incentre, 0.497 mm from the rim's edge, not 0.5).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:20:47 -04:00
jyvikoandClaude Opus 5.5 374d3b7e87 Sheet machining: a depth an ulp off the sheet's face is on it
A hole drawn on a flange's face and cut through ("direction": "negative") was refused as
"below the supported 0.000001 mm extrusion resolution": the flange panel's frame, turned
up by the cosine and sine of 90 degrees, puts the panel's origin at -1.9999999999999998
along the sketch normal, so the cut ends 2.2e-16 mm short of the sheet's far face and
reads as a layer 2.2e-16 thick. A depth within four units in the last place of the
numbers it is worked out from (the frame origins, the tool's span and the thickness) now
lands on the face. A real thin layer stays: a 1e-8 mm layer of a sheet 1e5 mm from the
origin (bound 9e-11 there) is still refused
(partial_depth_intersect_sub_extrusion_resolution_layers_refuse_atomically passes).

Fixes sheet::tests::a_sketch_on_a_sheet_face_follows_the_sheet_when_its_thickness_changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:20:47 -04:00
jyvikoandClaude Opus 5.5 41206c065b Sheet metal: a whole circle in the outline is sewn as its two exact halves
Since 09c979a4b a circle in a profile is one closed arc (Loop2::circle). The sheet's
faces passed it to the sew as one arc edge from a point back to itself, which the sew
refuses ("sew: a degenerate edge"): a sewn edge runs between two vertices, and an arc
edge is the circle through its ends and middle. A disc's flange failed (first with the
4-face minimum, then with the degenerate edge). Each closed curve of a cell is now split
into its two exact halves (Seg2::split_half) where the cell's edges are prepared, as a
hole's wall already came out: a disc is two caps and two half walls.

sheet::tests::tiny_cut_inside_exact_circle_survives_unfold_refold_and_dxf now builds the
disc flange and fails later, on SMLib's extrude of the 50 nm tool (an SMLib tolerance
defect, reported separately).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:20:47 -04:00
jyvikoandClaude Opus 5.5 beaed5b351 Kernel rig: threads/2369 names the tap maker's 6.8 mm drill for M8
The case expected "drill 6.75 mm for M8", the major diameter less the pitch.
Since 05f1c6b9a (Tapped holes: the tap maker's drill for every form) a tabulated
size names the tap maker's drill, 6.8 mm for M8 x 1.25 (Yamawa YEU23 p.704), as
case 2115 already grades and engine thread_tests.rs asserts; major less pitch
is for a size no table lists. The refusal itself and its reason are unchanged.
The case passes and leaves threads/KNOWN_FAILING.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:18:03 -04:00
jyvikoandClaude Opus 5.5 a0a75dc781 Kernel rig: import/4561 passes, off the known-failing list
The zero-area triangle is dropped (previous commit): the box converts with six
faces and V = 1000 mm^3, as the case expects.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:18:03 -04:00
jyvikoandClaude Opus 5.5 48d72ba2be Convert Mesh: a triangle of no area is dropped, not refused (#4561)
A triangle whose corners lie on one line (or weld into one another) adds no
surface, so welding now drops it, with any corner only it used, instead of
refusing the whole mesh as having a degenerate triangle. The closed and
consistently oriented check that follows still refuses a mesh that needed it to
close, and a mesh of nothing but such triangles is refused by name. Dropping its
unused corners keeps a dropped triangle from widening the part's extent, which
the prism search reads from every position.

Regression test a_zero_area_triangle_is_dropped: the 20 x 10 x 5 box with the
case's extra triangle (0,0,0) (10,0,0) (20,0,0) converts to six faces and
V = 1000 mm^3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:18:03 -04:00
jyvikoandClaude Opus 5.5 1ae748417a Robustness: seed 5's edge-only join keeps two bodies, as joins have since 94ee28d5c
fixed_seeds_run_clean expected the join of a box touching the first only along
an edge to be refused with "zero-thickness edge contact". Since 94ee28d5c (doc:
a join keeps solids that only touch as separate bodies) such a join succeeds and
keeps the new box a body of its own with an along_edge notice, which
join_touching_along_an_edge_keeps_a_separate_body asserts in engine tests.rs.
The seed now expects that: the notice, two bodies, each valid, and the volumes
unmoved, 25 x 15 x 10 + 17.5 x 17.5 x 20 = 3750 + 6125 mm^3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:18:03 -04:00
jyvikoandClaude Opus 5.5 191c1b8551 Fair: a net of up to 128 x 128 control points, the band bounding the solver
SMLib's thickening of the test sheet makes a top face of 72 x 78 control points,
which the 4096-point cap refused (TooLarge) before the solver saw it. The band
cap (2^21 entries, 16 MB) is what bounds the system's memory and its
factorisation (at most n min(n, bw)^2 work); the 72 x 78 bicubic net needs
5320 unknowns 213 apart, 1.14 M entries, well within it. The point cap now
bounds only the per-step energy sweep and the net's copies: 2^14 points, above
the band's own limit for square bicubic nets (about 90 x 90), so a face is
refused for the system it needs rather than its size. The hostile-input test
asks for 129 x 129 and checks the refusal is TooLarge.

a_body_face_is_faired_with_its_edges_untouched_and_its_history_kept passes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:18:03 -04:00
jyvikoandClaude Opus 5.5 db757efc7c Tests: the pi case and the hole wall read as on green-truck-era-tests, so both branches agree
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 2debdd87ae Pi case test: each standoff is four faces, its walls one face each
The README demo's Raspberry Pi case stands four standoffs on its floor: Extrude2's ring of
radius 3 round a 1.25 hole, patterned by RectangularPattern1. Each is its outer wall, its inner
wall, its top and the floor inside it: four faces. The recorded counts were truck's, which made
each cylindrical wall two halves (six faces a standoff): 25 after feature 6, 43 after the
pattern, and 8 more than now at every step after it. On SMLib each wall is one face closed on
its seam, and the counts are 23, 35, 35, 47, 47, 51, 51, 55, 71 from feature 6 on (the feature
names show it: F6:side:c1, F6:side:c2, F6:top and the floor piece bounded by F6:side:c2 per
standoff). The outer sides stay one face each, and (b) and (c) still agree step by step.

Fixes cli rebuild_topology::pi_case_faces_per_step_at_both_heights.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 4ebc3d0782 UI tests: the thread catalogue's error and Press Pull's hole wall as they are now
- A modelled thread reopened with the designation 1/4-20 UNC on the M8 it was made as: the
  thread is metric, and since b4549d270 (threads in the standard forms) an unknown designation
  is named with its form: "unknown metric thread `1/4-20 UNC` (like M8 or M8x1)". The test looked
  for the old wording, "ISO metric".
- Press Pull on a hole's wall opens Offset Faces with the whole wall: one face, closed on its
  seam, on SMLib (a cylinder wall was two halves on truck).

Fixes ui-egui dialogs_thread::contribution_tests::expanded_catalogue_rejects_external_taper_holes_and_nonmetric_thread_features
and preselect_tests::press_pull_then_curved_face_offsets_it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 514426e5d6 STEP import: a closed spline a face lies across the start of starts clear of the face
A face on a B-spline surface closed around u (first and last control columns the same) may lie
across the surface's start without winding round it: the strip on a radius-3000 rational
cylinder whose seam is 0.001 rad into the strip. A kernel's trims run inside the surface's
knots, so its pcurve came back clamped at the start, 2.28 mm off its edge, and the strip was not
imported.

Before seams are added, such a surface is started anew in the middle of the stretch of u the
face leaves free (each loop followed round, unwrapped across the start; a face winding round is
the seams' to handle): the new start inserted to full multiplicity and the piece after it put
before the piece before it, a period on. The same points, a period apart in parameter before
the new start: exact. The face then lies inside the knots.

Fixes kernel step_in::tests::explicit_outer_bound_crossing_a_closed_nurbs_seam_stays_trimmed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 1a02890118 Planar region tests: edges on one line are one edge of the result
Two tests counted the old 2D boolean's edges, which kept a vertex wherever an operand's corner
or edge end lay on another's edge. SMLib's planar boolean leaves no vertex that is no corner:
edges on one line within the tolerance are one edge. The results are the same regions with
fewer, whole edges, and each test's point stands (no edge shorter than the tolerance, no sliver):
- a quadrilateral cut away from below a square whose bottom edge it lies on within 1e-8 (tilted
  1e-9 rad) leaves the square's four 10 mm edges (its corner at x = 4 is within 1e-8 of that
  edge's line), and its union runs along y = 0 as one 14 mm edge (the quadrilateral's bottom
  edge is within 1e-8 of y = 0 all along): [4, 5, 5, 10, 10, 14];
- the bent plate and the strip under it: their ends on the line x = 150 are one edge from
  y = 47 to 80, six edges for every turn and offset tried, the shortest 3.

Fixes prism::planar_tests::overlapping_lines_a_hair_from_parallel_do_not_cross and
a_bent_edge_crossing_its_neighbour_by_their_corner_leaves_no_sliver.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 64188ce435 Planar regions: a hole goes to the material that holds it, read closer than the hole lies
Reading a planar sheet's faces back as regions, each hole went to the smallest outline whose
Loop2::contains held its middle: even-odd against the outline's polyline within 1e-3 mm. A
5e-5 mm square cut 1.7e-4 mm inside a radius-10 circle lies outside the polyline's chords there,
so no outline held it and the cut failed ("face 0 has a hole outside its material"). An
outline now holds a point by its polyline within a quarter of the point's distance from it (its
nearest point on the exact segments), which no chord can pass the point by.

Fixes kernel prism::planar_tests::tiny_tool_between_circle_and_display_chord_is_not_lost.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 f8b45f2772 STEP import: a void reads as a cavity whichever way its shell flag points, again
94bd8719a (#3730) turned a BREP_WITH_VOIDS void inside out when it enclosed volume of the
outer shell's sign: SOLIDWORKS writes .F. over a void shell already facing into its cavity,
SolidCraft .T. That lived in the truck reader; the schema-4 reader (crates/step) that replaced
it took the flag alone, and the block with a 20 x 6 x 5 cavity read as 15600 (the cavity added)
instead of 15000 - 600 = 14400.

The reader now takes each void's sign from the faces themselves before it orders the record:
the divergence theorem on the record's surfaces and pcurves (sew's face_flux of p / 3, moved
to geom's brep::eval so both use it). A void enclosing volume of the outer shell's sign has its
faces turned over. Flipping on the finished record is not an option: its edges are ordered by
the faces' sides.

Fixes kernel step_in::tests::a_void_reads_as_a_cavity_whichever_way_its_shell_flag_points.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 e5476706b1 Issue 616 test: the lid's volume is its closed form, 6703.5344
The expected 6703.5222 was a mesh measure (truck). The lid exactly: the 76.8 x 89.3 x 2.4
plate less its four 3 mm corner rounds ((76.8 * 89.3 - 36 (1 - pi/4)) * 2.4 = 16441.2344), the
skirt ring ((71.5 * 84 - 68.5 * 81) * 3 = 1372.5), less the window (68 * 61 * 2.4 = 9955.2) and
the slot (44 * 10 * 2.4 = 1056) through the plate, and the notch through the skirt's 1.5 mm wall
(22 * 1.5 * 3 = 99): 6703.534401. The window and slot lie inside the ring's opening and the
notch above the plate, so nothing else overlaps. SMLib measures 6703.534401575, 2.6e-7 off.
The test now computes that closed form and holds the body to 1e-6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 a100c7c063 Loft rails: a station grows about its section's centroid by length, not the mean of its control points
A whole circle is now one closed rational curve (Loop2::circle is one segment), whose first
control point is repeated as its last: the mean of its nine control points sat r/9 towards the
seam, and a rail scaled each station about that point. A rail bulging from radius 10 to 15
(r = 10 + 5 sin(pi z/40)) then grew the circles as if r = 10 + 5.625 sin, volume
4632.8 pi + 9000 = 23553.9 against the solid of revolution's pi * integral r^2 dz =
4500 pi + 8000 = 22137.2 (+6.4%; the engine's arc rail +6.5%).

The middle is now the curves' centroid by length, integral x ds / integral ds (8-point
Gauss-Legendre per knot span on the rational point's speed): the shape's alone, however its
curves are written; a circle's is its centre. geom's GAUSS_8 is public for it.

Fixes kernel loft_rails_tests::a_bulging_rail_makes_the_solid_of_revolution_of_the_rail and
engine loft_rails_tests::a_rail_turns_a_loft_into_its_solid_of_revolution_and_stretching_is_an_edit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:59 -04:00
jyvikoandClaude Opus 5.5 8c37bc7568 Fillet rig: R10 past the full round is refused naming 7.5 mm, as the case asks
fillets/4782-fillet-two-end-verticals-past-a-full-round passes: SMLib (90aabff) refuses
R10 on the 15 mm wide box's two end verticals as too large, and the refusal now names
the largest radius that fits, 7.5 mm (the full round). Run on aarch64 Linux with
--known-failing: every other fillets case as listed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:55 -04:00
jyvikoandClaude Opus 5.5 c47c1d26a6 Tests: the fit and taper tests use geometry that still doesn't fit
Under the blend-overflow decision (237f0ae74) a convex round running over a face's far
edge (a cliff) is built and cut from the part, so the truck-era fixtures of the reduce
and taper fits (a 2 mm fin, a plate narrowing to 2 mm, a wedge, a 10 mm cube's edge at
R20) no longer refuse their radius and the fits have nothing to react to. Each test now
uses a case SMLib still refuses, and checks the cliff case builds:

- engine fillet_fit_reduce_keeps_the_radius_where_it_fits: a 14 x 6 x 10 post on a
  40 x 30 x 20 block, its four verticals at 3.5 (two rounds would cross on its 6 mm ends)
  reduced to 3 on 4 of 5 edges, the block's corner kept at 3.5: 24840 - (4 - pi) 90 -
  (1 - pi/4) 3.5^2 20. New fillet_fit_reduce_keeps_a_round_over_a_cliff: the fin's R4
  builds, nothing reduced, at the kernel's fillet_max_each answer.
- engine fillet_fit_taper_follows_the_room_along_the_edge, spline_fillet_takes_over_a_taper,
  kernel taper_follows_the_room_along_the_edge, ui-egui fillet_spline_handle_tests: the
  narrowing plate stands against a wall behind its slanted side (z -15 to 30), so its top
  and bottom end in concave edges: R3 is refused and tapers 3 -> 1.8 as before. Without
  the wall, R3 is cut over the 2 mm top's far edge and kept constant: at x the section
  loses (1 - pi/4) 9, or 3 w - (F(3) - F(3 - w)) where the top is w < 3 wide, 6522.7745566.
- The wedge closing to a point: on its own R16 is cut over its cliffs (the section
  integral, 4195.578821, SMLib within 4e-8) and kept; its room's taper is checked as a
  spline fillet. Against a wall (new fillet_fit_taper_closes_to_a_point) the taper must
  close to 0, which SMLib fails today (status 1001).
- kernel taper_mesh_tests: the collapsed taper is built from taper() as a spline fillet.
- ui-egui the_feature_menu_copies_a_warning_message: the 10 mm cube's four verticals at
  6 are reduced to 5 (a full round), which the warning says.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:55 -04:00
jyvikoandClaude Opus 5.5 deaf8e6793 Tests: convex blends past a cliff are cut from the part, as the owner decided
The owner's blend-overflow decision (2026-10-25, 237f0ae74): a convex round or chamfer
whose rail runs off its face across a cliff (an opening's rim, a hole, the part's
outline) is built on the faces continued and what it removes is subtracted, so it never
bridges an opening; a round may use up a face; a chamfer of a face's full width stays
refused. These tests still expected truck's refusals. Each now expects the decision's
body, with its answer from the geometry:

- issue_1080 chamfer_into_a_pocket_is_cut_by_it (was ..._is_refused_with_the_size_that_fits):
  chamfer 6 into the pocket 4 mm in removes 360 - 20 (its triangle less the part over
  the pocket): 14660; 6 along the top and 2 down, 120 - 20/3; 2 and 6, 120.
- issue_1080 fillet_into_a_pocket_is_cut_by_it_and_one_that_fits_builds: R5 removes
  (1 - pi/4) 25 along 20 less 10 (5 - (sqrt(24)/2 + 12.5 asin(1/5))): 14893.0344442.
- issue_1080 chamfers_crossing_each_other_are_refused: still refused (they cross);
  chamfer_max and fillet_max find 2 mm.
- issue_1080 rounds_on_both_sides_of_a_wall_build_as_one_fillet: R7 alone opens a slit
  where its arc passes the inside corner: V0 - (104 (1 - pi/4) 49 - 100 a), a = the square
  [25, 30] x [35, 40] outside the circle about (25, 35), 5 (5 - sqrt 24) - (F(5) - F(sqrt 24)):
  38458.8958265. Both at R7: the arcs about (25, 35) and (23, 33) cross only outside both
  quarter arcs and the inner round's material holds the slit, so V0 - 4 (1 - pi/4) 49 =
  39509.9380404 (was expected refused).
- issue_324 a_round_into_a_hole_is_cut_by_it (was the_radius_offered_beside_a_hole_fits):
  R4 over the r3 hole: 8000 - 90 pi - (640 (1 - pi/4) - the round's height over the
  hole's width, integrated with y = 17.5 - s^2): 7580.2873154.
- issue_851 arc_top_blend_uses_up_the_wall_and_refuses_a_collapsed_one: a round of the
  wall's full height uses the wall up (one face for the wall, the removal integrated as for
  the other sizes); the full-height chamfer stays refused.
- kernel tests: fillet_max_finds_the_largest_radius_that_works keeps the post (3.5 -> 3)
  and the no-edge case; its disc and notch cases move to
  rounds_past_the_bottom_of_a_wall_are_cut_from_the_part: the 2 mm disc's R2.5 turned
  section, pi (338 - integral of (169 - rho^2) dz), rho = 10.5 + 2.5 cos(theta) (the same
  formula gives SMLib's R2 994.15188 exactly), 957.6922389; the notched block's outline
  R7, 11925 - (1 - pi/4) r^2 (140 - 8 c), c = r (10 - 3 pi) / (3 (4 - pi)) (SMLib's R7 within
  5e-8), and R8 less its part over the notch, integral of 2 (5 g - g^2/2), g = 8 - sqrt(64 - t^2).
- kernel tests: chamfer_wider_than_sloped_basin_rim_is_cut_and_a_full_width_one_refused:
  past the 1 mm and 0.5 mm rims the chamfer runs over the slab's front edge and is cut:
  the clipped triangle's area (30 + z centroid), its length 60 - h between the sloped end
  walls (the same formula gives chamfer_sloped_basin_rim's fitting chamfer to 1e-12);
  a chamfer as wide as the rim is refused.
- blend_corner sloped_rim_fillets_stay_inside_the_material, equal_slope_rim_loops_stay_
  inside_the_material: R4 and chamfer 2 over the thin rim build, every vertex inside the slab.
- engine blend_fit chamfer_through_the_openings_is_cut_by_them: the report's 9 mm chamfer
  is cut by the openings, 3350 (the rig's fillets/1080 case).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:55 -04:00
jyvikoandClaude Opus 5.5 8bcd81244b Tests: a blend refused as too large is SMLib's NO_ROOM, in its own words
Since bcbb99005 a blend larger than its faces is SMLib's refusal (KernelError::TooLarge,
"the fillet is larger than the faces beside its edges allow"); truck's room check, whose
words these tests still matched, went with blend_fit. The refusals themselves stand:

- fillet_consuming_a_side_face_makes_a_full_round: R3.001 and R3.5 on the 14 x 6 x 10
  box's four vertical edges, past the full round, are refused as too large (no longer
  "larger than the neighbouring faces"); the body unchanged is its own volume before
  (SMLib's measure of the box is 839.9999999999998, not 840 bit for bit).
- a_chamfer_that_would_grow_the_part_on_a_convex_edge_is_refused: refused as too large;
  the word "convex" was the old check's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:55 -04:00
jyvikoandClaude Opus 5.5 d945cf53a0 Fillet and chamfer: a refusal as too large names the largest size that fits
When the kernel's room pre-check went (bcbb99005), a fillet or chamfer refused as
too large stopped saying what would fit: only SMLib's NO_ROOM words were left. The
rig expects the refusal to name it (fillets/4782-fillet-two-end-verticals-past-a-full-round:
"the largest radius that fits is 7.5 mm", fillet_max for the exact fit).

A constant fillet with the exact fit, and an equal-distance chamfer, refused as too
large now add "; the largest radius (distance) that fits is X mm", found by the same
bisection fillet_max runs (up to 16 blends, three significant digits), now shared with
a new kernel::chamfer_max. Where the search itself fails (a candidate failing for
another reason), the refusal is left as it was. The reduce and taper fits and the
kernel's own searches call the kernel blends directly and do not pay for it.

Tests: the 14 x 6 x 10 post's R3.5 names 3 mm; a 4 mm rib's crossing chamfers and
rounds at 3 name 2 mm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:55 -04:00
jyvikoandClaude Opus 5.5 44b7793642 Tests: a point path's sweep has a wall along each line; coplanar walls join at a corner
sweeps_along_paths expected one wall for the circle swept through 41 points of
a smooth curve: a point path is the polyline its points make, swept line by
line and mitred at each point since 43e8b0349 (sweep_path's own test expects
40 + 2 faces since d9274aaf1), so the circle's one segment has a wall along
each of the 40 lines.

The holed square along the L-shaped path expected two faces per segment. The
corner turns the profile about Y, so each line at a constant y (the outer
loop's segments 0 and 2, the hole's 1 and 3) sweeps the plane y = c it lies in
along both legs, and the two walls meet edge to edge on the mitre in that one
plane: one L-shaped planar face. The lines at a constant x sweep two planes,
two faces. check_sweep takes the count per segment.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:51 -04:00
jyvikoandClaude Opus 5.5 1e4b644028 Provenance: a sweep's origins are the ones it recorded
sweep_origins read a sweep_path tool's faces by the truck face order (walls in
profile order, then the start and end caps), and fell back to swept_origins,
which names a face without an edge in the profile's plane an end cap. SMLib's
sweep along lines and arcs is made piece by piece and mitred at each corner
(tangency-labs/smlib#43), so most walls start further along the path: 39 of a
44-face sweep came out as end caps (105 of 110 before the previous commit). The
sweep records each face's origin as it builds it (Body::history), and
sweep_origins now returns those, finding by geometry only a face the tool names
no origin for. swept_origins says what it holds for.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:51 -04:00
jyvikoandClaude Opus 5.5 1ee5f1af30 Kernel: a mitred sweep carries a slanted section all the way to each mitre
A sweep along a path with corners sweeps each run past its corners and cuts it
back to the plane halving the corner. The lead past the corner was the
profile's reach times tan(turn / 2), enough only for a profile square to the
path. A point standing s ahead of the path and w from it needs
w tan(turn / 2) - s past a corner (w tan(turn / 2) + s before one): a profile
at a slant to its path reaches across the mitre by its slant as well, and a run
carried short of it leaves a notch with a piece of the run's section in it.
The section keeps both distances along a run and through each corner (it
turns with the path; a twist keeps them, an end scale grows them by at most
its largest scale), so the lead is taken from the profile's points at the
start, for the plain and the controlled sweep. A profile square to the path
(s = 0) leads exactly as before.

The walls' history seeds sat at the middle section of each run, which for a
slanted profile on a run shorter than its slant lies past the mitres, on the
next run's wall: half the walls came out generated. Each piece's seed now sits
half way along the stretch its own point keeps between the mitres, carried
there exactly along lines and arcs (as SMLib's sweep turning with the path
carries the profile), at the station there in the controlled sweep.

A flat 4 mm square swept along 21 points of a rising sine (provenance test):
110 faces, 66 of them notch faces, and walls left unnamed; now 44 (two caps, the two
walls in the path's plane, a wall of each slanted side along each line), volume
16 cos(slant) L to 1e-6 (new test a_slanted_profile_meets_itself_at_every_mitre).
The square round a closed 122-line polyline (issue_2005
closed_polyline_sweep_shares_its_starting_section): the first section leaned
by half a chord's turn left a 6.2 mm^2 piece of it at the closing mitre, named
the start cap; now 246 faces, every one a wall.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:51 -04:00
jyvikoandClaude Opus 5.5 b6c3bf3c53 Face capture test: an Offset Face's top is anchored by its exact history name
legacy_internal_capture_refuses_an_uncaptured_source_in_another_component
picked the top Offset Face raised as a face with neither a construction
certificate nor an exact history name (#494), to reach the legacy path
that refuses a profile across components while the source occurrence's
move is uncaptured. Offset Face has SMLib's history since 0f3d6f177 (shell,
offset faces and thicken through SMLib), so that top is now named exactly
(F3:+z#[F3:-x], verified) and capture_face_anchor gives it a lineage
anchor; the legacy path is not taken, and the capture is right to
succeed: an anchored attachment captures its path's pending positions
when it is made (capture_positions).

The test, renamed to what it now checks
(internal_capture_in_another_component_anchors_an_offset_face_by_its_history_name),
asserts the face still has no construction certificate, the capture is a
Lineage anchor on the occurrence's path, and capturing changes neither the
document nor the pending moves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:46 -04:00
jyvikoandClaude Opus 5.5 b9d0a33080 Mesh memo test: SMLib's booleans mesh neither operand
The test cut three regions from a plate that keeps its meshes and
expected the memo to hold one mesh afterwards: the old kernel's booleans
meshed their operands. On SMLib (ops::boolean -> smlib_boolean, since
42c41464a) a boolean reads the exact record and a tool apart from the
body is found from the exact boxes, so no boolean meshes anything and the
memo is empty after them. The test now asserts that, then that meshing
the kept body twice at one tolerance makes one memo entry, bit-equal to a
fresh mesh, which is the reuse the memo is for.

Fixes kernel body::mesh_memo_tests::regions_cut_from_a_body_keeping_its_meshes_are_unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:46 -04:00
jyvikoandClaude Opus 5.5 e1b762c4bd Booleans and Shell keep the lines faces were split along on purpose
Split Face records its lines on the body (split_lines): heal and the
certified-planar regularizer keep the faces apart along them, and they
make the body regularization-protected. On SMLib the boolean, the n-way
union and Shell carried the protection over but dropped the lines, so a
body with an authored split lost its record after a Union with partial
contact (issue #674/#782's case), and a shelled one after Shell. Each
result now keeps its operands' lines, each line once
(Body::inherit_split_lines), as the old kernel's coplanar join did.

regularization_protection_tests: SMLib's shell makes no section strips,
so the painted cup no longer has more faces than the ordinary one. The
ordinary cup is the box's five kept faces, their five linings and the
rim: 11. A paint over a whole face authors no boundary inside it, so the
painted cup has the same 11 faces; the split side's line stays an edge on
the wall and its lining: 13. The test now asserts those counts exactly
(it asserted more than 11 for both, the old strip route's witness) and
that the split lines survive.

Fixes kernel issue_674_tests::partial_contact_retains_an_authored_split_away_from_the_contact
and body::regularization_protection_tests::stamped_shell_keeps_authored_painted_and_split_boundaries.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:46 -04:00
jyvikoandClaude Opus 5.5 f60bf96dfb Planar sources test: two bodies side by side joined as the record requires
The test helper side_by_side copied the second body's regions by hand,
dropping its voids and keeping its infinite region (region 0) as if it
were a bounded one. Its closed shell was then the outer shell of two
regions, which the portable record refuses ("a closed shell bounds two
regions and encloses one"). The helper now joins the two records with
geom's brep::part::compound, which puts each body's outer shells in the
one infinite region and keeps its bounded regions; the face sources are
still found by plane afterwards, so nothing the test checks changes.

Fixes kernel body::planar_sources::tests::coincident_competing_source_planes_and_tool_planes_stay_unknown.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:46 -04:00
jyvikoandClaude Opus 5.5 049b2bc405 Lumps: a face-source table of another length is refused, never sliced
Body::parts (and so Body::lumps) mapped each piece's faces through the
body's face-source table with a silent `get`, so a table shorter or longer
than the body's faces gave its pieces sources of other faces, or none. The
table is by face position: one whose length is not the body's face count
belongs to another body. The pieces are now refused with "lumps: face
source table does not match the body", as before the SMLib port (the check
went with the old lumps_with_clearance in 66e31bede).

Fixes kernel body::lump_tests::grouping_lumps_does_not_infer_absent_or_misaligned_sources.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:46 -04:00
Brett LawsonandClaude Opus 5.5 7b0b1f63b7 Merge develop 322ac259 into solidcore (via ws/develop-sync-1030: SMLib 90aabff test expectations, the closed-sheet offset and cylinder draft ports)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
2026-10-30 04:17:44 +01:00
jyvikoandClaude Opus 5.5 15c31a96fc Kernel: planar source lineage finds each face's support through an index, with no budgets
Which input plane each result face lies on was found by scanning every input plane whose
normal x was within the resolution's angle: quadratic on axis-aligned parts (two thirds of the
faces have normal x = 0), so it was capped at 16 384 faces a body and 2 M comparisons, and the
join of the 20 level-2 sponges of a level-3 Menger sponge (7 326 faces) was refused past the
comparison budget.

The planes are now indexed by their unit normal, in cells twice the bound on two matching
normals' difference (asin(angular) < 2 angular), and in each cell by their offset from a common
centre, searched in the window linear + |a.o - c| |n_b - n_a| that
d_b - d_a = (b.o - a.o) . n_b + (a.o - c) . (n_b - n_a) gives, plus rounding slack. The index
offers a superset; same_support still decides each match, and candidates are taken in the same
order as before, so every answer is unchanged. A plane with a normal not of unit length is
offered to every query. Both caps are removed: results are bounded by inputs capped where they
entered. The descriptor-size budgets on kept roles are unchanged.

Rig, --known-failing, results compared case by case with develop's: booleans (129) and shell
(28) identical except booleans/5126-join-menger-sponge-level-3, which now passes in 38.9 s on
aarch64 and leaves KNOWN_FAILING.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 23:17:42 -04:00