partforge 0.36.0 → 0.37.0

package/docs/AUTHORING-PARTS.md

@@ -152,6 +152,9 @@ future contract v2 — but are not shown here; see `docs/KERNEL-CONTRACT.md`
 | `k.loft({ rings, ruled?, closed? })` | stack polygon cross-sections into a solid — ruled walls between consecutive rings, capped ends (both backends; `closed:true` capless loops are Manifold-only). `ruled:false` (smooth C2 blend) is honoured only by OCCT/STEP export; the Manifold preview always shows faceted straight walls |
 | `k.sweep({ profile, path, cornerRadius?, closed?, ruled?, smooth? })` | sweep a fixed 2-D profile along a 3-D polyline path — sharp mitered corners (or `cornerRadius` fillets), capped ends (both backends). `closed:true` capless loops and `smooth:true` (OCCT-native swept B-rep, STEP-exact / preview-faceted) are backend-specific, like loft's `closed`/`ruled:false`. `closed:true` loops must be **planar** — RMF frame-transport holonomy can seam-twist a non-planar closed loop where the last station rejoins the first, so only planar closed loops are supported/tested |
 | `k.sphere({ r\|d })` | sphere centred at the origin; bare `k.sphere(r)` also stays valid |
+| `k.roundedBox({ size, center?, round })` | box with rounded edges — `round` = number (all edges) or `{ side?, top?, bottom? }` (vertical edges / rims); stays on Manifold (no OCCT routing, unlike `fillet`); `side` must be 0 or ≥ the rim radii (between clamps with a warning); with `side > 0`, `top + bottom` must be strictly `< h` |
+| `k.roundedCylinder({ r\|d, h, center?, round })` | cylinder with rounded rims — `round` = number (both) or `{ top?, bottom? }`; `round: r` with `top+bottom = h` gives a sphere (capsule when `h > 2r`); one lathe revolve, curve-exact in STEP |
+| `k.torus({ rMajor, rMinor })` | torus centered at the origin (tube centerline in z=0); `0 < rMinor < rMajor` |
 | `k.revolve({ profile, degrees? })` | revolve a lathe profile `[[r,z],…]` (r ≥ 0) around the Z axis (full or partial) |
 | `k.helixSweptTube({ pathR, profileR, pitch, turns, z0, lefthand })` | circle swept along a helix (e.g. a rope groove) |
 | `k.union(solids[])` | boolean union |
@@ -194,6 +197,9 @@ const tab = pathProfile([0, 0])
   .cubicTo([0, 8], [14, 16], [6, 16])   // curved top edge
   .close();
 k.extrude({ profile: tab, h: 3 });
+
+// Rounded enclosure: soft vertical edges, a softer lid, a flat base.
+const shell = k.roundedBox({ size: [60, 40, 22], round: { side: 4, top: 2, bottom: 0 } });
 ```
 
 2-D polygon helpers for `prism`/`extrude`/`loft`: `import { piePolygon, hexPolygon,
@@ -542,8 +548,10 @@ Pure helpers from `partforge/geometry` (no backend dependency):
 cut an inner cylinder from an outer one instead).
 `circleProfile(r, center?)` — a circle of radius `r` centered at `[cx,cy]` (default origin).
 Compose it for round solids: `k.prism({ points: circleProfile(r), h })` is a cylinder, and
-**a torus is `k.revolve({ profile: circleProfile(minorR, [majorR, 0]) })`** (with `majorR > minorR`) —
-partforge has no `torus` primitive because it's just a revolved circle.
+**use `k.torus({ rMajor, rMinor })` for a torus** — it desugars to a revolve of
+an arc-exact circle profile (`k.revolve({ profile: circleProfile(minorR,
+[majorR, 0]) })` is the faceted hand-rolled equivalent; the primitive keeps
+real TORUS faces in STEP).
 
 **Patterns** (return `Solid[]` — feed to `k.union(...)` for features or `s.cutAll(...)` for holes):
 `linearPattern(solid, count, [dx,dy,dz])`, `circularPattern(solid, count, { center, axis, angle, rotateCopies })`.

package/docs/ERROR-PATTERNS.md

@@ -83,6 +83,24 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** Offsetting the rim by the bevel distance would pinch a narrow feature (a tooth land, a thin bar, a thin web beside a hole) shut, so the bevel deterministically backs off to the largest offset the outline can take — the same geometric limit OCCT's chamfer hits, resolved in pure JS instead of kernel re-runs.
 - **Fix:** Usually nothing — the reduced bevel is the correct maximum for the geometry. To silence it, clamp the bevel parameter below the printed value or widen the narrow feature.
 
+## roundedbox-rim-clamped
+
+- **Symptom:** `roundedBox: round.top <n> clamped to round.side <m> (side must be 0 or ≥ rim radii; use side: 0 for a rim-only round-over)` in the console, and the built rim round-over is smaller than the `round.top`/`round.bottom` you passed.
+- **Cause:** the middle regime `0 < side < rim` has no closed-form corner shared by both backends, so the rim radii clamp down to `side` (the footprint-defining radius never grows silently).
+- **Fix:** either raise `round.side` to ≥ the rim radii (torus/sphere corners), or set `side: 0` exactly for a full-size rim-only round-over on sharp vertical edges.
+
+## roundedbox-strict-h
+
+- **Symptom:** `roundedBox: with round.side > 0, round.top + round.bottom must be < h (the rim fillets would meet tangentially; reduce the rim radii slightly, or use side: 0 for a sharp-sided full-height round-over)` thrown from a build.
+- **Cause:** with `round.side > 0`, the top and bottom rim fillets are separate features that need a straight wall band between them; `top + bottom == h` (or greater) leaves no band, so the fillets would meet tangentially — which the B-rep backend cannot build.
+- **Fix:** reduce `round.top`/`round.bottom` slightly so their sum is strictly less than `h`, or set `round.side: 0` for a sharp-sided full-height round-over. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § roundedBox row.
+
+## roundedbox-fillet-skipped
+
+- **Symptom:** `partforge: fillet(<r>) produced invalid geometry — feature skipped` (or `… produced an empty solid — feature skipped`) in the console during a `roundedBox` build, and the OCCT-exported rim is sharp where a round-over was requested.
+- **Cause:** OCCT's native fillet cannot build the rim round-over at a degenerate boundary (e.g. a rim radius exactly equal to `round.side` on a stadium profile, `2·side == min(w, d)`) and would otherwise return invalid-but-nonempty geometry; the monotonicity/validity gate in `occt-repair.js`'s `safeOp` catches it and skips the feature rather than exporting invalid STEP.
+- **Fix:** shrink the affected rim radius slightly below `round.side` (or below the degenerate boundary), or accept the sharp rim at that exact radius.
+
 ## boolean-not-watertight
 
 - **Symptom:** `NOT watertight ✗` from `partforge measure` (non-zero exit) after adding a boolean cut or union.

package/docs/KERNEL-CONTRACT.md

@@ -177,6 +177,9 @@ above. All ops return a `Solid`.
 | `cylinder({r\|d, h, center?})` · `cylinder({r1, r2, h, center?})` \| `{d1, d2, h}` | Cylinder along +Z from z = 0 (straight: exactly one of `r`/`d`); the cone form (`r1`/`r2` or `d1`/`d2` ends) gives a frustum. `center: true` centers on z = 0. |
 | `boredCylinder({od, h, bore})` | Compound: cylinder of diameter `od` with a through-bore `bore`. Semantically identical to the composition in `kernel-front.js`; a backend may override only for caching, never for different geometry. |
 | `sphere({r\|d})` | Sphere centered at the origin; bare `sphere(r)` stays valid. |
+| `roundedCylinder({ r\|d, h, center?, round })` | Cylinder with rim round-overs (`round`: number = both rims, or `{ top?, bottom? }`), built as one lathe `revolve` of an arc-exact profile — real torus faces in STEP. Validation: radii ≥ 0, each ≤ r, top + bottom ≤ h. Options-only. |
+| `torus({ rMajor, rMinor })` | Torus centered at the origin, tube centerline in the z = 0 plane; requires 0 < rMinor < rMajor. Curve-exact on B-rep backends. Options-only. |
+| `roundedBox({ size, center?, round })` | Box with selectively rounded edges; `round`: number = every edge, or `{ side?, top?, bottom? }` (vertical edges / top rim / bottom rim). Corner semantics and the `0 < side < rim` clamp-with-warning rule are normative in the design spec and summarized under [Rounded primitives](#rounded-primitives). Options-only. |
 | `box({size, center?})` · `box({min, max})` | Axis-aligned box: `{size:[x,y,z]}` centered in X/Y with base at z = 0 (`center: true` also centers Z), or explicit `[x,y,z]` `{min, max}` corners. |
 | `prism({points, h, twist?, scaleTop?})` | Extrude one CCW contour (point list or arc profile) from z = 0. `twist` = total degrees over the height; `scaleTop` = uniform top scale (1 straight, 0 → apex). |
 | `extrude({profile, h, twist?, scaleTop?, bevel?})` | Same, for a polygon-with-holes region — `profile` is `{outer, holes?}` (bare contour = outer only) — in one op, no per-hole boolean. `profile` may also be a `Shape2D` (see below). `bevel` (number = both rims, `{bottom?, top?}` = per rim) cuts a 45° rim bevel; it desugars at the shared front into extrude + loft + intersect/cut, so it is backend-identical by construction and is **not** a CAD-only op (no OCCT routing). Every profile form works — point array, arc profile, `{outer, holes}` (hole rims flare outward), or `Shape2D` (multi-region bevels each and unions) — but curved profiles are **materialized to point rings** first, so a beveled extrusion is faceted at the sampling LOD even in STEP (arc contours at a fixed pure-JS LOD, backend-identical; a `Shape2D` at its backend's own LOD — `hull`'s parity class). No `twist`/`scaleTop`, and `bottom + top < h` or it throws; a bevel a rim's narrow features cannot take is deterministically reduced with a console warning (`ERROR-PATTERNS.md#extrude-bevel-reduced`). |
@@ -206,6 +209,41 @@ render the ruled form. `sweep` `closed: true` loops must be planar. Where both b
 shape they do it **by construction, not by tolerance**: sweep elbows loft the identical
 station list (`sweep.js`) on both backends.
 
+### Rounded primitives
+
+`roundedBox` / `roundedCylinder` / `torus` are options-only compound
+primitives. `roundedBox` is an atomic compound node; `roundedCylinder`/`torus`
+desugar to a `shape2d` + `revolve` pair (both nodes hash deterministically
+from the op's arguments). Normative semantics for `roundedBox`
+(design spec 2026-07-30): the cross-section at height z is the rounded
+rectangle inset by δ(z) with corner radius max(side − δ(z), 0), where δ
+traces a quarter circle of the rim radius in each rim zone and is 0 in the
+straight zone. Consequences an implementation must honour:
+
+- **side ≥ max(top, bottom)**: top/bottom corners are exact torus patches
+  (sphere octants when equal).
+- **side = 0**: each rim round-over runs the full edge length and adjacent
+  round-overs meet in their natural intersection curve — NOT a
+  kernel-specific vertex blend; the top/bottom face keeps sharp corners.
+- **0 < side < max(top, bottom)**: the rim radii CLAMP DOWN to side, with a
+  console warning (deduped per distinct message). A clamped call and its
+  explicitly-clamped equivalent are the same normalized arguments — one
+  cache node. For a rim-only round-over use side: 0 exactly.
+
+Validation (op-named plain Errors, backend-identical): radii ≥ 0 and finite;
+box: 2·r ≤ min(w, d) for every group, top + bottom ≤ h (strict < when
+side > 0 — the two rim fillets would meet tangentially, which the B-rep
+backend cannot build; side: 0 full-height round-overs stay valid); cylinder:
+rims ≤ r, top + bottom ≤ h; torus: 0 < rMinor < rMajor. `roundedCylinder`/
+`torus` are single lathe revolves of arc-exact profiles — B-rep backends
+carry real torus/sphere faces to STEP; mesh backends facet at the segs LOD
+(the standard exact-vs-faceted split, not a parity waiver). `roundedBox` is
+faceted at the segs LOD on mesh backends and exact B-rep on OCCT; measure
+parity holds within facet tolerance — except where a rim fillet hits a
+degenerate boundary (e.g. rim = side on a stadium profile) and the B-rep
+backend skips it with a warning (`ERROR-PATTERNS.md`,
+`roundedbox-fillet-skipped`) rather than export invalid geometry.
+
 ## Solid ops (combine / transform / query / output)
 
 Normative signatures: `kernel.js`'s `@typedef Solid`.
@@ -222,7 +260,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `genus()` / `isEmpty()` | Optional (`SOLID_OPTIONAL_OPS`): mesh-topology queries — through-hole count / no-geometry test. The mesh backend provides them; OCCT has no cheap equivalent. |
 | `toMesh({quality?})` | Render mesh: `{positions, normals, indices?, triangles, edges?, featureIds?, features?}`. `indices` optional (a backend may emit soup or indexed); `normals` may be empty (`length 0`) to delegate creasing to the viewer; `edges` (feature-line segments) and the feature fields are optional metadata. |
 | `toSTL({quality?})` | `Promise<ArrayBuffer>`, binary STL, outward CCW winding. Stored facet normals may be zero — slicers recompute them (the mesh backend happens to write them). |
-| `toIndexedMesh()` | `{positions, indices}` indexed mesh (3MF path). |
+| `toIndexedMesh({quality?})` | `{positions, indices}` indexed mesh (3MF path); defaults to `"print"` like `toSTL`. Coincident vertices need NOT be welded — the 3MF writer welds, because that format reads topology from the indices rather than re-stitching soup by position the way an STL consumer does. |
 | `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | B-rep class (core throws `KernelCapabilityError`). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` hollows inward, keeping outer dimensions; `open` (face selector) is required. |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/geometry/kernel-front.js

@@ -28,6 +28,7 @@ import { textGlyphs } from "./text2d.js";
 import { beveledExtrude } from "./rim-bevel.js";
 import { DEFAULT_FONT_BYTES } from "./fonts/default-font.js";
 import { convexHull, hullPoints } from "./hull.js";
+import { latheRoundedRect, torusContour } from "./rounded-solids.js";
 
 export function finishKernel(k) {
   // Compound default: bored-through cylinder (tool overshoots 2 mm each end for
@@ -36,6 +37,16 @@ export function finishKernel(k) {
   k.boredCylinder ??= ({ od, h, bore }) =>
     k.cylinder(od / 2, od / 2, h).cut(k.cylinder(bore / 2, bore / 2, h + 4).translate([0, 0, -2]));
 
+  // Compound defaults: rounded lathe solids — ONE revolve of an arc-exact
+  // profile, so OCCT gets real torus/sphere/cylinder faces in STEP and
+  // Manifold facets at the mesh LOD. Zero booleans; neither backend overrides.
+  k.roundedCylinder ??= ({ r, h, center, round }) => {
+    const s = k.revolve({ profile: k.shape2d(latheRoundedRect(r, h, round.top, round.bottom)) });
+    return center ? s.translate([0, 0, -h / 2]) : s;
+  };
+  k.torus ??= ({ rMajor, rMinor }) =>
+    k.revolve({ profile: k.shape2d(torusContour(rMajor, rMinor)) });
+
   for (const [op, { toArgs, check }] of Object.entries(KERNEL_OP_SPECS)) {
     const raw = k[op];
     if (!raw) continue;

package/src/framework/geometry/kernel.js

@@ -20,6 +20,7 @@ export const CONTRACT_VERSION = 1;
 export const KERNEL_OPS = [
   "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
   "loft", "sweep", "helixSweptTube", "union", "shape2d", "text2d", "hull", "hullChain", "toSTEP",
+  "roundedCylinder", "torus", "roundedBox",
 ];
 
 // Backend-optional kernel ops: the sub-part cache brackets + WASM lifetime hooks.
@@ -99,6 +100,9 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(o:{r?:number,d?:number,r1?:number,r2?:number,d1?:number,d2?:number,h:number,center?:boolean}) => Solid} cylinder   canonical: {r|d,h} straight, {r1,r2,h}|{d1,d2,h} cone; legacy (rBottom,rTop,h,opts) accepted until contract v2
  * @property {(o:{od:number,h:number,bore:number}) => Solid} boredCylinder   compound: bored-through cylinder (one cache node)
  * @property {(o:{r?:number,d?:number}) => Solid} sphere   sphere centred at the origin; {r|d}; bare sphere(r) stays valid
+ * @property {(o:{r?:number,d?:number,h:number,center?:boolean,round:number|{top?:number,bottom?:number}}) => Solid} roundedCylinder   rim round-overs via one lathe revolve; options-only; round ≤ r, top+bottom ≤ h
+ * @property {(o:{rMajor:number,rMinor:number}) => Solid} torus   centered at origin, tube centerline in the z=0 plane; 0 < rMinor < rMajor; options-only
+ * @property {(o:{size:number[],center?:boolean,round:number|{side?:number,top?:number,bottom?:number}}) => Solid} roundedBox   selective edge rounding (side = vertical edges, top/bottom = rims); 0 < side < rim clamps rims down to side with a console.warn; options-only
  * @property {(o:{size?:number[],center?:boolean,min?:number[],max?:number[]}) => Solid} box   {size} = centered X/Y, base z=0 ({center:true} centers Z too) or {min,max}; legacy (min,max) accepted until v2
  * @property {(o:{points:number[][],h:number,twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0; legacy (points,h,opts) accepted until v2
  * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   polygon-with-holes region from z=0; bevel = 45° rim bevel (any profile form incl. Shape2D, materialized to point rings; no twist/scaleTop); legacy (profile,h,opts) accepted until v2

package/src/framework/geometry/manifold-backend.js

@@ -1,6 +1,7 @@
 import { helixTube } from "./helix-tube.js";
 import { loftMesh } from "./loft.js";
 import { sweepMesh } from "./sweep.js";
+import { roundedBoxRings } from "./rounded-solids.js";
 import { tessellateContour, tessellateProfile } from "./profile.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
@@ -197,6 +198,16 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       const tool = T(tool0.translate([0, 0, -2])); // raw ops: track each result
       return T(body.subtract(tool));
     }),
+    // Rounded box: ONE hand-meshed ring stack (no booleans) whose cross-
+    // sections follow the normative formula (rounded-solids.js / the design
+    // spec). Reuses loftMesh's stitch/cap/winding machinery. Atomic cache
+    // node hashed from its own args, like boredCylinder.
+    roundedBox: ({ size, center, round }) => cached(
+      h("roundedBox", size, center, round.side, round.top, round.bottom, segs),
+      () => {
+        const solid = T(loftMesh(wasm, roundedBoxRings(size, round, segs)));
+        return center ? T(solid.translate([0, 0, -size[2] / 2])) : solid;
+      }),
     sphere: (r) => wrap(T(Manifold.sphere(r, segs)), h("sphere", r, segs)),
     box: (min, max) => {
       const cube = T(Manifold.cube([max[0] - min[0], max[1] - min[1], max[2] - min[2]]));

package/src/framework/geometry/occt-backend.js

@@ -26,6 +26,7 @@ import { classifyFaceGroups } from "./feature-attribution.js";
 import { resolveRings } from "./loft.js";
 import { resolveSweepStations } from "./sweep.js";
 import { normalizeProfile } from "./profile.js";
+import { roundedRectContour } from "./rounded-solids.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
 import { composePose, transformPositions } from "./pose.js";
@@ -34,7 +35,7 @@ const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.5 }, print: { tole
 
 export function createOcctKernel(replicad) {
   const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
-          makeCompound, loft, draw, exportSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
+          loft, draw, exportSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
 
   // Fillet/chamfer/shell failure recovery (skip-on-failure, chamfer binary search) —
   // see occt-repair.js for the policies and why they differ per op.
@@ -127,8 +128,12 @@ export function createOcctKernel(replicad) {
         const key = h("cutAll", hash, tools.map((t) => t._hash));
         return cached(key, () => {
           const a = mat(), bs = tools.map((t) => t._mat());
+          if (bs.length === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          const fusedTools = bs
+            .slice(1)
+            .reduce((acc, b) => acc.fuse(b._s.clone()), bs[0]._s.clone());
           return wrap(
-            a._s.clone().cut(makeCompound(bs.map((b) => b._s.clone()))),
+            a._s.clone().cut(fusedTools),
             [...cloneLabels(a._labels), ...bs.flatMap((b) => cloneLabels(b._labels))],
             key,
           );
@@ -210,8 +215,10 @@ export function createOcctKernel(replicad) {
         });
       },
       volume: () => measureVolume(mat()._s),
-      toIndexedMesh: () => {
-        const base = baseMesh("preview");
+      // Same default as toSTL: an export is an export, so a .3mf must not ship a
+      // coarser tessellation than the .stl of the same solid would.
+      toIndexedMesh: ({ quality = "print" } = {}) => {
+        const base = baseMesh(quality);
         return { positions: posedPositions(base), indices: Uint32Array.from(base.indices) };
       },
     });
@@ -230,6 +237,53 @@ export function createOcctKernel(replicad) {
     });
   };
 
+  // Rounded box. side > 0: an arc-exact rounded-rect extrusion (real CIRCLE
+  // wall edges in STEP) with each rim rounded by ONE native fillet on its
+  // smooth rim loop — exact torus/sphere corner patches, matching the mesh
+  // backend's ring semantics by construction. side = 0: rim round-overs are
+  // CUT with strip-minus-quarter-cylinder wedges running the full edge
+  // length, so corners are the deterministic intersection of adjacent
+  // round-overs (native fillet's vertex blend is kernel-specific and the
+  // mesh backend could not reproduce it — see the design spec).
+  const roundedBox = ({ size, center, round }) => {
+    const [w, d, hgt] = size;
+    const { side, top, bottom } = round;
+    const key = h("roundedBox", size, center, side, top, bottom);
+    return cached(key, () => {
+      const z0 = center ? -hgt / 2 : 0;
+      if (side > 0) {
+        let s = contourDrawing(roundedRectContour(w, d, side)).sketchOnPlane("XY", z0).extrude(hgt);
+        // A rim fillet can only remove material, never add it — OCCT's fillet is
+        // known to produce invalid-but-nonempty geometry at certain degenerate
+        // boundaries (e.g. rim radius == side on a stadium profile), so gate
+        // acceptance on strict volume reduction rather than just "non-empty".
+        const isRimFilletValid = (vol, before) => vol > 0 && vol < before - 1e-9;
+        if (top > 0) s = safeOp(s, (sh) => sh.fillet(top, (e) => e.inPlane("XY", z0 + hgt)), `fillet(${top})`, isRimFilletValid);
+        if (bottom > 0) s = safeOp(s, (sh) => sh.fillet(bottom, (e) => e.inPlane("XY", z0)), `fillet(${bottom})`, isRimFilletValid);
+        return wrap(s, [], key);
+      }
+      let s = makeBox([-w / 2, -d / 2, z0], [w / 2, d / 2, z0 + hgt]);
+      for (const [rim, zFace, into] of [[top, z0 + hgt, -1], [bottom, z0, 1]]) {
+        if (!(rim > 0)) continue;
+        const zAxis = zFace + into * rim;
+        const zMin = Math.min(zFace, zAxis), zMax = Math.max(zFace, zAxis);
+        for (const sy of [1, -1]) { // ±Y walls: strip + quarter-cylinder axis along X
+          const strip = makeBox([-w / 2, sy > 0 ? d / 2 - rim : -d / 2, zMin],
+            [w / 2, sy > 0 ? d / 2 : -d / 2 + rim, zMax]);
+          const cyl = makeCylinder(rim, w + 4, [-w / 2 - 2, sy * (d / 2 - rim), zAxis], [1, 0, 0]);
+          s = s.cut(strip.cut(cyl));
+        }
+        for (const sx of [1, -1]) { // ±X walls: strip + axis along Y
+          const strip = makeBox([sx > 0 ? w / 2 - rim : -w / 2, -d / 2, zMin],
+            [sx > 0 ? w / 2 : -w / 2 + rim, d / 2, zMax]);
+          const cyl = makeCylinder(rim, d + 4, [sx * (w / 2 - rim), -d / 2 - 2, zAxis], [0, 1, 0]);
+          s = s.cut(strip.cut(cyl));
+        }
+      }
+      return wrap(s, [], key);
+    });
+  };
+
   // Draw a closed Drawing from a Contour: a legacy 2-D point list (all straight edges,
   // the former polyDrawing) OR an ArcContour whose { to, via } segments become true
   // OCCT arc edges via threePointsArcTo — so a rounded corner survives to STEP as a
@@ -435,6 +489,7 @@ export function createOcctKernel(replicad) {
   const kernel = finishKernel({
     cylinder, // boredCylinder: the kernel front's default composition is exactly right here
     box: (min, max) => cached(h("box", min, max), () => wrap(makeBox(min, max), [], h("box", min, max))),
+    roundedBox,
     prism, extrude, revolve, loft: loftOp, sweep, helixSweptTube,
     sphere: (r) => cached(h("sphere", r), () => wrap(makeSphere(r), [], h("sphere", r))),
     union: (solids) => {

package/src/framework/geometry/occt-repair.js

@@ -74,13 +74,24 @@ export function createOcctRepair(measureVolume) {
   // or awkward edge interactions. Rather than letting the whole part vanish, attempt
   // the op on a clone and fall back to the original shape (feature skipped) on a
   // throw or empty result, with a console warning so it's discoverable.
-  const safeOp = (shape, op, label) => {
+  //
+  // `isValid` is an optional second acceptance gate, evaluated ONLY when the op
+  // produces non-empty geometry: (resultVolume, inputVolume) => boolean. Some OCCT
+  // fillet failures don't throw or empty out — they return non-empty geometry that
+  // is nonetheless topologically invalid (e.g. a rim fillet on a stadium profile
+  // whose radius equals the straight-side radius can report MORE volume than the
+  // un-filleted input, which is impossible for a material-removing fillet). The
+  // default (no `isValid`) keeps every existing caller's behavior unchanged.
+  const safeOp = (shape, op, label, isValid) => {
     const backup = shape.clone();
+    const beforeVolume = isValid ? measureVolume(shape) : undefined;
     try {
       const result = op(shape);
-      if (measureVolume(result) > 0) { backup.delete?.(); return result; }
+      const resultVolume = measureVolume(result);
+      if (resultVolume > 0 && (!isValid || isValid(resultVolume, beforeVolume))) { backup.delete?.(); return result; }
       result.delete?.();
-      console.warn(`partforge: ${label} produced an empty solid — feature skipped (radius out of range?)`);
+      if (resultVolume > 0) console.warn(`partforge: ${label} produced invalid geometry — feature skipped`);
+      else console.warn(`partforge: ${label} produced an empty solid — feature skipped (radius out of range?)`);
     } catch (e) {
       console.warn(`partforge: ${label} failed (${e?.message || e}) — feature skipped`);
     }

package/src/framework/geometry/op-options.js

@@ -126,6 +126,94 @@ export function sweepArgs(o) {
     ...tail(o, ["closed", "cornerRadius", "ruled", "smooth"])];
 }
 
+// ---- rounded primitives (options-only ops) -------------------------------
+
+// Clamp warnings are deduped per distinct message so a slider sweep doesn't
+// spam the console on every rebuild. Console-only side channel; the returned
+// geometry stays a pure function of the arguments.
+const warnedClamps = new Set();
+
+// `round` accepts a number (broadcast to every group) or a plain object with
+// the op's group keys (missing keys → 0).
+const normalizeRound = (op, v, keys) => {
+  if (typeof v === "number") return Object.fromEntries(keys.map((key) => [key, v]));
+  if (isPlainOptions(v)) {
+    checkKeys(`${op}: round`, v, keys);
+    return Object.fromEntries(keys.map((key) => [key, v[key] ?? 0]));
+  }
+  throw new Error(`${op}: round must be a number or { ${keys.join("?, ")}? }`);
+};
+
+const checkRoundRadius = (op, name, v, max, maxDesc) => {
+  if (!(typeof v === "number" && Number.isFinite(v) && v >= 0))
+    throw new Error(`${op}: ${name} must be a finite number ≥ 0`);
+  if (v > max + 1e-9) throw new Error(`${op}: ${name} (${v}) must be ≤ ${maxDesc}`);
+};
+
+export function roundedBoxArgs(o) {
+  checkKeys("roundedBox", o, ["size", "center", "round"]);
+  const size = req("roundedBox", o, "size");
+  if (!Array.isArray(size) || size.length !== 3 || !size.every((v) => Number.isFinite(v) && v > 0))
+    throw new Error("roundedBox: size must be [w, d, h] with three positive numbers");
+  const [w, d, h] = size;
+  const round = normalizeRound("roundedBox", req("roundedBox", o, "round"), ["side", "top", "bottom"]);
+  checkRoundRadius("roundedBox", "round.side", round.side, Math.min(w, d) / 2, "min(w, d)/2");
+  checkRoundRadius("roundedBox", "round.top", round.top, Math.min(w, d) / 2, "min(w, d)/2");
+  checkRoundRadius("roundedBox", "round.bottom", round.bottom, Math.min(w, d) / 2, "min(w, d)/2");
+  // Normalize the +1e-9 validation slack above to the exact stadium bound, so
+  // Manifold and OCCT build from bit-identical arguments at that boundary.
+  round.side = Math.min(round.side, Math.min(w, d) / 2);
+  // Middle regime (0 < side < rim): rims clamp DOWN to side — side defines the
+  // footprint and must not grow; a shrunk round-over only adds material. The
+  // side = 0 sphere-free rim round-over stays fully valid (see the spec).
+  if (round.side > 0) {
+    for (const key of ["top", "bottom"]) {
+      if (round[key] > round.side) {
+        // Keyed on op/field/side rather than the full message — a slider sweep
+        // over the raw rim value (round[key]) would otherwise mint a distinct
+        // message (and a distinct Set entry) on every rebuild, defeating the dedupe.
+        const dedupeKey = `roundedBox.${key}|${round.side}`;
+        const msg = `roundedBox: round.${key} ${round[key]} clamped to round.side ${round.side} (side must be 0 or ≥ rim radii; use side: 0 for a rim-only round-over)`;
+        if (!warnedClamps.has(dedupeKey)) { warnedClamps.add(dedupeKey); console.warn(msg); }
+        round[key] = round.side;
+      }
+    }
+  }
+  if (round.top + round.bottom > h + 1e-9)
+    throw new Error("roundedBox: round.top + round.bottom must be ≤ h");
+  if (round.side > 0 && round.top + round.bottom > h - 1e-6)
+    throw new Error("roundedBox: with round.side > 0, round.top + round.bottom must be < h (the rim fillets would meet tangentially; reduce the rim radii slightly, or use side: 0 for a sharp-sided full-height round-over)");
+  return [{ size: [w, d, h], center: o.center === true, round }];
+}
+
+export function roundedCylinderArgs(o) {
+  checkKeys("roundedCylinder", o, ["r", "d", "h", "center", "round"]);
+  const hasR = o.r !== undefined;
+  if (hasR === (o.d !== undefined)) throw new Error("roundedCylinder: pass exactly one of r/d");
+  const r = hasR ? o.r : o.d / 2;
+  if (!(Number.isFinite(r) && r > 0)) throw new Error("roundedCylinder: r must be > 0");
+  const h = req("roundedCylinder", o, "h");
+  if (!(Number.isFinite(h) && h > 0)) throw new Error("roundedCylinder: h must be > 0");
+  const round = normalizeRound("roundedCylinder", req("roundedCylinder", o, "round"), ["top", "bottom"]);
+  checkRoundRadius("roundedCylinder", "round.top", round.top, r, "r");
+  checkRoundRadius("roundedCylinder", "round.bottom", round.bottom, r, "r");
+  // Normalize the +1e-9 validation slack to the exact bound (the roundedBox
+  // side clamp's twin) so the lathe profile never crosses the revolve axis.
+  round.top = Math.min(round.top, r);
+  round.bottom = Math.min(round.bottom, r);
+  if (round.top + round.bottom > h + 1e-9)
+    throw new Error("roundedCylinder: round.top + round.bottom must be ≤ h");
+  return [{ r, h, center: o.center === true, round }];
+}
+
+export function torusArgs(o) {
+  checkKeys("torus", o, ["rMajor", "rMinor"]);
+  const rMajor = req("torus", o, "rMajor"), rMinor = req("torus", o, "rMinor");
+  if (!(Number.isFinite(rMajor) && Number.isFinite(rMinor) && rMinor > 0 && rMinor < rMajor))
+    throw new Error("torus: requires 0 < rMinor < rMajor");
+  return [{ rMajor, rMinor }];
+}
+
 // Per-op semantic validations, applied to the NORMALIZED positional args so
 // they cover both calling forms (these moved here from kernel-front.js).
 const checkScaleTop = (op) => (_profile, _h, opts) => {
@@ -151,7 +239,11 @@ export const KERNEL_OP_SPECS = {
   extrude:  { toArgs: extrudeArgs, check: checkScaleTop("extrude") },
   revolve:  { toArgs: revolveArgs, check: (pts) => {
     if (pts && pts._shape2d) {
-      if (pts.boundingBox().min[0] < 0) throw new Error("revolve: profile radius must be ≥ 0");
+      // The B-rep backend's Drawing bounding box is tolerance-padded (1e-6 on
+      // every side, measured), so a lathe profile touching the revolve axis at
+      // x = 0 reports min[0] = -1e-6. Tolerate the padding; a real negative-
+      // radius profile still trips the check.
+      if (pts.boundingBox().min[0] < -1e-5) throw new Error("revolve: profile radius must be ≥ 0");
       return;
     }
     for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
@@ -161,6 +253,9 @@ export const KERNEL_OP_SPECS = {
   boredCylinder:  { toArgs: passThrough("boredCylinder", ["od", "h", "bore"], ["od", "h", "bore"]) },
   helixSweptTube: { toArgs: passThrough("helixSweptTube",
     ["pathR", "profileR", "pitch", "turns", "z0", "lefthand"], ["pathR", "profileR", "pitch", "turns"]) },
+  roundedBox:      { toArgs: roundedBoxArgs },
+  roundedCylinder: { toArgs: roundedCylinderArgs },
+  torus:           { toArgs: torusArgs },
 };
 
 // Solid ops under the options convention; addSugar() wraps these when the

package/src/framework/geometry/rounded-solids.js

@@ -0,0 +1,126 @@
+// src/framework/geometry/rounded-solids.js
+// Pure geometry builders for the rounded 3-D primitives (roundedBox /
+// roundedCylinder / torus). No WASM, no DOM — shared by the kernel front
+// (lathe contours for the revolve-based ops) and the Manifold backend
+// (roundedBox ring stack). Normative semantics: the design spec
+// (docs/superpowers/specs/2026-07-30-rounded-primitives-design.md) — at
+// height z the box cross-section is the rounded rect inset δ(z) with corner
+// radius max(side − δ, ~0), δ tracing a quarter circle in each rim zone.
+
+const COS45 = Math.SQRT1_2;
+
+// Minimum corner radius standing in for a "sharp" ring corner: keeps every
+// ring at the same vertex count (4·(A+1)) without coincident points, so the
+// loft stitching never sees a degenerate quad. Far below mesh/print resolution.
+export const EPS_R = 1e-6;
+
+// One CCW rounded-rectangle ring: half-extents hw/hd, corner radius rc, A arc
+// segments per corner → 4·(A+1) points. Corner centers sit at (±(hw−rc),
+// ±(hd−rc)); the straight edges are implied between consecutive corner arcs.
+// rc is clamped into [EPS_R, min(hw, hd) − EPS_R] so sharp corners and
+// full-radius (stadium) corners never emit coincident points.
+export function roundedRectRing(hw, hd, rc, A) {
+  const r = Math.min(Math.max(rc, EPS_R), Math.max(EPS_R, Math.min(hw, hd) - EPS_R));
+  const cx = hw - r, cy = hd - r;
+  const C = [[cx, cy], [-cx, cy], [-cx, -cy], [cx, -cy]];
+  const pts = [];
+  for (let q = 0; q < 4; q++) {
+    const a0 = (q * Math.PI) / 2; // corner (+,+) spans 0..90°, then CCW
+    for (let i = 0; i <= A; i++) {
+      const a = a0 + (i / A) * (Math.PI / 2);
+      pts.push([C[q][0] + r * Math.cos(a), C[q][1] + r * Math.sin(a)]);
+    }
+  }
+  return pts;
+}
+
+// Ring stack for the Manifold roundedBox: ascending-z loft ring specs
+// [{ polygon, z }]. A (arc samples per corner AND z-stations per rim zone) is
+// derived from the kernel's segs so the z-sampling matches the in-plane LOD.
+// Consecutive duplicate stations (top + bottom = h) are deduped so the loft
+// never sees a zero-height band.
+export function roundedBoxRings([w, d, h], { side, top, bottom }, segs) {
+  const A = Math.max(2, Math.ceil(segs / 8));
+  const st = [];
+  const push = (z, delta) => {
+    const last = st[st.length - 1];
+    if (last && Math.abs(last.z - z) < 1e-9 && Math.abs(last.delta - delta) < 1e-9) return;
+    st.push({ z, delta });
+  };
+  if (bottom > 0) {
+    for (let i = 0; i <= A; i++) {
+      const phi = (i / A) * (Math.PI / 2);
+      push(bottom * (1 - Math.cos(phi)), bottom * (1 - Math.sin(phi)));
+    }
+  } else push(0, 0);
+  if (top > 0) {
+    for (let i = A; i >= 0; i--) {
+      const phi = (i / A) * (Math.PI / 2);
+      push(h - top * (1 - Math.cos(phi)), top * (1 - Math.sin(phi)));
+    }
+  } else push(h, 0);
+  return st.map(({ z, delta }) =>
+    ({ polygon: roundedRectRing(w / 2 - delta, d / 2 - delta, side - delta, A), z }));
+}
+
+// ArcContour for the roundedCylinder lathe profile: the rectangle
+// [0,0]→[r,0]→[r,h]→[0,h] with the two outer corners rounded (rBottom, rTop).
+// Built with explicit tangent/via points — NOT roundedProfile, whose
+// conservative per-corner clamp (tangent ≤ min-adjacent-edge/2) would
+// silently shrink a capsule's full-radius corner. Zero-length lines are
+// skipped so boundary radii (rBottom = r, rTop + rBottom = h) stay valid.
+export function latheRoundedRect(r, h, rTop, rBottom) {
+  const start = [0, 0];
+  const segments = [];
+  let cur = start;
+  const lineTo = (p) => { if (Math.hypot(p[0] - cur[0], p[1] - cur[1]) > 1e-12) { segments.push({ to: p }); cur = p; } };
+  const arcTo = (to, via) => { segments.push({ to, via }); cur = to; };
+  lineTo([r - rBottom, 0]);
+  if (rBottom > 0)
+    arcTo([r, rBottom], [r - rBottom * (1 - COS45), rBottom * (1 - COS45)]);
+  lineTo([r, h - rTop]);
+  if (rTop > 0)
+    arcTo([r - rTop, h], [r - rTop * (1 - COS45), h - rTop * (1 - COS45)]);
+  lineTo([0, h]);
+  return { start, segments }; // consumers close() back down the revolve axis
+}
+
+// ArcContour for a rounded rectangle centered at the origin (the OCCT
+// roundedBox base profile). Like latheRoundedRect, built with explicit
+// tangent/via points and zero-length lines SKIPPED, so the exact stadium
+// boundary (2·r = min(w, d), adjacent arcs meeting at the edge midpoint)
+// stays a valid Drawing — roundedProfile emits zero-length segments there.
+// Requires r > 0 (the side = 0 box never takes this path). The loop ends
+// exactly on its start (close() is a no-op, like torusContour).
+export function roundedRectContour(w, d, r) {
+  const hw = w / 2, hd = d / 2, c = r * (1 - COS45);
+  const start = [hw, -(hd - r)];
+  const segments = [];
+  let cur = start;
+  const lineTo = (p) => { if (Math.hypot(p[0] - cur[0], p[1] - cur[1]) > 1e-12) { segments.push({ to: p }); cur = p; } };
+  const arcTo = (to, via) => { segments.push({ to, via }); cur = to; };
+  lineTo([hw, hd - r]);
+  arcTo([hw - r, hd], [hw - c, hd - c]);
+  lineTo([-(hw - r), hd]);
+  arcTo([-hw, hd - r], [-(hw - c), hd - c]);
+  lineTo([-hw, -(hd - r)]);
+  arcTo([-(hw - r), -hd], [-(hw - c), -(hd - c)]);
+  lineTo([hw - r, -hd]);
+  arcTo([hw, -(hd - r)], [hw - c, -(hd - c)]);
+  return { start, segments };
+}
+
+// ArcContour for the torus lathe profile: a full circle of radius rMinor
+// centered at [rMajor, 0], as four quarter arcs. The loop ends exactly on its
+// start: replicad's close() skips the closing line when the pen is already
+// home (verified in _closeSketch), and the Manifold tessellator's duplicated
+// seam point is cleaned by Clipper2 (CrossSection.ofPolygons).
+export function torusContour(rMajor, rMinor) {
+  const R = rMajor, r = rMinor, c = r * COS45;
+  return { start: [R + r, 0], segments: [
+    { to: [R, r], via: [R + c, c] },
+    { to: [R - r, 0], via: [R - c, c] },
+    { to: [R, -r], via: [R - c, -c] },
+    { to: [R + r, 0], via: [R + c, -c] },
+  ] };
+}

package/src/framework/geometry/threemf.js

@@ -19,6 +19,54 @@ const RELS =
 const xmlEsc = (s) => String(s).replace(/[<>&"]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;" }[c]));
 const r = (x) => +x.toFixed(4); // 0.1 µm precision — finer than any printer, much smaller XML
 
+// Weld coincident vertices and drop triangles that collapse to zero area.
+//
+// This is what keeps a .3mf manifold, and it has no STL equivalent: STL is vertex
+// soup, so a consumer re-stitches triangles by POSITION and never sees how the
+// mesh was indexed. 3MF reads topology from the indices instead, so two triangles
+// that meet along an edge must literally cite the same two vertex ids — otherwise
+// each counts the shared edge as its own boundary and slicers report the solid as
+// non-manifold. The OCCT backend triangulates every B-rep face independently and
+// concatenates the results, so it hands us one copy of each seam vertex PER
+// adjacent face; welding here is what closes that mesh. (Manifold's own output is
+// already welded, so for that backend this is a no-op beyond the copy.)
+//
+// Welding uses `r` — exactly the precision the file is written at — so any two
+// vertices that would print identical coordinates always collapse to one id. A
+// looser tolerance would move geometry; a tighter one would leave split vertices
+// sitting at coordinates the file cannot tell apart.
+function weld(positions, indices) {
+  const idOf = new Map(); // "x,y,z" → canonical vertex id
+  const coord = []; // canonical id → rounded x,y,z (flat)
+  const canon = new Uint32Array(positions.length / 3);
+  for (let i = 0, v = 0; i < positions.length; i += 3, v++) {
+    const x = r(positions[i]), y = r(positions[i + 1]), z = r(positions[i + 2]);
+    const key = `${x},${y},${z}`;
+    let id = idOf.get(key);
+    if (id === undefined) { id = coord.length / 3; idOf.set(key, id); coord.push(x, y, z); }
+    canon[v] = id;
+  }
+  // Emit vertices in order of first use by a surviving triangle, so a vertex left
+  // behind by a dropped degenerate never ships as an unreferenced <vertex>.
+  const emitted = new Map(); // canonical id → written vertex index
+  const verts = [], tris = [];
+  const emit = (id) => {
+    let at = emitted.get(id);
+    if (at === undefined) {
+      at = verts.length / 3;
+      emitted.set(id, at);
+      verts.push(coord[id * 3], coord[id * 3 + 1], coord[id * 3 + 2]);
+    }
+    return at;
+  };
+  for (let k = 0; k < indices.length; k += 3) {
+    const a = canon[indices[k]], b = canon[indices[k + 1]], c = canon[indices[k + 2]];
+    if (a === b || b === c || a === c) continue; // zero area at print precision — carries no surface
+    tris.push(emit(a), emit(b), emit(c));
+  }
+  return { verts, tris };
+}
+
 // parts: [{ name, positions: Float32Array (x,y,z per vertex), indices: Uint32Array (3 per triangle) }]
 // → ArrayBuffer of the .3mf zip (millimetre units; one <object> + <build> item per part).
 export function meshTo3MF(parts) {
@@ -29,10 +77,9 @@ export function meshTo3MF(parts) {
   ];
   parts.forEach((p, i) => {
     out.push(`<object id="${i + 1}" type="model" name="${xmlEsc(p.name)}"><mesh><vertices>`);
-    const v = p.positions;
-    for (let k = 0; k < v.length; k += 3) out.push(`<vertex x="${r(v[k])}" y="${r(v[k + 1])}" z="${r(v[k + 2])}"/>`);
+    const { verts: v, tris: t } = weld(p.positions, p.indices);
+    for (let k = 0; k < v.length; k += 3) out.push(`<vertex x="${v[k]}" y="${v[k + 1]}" z="${v[k + 2]}"/>`);
     out.push("</vertices><triangles>");
-    const t = p.indices;
     for (let k = 0; k < t.length; k += 3) out.push(`<triangle v1="${t[k]}" v2="${t[k + 1]}" v3="${t[k + 2]}"/>`);
     out.push("</triangles></mesh></object>");
   });

package/src/framework/jobs.js

@@ -136,7 +136,7 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       if (names.length === 0) throw new Error("no exportable parts selected");
       const meshes = names.map((name) => {
         onProgress(`building ${label(name)}`);
-        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh();
+        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh({ quality: msg.quality ?? "print" });
         return { name: exportName(name), positions, indices };
       });
       onProgress("writing 3MF file");