Validation::EachStep checks every solid sweep, boolean and blend result
in SMLib as before; EachFeature leaves those checks to the end of the
feature and says a check was left; Off skips them. The evaluation installs
the mode around a feature (validating), as watch installs a watch; outside
it every step is checked as always, and the kernel's worker threads run
under the caller's mode.
Under EachFeature a body decoded from a step keeps that step's SMLib
result (for its own record only), and check_kept checks it as the step's
own check would have, then lets it go; any other kept body is checked as
SMLib imports its record. The record can pass where the result fails: a
fillet's surface of revolution whose polar curve SMLib's check refuses
(fillets/1080-fillet-sloped-basin-1-mm-rim-r0-5-4-edges) is rebuilt on
import, and its round meets a wall at 72 degrees; checking the record
alone kept that round.
The largest-size search of a blend checks every candidate as it is built,
whatever the mode: a candidate fits only as a body the check accepts.
Surface operations and stitching keep their checks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This replaces the five fixed stations of 0a166bf3d, which compared the faces' normals at the
edge's ends and quarters: a sampled guess that misses a crease or a tangency between stations.
Along each use's pcurve (on the edge's own parameter), the face's natural normal Su x Sv is a
polynomial in t on every piece where the pcurve stays in one span of its knots and one knot cell
of its surface: of degree (2p + 2q - 2) r for a B-spline surface of degree (p, q) and a pcurve
of degree r, (4p + 4q - 2) r for a rational one (its homogeneous form), 0 for a plane. The cross
product of the two outward normals is then a polynomial of degree D, the sum, and it vanishes
on the piece iff it vanishes at D + 1 points of it (the piece's Chebyshev points). Pieces end at
the pcurves' knots and where a pcurve crosses a knot line of its surface (periodic copies too),
each a root of U(t) - k W(t) on a Bézier span, isolated on its Bernstein coefficients. A point
where the normals differ is a witness of a crease; agreement at all of them is a proof of
tangency (crate::tangent_edge). Outward normals opposite (a cusp, a knife edge) is not smooth,
as SMLib's GetBlendEdgeuse has it since fork 81f411d; a seam, whose two uses are on one face,
is smooth.
The C API has no edge classification query; SMLib's own (GetBlendEdgeuse at t = 0.34,
IsTangentSector at five stations) is sampled too. A fork item to make it exact and expose it is
written up for the SMLib batch. The tangent-chain walk decides each edge once.
The bar whose front face runs tangent into a cylinder R8, its front top edge rounded r2: the
round's contact with the front face and the front face's tangent line with the wall are smooth;
the round's edge with the wall (tangent at (40, 0, 8) only) and a box edge are creases; the
knife edge of #851 is a cusp, not smooth (blend.rs test). The blend, fillet and chamfer kernel
tests and the fillets rig keep their outcomes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A curvature-continuous fillet (type curvature, equivalent radius 2) of the three edges at a top
corner of the owner's bar built, but its corner was SMLib's own patch, which is only tangent to
the rounds: Continuity Analysis measures a 35.8 / mm curvature jump across its seams (with the
rounds G2 to the faces everywhere else), and it shows as a dome sitting on the corner, the
vertical round's shading lost under it. All three edges were rounded; the corner was not
curvature-continuous, and nothing said so.
Such a corner, where three or more rounded edges meet, is now set back (1.5 r unless a setback
names it) and left open by SMLib with the curvature sections (smlib_blend_setback_open with
SMLIB_BLEND_CURVATURE), and filled with the G2 patch fillet_g2_corners already uses for circular
rounds (fillet_g2_with_g2_corners). The `corner` option no longer leaves a curvature fillet with
SMLib's patch: its corners are always G2, and setbacks on it set back the curvature rounds (they
were circular rounds before). Where SMLib or the patch cannot build it, it is refused.
On the reported geometry every seam of the rounds and the patch is G2 (rig
report-fillet-curvature-three-edges-at-bar-corner-solver-residues), and the rounds outside the
setback cube measure exactly: V0 - 27 - (the quintic section, A2 = 0.597884, along the front edge
from 3 to the wall and along 7 and 13) = 9541.116961 (...-outside-setback). With round coordinates
SMLib's open sheet fails its own check (a 2D curve cusp, SmBSplineCurve test 13): the fillet is
refused, listed as known failing (report-fillet-curvature-three-edges-at-bar-corner).
Test: corner_g2_tests::curvature_rounds_meet_at_a_g2_corner (box corner, r5: the patch's jump
under CURVATURE_SHARE / r clear of the hole's corners, SMLib's own patch over ten times that).
Changes a default: a saved curvature fillet with such a corner rebuilds with the G2 patch; there
is no preference or fallback to SMLib's patch.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`inspect.curvature_comb` read the display mesh for model geometry: an
edge's comb fitted a circle through every three points of the nearest
mesh polyline, a face's did the same on its iso lines' chord points. The
comb was jagged, changed with the mesh tolerance and ignored `density`.
- geom: `CurveEval::jet`, a curve's point, unit tangent and curvature
vector kN from its first two derivatives (lines and conics in closed
form, B-splines and NURBS from the basis functions' derivatives, a
traced intersection from both surfaces' normal curvatures along its
tangent, by Meusnier: kN lies in the plane of the two normals and its
component along each is that surface's normal curvature).
- kernel (curvature_comb.rs): the edge nearest a pick by the exact
distance to its curve (a periodic face's seam and poles left out),
`density` teeth at even steps of the edge's parameter; along an iso
line, the surface's normal curvature n.S_tt / |S_t|^2 along its normal.
`IsoLine` carries the running surface parameter's span.
- engine: edges and faces use them (and `inspect.minimum_radius` on
edges); new optional `length` multiplies the automatic scale. The reply
keeps its shape.
Tests: a circle edge reads 1/R to 1e-9 at Coarse and Ultra display
quality alike, with `density` teeth; an extruded ellipse's edge matches
ab/(b^2 cos^2 t + a^2 sin^2 t)^(3/2) at every tooth, a/b^2 and b/a^2 at
the vertices; a cylinder face's rings read 1/R and its lines 0; `scale`
and `length` set the teeth's length; curve jets on every record kind.
The existing cylinder-edge check tightens from 0.5 mm to 1e-9.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
a_round_into_a_hole_is_cut_by_it (issue_324_tests.rs) built rig case
fillets/324-fillet-over-hole-overlap's body, but cut its hole with a cylinder
longer than the block (z -1 to 11) where the rig extrudes a sketch circle
flush. The new case fillets/324-fillet-over-hole-cut-by-overlong-cylinder
builds it that way (solid.cylinder, base z -1, height 12, cut) and holds it to
the same hand-derived answer: block 40x20x10 less the r3 hole at (20, 14.5)
(282.74) less the R4 round on the top edge at y = 20, 40 (16 - 4 pi) = 137.35,
plus what both remove, the integral over y in [16, 17.5] of
(4 - sqrt(16 - (y - 16)^2)) * 2 sqrt(9 - (y - 14.5)^2) = 0.375830 (re-derived
with the substitution y = 17.5 - s^2, 200000 steps):
V = 8000 - 90 pi - 40 (16 - 4 pi) + 0.375830 = 7580.287315, and G1 on the
blend. It passes today (aarch64, SMLib), as the flush case does, so it needs no
KNOWN_FAILING line; the unit test, a duplicate of the two cases, is dropped.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A To Object extrude to a curved face runs its tool through the target and
cuts the target out of it. The SMLib boolean carries no extrusion face
sources (they stood for the untrimmed profile), so sheet_tool_span, which
read the tool's depth and footprint only off its extrusion caps, gave up
and the intersect was refused as unrepresentable.
The tool's current geometry says what it is: the kernel's prism
certificate (prism_measure, the one component copies are compared by)
reads off the exact record whether a body is a uniform prism along a
direction, its two cap levels and its section of lines and arcs. It is
now public as certified_prism_section, and sheet_tool_span uses it when
the caps don't certify the tool: the levels are the depth, the section the
footprint the To Object cut is bounded by. A tool trimmed to something
that is not a prism (a curved roof over it) is still refused.
partial_depth_intersect_curved_to_object_preserves_current_trimmed_cap_footprint
passes: the tool is the square 20 ... 30 less the pin's circle (radius 2),
z 0 ... 1, 100 - 4π, as the test's own witness extrude measures it. A
kernel test reads that section off the trimmed lump.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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>
Both walked the picked curve's display polyline: a point a third along an R10 sketch arc was
0.87 µm off (8.6603, 5). They now evaluate the path's exact curves by arc length: lines and arcs
in closed form, a free-form span at the parameter its arc-length integral reaches (body edges by
their record curves, 3D sketch curves by their arc, spline, line or linked exact curves; only a
curve that exists as points alone, an intersection edge or a projected curve, runs along them).
The arc's point is now within 1e-12 mm of (10 cos 30°, 5, 0).
A t outside 0…1 was clamped silently, which the contract (`t: expr, 0…1 along it`) does not
say: it is refused ("t is 1.5: a point along a path is 0 (its start) to 1 (its end) of the way
along it"). The construction cases grade the arc and line to 1e-9 mm, past-the-end is refused,
and a new case takes the middle of a symmetric cubic spline, (20, 7.5).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A chamfer picked at (10, 0, 20) on a cylinder's top rim lies on the vertex where SMLib's
cylinder has its seam. The blend takes the rim there (blend_smlib::resolve: a seam or a smooth
join loses a tie), but the name stored with the feature came from the nearest mesh edge, the
seam (`F2:side:c1`). Once the stem grew, the name found the seam and SMLib refused the chamfer
(join_extrude_from_a_chamfered_top_face). edge_names_for names the edge each pick takes as a
blend takes it (kernel::blend_edges), the nearest edge only where that finds none.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new undoable feature (`repair`, one pending format file) and command with input and
output schemas. In order:
- A cylinder, cone, sphere or torus face SMLib refuses on its own is rebuilt on a NURBS
form of its surface laid on arcs from where the face starts
(`form::surface_on_own_arcs`), with SMLib's own trims: the import's quarter-grid form of
a face round most of a turn closes on itself, which SmTorus::IsNurbSurfaceTorus does not
recognise. Geometry unchanged.
- Free edges that pair up within `gap` are sewn by SMLib's stitch; GlueEdgesGeneral gives
each glued edge its own tolerance (at least twice its gap), the body's and the other
edges' stay. The result is checked against the input's own SMLib check, the
tolerance-bound tests (#5, #6, #59, #82) exempt.
- Loops of free edges left are holes: offered as surface.patch, and with patch_holes made
(flat only when the loop is planar and every face around it is a plane, else G1) and
sewn in.
The reply reports what changed face by face; nothing to do is refused with why.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Conflicts in xtask/src/kernel_cases.rs and xtask/src/main.rs: both the
multi-backend runs (--kernel, --route) and develop's --known-failing
regression gate are kept. The gate grades the SMLib side: --known-failing
needs --kernel smlib (the default) or both, and is refused with
--kernel solidcore. A gate run saves every backend's results.json and
writes no report or side by side. Both report texts are merged; all tests
from both sides are kept, plus one for the gate's option rule.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SdcgExNEwfR9CX2RAzp2Pt
expected.json may give `continuity: {order: g0…g4, edges?: "blend" | "corner"}`: the
seams of each round, chamfer face or corner patch with the faces either side of the edge it
replaced, and of each corner patch with its rounds, are measured as Continuity Analysis
measures them (seam_diagnostics at its default 33 stations and default tolerances), and the
case fails naming the worst seam, its faces, the order it reaches and the next order's worst
value. The seams come from the faces' persistent names (doc::naming::blend_seams). The older
`{near, within_mm, …}` form is kept.
Every fillet-area case with a body gets its order: constant rounds and rolling corners g1,
curvature rounds g2, chamfers g0, the corner: g2 patch g2 at its seams.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SMLib's import says only that it refuses a body, so the kernel now keeps a structured
refusal with the body's SMLib cache (Body::smlib_refusal / smlib_refused: the first face SMLib
refuses on its own, found by sending each face alone, and its surface kind). A STEP import sends
each part's first instance as an operation would, notes the parts that need repair in the
import report, and the browser marks them ("VALVE_COVER_01: needs repair").
A feature dialog whose operation fails on such a part says, instead of the kernel's words and
an issue report: "Couldn't join to VALVE_COVER_01. One of its rounded faces can't be used for
modelling.", with Repair part (body.repair, declared as planned, also in the part's menu) and
Show face (selects and frames the face).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The kernel's import warnings get a structure (ImportReport: the file's parts, how many came
in as solids, and each warning's kind, part, faces and count; the reads' notes are typed as
repairs or faces left out). The Import feature's result carries it (and the model cache keeps
it), and the timeline tooltip and the status line after an import word it from the catalogs:
"Imported 40 of 43 parts as solids. 1 part couldn't be made into a solid and is shown as a
mesh. 3 faces couldn't be repaired and are missing." with what may help. Entity numbers and
the kernel's wording stay in Copy Warning Message, which now lists every warning.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Setback field reached the command and the kernel used it: on a box corner
with r 2 rounds a 3 mm setback built, while 1.5 and 2 mm failed inside SMLib
(status 1001), shown as "could not be built" with nothing saying why. A setback
must reach past where the rounds meet without one (the radius on square faces).
The kernel now refuses such a setback before SMLib runs, naming the least
(the pre-check of aa2b09bc2 on fillet-kernel-cases), and exposes that least
(fillet_least_setback). The field shows the default, 1.5 x the radius, as an
editable length that follows the radius until the user types one, and outlines
a value at or below the least in the warning colour with "More than 2 mm"
under it (ui_kit::checked_row, warning_caption). Its hover text says what a
setback does, the default and the least.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5Lzv2n8fyKqD61NCHSF
The kernel's Continuity moves out of bridge.rs into continuity_order.rs and gains G4. One
table holds each order's command word (g0-g4), its code (G0-G4, for tips and messages) and
the message ids of its label and hover text. Construction says which orders the patch,
bridge, network, match and sketch blend curve build today; Continuity::built_by is the one
refusal every command and kernel entry point uses. A design may now save g4 (format note).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LUXeKMoxpM7Vuv8Rb6E3K2
The analysis sliced the display mesh with planes: faceted, approximate, and
broken at triangle seams and trims; the window drew it as a 2D overlay without
depth while the tool was active. Now one kernel routine (kernel::iso) clips a
surface's u = const or v = const line to a face's pcurve loops; the curve through
a point (sketch projection) and the analysis grid (count each way, evenly across
the face's extent) both use it. The loop polygon follows the loop's order (a
pcurve the loop runs against is walked backwards), which the inside test got
wrong before, and closes over vertex-loop poles.
ModelBody caches the lines per face, count and display quality. The session
keeps the picked faces as view state (inspect.isocurve add/clear, hostile counts
refused); the viewport, ui.render and snapshots draw them depth tested in the
accent colour. Curvature combs on faces follow the same exact lines.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A corner where three or more rounded edges meet, every edge there rounded, is
set back (1.5 r unless a setback names it) and left open by SMLib
(blend_smlib::fillet_setback_open: the sheet and each corner's hole, in the
sheet's orders); each hole is filled by fill::matched_patch, the height field
over its plane fitted to the position, tangent plane and normal curvature
across the boundary of every face beside it (exact second derivatives), rounds
and planes alike, each edge's pcurve its exact projection; SMLib sews the
sheet and the patches into one solid, which must close. The history is the
sewing's carried through the sheet's, each patch face made from the rounded
edges its neighbours come from.
corner_g2 is that construction now. The polar patch over three sections it
held (never sewn in) could not be: its boundary is a closed cubic through
stations, which rounds off a corner of the loop, and the setback hole has six.
The 60 x 40 x 20 box corner of r5 rounds (07/015): 10 faces, a valid closed
solid (record and SMLib's check), curvature jump across the patch's seams
6.3e-4 per mm clear of the hole's corners against the ball's 0.2; set back 8
between the hull and prism bounds; set back 11 to 15 inside the box but by
under 7e-4; all eight corners of a box filled; refusals named.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The branch rebased onto main keeps each of its commits; where both sides
changed the same code, these are the pieces neither side's commit had.
- Cargo: one [features] table in the CLI's manifest (two met in the merge).
- geom: a NURBS surface's `closed` set once in a placed copy (both sides
added it).
- kernel: the whole-face extrude tools (#2040) work around truck's boolean
on truck types, which left the workspace with the SMLib kernel; the
module, its tests and the doc crate's tool and tests go. The display
planner's flat fill (tess/fallback.rs) has no caller with the schema 4
mesher, and the tessellator's seam and uv modules are the branch's. A
body's boundary tolerance from a STEP file belongs to the truck body the
schema 4 record replaced: `with_boundary_tol` goes. `unmeshed_faces`
counts the coarse mesh as the branch does. A loft's section re-split
passes the lead's perimeter shares to main's `resample` (a circle breaks
there when the matched corners do not go round in order). Main's tests of
the mesh-based measure (the SMLib kernel measures exactly) and of the
IGES preprocessor name (no such field on the branch's import record) go.
- doc: a feature result carries no boolean diagnostics on the branch, so
the model cache neither writes nor reads them, and a pattern copy's miss
test runs the intersect as it is. A placed body's worker result is a
Result: a body taken from the previous placement is Ok. A thread's
clipboard remap takes main's arguments, the tapped catalogue names a
metric size by ThreadForm::Metric, and main's tests unwrap the placing
calls that return their error.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each (point, distance) sets back the corner at the body's nearest vertex: its
patch starts that far along every edge there. Tested on the 60 x 40 x 20 box
corner with r5 rounds set back 8 (volume between the convex hull and the
rounds' prisms bounds, 15/36/23 topology, the box's bbox) and on refusals.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Ladder 06/009 had no way to ask for one: "solid.thread has no runout (vanishing thread)
length". With SMLib's smlib_screw_sweep_radial (replay e7acea1):
- smlib: the FFI binding and Brep::screw_sweep_radial, the profile moved off the axis by a
piecewise linear law of the turn; crate test: a tooth moved out 1 mm over three turns has
A 2π (c turns + ∫ offset dt).
- kernel: sweep_helix_radial, sharing sweep_helix's checks (helix_profile).
- doc: `ease_in`, `ease_out` (a length, or ISO 3508's standard 2.5 P or short 1.25 P) fade the
groove over that length, its section moving out of the material as it turns (outward for a
shaft, inward for a nut). ease_in is at the end the thread starts from. The runout lies past
the full-form length: beyond a square stop, before a shoulder up to its clearance; at a free
end inside the face. Runouts longer than the thread are refused. No end gets one by default,
so saved threads keep their geometry.
The cut is the integral over the turn of the clipped section's 2π∫ r dA: engine test (2.5 P
and 1.25 P between two collars) within the sweep's wall tolerance times the runouts' wall area
(0.029 against a 0.036 mm³ bound), ladder 06/009 (004's shaft, a 2 P runout before the
shoulder) graded in closed form (measured 1.7e-6 off).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A thread of some length ran from "the end of the face nearest the pick", a coin toss for a
pick in the middle (rig 602's 4 mm thread meant for the free bottom end ran at the head end,
cutting 1.17 mm into the hex), and every thread end at a face end got a one-pitch overrun,
which at a shoulder gouged the material past it (ladder 06/004 cut 0.9% of its volume out of
the collar).
- kernel: material_in_ring, the exact intersection of a body with a ring about a cylinder
face's axis, by an SMLib boolean.
- doc: a face end is free when no material lies past it, over the span the groove's one-pitch
overrun reaches beyond its first pitch, within the radii the groove cuts (a cap, a chamfer
the groove runs out through, a counterbore). At a free end the groove runs out as before; at
a closed one (a shoulder, a head, a blind hole's bottom) it stops with its widest part clear
of it; inside the face it stops square.
- doc: a thread of some length starts at the end nearest `from`, else at the face's only free
end, else at the end the pick lies within a third of the face of; a pick in the middle of a
face whose ends are alike is refused, naming `from`. A length as long as the face runs the
whole face. `up_to` a plane or a point's place along the axis. New fields `from`, `up_to`
default to none, so saved threads keep their meaning where it was not a coin toss.
- engine: solid.thread takes extent (full|length|up_to), from and up_to.
- ladder 06/003 (now with `from`), 004 and 007 are graded by volume and centre of mass in
closed form (a square stop inside material removes exactly length/P turns, the section being
symmetric); rig 602's method says why the thread is at the bottom, tolerance 0.02%.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The kernel blends exactly the edges given; the feature's tangent_chain (default true, saved
only when false: pending format note blend-tangent-chain) expands each pick to its tangent
chain (kernel::tangent_chain) before the kernel call. A variable or spline round takes its
edge alone. Scripts and MCP passing one pick get the chain again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
SMLib (fork 68e3086) refuses a blend whose rails leave the faces they roll on with
SMLIB_ERR_NO_ROOM, which the kernel reports as KernelError::TooLarge. The kernel's own
pre-checks go: blend_fit's fit check and the 256-station band check of the variable fillet.
The shim no longer follows tangent chains; the Fillet/Chamfer dialog already expands a pick
to its chain (its Tangent Chain option) and stores every edge in the feature.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
extrude_tapered(_between) take a DraftCorner: PreserveCurvature (each wall
continues as itself, a line's plane or an arc's cone, until it meets its
neighbour; SMLib's SM_OC_CURVE_EXTENSION), Tangent (the offsets continued
along their end tangents) or Round (an arc about the corner). A corner
the rule cannot close is refused with its point and why
(solidcraft_smlib::Error::Corner). draft_corners reports, per sharp
corner of a profile, what each rule gives: how far each offset curve runs
on or is trimmed, whether the corner cuts inside the exact offset, or why
the rule refuses it. SMLib pinned at the fork's draft-corners head.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
Owner's decision for strips whose rulings turn freely along their edge (a face's
normal along a free-form face, which was refused): the far edge is not the
offset curve but a B-spline the kernel defines, and the strip is exactly the
ruled surface between the edge and it.
The far curve has the edge's own degree, knots and weights (so the ruled NURBS
needs no knot merging); it runs from the strip's start corner to its end corner
(where the rulings at the edge's ends reach); its interior control points are
given (handles) or the least-squares solution of weighted terms, the
construction's parameters: closeness to the rulings' ends at the edge's
Greville abscissae (W_CLOSE), fairness by arc length (W_FAIR), each end leaving
along the chord to the other end (W_TANGENT, one small function), and at a joint
where the chain runs on smoothly with shared sides the first and second
derivatives by arc length matched to the neighbour's (W_JOIN), in one solve
along the chain, an exact neighbour's far edge matched as it is. Exact strips
are unchanged.
ruled_far_handles gives each free strip's default handles; ruled_surface_with
takes moved ones. The Ruled Surface feature saves them as `far` (per chain
edge, null for the default; pending format note ruled-far-handles), and
surface.ruled takes them as `far`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
Every lib warning under --features smlib outside the files agents are editing
(assemble.rs, sweep_path.rs) pointed at code nothing calls any more:
- body: shell_nesting;
- boolean_record: of_pair and its Traced alias;
- planar_regularize: the generated-wall regularization (and its branches in the
certified one, which was its only other path); planar_sources:
with_shell_planar_sources;
- plane_fit: plane_through, EdgeSampler, planar_face, plane_frame (the patch is
fill's); only loop_area is left;
- polyhedron: solve3; prism: wall_along; offset: Surf::normal;
- record: regions, region; shell_groups: groups, parents and their limits;
- splitface: side_of_point, Analytic, analytic_face, face_sides, canonical;
- spline_conv.rs, all of it (surfaces builds NURBS records); an unused import in
tess/uv.rs.
The tests of deleted items go with them: prism's wall_along test, the shell
grouping test in body_lump_tests, and the generated-regularization assertion in
regularization_protection_tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
The doc puts exact tools into SMLib's boolean as drawn, so nothing asks whether a touching tool
can be joined, batches extrusions, or probes for room to grow a profile.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
A rig case whose SMLib call fails left nothing to replay it from: nothing called
solidcraft_smlib::set_dump_dir. `solidcraft-cli kernel-cases --dumps=DIR` now points SMLib's
dump folder at DIR/<area>-<case> before each case runs, so a failing call leaves its
arguments and B-reps there (smlib_brep_read reads them back into a scratch C program), and
turns it off after the run. Off without the flag. The kernel exposes it as
smlib_dump_dir, beside smlib_built (the CLI reaches SMLib only through the kernel).
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
face_params and outline are gone (no callers on the record). The fork head adds the 2D planar
boolean (smlib_planar_faces, smlib_boolean2d), the grazing-curve crossing rule (solidcore#480) and
untrim's parameter-box status.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
A solid body's volume, area and centre are SMLib's mass properties at its documented 1e-4 and its
box SMLib's exact one; a body SMLib cannot measure is an error. The three-mesh measure and the
mesh cross-check beside SMLib's numbers are gone, and with them the kernel switch
(SOLIDCRAFT_KERNEL, Backend): SMLib is the kernel. The smlib feature gates in the crate root, the
validity check and the offset backend go, since SMLib's crate is always linked (answering not
built without the feature).
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
A boolean is SMLib's boolean, its history SMLib's tags: the jittered retries, tool nudges, prism
and coaxial routes, the retry result guard and their diagnostics are gone. A rigid placement moves
the record; any other matrix goes through SMLib's transform (new Brep::transformed over
smlib_brep_transform). Bodies apart join as their records side by side (brep part::compound),
with each piece's faces, sources and history; apart means their exact boxes do not meet. A split
is the intersection with a half-space box, with no faces pushed off the plane.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
The fork head carries untrim and extend shims with their history tags, the local solvers that
take no value from a failed evaluation (solidcore#481), the B-spline curve radius check
(#475), the torus minor-interval check (#482), the blend rail along its face's rim (#485) and the
intersection path's statuses.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
assemble (records rebuilt after removing and adding faces) joins; the boolean guards that re-ran
a failed boolean with a changed tool (bore_guard, candidate_reach, sphere_lens, tangent_cylinders,
touching_walls) are gone; the lens-cut result stays as a boolean test. SMLIB_REV at the fork's
integration head with smlib_merge_faces.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
SMLib's blend builds rolling-ball rounds, corners, loops and vertex spheres in one call; the
modules that built them on the old kernel were deleted by the blends port.
(not built: base in progress)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
A drawn 3D spline reached the kernel only as its sampled polyline (Wire.pts), so SMLib refused
to sweep along it ("not supported yet: SMLib sweep along a smooth path of points"). The doc
holds the spline's fit points; the curve is the centripetal Catmull-Rom spline that
fit_polyline samples. Each span of it is a cubic (Barry-Goldman), and its derivative at a fit
point depends only on that point, its neighbours and the two knot intervals, so neighbouring
spans share it: the spline is exactly one cubic Bézier per span, C1 across the spans.
- geom: catmull_rom holds the curve: samples() (fit_polyline's arithmetic, moved verbatim;
sketch::fit_polyline now calls it) and beziers(), the exact spans; ArcLength on CurveN
(Gauss-Legendre per knot span, Newton for the parameter at a length).
- kernel: PathSeg::Cubic, a cubic Bézier in space (the 3D counterpart of PathSeg::Curve, which
is planar), with its arms wherever PathSeg is matched (start/end, tangents, length, point at
a length, turn, SMLib curve as a degree-3 NURBS, halving). PointPath / PathPiece carry a path
through 3D sketch curves: polylines as points, drawn splines as their fit points (reversed
when the path runs them backwards); PointPath::segs gives SMLib the spans and the lines;
sweep_point_path_with sweeps it (SMLib through sweep_with, so corners, twist, scale, rails and
orientation take the existing routes). A smooth polyline piece (a projected or linked curve,
which the kernel only has as points) is still refused on SMLib.
- doc: path_points builds the PointPath (a wire with three or more fit points is a spline
piece); solid sweep and pipe call sweep_point_path_with; rails, surface sweeps and curve
networks take its points as before.
Checked in scratch (not committed): the spans pass through every fit point and every
fit_polyline sample at its parameter (1e-12), C1 at the joints and round a closed spline;
samples() is bit-identical to the old fit_polyline over 1180 random open and closed inputs;
SMLib sweeps of a radius-2 circle along an open spline and round a closed one match
pi r^2 L (L by independent quadrature of the curve's definition) to 1e-7 and 3e-8.
sketch/wire.rs: the existing closed-spline test reads SPAN_SAMPLES from its new home.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt