Commit Graph
478 Commits
Author SHA1 Message Date
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 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 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
Brennen HerbruckandClaude Opus 5.5 17eafa2d48 solidcraft-smlib: revolved surfaces into SMLib as exact rational B-splines
A PlacedRevolution record goes to SMLib as its exact rational B-spline
surface: each profile control point swept round the axis by a full circle of
four rational quadratic quarters starting at the face's first angle, then
mapped by the placement. The circle's parameter is not the angle, so the
face's angle range is converted pointwise and its pcurves are not carried
(SMLib rebuilds the trims). Where the placement mirrors, the record's natural
normal is the opposite of the map's, so the directions swap.

The B-spline matches the record's surface to 1e-12 with the same normal,
forward or not, mirrored or not; truck's sphere and torus now reach SMLib
with their analytic volume (1e-6) as manifold solids.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:46 -04:00
bherbruckandClaude Opus 5.5 678a70da2c kernel-cases: shells as a graded count, no SMLib verdict where it can't take the record, $OUT
- `"shells": N` in expected.json grades the total number of shells: a body with a sealed void
  holds two, and some joins keep several lumps in one body. Those cases (#3175, #3455, #3526,
  #3730) are graded on validity again instead of being marked not valid.
- When SMLib's record conversion says "not supported yet" (revolved surfaces, traced intersection
  curves), its check gives no verdict. That's shown but not graded, since it isn't a fault of the
  body. solidcraft_kernel::SmlibCheck carries the three outcomes.
- `$OUT` in a recipe is a scratch directory outside the repository, for files a case writes. The
  two STEP-export crash cases write there instead of /tmp.
- cargo xtask kernel-cases --results FILE keeps every result as JSON.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:45 -04:00
jyvikoandClaude Opus 5.5 62124a7117 kernel: spline edges on part of their curve load as that piece
SMLib bounds an intersection edge on a piece of its spline (seed 32 intersect:
a block and a cylinder, the top disc's edges), and the truck decode refused
such an edge ("not supported yet: a spline or intersection edge on part of its
curve"), since truck bounds an edge by its curve's whole range.

bspline::segment cuts a B-spline to a sub-interval of its domain exactly:
Boehm insertion of both ends until each has multiplicity p, then the knots and
control points between them, clamped on the interval. The same points at the
same parameters, so the edge keeps its interval and the record its numbers.
load_edge_curve loads a spline or rational spline edge on part of its curve as
that piece; an intersection edge on part of its curve is still refused. Our
own records (interval = the curve's range) load as before.

Tests: segments of a rational cubic with a double knot, inside a span, across
knots, from or to a domain end, match the whole curve within 1e-12; both
spline kinds load on a piece with that range and the same points, and beyond
the domain are refused; SMLib's block ∩ cylinder decodes (it was refused) with
π r² h within 1e-3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:45 -04:00
jyvikoandClaude Opus 5.5 62142ef38e brep: a revolution of a closed profile is periodic along it
The adapter loads an analytic torus as truck's revolution of the whole profile
circle, a rational quadratic closed on itself, so an SMLib torus is one face
bounded by its two seam circles, each used both ways. The display evaluator's
domain gave a revolution a period around its axis only: projected along the
profile the loop jumped from one end of the knot interval to the other at its
start vertex, the plan failed ("boundary crosses itself") and the body fell
back to truck's mesher, which meshes a sphere bounded by its seam alone as
nothing (seed 60 union, a torus beside a sphere: 925.0 of 990.7 mm³).

tess::uv::closed_curve detects a closed profile the way closed does a closed
spline surface (clamped knots, first and last control point and weight the
same within 1e-9 of the polygon's extent; the shared checks are factored out),
the domain then has period = the profile's knot interval along it, and
EvalSurface::wrap/derivs wrap that parameter back into the interval, so the
plan's projection, unwrapping and both evaluators treat it as periodic. A
cylinder's or cone's line profile is unchanged.

Tests: a revolved whole circle, either parameter order, has both periods and
evaluates a period away as inside; SMLib's torus, alone and beside a sphere,
decodes without meshing to orient it, plans every face and measures within
1e-3 of 2π²Rr² (+ 4/3 πr³). With the closed profile undone the torus plan
fails as above.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:45 -04:00
jyvikoandClaude Opus 5.5 ce201eea1b kernel: SMLib spheres cut by a boolean decode oriented and meshed
Results of SMLib booleans on its own spheres came back wrong through
body_from_smlib (side-by-side runner: seed 13 cut −1611.9, seed 61 cut −252.4
against SMLib's 4056.9, seeds 46/61 union 80 % short). The schema 4 records were
right (check_geometry passes, outer loops counter-clockwise, shells out of the
material); three things on the truck side were not:

- Body::new orients a solid by the volume of truck's coarse mesh, and truck's
  mesher meshes a sphere bounded by its seam alone as nothing: the rest of the
  body set the sign and turned it inside out. A foreign record is oriented by
  its shells, so body_from_smlib now builds the body with Body::oriented
  (revolved faces turned as before, orientation kept, nothing meshed).
- rephase_revolved turns each revolved face so it sits around angle π. A face
  that uses its seam both ways goes all the way round; turning its surface ran
  the wrap through the face's hole, the display plan failed and the sphere
  meshed as nothing. Such faces now keep their wrap on their seam (truck's own
  primitives have none: their round faces are split).
- The display plan opened only a loop of one seam used both ways. A sphere face
  whose meridian a trim splits uses each piece both ways, turning back at each
  pole, and projected onto one parameter line ("boundary crosses itself"), so
  the whole body fell back to truck's mesher and lost its sphere faces. A loop
  through both poles that turns straight back at one now has its run between
  the poles moved one period along, whichever way keeps it within one period
  with a positive area (poles split as the planner splits them); the routing
  check finds such loops too.

Test: SMLib's sphere less a box cap beside its seam, across it (seam split) and
a bar bored into its side away from the seam decode without meshing to orient,
oriented as recorded, every face meshed, within 1e-3 of the exact volume.
Before, the decode meshed the body to orient it; with only the plan's pole
handling undone the −x cap measures 50.3 of 469.1 mm³, with only the
rephase undone the bored ball 252.4 of 4059.5.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:45 -04:00
bherbruckandClaude Opus 5.5 7bb74d1c6b kernel-cases: an smlib feature for the CLI, and no grading of a kernel the build isn't running
- solidcraft-cli and solidcraft-engine forward an `smlib` feature to solidcraft-kernel/smlib, so
  `cargo build -p solidcraft-cli --features smlib` gives the rig SMLib's check.
- solidcraft_kernel::boolean_kernel() says which kernel this process runs booleans on.
  `default` until the SMLib switch (SOLIDCRAFT_BOOLEANS=smlib) lands and answers there. An smlib
  run on a build without the switch reports "not supported yet" instead of grading the default
  kernel under SMLib's name.
- An area may keep its skipped list in parts (skipped-<part>.json).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:45 -04:00
Brennen HerbruckandClaude Opus 5.5 a7c0109eab kernel: boolean runner grades the seeds against a reference volume
Rows without an analytic volume (the fuzz seeds) get one from the
primitives' definitions, by no kernel: along each vertical line both
operands are exact z intervals, combined exactly, integrated over a grid
whose cell edges include every straight face, with the half-resolution
grid bounding what error is left. Each kernel's volume is graded against
it (within 1e-3 relative or 3x that bound), in the JSON per row and in the
report's summary.

On 64 seeds truck is right on all 192 rows. SMLib's own measure is wrong on
13, all with cylinders or spheres, although truck's measure of the same
exported bodies is right on every one of them; 5 give no closed solid.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
bherbruckandClaude Opus 5.5 732fd2ace2 kernel-cases: a regression rig that grades each kernel against the case's own answer
Every geometry case the old kernel got wrong becomes tests/kernel-cases/<area>/<id>/: an
engine script or oracle recipe, and expected.json with the right answer, from analysis or a
hand calculation, or else the invariants. Never a kernel's output.

- solidcraft-cli kernel-cases <dir>...: runs a case and grades it. The checks are the outcome
  (succeeds, or refuses cleanly), the body count, and one closed shell per body that passes the
  record's structure and geometry checks and, with SMLib built, SMLib's check(All). Counts,
  volume, area, centroid and box are graded where the case gives them. Each run is pass, fail,
  not supported yet or crash.
- cargo xtask kernel-cases [--kernel default|smlib|both]: one process per case, so a native crash
  or a hang (--timeout) is that case's result. It writes docs/kernel-cases.md: coverage per area
  and source, results per kernel, and the sources looked at and skipped (<area>/skipped.json).
- solidcraft_kernel::validity and smlib_built, which the rig's checks use.

tests/kernel-cases/README.md gives the format.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 79ae117dd9 kernel: boolean runner measures SMLib's results again on truck
When SMLib's volume of a boolean result differs from truck's, the report could
not tell a wrong body from a wrong SMLib measure. The runner now measures the
result it exports back to truck as well, keeps that volume in the JSON, and
shows it in the export column wherever it leaves SMLib's own measure or SMLib
could not measure the body at all.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 ac6ddbdbec kernel: boolean runner times both kernels and runs the cut sequence
The side-by-side runner now reports how long each boolean takes on truck and
on SMLib (the call alone), and apart from that the SMLib side's conversions:
the operands' truck→SMLib import and the result's SMLib→truck export, which
the app pays while truck still holds the bodies. The report gains a times
summary (median, worst, total), solid counts, the analytic volume of each named
case's union, intersection and cut, and how many results land on it.

It also runs the "each cut gets slower" case from TASK_kernel-smlib-booleans as
a named sequence: a 63.6 × 31.7 × 9.5 block, a Ø20 × 10 boss joined on top, a
slot front to back, a Ø6 cross hole through the boss and a slot that splits
the block, each step on the previous result. SMLib keeps its own results from
step to step (only the tools come from truck), in a child process like the
cases, and every step's volume is checked against its closed form.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 2196129f16 kernel: side-by-side boolean runner calls SMLib's boolean
The smlib_booleans example answered "not supported yet" for every SMLib case.
Now it runs solidcraft_smlib::Brep::boolean on the tagged operands (cut maps
to Subtract, None is an empty result), reads the result's history from the
tags, and measures its volume with mass_properties at MEASURE_ACCURACY, so the
report compares truck and SMLib on real results.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 27e996c44d brep: splines closed on themselves are periodic for pcurves and tessellation
A spline surface whose first and last control rows coincide in a direction
(points and weights, knots clamped there) closes on itself, but the display
evaluator's domain gave NURBS no period. The pcurve routine therefore never
moved a seam's second use by a period: SMLib's fillet round a hole's rim (a
rational spline closed in u) got both seam pcurves on u = 0, its outer loop
enclosed no (u, v) area, the decoded face tessellated to nothing and the body
measured 6839.73 mm3 against SMLib's 6989.00.

tess::uv::closed detects the closure from the record, within 1e-9 of the
control net's extent; the domain then has period = the active knot interval's
width, and the evaluator wraps a parameter outside that interval back inside
it, so pcurves, projection, sizing and the display plan all treat the direction
as periodic. The record stays as it is. The display plan hands both evaluators
wrapped parameters (the GPU does not wrap).

Tests: a rational torus band, a NURBS cylinder and a NURBS dome with a pole,
each bounded by a seam used twice, get seam pcurves one period apart; a record
of the band passes check_geometry and its seam uses on one line are refused;
SMLib's hole-rim fillet decodes with every face meshed and SMLib's volume
within 1e-3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 5b8d89abd5 kernel: schema 4 STEP records of revolved and conic-bounded parts against closed-form volumes
The hyperbola and parabola cone pieces and the revolved cylinder, read by solidcraft-step into
schema 4 and built back into truck bodies, keep their closed-form volumes with their faces
pointing out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 91e482fc8a solidcraft-step: refuse loops across a closed spline surface's seam; conformance parts and truck volumes
A face winding around a closed (non-periodic) spline surface without a seam edge has loops
that jump across the surface's domain; it is refused for now instead of making a record whose
loops do not close. The step-conformance parts are read in a test, and the kernel's ignored
corpus comparison builds each record back into a truck solid to compare volumes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 3d7e465b16 solidcraft-step: seams for STEP faces that wind around their surface, looser pcurve fits
A face on a cylinder, cone or sphere bounded by loops that go round the axis (a band
between two circles, a dome on its equator, a cone on its base and apex) gets a seam:
a ruling or meridian from one loop to the other (split where it has no vertex at that
angle) or to the pole it covers, so every loop closes in (u, v) as schema 4 requires.
Pcurves may be fitted up to 1 mm off for edges that lie off their surfaces. The kernel
gets an ignored corpus test comparing truck's face and edge counts with schema 4's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 acff340a04 solidcraft-step: representation context units and uncertainty, shared with the kernel's STEP reader
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 4983b88722 kernel: the boolean runner builds every SMLib operand
Boxes and cylinders go into SMLib as truck's own B-reps, through their
schema 4 records (smlib_body), so both kernels start from the same input
whatever the axis. Spheres and tori are SMLib's primitives about +Z, like
truck's, since the import doesn't take truck's revolved surfaces yet. All
41 cases' operands now build; only the boolean itself waits for its shim.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 144b569246 solidcraft-smlib: SMLib bodies into SolidCraft through schema 4
SMLib B-reps leave the C API as its flat arrays, read through the crate's
one flat wrapper (crate::flat::Flat, copied out as import::Arrays), and
become schema 4 records: shell pairs merged, sheets collapsed, radial cycles
normalised, analytic surfaces as their kinds (narrowing cones kept), loops
reversed where SMLib's surface is inside out, every pcurve from
brep::pcurve, canonical order, then validate() and check_geometry(). Edges
arrive as their own kinds; NURBS edges that are lines or circular arcs (the
primitives' circles) are recognised as a fallback and counted. With the
kernel's `smlib` feature, body_from_smlib() decodes them into a Body.

Adds the cylinder, sphere, cone and torus primitives. Each primitive passes
SMLib's own check at every level, its volume from the exact mass properties
matches the closed form, and it goes round SMLib -> schema 4 -> SMLib with
its counts, volume and a clean check. Truck now meshes a whole sphere
bounded only by its seam (SMLib's sphere) through the display plan.

SMLIB_REV moves to the fork's capi-primitives (the primitives on capi-flat
40bb855).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 2a22f4641b solidcraft-smlib: schema 4 records into SMLib through the flat arrays
SMLIB_REV moves to the fork's capi-static 40bb855 (flat arrays, C ABI 2).
flat.rs wraps them (Flat: arrays by id, Brep::export, Flat::import,
Brep::is_manifold_solid; FFI in ffi/flat.rs). import.rs lays a schema 4 record
out as those arrays: a closed shell becomes one SMLib shell per region it
separates, a sheet's shell holds both sides of each face, the infinite region
is marked void as SMLib has it, pcurves become UV trims on B-spline faces only
(reversed for edgeuses against their edge), planes with non-unit axes go as
their exact bilinear patch. Brep::from_record builds the SMLib body.

kernel: brep_record(body) gives a body's schema 4 record, and smlib_body
(feature smlib) its SMLib body, trusted (no healer: healing moved a
cylinder's volume by 9e-7). Box, cylinder and tilted cylinder keep their
analytic volume in SMLib (1e-9, 1e-6) and are manifold solids; truck's
spheres and tori are revolutions, refused with "not supported yet" for now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 570028f31e brep: the truck adapter checks a record's geometry before decoding it
decode builds topology with Edge::new_unchecked and Face::new_unchecked,
so a record whose curves miss their vertices or whose pcurves miss their
edges loaded and failed later inside truck. It now runs check_geometry
after validate and refuses such a record (a cache miss at the IO
boundary). Only our own cache feeds it today; STEP and SMLib exports will.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 4a4e11ef71 kernel: a side-by-side runner for truck and SMLib booleans
examples/smlib_booleans runs truck and SMLib on the same cases (named pairs
whose results are known by hand, then fuzz::boolean_shapes for N seeds),
each as union, intersection and cut, and compares volume, face and edge
counts and the shape of the history (how many faces Kept, Modified, Split,
Merged, Generated; edges from an operand edge, new, or without origin). It
writes a JSON and a Markdown report and never changes the default kernel.

SMLib runs in a child process per case, so a crash inside it is reported as
that case's result. Its primitives and booleans arrive with the operation
shims; until a call exists the case is reported as not run on SMLib.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 f06581ca50 STEP geometry as plain data: read and write ISO 10303-42 curves and surfaces without truck
A new crate, solidcraft-step (L1, no modelling backend), holds the Part 21
parser (moved from the kernel, which now reads through it) and STEP geometry
as plain data: lines, conics, B-splines (rational and implied knots),
polylines, trimmed curves, surface curves with their pcurves, 3D offset
curves; planes, cylinders, cones, spheres, tori (degenerate too), B-spline
surfaces, revolutions, linear extrusions, offset and rectangular trimmed
surfaces. Each keeps STEP's own definition and parameterisation, in mm and
radians, with pcurves scaled by their surface's parameter units. Shared
entities stay shared. A writer emits the same entities back, deduplicated.

Tests per entity check values against analytic points, units, round trips
and hostile input; an ignored test reads and round-trips every edge curve
and face surface of the tangency-labs/models STEP files.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
Brennen HerbruckandClaude Opus 5.5 8695af8acc solidcraft-smlib: SMLib statically linked behind its C API, with a safe wrapper
A new crate (L1, only the kernel uses it) builds tangency-labs/smlib's SMLib,
SM_API and C API with the cc crate when its `native` feature is on, from the
commit in crates/smlib/SMLIB_REV (scripts/fetch-smlib.sh fetches just those
sources). The kernel's `smlib` feature turns it on. Without it nothing C++
is built and every call returns NotBuilt, so workspace builds need no C++
toolchain.

unsafe is confined to src/ffi.rs. The wrapper owns handles, maps statuses to
errors, checks the C API version, and sends SMLib's per-call log to the log
crate. Crash reports note the native kernel call in flight.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 95b2295160 kernel: the truck adapter writes pcurves through brep::pcurve
The adapter now saves each edge's curve record and interval when the edge first appears and
computes every face's pcurves from those records and the surface record it writes, with the
shared plain-record routine; the truck-face version in native/pcurve.rs is deleted. Loops go
in as the record keeps them (relative to the surface), so a reversed face no longer has its
wires reversed and back again.

The native tests are ported (adapter::face_alone gives one face's record for them). The cut
body's intersection pcurves now fit at 1e-6 mm too: the routine follows the converged
intersection, and truck's own points are within its 1e-6 mm of it, which the lift check
allows for on intersection edges. docs/native-brep.md says where pcurves come from and what
a surface intersection's point at t is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 1d49160081 brep: a surface point's parameters move to geom
The parameter box, the projection of a point onto an evaluator surface (closed form on a
plane, damped Gauss-Newton elsewhere), unwrapping and the pole test work on geom's
EvalSurface alone. They move from the kernel's tessellator to solidcraft_geom::tess::uv so a
pcurve routine on plain B-rep records can use them without truck; the kernel re-exports them
and its tessellation is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 02abecd52c brep: docs for schema 4, and a pcurve lift test
docs/native-brep.md describes schema 4: the records with their SMLib and
STEP names, regions and shells, the loop convention, every edge's uses,
the canonical order (a reversed face walked backwards), each curve and
surface kind's parameterisation, pcurve rules, validation, history, the
SCBREP05 envelope and what the truck adapter writes and refuses.

A test lifts every pcurve of a box, a filleted box with a bore and a
sphere onto its face and checks it is its own edge at both ends and the
middle; with a reversed face's pcurves left in truck's oriented order it
fails by 30 mm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 2f4d6acacb brep: working tolerance, golden v5 records, cache producer 4
Edges, vertices and the body carry the face tolerance (10^-6 of the
body's size, at least 10^-5 mm): truck's traced intersection edges sit
about 1e-6 mm off their surfaces, so the linear tolerance is too tight for
a pcurve to lift onto them. The box-and-fillet golden fixture is the
schema 4 envelope now (NATIVE_BREP_BLESS=1 rewrites it), and the adapter
tests cover a pair of lumps. The model cache's producer revision becomes
solidcraft-truck-adapter/4.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 445fb23859 brep: schema 4 types, validator and truck adapter
The plain B-rep follows SMLib's flat form with STEP's names: regions
(infinite first), face/wire/vertex shells, oriented faces, faces with a
domain and edge or vertex loops, oriented edges with a pcurve each, edges
with an interval, a tolerance and their list of uses, vertices with a
tolerance. Curves and surfaces are unbounded; their bounds are the edge
interval and the face domain. Loops are relative to the surface's natural
normal. Schema 3's read-only intersection and revolution records go.

The validator keeps schema 3's caps and adds the structural rules:
references, loop shape and connectivity, regions and closed shells, the
pcurve interval, natural parameter ranges, every edge's uses (primary
first, upper = !forward) and the canonical order of shells, faces, edges
and vertices. A reversed face is walked backwards, as truck's edge_iter
walks it, so truck's face and edge indices are the canonical ones.

The truck adapter writes truck's absolute wires as the loops, numbers
everything as the kernel does, and builds regions from the shells (a
tessellated nesting test only when there are several closed shells).
Pcurves come from pcurve::pcurves only; until it supports a face, encode
fails and the body is a cache miss. The envelope signature becomes
SCBREP05.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 5a9bd4398d brep: history types move to solidcraft_geom::brep::history
FaceOrigin, Change, FaceProv, Side, EdgeOrigin, EdgeProv and History move
unchanged (fields, serde derives) to solidcraft-geom, so a backend can
report history without depending on solidcraft-kernel. The pure methods
(composition, renumbering, count checks, mark_shared_split) move with
them and return brep::history::Failed, which converts to
KernelError::Failed with the same "history: …" message.

What needs a kernel body (History::identity, check, face_sources) stays
in the kernel as the BodyHistory trait; solidcraft_kernel::history
re-exports the types, so existing paths keep working.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 4afbe3b909 kernel: pcurve test for a face round its surface without a seam
A band of a cylinder bounded by two full circles and no seam cannot close
in (u, v): each loop's pcurve runs one period. The test records that such
loops come back continuous and a period open (the caller needs a seam
there), and that a hostile tolerance is refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 0d026e9757 kernel: pcurve fits start from four samples per span
Each sample of an intersection curve is one of truck's double projections
(about 0.13 ms in a release build), and a fit evaluates the curve at every
sample and halfway between. Starting from four samples a span instead of
eight halves that; the checks stay at eight points a span, and the knots
at the curve's own breaks already carry the shape. The cylinder cut by a
tilted box now takes 70 ms at 1e-3 mm and 149 ms at 1e-5 mm for all its
faces (release), from 183 and 638 ms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:44 -04:00
jyvikoandClaude Opus 5.5 c7088fac9c kernel: pcurve tests for seams, poles and loop orientation, and pictures
Faces with seams as imported faces have them (the kernel's own
revolutions come in pieces): a cylinder whose seam line is used twice
between two full circles, each a closed edge on one vertex, and a sphere
bounded by one meridian used twice from pole to pole. Their seam uses come
out a period apart, in the base period. The checks now also require every
face's outer loop to turn counter-clockwise in (u, v) for a face along its
surface's normal and clockwise against it, holes the other way: the rule
the pole junctions rely on, which every test body follows.

With SOLIDCRAFT_PCURVE_SVG=<dir>, a test writes each test body's face
loops in (u, v) as SVG for review.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:43 -04:00
jyvikoandClaude Opus 5.5 099026d94d kernel: fitted pcurves on curved surfaces, unwrapped and closed per wire
Every edge not exact on a plane gets a cubic 2D B-spline on its curve's own
parameter: through the parameters of the curve's ends, least squares
through samples between (banded normal equations), with spans halved and
sampled twice as densely wherever the lift misses the curve by more than
half the tolerance, at the samples or halfway between them. Knots start
where the curve's parameterisation is less smooth: a spline's own knots
and the vertices of an intersection curve's leader polyline, with the
multiplicity a cubic needs there (without them the cylinder-minus-box
intersection curves took 400 spans at 1e-3 mm). Spans and rounds are
capped; a fit that does not converge, or a curve farther from the surface
than the tolerance allows, fails naming the wire, edge and distance.

Samples are projected with the kernel's own surface parameter search (the
evaluator's form, parameterised as truck parameterises it; truck's search
for surfaces it does not take), each from the one before, unwrapped along
periodic directions. Where the surface collapses (a pole) the undefined
parameter comes from the nearest sample that defines it, so a pcurve runs
straight into the pole. Each wire's uses are then moved by whole periods so
each starts where the one before it ends, starting after a pole junction
if there is one; at further pole junctions the offset that gives the loop
a boundary's turn is taken. The wire then moves into the base period. A
seam edge used twice is fitted once.

Truck places intersection curves on their surfaces to about 1e-6 mm, so
their pcurves need a tolerance of 1e-5 mm or more; the test records that.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:43 -04:00
jyvikoandClaude Opus 5.5 26ab8981d0 kernel: exact pcurves of lines and splines on planes
A plane's parameters are affine in space, so the pcurve of a line or a
(rational) B-spline on a plane is the curve's own knots and weights with
its control points mapped into (u, v): no fit. Curved surfaces and
intersection curves still return "not supported yet". A test helper checks
every pcurve the way the schema validator does, its interval against the
curve's range, the lift error and the wire's closure in (u, v); the box's
line pcurves lift onto their lines' ends bit for bit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:43 -04:00
jyvikoandClaude Opus 5.5 ee5deffaa4 brep: Curve2 pcurve type and the truck pcurve entry point
The shared base for the schema 4 types and the truck pcurves: 2D B-spline
pcurves as SMLib keeps its UV trim curves, and the truck adapter's pcurve
function, not supported yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-27 02:28:43 -04:00
7734ba2300 Offset Face: split a periodic face off its seam first, as booleans already do (#6226) (#6227)
* claim: #6226

* Offset Face: split a face off its seam and try again, as booleans do (#6226)

A hole's wall arrives from a STEP file as one whole turn bounded by one wire that
runs along its seam twice, where SolidCraft builds the same wall as two halves.
Offset Face heals the body before it moves anything, and healing such a face
fails inside truck with `This wire is not simple`, so the panic guard turned the
whole operation into a kernel internal error. Since importing is how a part with
a hole usually arrives, Offset Face did not work on imported parts with holes at
all.

`seam_faces` already answers this for booleans: split every such face in two
along a plane through its axis, run the operation, and compose the history back
over the body as it was given. This gives the offset path the same retry.

- `seam_faces::one_body` is `boolean`'s answer for an operation that takes one
  body, with `needed_one` beside `needed`.
- `offset_faces` now does its healing, its face picking and its offset inside one
  closure, so the retry runs the whole of it on the split body; the first attempt
  is guarded, so the failure is an error the retry can act on rather than an
  unwind. The faces are picked per body, because the pieces are numbered
  differently once a face is split — the points do not move, so they pick the
  same surface either way.

The regression test is in `seam_faces_tests.rs`, beside the boolean ones: a
20 x 20 x 10 block with a 6 mm hole, read back from STEP, whose top moves 2 mm
and lands on the same volume as moving the built body's top, with its history
intact.

Checked against `main` before and after: the three kernel tests that fail here
(`blend::…seam_twice`, `step_in::…parallel_body_preparation`,
`tests::a_box_cut_round_a_small_hole…`) fail the same way without this change.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: CarlosKeese <dudukeese@gmail.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-10-25 18:49:44 +00:00
wckdboyandClaude Opus 5.5 743accca7a Triangulation: split a crossing boundary segment ourselves, never in spade's assert (#4031) (#5409)
* claim: #4031

* Triangulation: split a crossing boundary segment ourselves, never in spade's assert (#4031)

A trimmed face's boundary segment that crosses a constraint already in the
triangulation went to spade's add_constraint_and_split, which asserts
(cdt.rs:978, `!previous_region.is_empty() || from == final_vertex`) when a
split lands so near another vertex or constraint that the piece up to it is
blocked. The kernel guard caught it, but the whole operation failed and a
crash report was written; a STEP body imported empty or not at all (#4598,
also #4293, #4478, #5068, #5229).

PolyBoundary::add_constraints now adds every segment that can be added, then
splits each blocked one itself: a vertex at each crossing, inserted from the
crossed edge's own vertex, and the pieces between added where they can be. A
segment with crowded or very many crossings, or a face with more than four
blocked segments (a rim that runs back and forth across itself), leaves them
out, as truck did before #1653, so the face meshes slightly off instead of
not at all. Pinched faces (#1648) still split where they cross.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 02:55:24 +00:00
Artem Sushchev 30b01e8d79 A spherical shell revolves into a solid with a void, and cuts and joins with hollow tools work (#451) (#4182) 2026-10-23 22:53:42 +00:00