Commit Graph
2741 Commits
Author SHA1 Message Date
bherbruckandClaude Opus 5.5 b886ac36b9 solidcraft-smlib: the fork at be3fc10, whose boolean no longer reads a freed edge
A gap the boolean fixed on one side only left the freed edge in its common-edge map, and the next
pass read it: a square-wire coil cut into the wall of a bore crashed the process on SMLib
(sweeps/2552). It now fails with an error.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 a043e4ae2d kernel: an SMLib blend's corner patch comes from the edges meeting there
SMLib leaves a corner patch where blends meet untagged, and blends() matches no single edge to
it, so it had no origin, and the edges between two blend faces (two chamfers' mitre) none
either. The history checks refused both (modify_history_tests' corner, whole-box and mitre
cases on SMLib). Now a patch without origin is made in place of all the edges of the blend
faces beside it, as truck records a corner, and every edge of a face new to the blend is where
its two faces meet.

modify_history_tests with SOLIDCRAFT_KERNEL=smlib: the three blend cases pass (28 of 30; the
painted shell and the painted box cut's pieces are the shell's and boolean's). Truck: 30 of 30.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 ae1d746ae1 kernel: chamfers with two setbacks through SMLib
With SOLIDCRAFT_KERNEL=smlib, chamfer_sides (two distances, or a distance and an angle) runs
SMLib's new unequal chamfer instead of being refused: `d1` back along the face facing up most
(down most with `flip`, as truck's chamfer_sides picks its first face), the other side by the
distance or angle, with the body's history as for the other blends. A radius law SMLib refuses
as having a corner is "not supported yet", never truck's round.

Tests (with the feature): 5 and 2 on a cube edge either way round (the top face keeps 15 or 18
of its 20, the chamfer face comes from the edge), 5 at 45 degrees, and the corner law refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 07c36cfd01 solidcraft-smlib: Brep::chamfer_sides, and Error::Unsupported for a radius law with a corner
Brep::chamfer_sides reaches the fork's smlib_chamfer_sides: `distance` back along the face
whose outward normal leans most along a given direction, the other side by a second distance
(ChamferSecond::Distance) or at an angle to the first face (ChamferSecond::Angle). The fork's
smlib_fillet_variable refuses a radius law with a corner with SMLIB_ERR_UNSUPPORTED, which the
crate reads as Error::Unsupported ("not supported yet"): SMLib's section fit ran smoothly
across the corner and missed the law (4 -> 2 -> 4 on a 20 mm edge took 35.1 mm3 for 40.1;
tangency-labs/solidcore#430). Both are in the fork at the pinned bf7c272.

Tests (ops_tests.rs), against analytic values: 5 and 2 either way round (the centroid tells
which face took the 5), 5 at 30 degrees, rejected arguments; a quadratic law 4, 1, 4 and a law
down to zero (1e-5), the corner law refused and the same points joined C1 built.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 714475b84d kernel: measure through SMLib's exact mass properties, checked against the mesh
With SOLIDCRAFT_KERNEL=smlib, kernel::measure and measure_mass take volume, area and centroid
from SMLib's Brep::mass_properties (integrated on the exact surfaces, accuracy 1e-8). The mesh
measure is still made, as an independent check. Where SMLib disagrees with it beyond the mesh's
own accuracy (1e-3; tangency-labs/solidcore#384), or can't take the body, the mesh measure
stands and the measurement says why. BodyMeasure and MassMeasure carry `measured_by` (smlib |
mesh) and `notes`, and inspect.measure shows both. The box and topology counts stay the mesh's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 f4da252435 solidcraft-smlib: the fork at bf7c272, whose operation results hold their own gaps
SMLib's tolerance update now fixes the vertex gaps its check reports (gaps over half a vertex's
tolerance), and every boolean, blend, shell, offset and sweep result grows its vertex and edge
tolerances over gaps below SMLib's own rounding bound before it is handed out. A thread's groove
cut from a shaft no longer fails SMLib's check on vertex gaps of about 1e-5 mm, and an offset
sphere face no longer fails it on an edge gap of 5.015e-6 against 5e-6 (shell/2939).

Also carries the fork's blend commits since ca2559f (second offset per edge, two-setback
chamfers, variable radius laws with a corner refused) and the IGES knot check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 8ad09ec64c smlib export: a face's loop crosses its poles where the face's parameter box says
Where two edge uses of a loop meet at a pole (meridians of a sphere), the periodic parameter's
jump there is free, and the pcurves took whichever jump made the loop counter-clockwise. Two
meridians a three-quarter turn apart bound a quarter of the sphere or three quarters of it, and
the loop alone can't tell which: a half disc revolved 270 degrees on SMLib came back as a quarter
ball turned inside out (sweeps/2667, V = -226 against 678.6).

pcurve::pcurves_within takes the face's parameter box, as SMLib gives it, and picks the jumps
whose extent in that parameter is nearest the box's; pcurves is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 5014c4f17f kernel: with SOLIDCRAFT_KERNEL=smlib, STEP solids are SMLib's bodies
Each solid item of a STEP file goes through the schema 4 reader
(solidcraft_step::topology, at the file's units and uncertainty) into
SMLib through the flat converter, healed where SMLib's check refuses it,
and comes back as a kernel body; its faces keep the file faces they came
from. A solid the reader or SMLib refuses is not imported, with the
reason: there is no truck fallback on this path. truck's own reader is
unchanged and stays the default.

Test: the 17 step-conformance parts read into SMLib with their exact
volumes and face counts, every face traced to an ADVANCED_FACE; the three
NURBS parts stay refused by the reader (a loop across a closed spline
surface's seam), as on schema 4 today.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 8fde178fe4 kernel: any schema 4 record into SMLib with its order, healed where refused
smlib_record_ordered is smlib_body_ordered for a record of any origin (a
STEP file's, not only a body's): SMLib's body of it, healed where SMLib's
check refuses it as given, with where each of SMLib's faces and edges is in
the record's order. A record SMLib refuses outright now goes through the
healer too before the import gives up.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 863afb5e36 solidcraft-smlib: an arc past a full turn goes to SMLib a turn back
Schema 4 lets a circle or ellipse edge run up to one turn past its seam
(a quarter arc after the seam is [2π, 2.5π]); SMLib's circles take angles
within [-2π, 2π], and the flat import refused the whole body as invalid
input. The mapping now gives SMLib the same arc a whole turn back, and moves
the edge's pcurves on B-spline faces by the same amount, since their
parameter is the edge's. step-conformance's plate_100_holes now imports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 7e208529cd solidcraft-step: each record face names its face in the file
Solid::face_origin lists the ADVANCED_FACE or FACE_SURFACE entity of each
of the record's faces, in the record's face order, so a body made from the
record (in another kernel) can trace its faces to the file, as the truck
import's face_origin does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 82fe0e59e5 solidcraft-smlib: Brep::imprint
Imprint cuts each face of a body where a tool body meets it (the fork's
smlib_imprint, SMLib's imprinting boolean) and gives None where the tool
crosses no face. Trim builds on it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
bherbruckandClaude Opus 5.5 96bdbbf3ba docs: SMLib vs truck triage of the sweeps, threads and shell cases
169 rig and ladder cases on both kernels, graded against each case's own answer: where SMLib
fails, grouped by what goes wrong (wrong geometry, a crash, the thread groove's boolean failing
SMLib's check, shell refusals, sweeps with no SMLib path yet).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 1d8299aedf kernel: an SMLib body keeps each edge's and vertex's tolerance through its record
SolidCraft's own record of a body SMLib made (the rig's record check, the saved body, the next
SMLib import) re-fitted every pcurve at the kernel's working tolerance, 1e-5 mm. SMLib's fillet
and chamfer surfaces lie some 2e-5 to 2e-4 mm off their faces, so 15 fillet and chamfer cases
failed that check although SMLib's own passed. And SMLib reported one tolerance for a whole body,
the largest any part of it needed, so one loose edge (a pocket cut left one at 0.23 mm) made the
whole body loose on its way back into SMLib.

Now the tolerances go per edge and per vertex, both ways:
- solidcraft-smlib reads and writes the fork's new SMLIB_FLAT_EDGE_TOLERANCE and
  VERTEX_TOLERANCE arrays. Export gives each edge and vertex record its own (never below the
  floor, which becomes the body's). Where those understate what an approximated edge needs on
  its face (SMLib holds a blend's end curve 2.3e-5 mm off its plane at 2e-5), the export falls
  back to SMLib's largest everywhere, as before. Import writes each record edge's and vertex's
  tolerance.
- `geom::brep::pcurve::EdgeUse` carries its edge record's tolerance, and a pcurve is fitted to
  it where it is larger than the face's.
- The kernel's decoded body keeps its record's edge and vertex tolerances
  (`Body::tolerances`, in its edge and vertex order) after an SMLib operation and a saved body's
  decode, and keeps them through a rigid placement. Its record writes them again; anything that
  builds a new solid drops them.

SMLIB_REV moves to the fork commit that adds the arrays (smlib-blends-abi2 4a67471, ABI 2).

Rig and ladder fillet and chamfer cases on SMLib: 43 pass before, 60 now, none lost. Tests: a
pcurve fitted to its use's own tolerance, and the ladder's 08/006 cylinder rim chamfer whose
record, saved body and placed copy all stay valid and SMLib's check takes back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 f73d403830 kernel: an SMLib blend pick at a seam's end takes the sharp edge there
A pick at the vertex where a cylinder's seam meets its rim lies on both edges. The body's
nearest-edge order took the seam on SMLib-made bodies, and SMLib refused to chamfer it
(the ladder's part chamfer, step 22, SM_ERR_INVALID_INPUT). A seam or a tangent join is never a
blend's edge, so a pick as near to one as to a sharp edge takes the sharp edge; anywhere else the
nearest edge stands.

Test: every pick round a cylinder's top rim, the seam's end among them, takes the rim.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 baae4ee19b kernel: fillets and chamfers through SMLib when SOLIDCRAFT_KERNEL=smlib
Every blend entry point asks `backend()` and, on SMLib, hands its arguments to blend_smlib.rs:
fillet, fillet_each and fillet_radii (a radius per edge), fillet_g2 (SMLib's G2 blend-curve
section between the round's contacts), fillet_chord (constant-width section), chamfer, and
fillet_variable_spline (the radius law as an SMLib B-spline law; fillet_variable and
fillet_variable_points reach it, and fillet_max, fillet_max_each and fillet_tapered run on these).
Options SMLib has no construction for are refused as "not supported yet", never built by truck:
G2 corner patches, and chamfers with two different setbacks (distance and distance, or distance
and angle; equal setbacks are the equal-distance chamfer).

Each pick takes the body's nearest edge in its own edge order, as truck's blends do, and SMLib is
given that edge's midpoint, so a pick at a vertex never leaves SMLib to choose between edges. The
body goes in tagged as operand 0, SMLib's check must pass, and the decoded result carries SMLib's
history in the body's orders, the blend faces given FaceOrigin::Edge of the edge each replaced
(the picked edges and the rest of their tangent chains). The truck path is unchanged.

Tests (with the feature): a round's volume and its face's origin, a size per edge for rounds and
chamfers, a linear law from either end, refused sizes and picks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 3fcb3ea5c6 solidcraft-smlib: Brep::blend (per-edge sizes; round, G2, chord, chamfer) and Brep::fillet_variable
The Rust side of the fork's smlib_blend and smlib_fillet_variable, which the kernel's fillets and
chamfers need on SMLib: `Brep::blend` takes a size per picked edge and a `Blend` (circular round,
curvature-continuous round between the round's contacts, constant-chord round, equal-distance
chamfer); `Brep::fillet_variable` rounds one edge with a clamped B-spline radius law from the end
nearest a start point. Selection errors map as for the other picking operations.

SMLIB_REV moves to the fork commit that adds them (smlib-blends, on capi-solidcraft ffcf56d).

Tests: per-edge rounds and chamfers and the chord round against analytic volumes, the linear law
from either end, and refused laws and picks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 b900d6d469 kernel: solids an SMLib boolean leaves touching come back as separate solids
The fork's booleans now hand out closed non-manifold results (SMLIB_REV e87e9b3, ABI 3): solids
touching each other along an edge or at a vertex, which the C API refused as "not a closed
solid". The SMLib → schema 4 mapping now gives each closed boundary its own record shell: the
faces sharing one runtime shell on the empty side and one on the material side, so solids that
share their empty side's runtime shell get a shell each. An edge or vertex faces of more than
one shell use is split into one copy per shell (same curve, interval and point), so every
shell is a closed manifold boundary; regions list each shell as before. The history follows: an
Order's `pieces` give each record edge of a split SMLib edge with the faces it bounds, and each
piece keeps the edge's origins.

SMLib's own check refuses the radial order of faces round an edge solids share, so a
non-manifold result is checked as the separate solids it becomes (imported as given). A solid
touching itself along an edge (one shell using an edge more than twice) is still refused, now
as "not supported yet: a solid touching itself along an edge".

Tests: cubes sharing an edge or a vertex unite into two shells of 1000 mm³ each, every face and
edge's history verified against the geometry; two opposite quarters cut off a slab leave two
solids. Of the pinch tests run through SMLib, cut_leaving_pieces_meeting_along_a_line now
passes; the other nine are solids touching themselves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
Brennen HerbruckandClaude Opus 5.5 5dd3acdec0 kernel-cases: on the kernel branch a thread off its hole or shaft size is refused
The kernel runs exact helical sweeps and never resizes; the check that
refuses a thread off its hole's or shaft's size is the engine's sugar
(AGENTS.md). So the seven cases (995, 1443, 2152, 2969, 3366, 2369,
2705) go back to expecting that refusal and its message, as 1375e905 had
them, reversing 1588dd70.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 29d307bdcd doc: a modelled thread through SMLib cuts the exact groove
On SOLIDCRAFT_KERNEL=smlib the thread's groove (the ISO 68-1 trapezoid, as before) is a B-rep
screw sweep (kernel::sweep_helix, SMLib's screw sweep) cut from the body by the B-rep boolean,
whose history carries the threaded face's names on. Truck keeps the faceted groove and the
faceted boolean. thread_groove_shape holds what both build from; the size checks before it
(a hole or shaft off the thread's size is refused with the size to use) are unchanged, so
neither kernel fits a thread to a face that is too large or too small.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 fe7b37720b kernel: extrude, revolve, sweep, loft and coil through SMLib behind SOLIDCRAFT_KERNEL
With SOLIDCRAFT_KERNEL=smlib, extrude (and extrude_whole_sides, so boxes and cylinders too),
revolve and revolve_whole, extrude_tapered(_between), sweep and sweep_with, loft,
loft_with_rails, loft_regions and sweep_helix (coils, and the threads' grooves) build their
bodies with the fork's sweeps (smlib_sweeps.rs): the profile's segments go to SMLib as curves
(lines, arcs, Béziers and conics as NURBS), the result comes back through its schema 4 record,
and one SMLib's own check refuses is an error. What SMLib has no sweep for answers "not
supported yet", never truck's sweep: twists, end scales, guide rails and orientation
directions; paths with corners and paths of points; lofts with holes or to a point; draft
extrusions of profiles with holes or with a straight foot.

History is in the builders' vocabulary, found from the result's geometry as provenance.rs does
for operations without exact history: a wall comes from the segments its start edge runs along
(and, for extrusions and revolutions, whose middles it holds half-way), the face in the start
plane where the profile bounds it is the start cap, the one at the end the end cap. Straight
extrusions also carry their faces' construction sources (ExtrudeCap, ExtrudeSide), which the
box and cylinder certificates need. The loft's section matching is truck's own, now
loft_numbered_loops (split out of loft_numbered_wires, unchanged), so both kernels pair the
same vertices.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 62b5add282 solidcraft-smlib: the fork's sweeps, from lists of curves
Brep::extrude (straight or drafted), Brep::revolve, Brep::sweep (turning with the path or only
moving along it), Brep::loft and Brep::screw_sweep wrap the fork's new smlib_sweeps.cpp shims.
Profiles, paths and sections are lists of sweeps::Curve (lines, circular arcs, NURBS), turned
into the C API's curve lists here; the FFI is ffi/sweeps.rs. SMLIB_REV moves to the fork head
that has the shims (c33df0f, on capi-solidcraft 1499681).

Tests check each sweep against closed-form volumes and SMLib's check, and hostile curve lists.
(The crate's test build currently stops at import/tests.rs, which calls import::surface without
its new analytic_planes argument; that is the import's, not this change's.)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 6bfbe1041f kernel: an SMLib shell opens a round wall whole; split pieces press on either kernel
The SMLib shell passed the user's pick points to SMLib, which refuses a point as near to two
faces; a pick on a hole's wall at the line between its two halves (kernel-cases shell/4010)
failed. The open faces are now picked as truck's shell picks them (the face of the nearest
triangle), grown by the faces on the same surface joined to them (offset::with_same_surface:
a round wall stored in pieces opens whole), and SMLib gets one point inside each.

Offset faces keeps its design on both kernels: when moving the faces fails on a body with
split lines, the chosen pieces are pressed (swept and joined or cut) instead, as truck's path
always did; the booleans of the press run on the selected kernel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 82865e2832 kernel: a body SMLib walks some loops of the other way keeps its order
smlib_body_ordered keeps SMLib's face and edge order for history only where SMLib's export
numbers the body as its record does, and compared each loop edge for edge in the same order
and direction. SMLib walks a face whose surface it turned (a hole's wall, a concave cylinder)
the other way round and may start the loop elsewhere, so a plate with a hole lost its history
through every SMLib boolean and shell although its faces and edges are numbered alike. A loop
now matches when it walks the same edges in the same cyclic order, or in the opposite order
with every edge reversed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 0f3d6f177e kernel: shell, offset faces and thicken through SMLib, with SMLib's history
With SOLIDCRAFT_KERNEL=smlib (the one kernel switch), shell, offset_faces and thicken send
the body to SMLib tagged as operand 0 (offset_backend.rs) and bring the result back with
SMLib's own history, as booleans do. A result SMLib's check refuses is an error.

SMLib's tags travel through the copies its offset makes, so a shell's inner wall and a
thickened sheet's moved copy read as pieces (Split) of the face they came from. A result face
lying more than half the operation's distance from its tagged face is recorded as that face's
offset (FaceOrigin::Offset) and its edges as where its faces meet; a thickened sheet's walls,
new to SMLib, are recorded as made in place of the sheet edge their edges are tagged with, as
truck's thicken records them. Offset faces pick the faces truck's path picks (a round wall's
pieces together) and pass SMLib one point inside each; the moved faces are Modified.

The histories are checked against the geometry as truck's are (modify_history_tests), with
the analytic volumes, the thicken direction, and the refusal of walls past the L-shaped body's
inradius (8.79) that its box (half extent 10) let through before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 51211ad1fe solidcraft-smlib: offset faces, thicken, and NoRoom for walls with no room
Brep::offset_faces and Brep::thicken reach the fork's new smlib_offset_faces and
smlib_thicken; SMLIB_REV moves to the fork commit that adds them. The shim now refuses an
inward wall that leaves no room inside the body with its own status, Error::NoRoom, instead of
an argument error, so callers can say what is wrong; the test that a wall thicker than the box
fails now expects exactly that.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 a6ca4e0dd4 AGENTS.md: one switch, SOLIDCRAFT_KERNEL, in place of the booleans-only note
Rebasing onto the sugar rule kept both the old SOLIDCRAFT_BOOLEANS
paragraph and its replacement; only SOLIDCRAFT_KERNEL exists now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 f35f06d98a kernel: a revolution that is no analytic surface goes into SMLib as its B-spline
The analytic mapping refused every revolution that is none of SMLib's plane, cylinder, cone,
sphere or torus (a profile of any other curve, a placement that is no rigid motion), which
now also kept those faces from kernel-smlib's exact rational B-spline import (da7ccba9). Such a
face now stays a revolution, so the import sends it as its B-spline; the analytic surfaces are
still taken wherever they fit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 d672cfa013 kernel: one switch, SOLIDCRAFT_KERNEL, picks the kernel for every operation
All operations move to SMLib at once, so the selector is no longer the booleans' own:
`SOLIDCRAFT_KERNEL=smlib|truck` (read once, unset is truck, the same refusals for an unknown
value or SMLib in a build without it) is answered by `solidcraft_kernel::backend()`
(crates/kernel/src/backend.rs), which every operation's dispatch calls. The boolean's SMLib path
moves to smlib_boolean.rs. The regression rig's kernel check (`boolean_kernel`) now answers from
the switch, and the rig and CLI set SOLIDCRAFT_KERNEL.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:47 -04:00
jyvikoandClaude Opus 5.5 ff0f7ccfa1 kernel: a body's record for SMLib takes a larger tolerance where an edge needs it
The record of a truck body is built to the body's working tolerance (1e-6 of its size, at
least 1e-5 mm), and truck's offsets and blends leave some edges a few times farther than that
from a face they bound: no pcurve fits, so the record and every SMLib boolean on the body
failed ("pcurve of loop 0 use 0 ...: the curve at 0 lies 3.2e-5 mm off the surface" in a
shelled revolve of the robustness generator). The record for SMLib now retries at ten and a
hundred times the working tolerance for the body, its edges and vertices before refusing; the
saved native body keeps the working tolerance. Robustness seed 64 (a filleted extrusion
joined to a cylinder), refused this way before, now builds as truck does to 1.6e-6 of its
volume.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 94c1598259 kernel: SMLib's round faces decode as truck's own revolutions are laid out
An SMLib cylinder, cone, sphere or torus decoded as a truck revolution with its parameters
swapped (angle, profile), which truck's own revolutions never have. The tessellator then put a
cone's apex at the wrong angle: a drill point through SMLib and back meshed 41 % too large and
oracle cases 18, 55 and 56 measured wrong areas and volumes. The profile now runs against the
record's v, unswapped, which keeps the record's natural normal and truck's (profile, angle).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 00e43aacce kernel: an operand SMLib's check refuses goes through SMLib's healer
Truck's bodies are trusted into SMLib as given, but some miss SMLib's rules by a little (an
edge's vertex 4.4e-5 mm off it against a tolerance of 3.3e-5 after a truck operation), and
every boolean on them was refused by the check of its result. An operand whose trusted import
fails SMLib's check is imported again through SMLib's healer, and the healed body is used only
where SMLib then finds it valid; its numbering is checked against the record as before, so a
heal that renumbers leaves the result without history rather than with a wrong one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 e35b4d744e kernel: revolutions of a line square to the axis go into SMLib as planes
A revolve's flat ends (a line square to the axis turned about it) were refused, so any
revolved profile off the axis could not reach SMLib (oracle case 29). Such a face now goes as
SMLib's plane square to the axis, its range the box round the sector the line sweeps.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 c344801cc2 kernel: note that the engine's and CLI's smlib features reach SOLIDCRAFT_BOOLEANS
kernel-smlib already gives solidcraft-engine and solidcraft-cli an `smlib` feature (for the
regression rig); the note on SOLIDCRAFT_BOOLEANS now says they are how the oracle, the naming
corpus and the robustness goldens run their booleans through SMLib.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 1980f9743f kernel: SMLib's export keeps every face of a void's shell
The export takes a closed boundary's faces from the side in the empty region and skipped
every use there that is not `same`, a rule meant only for a sheet (a shell that is its own
mate). It tested the chosen side against the mate instead of the shell against itself, so a
cavity's shell, taken from the void's side, lost its faces whose uses run opposite to their
surfaces: "a face no shell uses" for every cut that leaves a void.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 640d3d9ea5 kernel: truck's extruded circles go into SMLib as its cylinders
Truck extrudes a circle into rational splines, so every truck cylinder reached SMLib as
splines, and a box cut by one came back with edges 0.78 mm off their faces (SMLib's own check
refused it). A rational spline that is a circular arc swept straight along its axis (one
direction linear, the second row the first moved by one vector square to the arc's circle,
weights alike) now goes as SMLib's cylinder with the face's range on it.

The revolution mapping becomes one module for both (import/analytic.rs): each candidate face's
analytic surface is checked against the record's at 25 points of its domain, each point placed
on the analytic surface by its own (u, v), and turned over where the normals disagree.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 b27751d43f kernel: planes go into SMLib as its planes; analytic angles start at zero
Truck's planes run through three points, their axes the face's sides, so the SMLib import sent
every truck planar face as a bilinear NURBS patch: SMLib then intersected splines where it has
planes. A plane on any axes now goes as SMLib's plane on unit axes along U and at right angles
in the plane, its range the record's domain on those axes (a face's range need not be tight;
SMLib rebuilds an analytic face's trims from its edges).

A revolution's analytic frame turns to the face's first angle so u starts at 0: SMLib's check
refuses a cylinder whose range ends past 360°. A failed SMLib check of a boolean's result now
says whether an operand already fails it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 d271add1ad kernel: revolutions go into SMLib as its cylinders, cones, spheres and tori
Truck holds every round surface as a placed revolution, and a body SMLib made comes back from
truck that way too, so the SMLib import refused spheres, tori and any second boolean on a
first one's result. The import now turns each revolution of a line along or through the axis,
or of a circle centred on it or in a plane through it, under a rigid placement, into SMLib's
analytic surface: the face's range mapped from the revolution's parameters (angles moved into
the first turn: SMLib's torus breaks on a tube range below zero), checked against the
revolution at 25 points, and the face turned over (loops reversed, shell uses flipped) where
the analytic normal runs the other way. Other revolutions are still refused.

A result body's order is checked by each face's boundary edges as well as its identity:
Body::new rephases revolved faces onto new faces with the same edges.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 5238840bc8 kernel: booleans through SMLib behind SOLIDCRAFT_BOOLEANS, with SMLib's history
With the `smlib` feature, SOLIDCRAFT_BOOLEANS=smlib (read once per process, default truck)
sends every kernel::boolean through SMLib: each operand's schema 4 record imported and tagged
as operand 0 or 1, SmBrep's boolean, SMLib's check at every level, the result exported and
decoded (with its geometry check). A result either check refuses is an error. The setting
naming SMLib in a build without it, or anything unknown, fails every boolean instead of
quietly running truck, so a comparison never compares truck with itself.

The history is SMLib's tags renumbered into Body::history's index spaces. The export now
reports where each SMLib face and edge lands in canonical order (its arrays follow
SmBrep::GetFaces/GetEdges, the order the tags use). The result's order is checked against the
decoded solid by face and edge identity, the operands' by re-exporting the imported body and
comparing its numbering with the record's; where either differs the result has no history
rather than a wrong one. The result gets the operands' regularization protection and planar
roles as truck's does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 f7336497f9 AGENTS.md: the kernel does geometry, sugar lives above it
The owner's rule for the kernel-smlib branch: the kernel runs exact
operations and refuses what it cannot do exactly; sizes, standards tables,
defaults, pre-checks and conveniences live in the engine and doc. Threads
as the example: a helical sweep in the kernel, while the size table, the
off-size refusal and multi-start threads are sugar.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 54542890d1 kernel: hold every display-plan triangle to the chord tolerance
Only the Delaunay layout checked its triangles against the surface. The
grid divides each parameter direction within the tolerance, but on a
doubly curved surface the two sags add up in a cell's middle, along its
diagonal (SMLib torus 1.16x at 0.01, truck sphere 1.23x at 0.1, truck torus
1.40x at 0.01); the patches round a pocket cut into a sphere at its pole
fan out from the cut with no check at all (4.34x at 0.1, 1.90x at 0.01).

Every curved face's finished triangulation now goes through tess::sag:
each triangle is measured at its centroid and at the middle of each side
inside the face, across the surface (along the normal at the point of the
same parameters, which near a pole need not be the nearest), and the side
that leaves the surface most is split, both triangles on it together, so
the face stays conforming. Boundary sides are never split: they carry the
edges' own nodes, shared with the neighbouring face. At a pole the free
parameter of a midpoint comes from the other corners.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
jyvikoandClaude Opus 5.5 b90a5851c5 kernel: open a half sphere's loop at its pole, so its seam closes
A sphere from SMLib cut through its centre keeps one face bounded by its
rim and by its seam from the pole up to the rim, used both ways. Unwrapped
along the loop, both runs of the seam landed on one parameter line and the
loop came out one period short, so the planner took it for a face winding
round the sphere and cut it along a new line of its own. The two seam runs
stayed inside that strip as a slit of zero width, triangulated on each side
separately: open edges along the seam up to the rim (gaps up to 9.5e-3 mm
at chord 0.1), a zero-angle triangle and a non-manifold edge at the pole.

Such a loop is now unwrapped from the node after the pole round to it and
started at the node before it: the seam's uses lie a period apart on either
side of the face's parameter box, which then meshes like any sphere patch,
both uses on the seam's own nodes. It is kept as it was unless the opened
loop spans at most a period with a positive area and no longer winds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:46 -04:00
bherbruckandClaude Opus 5.5 c992630e10 ATTRIBUTION.md: rows for the kernel rig's STEP import fixtures
Eight are hand-written synthetic files (MIT OR Apache-2.0). The other eight are byte copies of
CC0 files from tests/step-conformance and say so. Each row names the issue its case comes from.
cargo xtask assets passes again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 de6633b9c6 smlib: pin the fork's SSI fixes (1499681); the corpus passes 111 of 119
SMLIB_REV moves to tangency-labs/smlib capi-solidcraft 1499681, eight SMLib
commits for surface/surface intersection: an empty curve is no longer
reverse-traced (SM_ERR_NULL_POINTER), tangent curves are traced once, curves
split at singular crossings, interior tangential contact points, tangential
curves and branches through tangent nodes, small loops above tolerance, and
high-order contact curves covered across their band. The corpus test's pass
list grows from 81 to 111 cases; the 8 still failing are all below SMLib's
1e-5 zone tolerance (angles 1e-6..1e-8, offsets 1e-7, loops of 2e-6 or less).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 f8b48d0e4d smlib: pin the fork at 70e1bf5 (capi: surface/surface intersection)
capi-solidcraft with smlib_surface_* and smlib_ssi. The C ABI version is
unchanged (2).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 201ca9a81e smlib tests: score SMLib's GlobalSurfaceIntersect on the SSI corpus
With the native feature, smlib_global_intersect_at_1e_6 builds both
surfaces of every case through solidcraft_smlib::ssi, intersects them
at approximation tolerance 1e-6 with the corpus runner's 4001 samples
per curve, turns the answer into what the runner writes for gsi, and
scores it. It asserts the exact set of passing cases (81, as score.py
grades the runner: 81 PASS, 25 INCOMPLETE, 11 WRONG TOPOLOGY, 2 ERROR),
so a regression and an improvement both fail until the list changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 880523514a smlib: surface/surface intersection wrapper (smlib_surface_*, smlib_ssi)
ffi/ssi.rs declares the C API's SSI block; ssi.rs wraps it: Surface
(plane, cylinder, cone, sphere, torus, NURBS, with the SSI corpus's
fields, angles in degrees), Method (Global, Advanced, Basic) and
intersect(), which returns every curve's type, UV flags, deviation,
interval and samples (xyz, uv on each surface, each surface at its uv)
and the isolated points. Without the native feature every call returns
NotBuilt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 3c1fbf4c9d smlib tests: SSI corpus scorer and its parity with score.py
ssi_score::score_case grades an engine result (sampled curves with xyz,
uv1, uv2, both surfaces at the UV samples and the curve type; points;
status; or a crash) against a corpus case: CRASH, ERROR, INCOMPLETE,
WRONG TOPOLOGY, INACCURATE or PASS, with score.py's flags and numbers.

ssi_corpus.rs checks every case parses, every NURBS surface lies on its
truth, the truth itself passes (bar unsplit singular points), and the
verdict rules. The ignored parity test scores the corpus runner's raw
outputs and compares with score.py: 119/119 identical verdicts and
flags for SMLib GlobalSurfaceIntersect at 1e-6 (81 PASS).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 6dbda8ecf1 smlib tests: SSI scorer geometry (truth distances, polyline sets)
Test-support port of the parts of the SSI corpus's ssi_geom.py and
score.py the scorer needs: exact distances to the implicit truths, the
Gauss-Newton closest point on traced param patches, B-spline/NURBS
evaluation of the case surfaces, and score.py's segment-hash polyline
set, polyline distance, components, free ends and topology signature,
following numpy's arithmetic order.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
Brennen HerbruckandClaude Opus 5.5 1edeb2a6f7 tests: SSI corpus fixtures (119 cases with exact truth)
The 119 surface/surface intersection cases of jyviko/ssi-corpus (b04c8a6,
MIT OR Apache-2.0), gzip-compressed, with its licence texts and a README
on the case format and the scoring rules. The 25 y23 cases come from
Yang, Jia & Yan 2023 (ACM TOG 42(6) Art. 211, CC-BY 4.0); both are in
ATTRIBUTION.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00