partforge 0.36.1 → 0.38.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 })`.
@@ -723,6 +731,25 @@ returns instead:
 Pass `onDownload({ data, filename, mime })` to `mount()` to receive the exported bytes
 yourself (e.g. to download from a different origin) instead of partforge's own DOM download.
 
+**Showcase capture (the mount handle).** The handle can also render the user's *current*
+framing offscreen at a resolution independent of the window size and devicePixelRatio —
+for gallery/preview images, where grabbing the live canvas would be capped at the viewer
+pane's pixel size:
+
+- `runtime.captureCurrent({ size = 2048, hideGrid = true, quality = 0.9 } = {}) → string | null` —
+  one offscreen render from the live camera's pose (position, up, and orbit target — not a
+  canonical pose) with the live viewport's aspect ratio, `size` px on the long edge
+  (clamped into `[256, maxTextureSize]`). Renders with 4× MSAA and the same
+  camera-relative capture lighting as `captureViews`, so the result is print-quality even
+  from a small window on a 1× display. Returns a `data:image/jpeg;base64,…` string, or
+  `null` when the runtime is disposed or nothing is built/visible yet — it never throws.
+  `hideGrid: false` keeps the floor grid so the capture matches the on-screen look
+  exactly. The live view is untouched: the camera never moves, and lights/grid/render
+  target are restored after the render.
+- `runtime.captureViews(viewNames) → [{ view, dataUrl }]` — the canonical-angle
+  counterpart (fixed poses, framed to the visible assembly, 1024², grid hidden). Sized
+  for feeding a vision model, not for display; use `captureCurrent` for showcase images.
+
 **The markup convention (`demo.html` is the canonical copy-me page):** `<body>` carries
 `class="pf-shell"`, the flex row that lays the viewer column next to the rail. `#app`
 (`class="pf-stage"`) *is* that viewer column, and now contains the floating chrome

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`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.36.1",
+  "version": "0.38.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/app-demo.js

@@ -9,7 +9,9 @@ import { mount } from "./framework/index.js";
 // Dev-only example app for the demo part (a parametric spacer). Identical wiring to
 // app.js — the only thing that differs per part is which definition you import and
 // which worker entry you point at. `npm run dev`, then open /demo.html.
-mount(demoPart, {
+// Dev-only: the handle is stashed on window so scripts/check-app.mjs can drive
+// the embedding contract (runtime.captureCurrent) the way an embedder would.
+window.__pfRuntime = mount(demoPart, {
   createWorker: (name) =>
     new Worker(new URL("./demo-worker.js", import.meta.url), { type: "module", name }),
 });

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";
@@ -236,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
@@ -441,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/mount.js

@@ -29,6 +29,7 @@ export function makeHandle({ ready, dispose, viewer, setParams, listExportablePa
   return {
     ready, dispose, setParams,
     captureViews: (viewNames) => viewer.captureCanonicalViews(viewNames),
+    captureCurrent: (opts) => viewer.captureCurrent(opts),
     listExportableParts,
     exportParts,
   };
@@ -63,10 +64,14 @@ function createCleanupStack() {
 // mesh-validity cache, and the geometry workers. The app supplies `createWorker(name)`
 // so Vite can bundle the worker (see geometry-service.js).
 //
-// Embedding contract (0.36.0):
+// Embedding contract (0.38.0):
 //   const runtime = mount(part, { createWorker, elements, onBuild, onPick, onDownload });
 //   await runtime.ready;   // first successful build of the default view
 //   runtime.setParams({ openAngle: 45 }); // programmatic edit; pose-only changes apply instantly
+//   runtime.captureCurrent({ size: 2048 });  // one offscreen render of the user's current
+//                                         // framing (live camera pose + viewport aspect) at the
+//                                         // given long-edge resolution → JPEG data URL, or null
+//                                         // when disposed / nothing built yet
 //   runtime.listExportableParts();        // [{ name, label }] — every exportable sub-part,
 //                                         // independent of the active view (for an embedder-drawn export UI)
 //   await runtime.exportParts({ parts: ["base"], format: "stl", onProgress });

package/src/framework/viewer.js

@@ -56,6 +56,36 @@ export function captureViewsFromScene(viewNames, { renderer, liveCamera, grid, b
   }
 }
 
+// Render the LIVE camera's current framing offscreen, once, at a caller-chosen
+// resolution — the showcase capture behind the runtime handle's captureCurrent.
+// Same injected-renderer split as captureViewsFromScene so it runs without a GL
+// context: pose comes from the live camera (never a canonical pose), the output
+// long edge is `size` clamped into [256, maxTextureSize], and the short edge
+// follows the live camera's aspect so the capture matches what the user framed.
+export function captureCurrentFromScene(
+  { size = 2048, hideGrid = true, quality = 0.9 } = {},
+  { renderer, liveCamera, target, grid, maxTextureSize },
+) {
+  const MIN_SIZE = 256;
+  // WebGL2 guarantees MAX_TEXTURE_SIZE >= 2048; only trust a larger reported cap.
+  const long = Math.min(Math.max(Math.round(size) || MIN_SIZE, MIN_SIZE), maxTextureSize ?? 2048);
+  const aspect = liveCamera.aspect || 1;
+  const width = aspect >= 1 ? long : Math.max(1, Math.round(long * aspect));
+  const height = aspect >= 1 ? Math.max(1, Math.round(long / aspect)) : long;
+  const before = liveCamera.position.clone();
+  const gridWasVisible = grid?.visible;
+  if (grid && hideGrid) grid.visible = false;
+  try {
+    return renderer.renderOffscreen(
+      { position: liveCamera.position.toArray(), up: liveCamera.up.toArray(), target },
+      { width, height, fov: liveCamera.fov, quality },
+    );
+  } finally {
+    if (grid && hideGrid) grid.visible = gridWasVisible;
+    liveCamera.position.copy(before); // belt-and-suspenders: never leak camera state
+  }
+}
+
 export function createViewer(container, part) {
   const names = Object.keys(part.parts);
 
@@ -345,14 +375,22 @@ export function createViewer(container, part) {
   const _rtSize = 1024;
   let _rt = null;
   let _capLights = null;
-  function renderOffscreen({ position, up, target }) {
-    _rt = _rt ?? new THREE.WebGLRenderTarget(_rtSize, _rtSize, { samples: 4 });
+  // Defaults reproduce the canonical-view capture exactly (1024² cached target,
+  // fov 45, quality 0.9). A custom size (captureCurrent) gets a fresh render
+  // target, disposed after the read — those captures are rare, so per-call
+  // allocation beats caching one target per size ever requested.
+  function renderOffscreen({ position, up, target },
+                           { width = _rtSize, height = _rtSize, fov = 45, quality = 0.9 } = {}) {
+    const cachedSize = width === _rtSize && height === _rtSize;
+    const rt = cachedSize
+      ? (_rt = _rt ?? new THREE.WebGLRenderTarget(_rtSize, _rtSize, { samples: 4 }))
+      : new THREE.WebGLRenderTarget(width, height, { samples: 4 });
     _capLights = _capLights ?? createCaptureLights();
-    const cam = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
+    const cam = new THREE.PerspectiveCamera(fov, width / height, 0.1, 1000);
     cam.position.set(position[0], position[1], position[2]);
     cam.up.set(up[0], up[1], up[2]);
     cam.lookAt(target[0], target[1], target[2]);
-    const buf = new Uint8Array(_rtSize * _rtSize * 4);
+    const buf = new Uint8Array(width * height * 4);
     // Swap the world-fixed key/fill for the camera-relative pair, for this one render
     // only. A DirectionalLight aims at its `target`, whose matrixWorld only updates
     // while it is in the scene graph, so both go in and both come back out.
@@ -365,30 +403,31 @@ export function createViewer(container, part) {
     liveLights.fill.visible = false;
     scene.add(capKey, capKey.target, capFill, capFill.target);
     try {
-      renderer.setRenderTarget(_rt);
+      renderer.setRenderTarget(rt);
       renderer.render(scene, cam);
       // render() resolves the multisample renderbuffer into the target texture, so this
       // reads antialiased pixels.
-      renderer.readRenderTargetPixels(_rt, 0, 0, _rtSize, _rtSize, buf);
+      renderer.readRenderTargetPixels(rt, 0, 0, width, height, buf);
     } finally {
       // Never leave the user's own view unlit or pointed at the offscreen target.
       renderer.setRenderTarget(null);
       scene.remove(capKey, capKey.target, capFill, capFill.target);
       liveLights.key.visible = true;
       liveLights.fill.visible = true;
+      if (!cachedSize) rt.dispose();
     }
     const canvas = document.createElement("canvas");
-    canvas.width = _rtSize; canvas.height = _rtSize;
+    canvas.width = width; canvas.height = height;
     const ctx = canvas.getContext("2d");
-    const img = ctx.createImageData(_rtSize, _rtSize);
+    const img = ctx.createImageData(width, height);
     // flip rows (GL origin is bottom-left)
-    for (let y = 0; y < _rtSize; y++) {
-      const src = (_rtSize - 1 - y) * _rtSize * 4;
-      img.data.set(buf.subarray(src, src + _rtSize * 4), y * _rtSize * 4);
+    for (let y = 0; y < height; y++) {
+      const src = (height - 1 - y) * width * 4;
+      img.data.set(buf.subarray(src, src + width * 4), y * width * 4);
     }
     srgbEncodeInPlace(img.data);
     ctx.putImageData(img, 0, 0);
-    return canvas.toDataURL("image/jpeg", 0.9);
+    return canvas.toDataURL("image/jpeg", quality);
   }
 
   // Render the canonical camera angles offscreen, framed to whatever is visible,
@@ -408,6 +447,22 @@ export function createViewer(container, part) {
     });
   }
 
+  // One offscreen render of the user's CURRENT framing (live camera pose +
+  // orbit target, live aspect) at a caller-chosen resolution — the showcase
+  // capture. Returns a JPEG data URL, or null when disposed / nothing visible.
+  function captureCurrent(opts) {
+    if (disposed) return null;
+    const box = getVisibleWorldBounds();
+    if (!box || box.isEmpty()) return null;
+    return captureCurrentFromScene(opts, {
+      renderer: { renderOffscreen },
+      liveCamera: camera,
+      target: controls.target.toArray(),
+      grid,
+      maxTextureSize: renderer.capabilities?.maxTextureSize,
+    });
+  }
+
   // --- render loop ----------------------------------------------------------
   renderer.setAnimationLoop(() => {
     controls.update();
@@ -484,6 +539,7 @@ export function createViewer(container, part) {
     subTriangles,
     frame,
     captureCanonicalViews,
+    captureCurrent,
     setAutoRotate,
     setTheme,
     getCameraState,