partforge 0.164.0 → 0.165.0

package/docs/AUTHORING-PARTS.md

@@ -1761,8 +1761,10 @@ const plate = k.shape2d(roundedRectProfile(40, 24, 4))
   .extrude({ h: 3 });   // sugar for k.extrude({ profile: …, h: 3 }); .revolve({ degrees }) too
 ```
 
-A `Shape2D` also carries `.extrude({ h, twist?, scaleTop? })` and `.revolve({ degrees? })`
-sugar (equivalent to the `k.extrude`/`k.revolve` forms), and `.regions()` — scission, which
+A `Shape2D` also carries `.extrude({ h, twist?, scaleTop?, bevel? })` and `.revolve({ degrees? })`
+sugar (equivalent to the `k.extrude`/`k.revolve` forms — every option is passed through, so
+`shape.extrude({ h, bevel: 1 })` bevels the rims exactly as `k.extrude` does; before partforge
+0.163.2 the sugar dropped `bevel` and any unknown key without a word), and `.regions()` — scission, which
 returns each disjoint region as its own live `Shape2D` (vs `.toRegions()`, which returns raw
 `{outer, holes}` data).
 
@@ -1774,7 +1776,7 @@ const wall  = k.shape2d(outer).offset(-2, { corners: "sharp" });  // inset, mite
 
 (This achieves the same geometry as building the profiles separately and using `k.extrude({ profile: { outer, holes }, h })`, but the Shape2D path is more idiomatic for complex 2-D operations.)
 
-`Shape2D.offset(delta, { corners: "round" | "chamfer" | "sharp" })` grows (`delta>0`) or insets (`delta<0`) a shape. It runs backend-independently on the shared contour engine — lines and arcs offset exactly (arcs stay arcs), so results are backend-identical by construction, like every other `Shape2D` op; it throws if the offset collapses the shape. A region with holes offsets material-wise: the outer grows/shrinks by `delta`, holes by `-delta`, so a positive `delta` always adds material. (For `derive()`/main-thread clearance math on plain point lists, use the pure `offsetPolygon` helper instead.)
+`Shape2D.offset(delta, { corners: "round" | "chamfer" | "sharp" })` grows (`delta>0`) or insets (`delta<0`) a shape. It runs backend-independently on the shared contour engine — lines and arcs offset exactly (arcs stay arcs), so results are backend-identical by construction, like every other `Shape2D` op; it throws if the offset collapses the shape. A region with holes offsets material-wise: the outer grows/shrinks by `delta`, holes by `-delta`, so a positive `delta` always adds material. (For `derive()`/main-thread clearance math on plain point lists, use the pure `offsetPolygon` helper instead.) The 3-D counterpart is `Solid.offset(d)` — a ball offset of a whole solid (see [`offset(d)`](#offsetd--grow-or-shrink-a-solid)).
 
 ## Editing profiles
 
@@ -4766,6 +4768,7 @@ at runtime — no declaration needed either way:
 | `s.fillet(radius)` · `s.fillet({ r, edges? })` | round edges (curve-following, exact); the bare-number scalar shorthand fillets **all** edges, the options form adds a selector |
 | `s.chamfer(distance)` · `s.chamfer({ d, edges? })` | bevel edges; same scalar-shorthand-or-options-with-selector shape as `fillet` |
 | `s.shell({ t, open })` | hollow inward, wall = `t`; `open` selector (`{inPlane,at}`/`{dir}`/`{near}`) chooses which face(s) to open. Closed (no-open-face) hollows are not supported. |
+| `s.offset(d)` · `s.offset({ d })` | grow (`d > 0`) or shrink (`d < 0`) the whole solid by `d` — a 3-D ball offset on both backends, imported meshes included; no OCCT routing. A closed constant-thickness skin is `body.cut(body.offset(-t))`. See [`offset(d)`](#offsetd--grow-or-shrink-a-solid) below. |
 
 `edges` (fillet/chamfer) / `open` (shell) chooses which edges/faces (omit `edges` for **all** edges — `shell` always requires `open`):
 
@@ -4885,6 +4888,50 @@ Rules of thumb:
 - A small ridge remaining where a thin rib was consumed is correct morphology
   (the rib's dilation fillet survives the opening), not a bug.
 
+### `offset(d)` — grow or shrink a solid
+
+`s.offset(2)` (or `s.offset({ d: 2 })`) grows the solid by 2 mm in every
+direction; `s.offset(-2)` shrinks it by 2 mm. Every point of the new surface is
+`|d|` from the old one — it is a true ball offset, the 3-D counterpart of
+`Shape2D.offset` — so it works on any solid, including an imported STL/3MF mesh,
+and it runs on both backends without routing. `offset(0)` is the identity.
+
+Its main use is a skin of constant thickness `t`, which `shell` cannot make for
+a closed body or an imported mesh:
+
+```js
+const helmet = k.import("helmet");
+const skin = helmet.cut(helmet.offset(-2));         // 2 mm thick everywhere, inside the helmet
+const cage = helmet.offset(1.5).cut(helmet);        // 1.5 mm thick everywhere, outside it
+```
+
+Do not build a skin from axis-shifted copies (`translate` by `±t` and union):
+that is six booleans, and the wall comes out only `t/√2` to `t/√3` thick on
+diagonal surfaces. `offset` is one op and holds `t` in every direction.
+
+**Corners.** A ball offset rounds what it moves away from: on a grow, convex
+edges and corners become arcs of radius `d` (a box grows into a rounded box);
+on a shrink, concave edges become arcs of radius `|d|` and convex corners stay
+sharp (a box shrinks into a smaller sharp box). Flat faces stay flat and move
+`|d|` along their normal. For sharp grown corners, offset the 2-D profile
+(`Shape2D.offset(d, { corners: "sharp" })`) and extrude it instead.
+
+**Thin features.** A shrink deeper than half a wall removes that wall, and a
+shrink past half the solid's thickness leaves nothing (an empty solid on
+Manifold). On OCCT (STEP export, or a sub-part that a `shell` routes there) a
+B-rep offset cannot change topology, so an offset it cannot build **throws**
+`offset-failed` — it never returns the un-offset solid, because a skin cut from
+that would be empty. See `docs/ERROR-PATTERNS.md`.
+
+**Cost note.** The mesh backend computes the offset as a Minkowski sum (grow)
+or difference (shrink) with a ball. On a non-convex solid each input triangle
+is hulled with the ball, so time grows with the triangle count — about 3 ms per
+triangle on a desktop (a 576-triangle dome ≈ 2 s, 8,448 triangles ≈ 23 s). An
+imported scan of 100k triangles is minutes. Decimate a dense import before you
+offset it, and offset once and reuse the result rather than offsetting inside a
+loop. The ball's own tessellation follows the quality tier (preview is coarser,
+so the wall can run up to ~0.1 mm under `t` on a diagonal; print is tighter).
+
 ### Cost on the OCCT path: fillet/chamfer scale with edge count — and order matters
 
 These costs apply when a sub-part **does** run on OCCT (a shell, an unsupported edge

package/docs/ERROR-PATTERNS.md

@@ -132,6 +132,24 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** the B-rep backend implements `roundAll` as a triple OCCT offset, which cannot change topology: a radius at or above the smallest local feature (thin wall < 2r, hole < 2r) has no valid B-rep offset result, so the op skips whole rather than emit garbage (KERNEL-CONTRACT.md, `roundAll` row). The mesh backend meanwhile performs true consumption — so preview and STEP legitimately differ in this regime.
 - **Fix:** reduce `r` below half the smallest wall/hole radius if STEP fidelity matters; or accept the divergence (preview/STL are correct) and gate the part with a `verify` volume assertion so the behavior is intentional.
 
+## offset-failed
+
+- **Symptom:** the build throws `offset-failed: offset(<d>) produced no valid solid on the OCCT backend — …` (STEP export, or a sub-part a `shell` routes to OCCT).
+- **Cause:** the B-rep backend implements `Solid.offset` as one OCCT offset, which cannot change topology: a shrink at or past half the thinnest wall (or a grow that would close a gap or hole narrower than `2d`) has no valid B-rep result. Unlike `roundAll`, `offset` never skips — returning the un-offset solid would make `body.cut(body.offset(-t))` empty without any sign of a problem — so it throws.
+- **Fix:** keep `|d|` below half the smallest wall/gap; or run the sub-part on Manifold (`meta.backend: "manifold"`, or drop the `shell` that routes it), whose Minkowski offset consumes thin features correctly. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "`offset(d)` — grow or shrink a solid".
+
+## offset-slow
+
+- **Symptom:** a build that calls `Solid.offset` takes many seconds or minutes, most often on an imported STL/3MF.
+- **Cause:** the Manifold backend's offset is a Minkowski sum/difference with a ball; on a non-convex solid every input triangle is hulled with the ball, about 3 ms per triangle (8,448 triangles ≈ 23 s; a 100k-triangle scan is minutes).
+- **Fix:** decimate the mesh before you import it, offset once and reuse the result, and do not offset inside a loop. Where the solid is an extrusion, offset the 2-D profile (`Shape2D.offset`) and extrude it instead — that is near-instant.
+
+## solid-offset-not-a-function
+
+- **Symptom:** `TypeError: <name>.offset is not a function` on a Solid (an extruded, imported or boolean result).
+- **Cause:** partforge before 0.165 had `offset` only on `Shape2D`; `Solid.offset` was added in 0.165.0.
+- **Fix:** update partforge to 0.165.0 or later. Do not fall back to unioning axis-shifted copies of the solid — that makes a wall only `t/√3` thick on diagonal surfaces.
+
 ## boolean-not-watertight
 
 - **Symptom:** `NOT watertight ✗` from `partforge measure` (non-zero exit) after adding a boolean cut or union.

package/docs/KERNEL-CONTRACT.md

@@ -80,6 +80,15 @@ Its coverage and tolerance band are part of the contract:
   labels upstream of the call do not survive through it (attribution uses the
   fallback path), and the result shades with the default SMOOTH policy.
 
+`offset` is required on every class too and is **parity-tolerant** while the
+offset does not change topology (a shrink less than half the thinnest wall, a
+grow that closes no gap): the mesh class computes it with one Minkowski pass
+(roundAll's sphere tessellation rule, sized from `|d|`) and a B-rep class with
+one native offset (`BRepOffsetAPI_MakeOffsetShape`, arc join). Past that, the
+mesh class changes topology correctly and a B-rep class throws `offset-failed`
+— unlike `roundAll`, skipping is NOT a permitted degrade, because the un-offset
+solid is a wrong answer rather than a missing feature.
+
 `roundAll` is required on **every** class (it is in `SOLID_OPS`, not
 `OCCT_ONLY_OPS`) and is **parity-tolerant with a regime split**: while `r` is
 strictly below the solid's smallest feature size (min wall, min hole
@@ -379,6 +388,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `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})` | `fillet`/`chamfer`: implemented on BOTH in-repo classes since v3 — exactly on B-rep, tolerance-band on the mesh class for straight, circular-arc, planar-rim and curved-face edge chains (see [Conformance classes](#conformance-classes)); an edge class the mesh kernel cannot blend throws `KernelCapabilityError` and reroutes. Zero magnitude — `fillet(0)` / `chamfer({d: 0})` — is the identity on every class (returns the solid unchanged, never throws; `shell` excluded, `t: 0` is degenerate). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` remains B-rep-only (core throws), hollows inward keeping outer dimensions; `open` (face selector) is required. |
 | `roundAll(r)` · `roundAll({r})` | Morphological close-then-open with a ball of radius `r`: rounds EVERY edge (convex and concave) at radius ≈ `r`; faces stay in place (within the class's tolerance band — the B-rep offset chain can drift ~0.1 mm); features smaller than the ball are consumed (walls < 2r melt, holes < 2r seal). Implemented natively on BOTH classes — never routes, never throws `KernelCapabilityError`. Parity-tolerant only while `r` is below the smallest feature size; at consuming radii the mesh class performs true consumption and a B-rep class MAY skip the whole op unchanged with a `roundall-skipped` warning (skip is the only permitted degrade). `roundAll(0)` is the identity on every class. |
+| `offset(d)` · `offset({d})` | 3-D ball offset — the solid counterpart of `Shape2D.offset`: `d > 0` grows the solid by `d` (Minkowski sum with a ball), `d < 0` shrinks it by `\|d\|` (Minkowski difference). Every point of the result's surface is `\|d\|` from the input's, within the class's tolerance band (the mesh class's faceted ball sits up to its sagitta inside the true ball, so diagonal faces land slightly short of `\|d\|`). Corners: a grow rounds convex edges/corners at radius `d` and keeps concave ones sharp; a shrink rounds concave edges at `\|d\|` and keeps convex ones sharp. Implemented natively on BOTH classes — never routes, never throws `KernelCapabilityError`; works on imported meshes on the mesh class. A shrink past the solid's half-thickness yields an empty solid on the mesh class. A B-rep class MUST NOT return the input unchanged on failure (a skin `body.cut(body.offset(-t))` would silently come out empty): it throws an error whose message starts `offset-failed:`. `offset(0)` is the identity on every class. Additive in 0.165 with no contract bump (the `loftSmooth` precedent). |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for
 speed and a backend may bake it at kernel creation (Manifold does). A part must never
@@ -942,6 +952,12 @@ in `kernel.js` define the current surface; only breaking changes bump the versio
   `cut` per CadQuery/replicad rather than OpenSCAD's `difference`), so LLM priors
   transfer. Renames are breaking changes with no offsetting benefit — don't.
 
+**Additive within v4** (partforge 0.165): `Solid.offset` joins `SOLID_OPS` — a 3-D
+ball offset (`d > 0` grows, `d < 0` shrinks), on both in-repo classes. No contract
+bump, following the `loftSmooth`/`heightfield` precedent for an op both in-repo
+backends implement; a third-party core kernel must add it to stay conforming
+(Manifold's `minkowskiSum`/`minkowskiDifference` with a sphere is the reference).
+
 **v3 → v4** (partforge 0.63): `Solid.roundAll` is added to `SOLID_OPS` (portable
 morphological rounding — rounds every edge with a ball of radius `r`;
 parity-tolerant, regime-split semantics, see

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.164.0",
+  "version": "0.165.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.js

@@ -51,6 +51,9 @@ export const SOLID_OPS = [
   "translate", "rotate", "rotateX", "rotateY", "rotateZ", "rotateAbout", "along", "at",
   "mirror", "scale", "toMesh", "toSTL", "toIndexedMesh",
   "fillet", "chamfer", "shell", "roundAll",
+  // Additive in 0.165 (no CONTRACT_VERSION bump — the loftSmooth/heightfield
+  // precedent): both in-repo backends implement it.
+  "offset",
 ];
 
 // Backend-optional Solid queries: Manifold mesh-topology numbers (measure.js
@@ -109,6 +112,8 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; fillet(3) or fillet({r,edges}); legacy (r,selector) accepted for now (see file header)
  * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted for now (see file header)
  * @property {(o:{t:number,open:object}) => Solid} shell   hollow inward (OCCT only); legacy (thickness,openFaces) accepted for now (see file header)
+ * @property {(r:number|{r:number}) => Solid} roundAll   morphological close-then-open with a ball of radius r: rounds every edge (both backends)
+ * @property {(d:number|{d:number}) => Solid} offset   3-D ball offset: grow (+d) / shrink (−d) the solid by |d| everywhere — convex edges round on a grow, concave on a shrink; both backends; the 2-D twin is Shape2D.offset
  * @property {() => number} [genus]     through-hole count (Manifold only)
  * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)
  *
@@ -135,7 +140,7 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(tolerance:number) => Shape2D} simplify   corner-preserving decimation/refit within tolerance
  * @property {() => {index:number,point:number[],interiorAngleDeg:number,convex:boolean,segTypes:string[]}[]} corners   corner list (the positional order fillet/chamfer `{indices}` index into)
  * @property {(p:number[]) => boolean} contains   is point [x,y] inside the shape (holes excluded)
- * @property {(o?:{h:number,twist?:number,scaleTop?:number}) => Solid} extrude   sugar for k.extrude({profile:this,…})
+ * @property {(o?:{h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   sugar for k.extrude({profile:this,…}); every option is forwarded
  * @property {(o?:{degrees?:number}) => Solid} revolve   sugar for k.revolve({profile:this,…})
  *
  * @typedef {Object} GeometryKernel

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

@@ -19,7 +19,7 @@ import { creasedNormals } from "./creased-normals.js";
 import { loftShadingPolicy, SMOOTH, BLEND } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
 import { affineAt, IDENTITY, invertAffine, mapSurface } from "./blend-surfaces.js";
-import { flatFacePlanes, meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
+import { flatFacePlanes, meshOffset, meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
 import { SEGS, circleSegs, doubleCurvatureSegs } from "./circle-segs.js";
 import { checkBooleanResult } from "./boolean-gate.js";
 import { KernelCapabilityError } from "./errors.js";
@@ -462,7 +462,12 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // meshRoundAll's simplify tolerance protects), so only the face and its seam
   // vertices are on a plane. Keyed on geometry like every descriptor (see
   // blendSurfaces above), so it is never removed with the cache entry.
-  const markFlatFaces = (input, out, r) => {
+  //
+  // offset() reuses it with `moveTo`: a single dilate/erode step moves each flat
+  // face along its normal instead of returning it to its plane, so the planes are
+  // moved to where the step put them before they are registered. `r` and `segs`
+  // are the ball the step used (the tolerance rule is the same).
+  const markFlatFaces = (input, out, r, segs = roundAllSegs(2 * r, quality), moveTo = null) => {
     const gi = input.getMesh();
     let planes;
     try {
@@ -470,8 +475,8 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     } finally {
       gi.delete?.();
     }
+    if (moveTo) planes = planes.map(moveTo);
     if (!planes.length) return out;
-    const segs = roundAllSegs(2 * r, quality);
     const tol = Math.min(1e-3, 0.25 * r * (1 - Math.cos((2 * Math.PI) / segs)));
     const go = out.getMesh();
     try {
@@ -569,6 +574,18 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       return cached(h("roundAll", hash, r, quality), () =>
         prismRoundAllFast(m, hash, r) ?? markFlatFaces(m, T(meshRoundAll(wasm, m, r, quality)), r));
     },
+    // Ball offset (mesh-roundall.js meshOffset): one dilate or erode, never
+    // routed, never NEEDS_OCCT. An erode deeper than the solid's half-thickness
+    // consumes it — the empty result is the honest answer, not a failure.
+    offset: (d) => {
+      if (!Number.isFinite(d)) throw new Error(`offset: d must be a finite number (got ${d})`);
+      if (d === 0) return wrap(m, hash); // contract: zero magnitude is the identity
+      return cached(h("offset", hash, d, quality), () => {
+        const { out, support, segs: ballSegs } = meshOffset(wasm, m, d, quality);
+        const sign = Math.sign(d); // a dilate moves a face out by h(n), an erode in by h(n)
+        return markFlatFaces(m, T(out), Math.abs(d), ballSegs, (p) => ({ n: p.n, d: p.d + sign * support(p.n) }));
+      });
+    },
     // batch difference: first minus the union of the rest, evaluated as one boolean
     // tree — no materialized intermediate union (the unionRaw memory note applies)
     cutAll: (tools) => cached(h("cutAll", hash, tools.map((t) => t._hash)), () => {

package/src/framework/geometry/mesh-roundall.js

@@ -84,6 +84,60 @@ export function meshRoundAll(wasm, m, r, quality) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Solid.offset on the mesh backend: ONE step of the chain above — a dilate
+// (d > 0, Minkowski sum) or an erode (d < 0, Minkowski difference) with a ball of
+// radius |d|. A true ball offset, so every point of the result's surface sits |d|
+// from the input's (within the ball's facet sagitta): convex edges and corners
+// round at radius d on a dilate, concave ones round at |d| on an erode, and the
+// other kind stays sharp. Same asOriginal-then-simplify cleanup as each roundAll
+// step, for the same sliver reason; the tolerance is roundAll's too, so the rim
+// ring that holds an offset face on its plane survives the simplify.
+//
+// Cost is the Minkowski's: on a non-convex input every triangle is hulled with
+// the ball, so time grows with the input's triangle count — measured ~3 ms per
+// input triangle on a dome (576 tris ≈ 2 s, 8,448 ≈ 23 s). The ball count is
+// sized from |d| alone, the one ball the op uses.
+export function meshOffset(wasm, m, d, quality) {
+  if (!Number.isFinite(d) || d === 0) throw new Error("offset: d must be a finite non-zero number (d = 0 is handled as the identity by the caller)");
+  const r = Math.abs(d);
+  const segs = roundAllSegs(r, quality);
+  const tol = Math.min(Math.max(r / 100, 0.01), 0.5 * r * (1 - Math.cos((2 * Math.PI) / segs)));
+  const ball = wasm.Manifold.sphere(r, segs);
+  try {
+    const raw = d > 0 ? m.minkowskiSum(ball) : m.minkowskiDifference(ball);
+    let orig;
+    try {
+      orig = raw.asOriginal();
+    } finally {
+      raw.delete?.();
+    }
+    try {
+      return { out: orig.simplify(tol), support: ballSupport(ball), segs };
+    } finally {
+      orig.delete?.();
+    }
+  } finally {
+    ball.delete?.();
+  }
+}
+
+// The faceted ball's support function h(n) = max over its vertices of n·v: how
+// far the offset actually moves a planar face with outward normal n (a dilate
+// puts it at n·x = d + h(n), an erode at d − h(n)). Equal to |d| where a ball
+// vertex lines up with n (the axes), a sagitta short of it elsewhere — the flat-
+// face shading below must place each plane where the face really landed.
+function ballSupport(ball) {
+  const g = ball.getMesh();
+  const np = g.numProp, vp = Float64Array.from(g.vertProperties);
+  g.delete?.();
+  return (n) => {
+    let best = -Infinity;
+    for (let i = 0; i < vp.length; i += np) best = Math.max(best, n[0] * vp[i] + n[1] * vp[i + 1] + n[2] * vp[i + 2]);
+    return best;
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Flat-face shading. The reference path's result is one fresh surface, shaded
 // SMOOTH (35° crease), and the rounding ball's facets bend far less than that, so

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

@@ -25,7 +25,7 @@ import { groupInteractingRegions } from "./region-interaction.js";
 import { finishKernel } from "./kernel-front.js";
 import { makeProfileWarner } from "./profile-warnings.js";
 import { createOcctRepair } from "./occt-repair.js";
-import { occtRoundAll } from "./occt-roundall.js";
+import { occtOffset, occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
 import { emscriptenThrowEvidence, labelImportFailure } from "../kernel-error.js";
 import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
@@ -412,6 +412,16 @@ export function createOcctKernel(replicad) {
           return wrap(occtRoundAll(replicad, a._s, r, recordWarning), cloneLabels(a._labels), key);
         });
       },
+      // Never skips: a failed offset throws `offset-failed` (occt-roundall.js says why).
+      offset: (d) => {
+        if (!Number.isFinite(d)) throw new Error(`offset: d must be a finite number (got ${d})`);
+        const key = h("offset", hash, d);
+        return cached(key, () => {
+          const a = mat();
+          if (d === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          return wrap(occtOffset(replicad, a._s, d), cloneLabels(a._labels), key);
+        });
+      },
       shell: (thickness, openFaces) => {
         if (openFaces == null) throw new Error("shell: openFaces is required (a fully closed hollow is not supported)");
         const key = h("shell", hash, thickness, selKey(openFaces));

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

@@ -15,7 +15,12 @@
 // Is a shape a closed solid? A broken chamfer (one that over-ran and consumed a face)
 // meshes to an OPEN surface; a valid one is closed. OCCT meshes each face separately,
 // so weld vertices by position, then a closed solid has every edge shared by exactly
-// two triangles. (A coarse mesh is enough — this is a topology check.)
+// two triangles. (A coarse mesh is enough — this is a topology check.) A triangle
+// the weld collapses (two corners in one 1/32 mm cell — a sphere's pole fan, a
+// sliver) has no area and bounds nothing, so it is left out of the count: kept,
+// its self-edge counts once and its doubled edge three times, and every sphere
+// read as open. A mesh the weld collapses ENTIRELY bounds nothing either, so it
+// needs at least one surviving edge to count as closed.
 export const isClosedSolid = (shape) => {
   const m = shape.mesh({ tolerance: 0.3, angularTolerance: 1.0 });
   const P = m.vertices, T = m.triangles;
@@ -27,8 +32,10 @@ export const isClosedSolid = (shape) => {
   const edges = new Map();
   for (let t = 0; t < T.length / 3; t++) {
     const a = vid(T[t * 3]), b = vid(T[t * 3 + 1]), c = vid(T[t * 3 + 2]);
+    if (a === b || b === c || c === a) continue;
     for (const [x, y] of [[a, b], [b, c], [c, a]]) { const e = x < y ? x * 1e7 + y : y * 1e7 + x; edges.set(e, (edges.get(e) || 0) + 1); }
   }
+  if (edges.size === 0) return false;
   for (const n of edges.values()) if (n !== 2) return false;
   return true;
 };

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

@@ -30,9 +30,15 @@ const VARIANTS = [
   { join: "int", inter: false },
   { join: "int", inter: true },
 ];
+// Solid.offset's cascade: the Arc joins alone. An Intersection join extends the
+// faces to sharp corners, which passes every gate yet is not a ball offset.
+const ARC_VARIANTS = VARIANTS.filter((v) => v.join === "arc");
 
-export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`partforge: ${msg}`)) {
-  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
+// One gated offset step: the variant cascade above, each candidate held to the
+// IsDone / closed / positive-volume / volume-monotonic gate. Returns
+// { solid, vol } or null when no variant survives. `variants` is the cascade
+// order. Never frees `topoOwner` — the caller owns it.
+function offsetStep(replicad, topoOwner, off, vol, variants = VARIANTS) {
   const oc = replicad.getOC();
   const tryOffset = (topo, offset, v) => {
     const progress = new oc.Message_ProgressRange_1();
@@ -55,6 +61,26 @@ export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`p
       progress.delete?.();
     }
   };
+  for (const v of variants) {
+    const cand = tryOffset(topoOwner.wrapped, off, v);
+    if (!cand) continue;
+    let cvol;
+    try { cvol = replicad.measureVolume(cand); } catch { cand.delete?.(); continue; }
+    if (!Number.isFinite(cvol) || cvol <= 0) { cand.delete?.(); continue; }
+    if (off > 0 && cvol < vol * 0.999) { cand.delete?.(); continue; } // dilation shrank: garbage
+    if (off < 0 && cvol > vol * 1.001) { cand.delete?.(); continue; } // erosion grew: garbage
+    // isClosedSolid meshes the candidate, and meshing OCCT offset garbage can
+    // throw — that is just another rejected candidate, not an escape hatch out
+    // of "roundAll never throws for geometry".
+    try { if (!isClosedSolid(cand)) { cand.delete?.(); continue; } }
+    catch { cand.delete?.(); continue; }
+    return { solid: cand, vol: cvol };
+  }
+  return null;
+}
+
+export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`partforge: ${msg}`)) {
+  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
   let vol;
   try {
     vol = replicad.measureVolume(shape);
@@ -65,30 +91,37 @@ export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`p
   }
   let cur = shape;
   for (const off of [r, -2 * r, r]) {
-    let next = null;
-    for (const v of VARIANTS) {
-      const cand = tryOffset(cur.wrapped, off, v);
-      if (!cand) continue;
-      let cvol;
-      try { cvol = replicad.measureVolume(cand); } catch { cand.delete?.(); continue; }
-      if (!Number.isFinite(cvol) || cvol <= 0) { cand.delete?.(); continue; }
-      if (off > 0 && cvol < vol * 0.999) { cand.delete?.(); continue; } // dilation shrank: garbage
-      if (off < 0 && cvol > vol * 1.001) { cand.delete?.(); continue; } // erosion grew: garbage
-      // isClosedSolid meshes the candidate, and meshing OCCT offset garbage can
-      // throw — that is just another rejected candidate, not an escape hatch out
-      // of "roundAll never throws for geometry".
-      try { if (!isClosedSolid(cand)) { cand.delete?.(); continue; } }
-      catch { cand.delete?.(); continue; }
-      next = cand;
-      vol = cvol;
-      break;
-    }
+    const next = offsetStep(replicad, cur, off, vol);
     if (cur !== shape) cur.delete?.(); // superseded intermediate; never the caller's shape
     if (!next) {
       warn(`roundall-skipped: offset step ${off} produced no valid solid — r=${r} is likely at/above the smallest feature size; returning the un-rounded solid`);
       return shape.clone();
     }
-    cur = next;
+    cur = next.solid;
+    vol = next.vol;
   }
   return cur;
 }
+
+// Solid.offset on the B-rep class: ONE gated offset step, Arc joins only, so the
+// corners match the mesh class's ball offset (convex edges round on a grow,
+// concave on a shrink). Unlike roundAll this never skips: an un-offset solid
+// handed back as an offset is silently wrong geometry (a skin cut from it comes
+// out empty), so a step no variant survives THROWS, with a greppable message
+// (docs/ERROR-PATTERNS.md "offset-failed"). The usual trigger is an erode at or
+// past half the thinnest wall — the B-rep offset cannot change topology, which
+// the mesh class's Minkowski does.
+export function occtOffset(replicad, shape, d) {
+  if (!Number.isFinite(d) || d === 0) throw new Error("offset: d must be a finite non-zero number (d = 0 is handled as the identity by the caller)");
+  let vol;
+  try {
+    vol = replicad.measureVolume(shape);
+  } catch (e) {
+    throw new Error(`offset-failed: offset(${d}) could not measure the input solid on the OCCT backend (${e?.message || e})`);
+  }
+  const next = offsetStep(replicad, shape, d, vol, ARC_VARIANTS);
+  if (!next) {
+    throw new Error(`offset-failed: offset(${d}) produced no valid solid on the OCCT backend — |d| is likely at/above half the thinnest wall, or the shape has faces OCCT cannot offset; the Manifold backend's offset handles both (meta.backend: "manifold")`);
+  }
+  return next.solid;
+}

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

@@ -365,6 +365,8 @@ export const SOLID_OP_SPECS = {
     return [req("shell", o, "t"), req("shell", o, "open")]; } },
   roundAll: { toArgs: (o) => { checkKeys("roundAll", o, ["r"]);
     return [req("roundAll", o, "r")]; } },
+  offset:   { toArgs: (o) => { checkKeys("offset", o, ["d"]);
+    return [req("offset", o, "d")]; } },
 };
 
 // A zero-magnitude fillet/chamfer is the identity on every conformance class

package/src/framework/geometry/shape2d-sugar.js

@@ -14,12 +14,17 @@ export function addShape2dSugar(s, { shape2d, extrude, revolve }) {
   // lifted and resolved by every boolean since — re-lifting them untrusted would
   // re-run profile validation on machine-produced geometry on every call.
   s.regions = () => s.toRegions().map((r) => shape2d.trusted(r));
-  // .extrude({ h, twist?, scaleTop? }) / .revolve({ degrees? }) → Solid. Sugar for
-  // k.extrude({ profile: shape, … }) / k.revolve({ profile: shape, … }). Passed as an
-  // options object (not positional) so the kernel op's key/required-arg validation still
-  // fires — e.g. a missing `h` throws "extrude: h is required" rather than silently
-  // producing empty geometry.
-  s.extrude = ({ h, twist, scaleTop } = {}) => extrude({ profile: s, h, twist, scaleTop });
-  s.revolve = ({ degrees } = {}) => revolve({ profile: s, degrees });
+  // .extrude({ h, twist?, scaleTop?, bevel? }) / .revolve({ degrees? }) → Solid. Sugar for
+  // k.extrude({ profile: shape, … }) / k.revolve({ profile: shape, … }). Every option is
+  // forwarded as-is, so the kernel op's own key/required-arg validation fires: a missing
+  // `h` throws "extrude: h is required", an unknown key throws, and an option the kernel
+  // grows later (as `bevel` was) works here with no change. Never list the keys: a list
+  // silently drops whatever it leaves out. `profile` is refused — this shape is the profile.
+  const sugar = (op, fn) => (o = {}) => {
+    if (o.profile !== undefined) throw new Error(`Shape2D.${op}: don't pass profile — the shape you call .${op}() on is the profile`);
+    return fn({ ...o, profile: s });
+  };
+  s.extrude = sugar("extrude", extrude);
+  s.revolve = sugar("revolve", revolve);
   return s;
 }

package/types/kernel.d.ts

@@ -290,6 +290,16 @@ export interface Solid {
    * never throws `KernelCapabilityError`. `roundAll(0)` is the identity.
    */
   roundAll(r: number | { r: number }): Solid;
+  /**
+   * 3-D ball offset — the solid counterpart of `Shape2D.offset`. `d > 0` grows
+   * the solid by `d` everywhere (convex edges round at radius `d`); `d < 0`
+   * shrinks it by `|d|` (concave edges round, convex corners stay sharp). Works
+   * on both backends and on imported meshes; never routes. A constant-thickness
+   * skin is `body.cut(body.offset(-t))`. `offset(0)` is the identity. The mesh
+   * backend's cost grows with triangle count (~3 ms per triangle); on OCCT an
+   * offset that cannot be built throws `offset-failed`.
+   */
+  offset(d: number | { d: number }): Solid;
   /** Through-hole count (Manifold only). */
   genus?(): number;
   /** No geometry at all (Manifold only). */