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
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
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
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
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
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
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
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
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
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
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
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
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>
- `"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>
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
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
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
- 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>
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>
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
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>
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>
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>
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
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>
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
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>
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>
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
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
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
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
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
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
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
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
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
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
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
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
* 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>
* 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>
A join failed with the kernel's internal error "tolerance must be no less
than 1e-6" at vendor/truck-geometry/src/decorators/intersection_curve.rs:172:
IntersectionCurve::parameter_division asserted truck's minimum tolerance,
and the guard turned the panic into a failed operation. A tolerance below
truck's TOLERANCE, or one that is not a number, now divides at TOLERANCE:
the curve's points are only found to within it anyway.
The test divides the intersection edges of a hole cut through a B-spline
face at 5e-7, 1e-12, 0, -1 and NaN: each gives the division at 1e-6. Without
the fix it panics with the reported message at the reported line.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* claim: #5150
* Stand it up: don't offer it for SolidCraft's own STEP files (#5150)
STEP replies from file.insert_step and doc.open now carry the file's
originating system, and the window skips the stand-up offer when it is
exactly SolidCraft, as SolidCraft's STEP export writes it.
* Stand up Y-up STEP and IGES files from SolidWorks automatically
The STEP header (originating system, preprocessor version, FILE_DESCRIPTION) and the IGES
global section's native system ID say which program wrote a file. A SolidWorks header means
Y up: the import's component is stood up as it opens, as one undo step, and the message offers
Undo. SolidCraft's own files are left alone; an unknown exporter keeps the offer.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Ray <raykholo@users.noreply.github.com>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
`Body::size` walked a mesh body's vertices on every call, and it is asked
for every frame. A mesh body's triangles never change after `mesh_body` or
`mesh_transformed` makes it, so both now measure it then (`TriMesh::span`)
and `size` returns it like a B-rep body's. `ModelBody::mesh` returns a mesh
it already has before working out the display tolerance.
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* Chamfer: a cutter that would reach into a nearby wall is not used
A straight chamfer's cutter reaches several times the chamfer's size out
from its edge, and further on a larger part. On a pin standing in a socket,
that far side lands inside the socket's walls, and the cut took bites out
of them. A cutter whose far side is inside the part is now refused, as one
whose ends are, and the chamfer is built locally instead.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Robustness goldens: seed 9 re-recorded for the chamfer cutter check
A chamfer in seed 9 was refused because its result changed more of the
part than a chamfer can. With its cutter refused, it now builds locally.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* STEP import: mesh band faces that wrap around a closed surface correctly
Fixes two related bugs that caused SolidCraft to fail to mesh a face wrapping
all the way around a closed, non-periodic surface (a revolved ridge band, or a
tube-shaped B-spline surface): a missing face, a folded/self-overlapping
triangulation, or a hole in the rendered body.
1. Ring edges that run slightly off their surface. STEP files write a surface
and the curves bounding it to the file's own declared uncertainty, so a
ring edge can legitimately sit a few micrometres off the surface it
bounds. The code finding where a ring edge crosses the planned split line
compared against the edge's raw (off-surface) point using a hardcoded
tolerance far stricter than the file's own precision, rejecting a valid
cut. Now matches against the point on the surface directly below the ring
crossing, respecting the file's declared tolerance.
2. Closed B-spline surfaces, their slits and their slivers. truck only treats
the rotation of a revolved surface as periodic; a face on a B-spline
surface whose control net closes on itself (a tube) wasn't recognized as
wrapping around at all. This produced a folded face, a hole (a boundary
loop landing a full period away from where it should cut), and one
near-zero-width sliver face costing the entire body its tessellation
plan. Adds periodicity detection for closed B-spline surfaces, period-
aware hole-loop alignment, dropping of zero-width slit boundaries, and
isolating a too-thin-to-triangulate face so it no longer takes the rest
of the body down with it. The GPU shader's periodic wrap mirrors the CPU
math so the two don't drift apart.
Regression tests: band_faces_split_when_ring_edges_run_off_their_surface,
band_face_with_a_zero_width_slit_is_still_meshed,
a_sliver_face_too_thin_to_triangulate_does_not_cost_the_body_its_plan.
Ablation-tested: disabling either mechanism in (2) reproduces its target
test's original failure message while leaving the other test unaffected.
* STEP import: mesh the band's split faces, not just split them
jyviko asked whether a band wall missing from the interactive app's render
was a shading issue or a genuinely missing face. It was missing: the ring-
edge split fix made the band's topology correct, but plan_face still
produced zero triangles for the two new sub-faces.
Two causes, both in plan_face (crates/kernel/src/tess/mod.rs):
1. The tolerance for how far an imported boundary may lie off its surface
was tied to the requested mesh's chord tolerance instead of to the
body's own size. A finer display tolerance could then reject a boundary
a coarser one had just accepted, so the face would drop out exactly when
zooming in on it.
2. Near a sharp corner of this flat-panelled band, several boundary points
that are legitimately a few micrometres apart (within the STEP file's
own declared precision) all projected onto the same surface point. The
boundary loop then repeated a point in (u, v), which a triangulator
can't follow, so the face's plan failed outright. One face without a
plan costs the whole body its plan, and the fallback mesher can't
handle a closed B-spline surface either, leaving both halves of the
split band with no triangles at all: present in the topology, invisible
in every renderer, and absent from the body's volume.
Fix: scale the off-surface tolerance to the body's own extent (new
Rules::extent), and collapse a run of boundary nodes that land on the same
surface point to one (drop_collapsed) before triangulating.
Regression test additions to band_faces_split_when_ring_edges_run_off_their_surface:
the body's volume now matches the analytic pentagon prism (was a third of
it - only the top cap - before this fix); display_plan leaves no face
without triangles from coarse to fine tolerance; and the actual tolerance
and facet angle the viewport draws with gives the split band its full
lateral area on both halves.
Confirmed on review_band_big.step, the fixture behind the review screenshots:
volume's relative error against the analytic pentagon prism drops from
1.4e-4 to 4.1e-6, and the band wall now occludes the floor grid behind it
in a snapshot the same way the top and bottom caps always did.
Full kernel suite: 739 tests, 0 failed.
* STEP import: hold an imported boundary to the file's own tolerance, not the part's size
jyviko: the off-surface acceptance added in the last commit
(rules.extent * OFF_SURFACE) scaled with the part, so a 2 m part
silently accepted a boundary 2 mm off its surface while a 20 mm copy
of the same part accepted only 0.02 mm. A STEP file's own declared
uncertainty does not grow with the part, so the bound shouldn't either.
Body gains boundary_tol: Option<f64>, Some(file's declared tolerance)
for a body read from STEP (crate::step_in::Units::tol, already used
by the ring-split fix in split.rs), None for anything this kernel
built. It's set before the import's own unmeshed-face check runs, and
carried over by the two face-split operations that re-cut an imported
surface (splitface.rs, outline.rs), since the file's uncertainty still
describes those boundaries afterward.
plan_face's accept now reads: the file's own tolerance when the body
declares one, or the old chord-tolerance/extent bound otherwise. The
old bound's tol * 10.0 term had to go too, not just the extent term:
at a 2 m part's typical display tolerance that term alone is ~20 mm,
nearly ten times the extent bound jyviko objected to, so keeping it
would have left the exact 2 m/2 mm example still silently accepted.
Two new tests in step_in/tests.rs:
- band_faces_split_when_a_scaled_copy_runs_off_its_surface: the same
band fixture at a realistic 2 m scale with the same absolute slop
and declared uncertainty as the small one, meshes the same way at
every chord tolerance from coarse to fine.
- off_surface_budget_follows_the_file_not_the_part_size: the actual
regression. The same off-surface error is accepted or refused the
same way whether the part is 20 mm or 2 m; a 2 mm error against a
1 µm declared uncertainty is refused at both sizes now (accepted at
2 m under the old bound, refused at 20 mm - that asymmetry was the
bug). Checked at both a coarse and a fine display tolerance.
Known gap, not fixed here: a STEP-imported body saved into a
.solidcraft design and reopened loses boundary_tol (native.rs's
decoder has no field to read it from) and falls back to the old
extent-based bound on reload. Today's design format has no concept of
this value at all; persisting it is a real format change, out of
scope for this fix.
Full kernel suite: 776 tests, 0 failed. clippy -D warnings clean.
* Display plans for STEP threads and pointed ends (#3847)
Three faces cost a threaded or pointed STEP part its whole display plan, so it
was drawn from the reference mesh: cracked, faceted, and never refined up close.
- A loop through a pole (a cone's apex on the boundary) seemed to wind around
the surface: the jump at the apex, unwrapped to the nearest copy, was
arbitrary. The loop is turned to end where it leaves the pole, so the step
that closes it is an ordinary one (`seam::close_through_pole`).
- Projection onto a spline with hundreds of spans (a helical flank) restarted
from a 16 x 16 grid and settled on another turn; it now starts from two
points per span, capped.
- Sag refinement no longer inserts a point exactly on a boundary side, which
split the side and failed the face.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* tess: a refused face's edges are divided finer and it is planned again (#2814)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* tess: sliver faces plan empty; a face no method plans is filled flat from its nodes (#2814)
A face whose boundary runs out and back along itself (two edges between the
same vertices, a rounding apart, as STEP files write slivers) encloses nothing
and is planned with no triangles. A face still refused after its edges are
divided finer (a cusp, a sliver whose sides sag across each other, a small cap
at a pole) is filled flat from its shared boundary nodes, so the rest of the
body keeps its display plan instead of falling back to the reference mesh.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* display mesh tests: a rim the chord tolerance leaves a line is divided again (#2814)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* portable B-rep: up to 8192 control points along a spline direction (#2814)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* solidcraft-cli: --debug logs what the engine reports to stderr
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* STEP import: a spline written over a tiny parameter range is read over one (#2814)
Some writers parameterize splines over a few millionths (a humanoid robot's
edges span 5.4e-6). The kernel tells parameters apart only to 1e-6, so over
such a range it evaluated the curve's end wrongly, and trimming an edge to its
vertices dropped a control point: the bodies could not be stored exactly and
the whole model cache was left out of the design. The knots are now stretched
to span one; the curve is the same and edges are trimmed by their vertices, so
nothing read from the file refers to the old parameters.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* model cache: a body keeps its file's declared accuracy (#2814)
A body restored from the cache dropped the accuracy the file it was read from
declares, so the planner held its boundaries to the kernel's own bound and a
reopened design drew differently from the import. It is stored with the body's
runtime values, and only when there is one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* tess: a boundary within a hundredth of its body lies on its surface, at every quality (#2814)
#1721 held a body read from a file to the accuracy the file declares. A writer
declares what it aims for, not a bound its edges keep: a 251-body robot
assembly declaring 0.01 µm has boundaries 10 to 30 µm off their surfaces, and
95 of its bodies lost their display plans. The bound is a hundredth of the
body again, what Normal quality always allowed, and now the same at every
quality, so zooming in still never drops a face (#1721's point). A file
declaring more raises it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
* STEP import: keep faces whose edge vertices sit slightly off their curves
Some exporters write an edge's vertex beside the end of its curve, further off
than the accuracy the file declares (a surface export declares
0.01 mm and puts a vertex 0.19 mm off two spline ends). The reader refused
such edges and left the face, and with single-face bodies the body, out.
A vertex may now sit up to the file's tolerance or 1/1000 of the model's size
(the diagonal around its VERTEX_POINTs), whichever is larger, never more than
the existing 1 mm ceiling. Spline and open-conic edges have the end control
point moved onto the vertex, so every such edge meets its vertices exactly.
The file's declared accuracy still governs closed-curve, seam and circle
checks.
* tess, io: review clean-ups (#2814)
- A sliver face is one whose loops are all slit: drop_slits finds it in the
retry after a failed plan, so the pre-check on every face (folded) is gone.
- The flat fill uses cdt::triangulate (a lenient fill that leaves out sides
crossing one already kept) and its flood-fill inside test, and the plane
from geom::Plane.
- Refinement only builds its indexes when a face was refused, takes the
faces to plan again from edge_faces, and re-samples edges on the pool;
Rules::finer for the finer rules.
- One PackageWriter::fits for the model cache, the preview and the thumbnail.
- The band split's ring tolerance lives in split.rs; comments say what the
off-surface bound is now.
- The CLI logger prints Level::as_str().
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM
---------
Co-authored-by: David Lackovic <lackovicdavid1234@gmail.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Ray <raykholo@users.noreply.github.com>