partforge 0.14.0 → 0.17.0

package/docs/AUTHORING-PARTS.md

@@ -147,11 +147,22 @@ k.sweep({ profile: circleProfile(3), path: [[0, 0, 0], [0, 0, 20], [15, 0, 20]],
 // round every corner of any CCW outline, then extrude/loft/prism it
 k.prism({ points: filletPolygon(bracketOutline, 3), h: 4 });   // tessellated corners (faceted in STEP)
 k.prism({ points: roundedProfile(bracketOutline, 3), h: 4 });  // true CIRCLE corners in STEP export
+
+// print clearance on an arbitrary cut profile, or an inset wall
+k.extrude({ profile: offsetPolygon(slotPolygon(20, 3), 0.2), h: 10 });   // slot cut 0.2 mm looser all around
+offsetPolygon(outline, -wall, { corners: "sharp" });                     // inset a wall (see planter.js)
+
+// A tab with one free-form curved side (exact on STEP, faceted at mesh LOD):
+const tab = pathProfile([0, 0])
+  .lineTo([20, 0]).lineTo([20, 8])
+  .cubicTo([0, 8], [14, 16], [6, 16])   // curved top edge
+  .close();
+k.extrude({ profile: tab, h: 3 });
 ```
 
 2-D polygon helpers for `prism`/`extrude`/`loft`: `import { piePolygon, hexPolygon,
-regularPolygon, roundedRectPolygon, starPolygon, circleProfile, filletPolygon,
-roundedProfile } from "partforge/geometry"`. `filletPolygon(points, r, { segs? })` rounds
+regularPolygon, roundedRectPolygon, starPolygon, slotPolygon, circleProfile, filletPolygon,
+roundedProfile, offsetPolygon, pathProfile } from "partforge/geometry"`. `filletPolygon(points, r, { segs? })` rounds
 every corner of a CCW polygon (per-corner radius clamped so neighbouring arcs never overlap)
 and returns points usable by `prism`/`extrude`/`loft` on both backends — but it **bakes each
 corner into line facets**, so STEP corners are faceted. `roundedProfile(points, r | r[])`
@@ -159,7 +170,17 @@ rounds corners the same way but keeps them **mathematically true** — it carrie
 symbolically so STEP export gets real circular edges. Use it for `prism`/`extrude` (not yet
 `loft` — arc rings are rejected there in v1). A scalar `r` rounds every corner; a per-corner
 `r[]` (length = points) rounds selectively (a `0`, a zero-length edge, or a straight/180°
-corner stays sharp).
+corner stays sharp). `offsetPolygon(profile, delta, { corners?, segs? })` offsets a
+point-list polygon or `{ outer, holes }` region by `delta` mm — positive grows material,
+negative insets; regions offset material-wise (outer `+delta`, holes `−delta`, so a
+clearance loosens the whole cut). `corners` picks the convex-corner style: `"round"`
+(default; the true Minkowski clearance), `"chamfer"`, or `"sharp"` (miter, falling back to
+chamfer past a miter length of 2·|delta|). It is **simple polygon in, simple polygon out**:
+an offset whose true result would collapse or split into multiple contours (e.g. insetting a
+dumbbell past its waist) **throws** a greppable error rather than returning degenerate
+geometry. Being pure, it works in `derive()` as well as `build()` — the natural home for
+clearance math.
+`pathProfile(start)` is a fluent builder for a curve-native path contour (`lineTo` / `arcTo` / `cubicTo` / `close`); cubic segments become exact B-rep spline edges on the OCCT/STEP backend and facet at the mesh LOD on Manifold — the same exact-vs-faceted split as `roundedProfile` arcs.
 **Import geometry helpers from `partforge/geometry`, never from `partforge`** — the main
 entry pulls in the DOM viewer/controls, and your build functions run in a Web Worker
 (importing the main entry there throws `document is not defined`).

package/docs/ERROR-PATTERNS.md

@@ -195,6 +195,44 @@ The sphere variant is `sphere: pass exactly one of r/d` (same cause and fix).
 - **Cause:** `center` was passed alongside `min`/`max`, but explicit corners already fix the placement.
 - **Fix:** drop `center`, or switch to `{size, center?}` — see [AUTHORING-PARTS.md](AUTHORING-PARTS.md).
 
+## offset-polygon-bad-input
+
+- **Symptom:** `offsetPolygon: need at least 3 points`
+- **Cause:** malformed input to `offsetPolygon` — too few points after dedup, or (variant messages) a non-finite `delta`, non-finite coordinates, an unknown `corners` style, or a profile that is neither a point list nor `{outer, holes}`.
+- **Fix:** pass a CCW `[[x,y],…]` list (≥ 3 distinct points) or `{outer, holes}`, a finite `delta` in mm, and `corners: "round" | "chamfer" | "sharp"` — see [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Profiles & patterns".
+
+Variant literals under this entry: `offsetPolygon: delta must be a finite number`, `offsetPolygon: coordinates must be finite numbers`, `offsetPolygon: corners must be "round" | "chamfer" | "sharp"`, `offsetPolygon: profile must be a point list or {outer, holes}`.
+
+## offset-polygon-input-self-intersects
+
+- **Symptom:** `offsetPolygon: input polygon self-intersects`
+- **Cause:** the input contour crosses itself — the profile is broken before any offsetting happens (checked up front so bad input is not blamed on the offset).
+- **Fix:** repair the generating math for the contour; the offset envelope requires simple polygons in and out.
+
+## offset-polygon-collapse
+
+- **Symptom:** `offsetPolygon: offset collapses the polygon`
+- **Cause:** the offset consumed the shape — either an inset ate the whole polygon (result area ≤ 0 or fewer than 3 points, `|delta|` past the narrowest half-width; also thrown for a region hole that would vanish), or an offset displaced an edge past its own length so the edge inverts (a large inset, or a large *outset* of a concave profile where `|delta|` exceeds a reflex-adjacent edge — this last case can also depend on `corners`, since `"sharp"` extends edges further than `"round"`/`"chamfer"`).
+- **Fix:** reduce `|delta|`, or clamp it from the shape's dimensions before offsetting (see planter.js's wall cap). If a vanishing hole is intended, remove the hole from the region explicitly. Realistic clearances (fractions of a mm) on any profile, and wall insets up to the narrowest feature, never trip this.
+
+## offset-polygon-result-self-intersects
+
+- **Symptom:** `offsetPolygon: offset result self-intersects (reduce |delta| or simplify the profile)`
+- **Cause:** the true offset of this shape at this `|delta|` is not a single simple polygon (e.g. insetting a dumbbell past its waist would split it in two) — out of `offsetPolygon`'s envelope.
+- **Fix:** reduce `|delta|`, or decompose the profile into separately-offset simple contours.
+
+## cubic-segment-mixes-arc-and-cubic
+
+- **Symptom:** `extrude: <role> segment cannot mix arc (via) and cubic (c1/c2)`
+- **Cause:** A path-contour segment carries both `via` (three-point arc) and `c1`/`c2` (cubic Bézier). A segment is exactly one kind.
+- **Fix:** Drop `via` for a cubic, or drop `c1`/`c2` for an arc. Use `pathProfile().arcTo(to, via)` or `.cubicTo(to, c1, c2)` to build segments.
+
+## cubic-segment-missing-controls
+
+- **Symptom:** `extrude: <role> cubic segment needs c1 and c2 as finite [x,y]`
+- **Cause:** A cubic segment is missing `c1` or `c2`, or a control point is not a finite `[x,y]` (e.g. `NaN`, wrong length).
+- **Fix:** Provide both control points as finite `[x,y]`. A cubic Bézier needs two controls between the previous point and `to`.
+
 # Hardware library
 
 Reserved for `hardware-*` patterns (issue #30). No entries yet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.14.0",
+  "version": "0.17.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/app.css

@@ -16,9 +16,11 @@ canvas { display: block; }
 #panel {
   position: fixed; top: 12px; left: 12px; width: 256px;
   max-height: calc(100vh - 24px); overflow-y: auto; z-index: 10;
-  background: var(--pf-surface); border: 1px solid var(--pf-border); border-radius: 14px;
+  background: var(--pf-surface); border: 1px solid var(--pf-border); border-radius: 16px;
   padding: 14px; color: var(--pf-text);
-  box-shadow: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);
+  /* shadow-lg, matching the partforge-cloud chat pane so the two floating
+     panes read as siblings (was the smaller shadow-md). */
+  box-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);
 }
 #panel h1 { font-size: 14px; margin: 0 0 2px; color: var(--pf-text-strong); letter-spacing: -0.01em; }
 #panel .sub {

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

@@ -89,8 +89,9 @@ export function createOcctKernel(replicad) {
   // 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
-  // real CIRCLE B-rep entity, not a fan of LINEs. close() joins the last point back to
-  // the start with a straight edge (mirrors the implied ArcContour closure).
+  // real CIRCLE B-rep entity, not a fan of LINEs. Cubic segments ({ to, c1, c2 })
+  // map to cubicBezierCurveTo for exact B-rep spline edges. close() joins the last
+  // point back to the start with a straight edge (mirrors the implied ArcContour closure).
   const contourDrawing = (contour) => {
     if (Array.isArray(contour)) {
       let pen = draw(contour[0]);
@@ -98,7 +99,10 @@ export function createOcctKernel(replicad) {
       return pen.close();
     }
     let pen = draw(contour.start);
-    for (const seg of contour.segments) pen = seg.via ? pen.threePointsArcTo(seg.to, seg.via) : pen.lineTo(seg.to);
+    for (const seg of contour.segments)
+      pen = seg.c1 ? pen.cubicBezierCurveTo(seg.to, seg.c1, seg.c2)
+          : seg.via ? pen.threePointsArcTo(seg.to, seg.via)
+          : pen.lineTo(seg.to);
     return pen.close();
   };
 

package/src/framework/geometry/polygon.js

@@ -156,6 +156,32 @@ export function filletPolygon(points, r, { segs = 8 } = {}) {
   return out;
 }
 
+// Fluent builder for a curve-native path contour { start, segments }. Segment kinds:
+// lineTo → {to}, arcTo → {to,via} (three-point arc), cubicTo → {to,c1,c2} (cubic Bézier).
+// close() returns the plain contour object (feeds extrude/revolve/prism), not a Solid.
+export function pathProfile(start) {
+  const fin2 = (p, what) => {
+    if (!Array.isArray(p) || p.length < 2 || !Number.isFinite(p[0]) || !Number.isFinite(p[1]))
+      throw new Error(`pathProfile: ${what} must be a finite [x,y]`);
+    return [p[0], p[1]];
+  };
+  const s = fin2(start, "start");
+  const segments = [];
+  const api = {
+    lineTo(to) { segments.push({ to: fin2(to, "lineTo point") }); return api; },
+    arcTo(to, via) { segments.push({ to: fin2(to, "arcTo point"), via: fin2(via, "arcTo via") }); return api; },
+    cubicTo(to, c1, c2) {
+      segments.push({ to: fin2(to, "cubicTo point"), c1: fin2(c1, "cubicTo c1"), c2: fin2(c2, "cubicTo c2") });
+      return api;
+    },
+    close() {
+      if (segments.length < 1) throw new Error("pathProfile: need ≥1 segment before close()");
+      return { start: [s[0], s[1]], segments: segments.slice() }; // snapshot — chaining after close() must not mutate the returned contour
+    },
+  };
+  return api;
+}
+
 // Arc-aware sibling of filletPolygon: rounds the corners of a CCW polygon with the SAME
 // tangent/centre/sweep math (via cornerArc), but instead of tessellating each arc into
 // line facets it emits a canonical ArcContour { start, segments:[{to}|{to,via}], arc:true }
@@ -227,3 +253,180 @@ export function circleProfile(r, center = [0, 0], segs = 48) {
   }
   return pts;
 }
+
+// --- offsetPolygon ---------------------------------------------------------
+
+const OFFSET_EPS = 1e-9;
+
+// Fresh copies, consecutive duplicates dropped, closing point (== first) dropped.
+function dedupePoints(points) {
+  const out = [];
+  for (const p of points) {
+    const last = out[out.length - 1];
+    if (!last || Math.hypot(p[0] - last[0], p[1] - last[1]) > OFFSET_EPS) out.push([p[0], p[1]]);
+  }
+  while (out.length > 1 &&
+    Math.hypot(out[0][0] - out[out.length - 1][0], out[0][1] - out[out.length - 1][1]) <= OFFSET_EPS) out.pop();
+  return out;
+}
+
+function polySignedArea(pts) {
+  let a = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const [x1, y1] = pts[i], [x2, y2] = pts[(i + 1) % pts.length];
+    a += x1 * y2 - x2 * y1;
+  }
+  return a / 2;
+}
+
+// True where segments a-b and c-d properly cross. Shared endpoints and collinear
+// touches don't count — adjacent edges always share a vertex, and the collinear
+// case is degenerate input the dedupe/straight-vertex paths already absorb.
+function segmentsCross(a, b, c, d) {
+  const orient = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+  return orient(a, b, c) * orient(a, b, d) < 0 && orient(c, d, a) * orient(c, d, b) < 0;
+}
+
+// True where p lies strictly inside segment a-b (not at either endpoint) —
+// a degenerate touch that segmentsCross's proper-crossing test doesn't see.
+function pointOnSegment(p, a, b) {
+  const cross = (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+  if (Math.abs(cross) > OFFSET_EPS) return false;
+  const dot = (p[0] - a[0]) * (b[0] - a[0]) + (p[1] - a[1]) * (b[1] - a[1]);
+  const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+  return dot > OFFSET_EPS && dot < lenSq - OFFSET_EPS;
+}
+
+// O(n²) simplicity test — trivial at profile point counts (tens to hundreds).
+function isSimplePolygon(pts) {
+  const n = pts.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (j === i + 1 || (i === 0 && j === n - 1)) continue;   // adjacent edges share a vertex
+      const [a, b] = [pts[i], pts[(i + 1) % n]], [c, d] = [pts[j], pts[(j + 1) % n]];
+      if (segmentsCross(a, b, c, d)) return false;
+      // A vertex landing exactly on a non-adjacent edge is also a self-touch —
+      // e.g. an inset waist pinching two opposite edges together.
+      if (pointOnSegment(a, c, d) || pointOnSegment(b, c, d) ||
+          pointOnSegment(c, a, b) || pointOnSegment(d, a, b)) return false;
+    }
+  }
+  return true;
+}
+
+// Intersection of two infinite lines given as point + unit direction; null if parallel.
+function lineIntersect(p, dp, q, dq) {
+  const denom = dp[0] * dq[1] - dp[1] * dq[0];
+  if (Math.abs(denom) < OFFSET_EPS) return null;
+  const t = ((q[0] - p[0]) * dq[1] - (q[1] - p[1]) * dq[0]) / denom;
+  return [p[0] + dp[0] * t, p[1] + dp[1] * t];
+}
+
+// Offset a profile by `delta` mm: positive grows material outward, negative
+// insets. `profile` is a CCW [[x,y],…] point list (either winding accepted,
+// output always CCW) or an {outer, holes} region — regions offset as material:
+// outer by +delta, holes by −delta, so a +0.2 clearance on a cut region loosens
+// the whole cut. Corners where the offset edges diverge fill per `corners`:
+// "round" (arc of radius |delta| about the original vertex, `segs` segments —
+// the true Minkowski clearance), "chamfer" (the arc's chord), or "sharp" (true
+// miter, falling back to chamfer past a miter length of 2·|delta|). Where
+// offset edges cross (reflex on outset, convex on inset) they trim to their
+// intersection regardless of style. Simple polygon in, simple polygon out:
+// a result that self-intersects or vanishes THROWS (greppable errors below)
+// rather than returning degenerate geometry — offsets that would split a
+// region (dumbbell insets) are out of scope. Pure and deterministic; usable in
+// derive() and build() alike. See AUTHORING-PARTS.md "Profiles & patterns".
+export function offsetPolygon(profile, delta, opts = {}) {
+  const { corners = "round", segs = 8 } = opts;
+  if (profile !== null && typeof profile === "object" && !Array.isArray(profile)) {
+    if (!Array.isArray(profile.outer)) throw new Error("offsetPolygon: profile must be a point list or {outer, holes}");
+    const region = { outer: offsetPolygon(profile.outer, delta, opts) };
+    if (profile.holes) region.holes = profile.holes.map((h) => offsetPolygon(h, -delta, opts));
+    return region;
+  }
+  if (!Array.isArray(profile)) throw new Error("offsetPolygon: profile must be a point list or {outer, holes}");
+  if (typeof delta !== "number" || !Number.isFinite(delta)) throw new Error("offsetPolygon: delta must be a finite number");
+  if (corners !== "round" && corners !== "chamfer" && corners !== "sharp")
+    throw new Error('offsetPolygon: corners must be "round" | "chamfer" | "sharp"');
+  for (const p of profile)
+    if (!Array.isArray(p) || !Number.isFinite(p[0]) || !Number.isFinite(p[1]))
+      throw new Error("offsetPolygon: coordinates must be finite numbers");
+
+  const pts = dedupePoints(profile);
+  if (pts.length < 3) throw new Error("offsetPolygon: need at least 3 points");
+  if (polySignedArea(pts) < 0) pts.reverse();                     // work in CCW
+  if (!isSimplePolygon(pts)) throw new Error("offsetPolygon: input polygon self-intersects");
+  if (delta === 0) return pts;
+
+  // Each edge i (pts[i] → pts[i+1]): unit direction and endpoints displaced
+  // along the outward normal (CCW ⇒ outward = (dy, −dx)).
+  const n = pts.length, dir = [], off = [];
+  for (let i = 0; i < n; i++) {
+    const p = pts[i], q = pts[(i + 1) % n];
+    const len = Math.hypot(q[0] - p[0], q[1] - p[1]);
+    const d = [(q[0] - p[0]) / len, (q[1] - p[1]) / len];
+    const mx = d[1] * delta, my = -d[0] * delta;
+    dir.push(d);
+    off.push([[p[0] + mx, p[1] + my], [q[0] + mx, q[1] + my]]);
+  }
+
+  // Join edge (i−1)'s offset to edge i's offset at each original vertex. Also
+  // track each edge's start/end parameter along its own direction: a heavily
+  // over-inset edge can be trimmed from both ends past its own start and still
+  // trace out a simple-looking (but phantom, reflected) loop — isSimplePolygon
+  // only catches crossing segments, not a reversed edge, so that case needs
+  // this separate check below.
+  const out = [];
+  const tStart = new Array(n), tEnd = new Array(n);
+  const paramOf = (i, p) => (p[0] - off[i][0][0]) * dir[i][0] + (p[1] - off[i][0][1]) * dir[i][1];
+  const join = (prev, i, point) => {
+    out.push(point);
+    tEnd[prev] = paramOf(prev, point);
+    tStart[i] = paramOf(i, point);
+  };
+  for (let i = 0; i < n; i++) {
+    const prev = (i + n - 1) % n, V = pts[i];
+    const endPrev = off[prev][1], startNext = off[i][0];
+    const cross = dir[prev][0] * dir[i][1] - dir[prev][1] * dir[i][0];
+
+    if (Math.abs(cross) < OFFSET_EPS) { join(prev, i, endPrev); continue; }   // straight vertex
+
+    if (cross * delta < 0) {                                             // offset edges cross → trim
+      const m = lineIntersect(off[prev][0], dir[prev], off[i][0], dir[i]);
+      join(prev, i, m ?? endPrev);
+      continue;
+    }
+
+    // Offset edges diverge → fill the wedge per style.
+    if (corners === "sharp") {
+      const m = lineIntersect(off[prev][0], dir[prev], off[i][0], dir[i]);
+      if (m && Math.hypot(m[0] - V[0], m[1] - V[1]) <= 2 * Math.abs(delta)) { join(prev, i, m); continue; }
+      out.push(endPrev, startNext);                                      // past the miter limit → chamfer
+      tEnd[prev] = paramOf(prev, endPrev); tStart[i] = paramOf(i, startNext);
+    } else if (corners === "chamfer") {
+      out.push(endPrev, startNext);
+      tEnd[prev] = paramOf(prev, endPrev); tStart[i] = paramOf(i, startNext);
+    } else {                                                             // round: short arc about V
+      tEnd[prev] = paramOf(prev, endPrev); tStart[i] = paramOf(i, startNext);
+      const a0 = Math.atan2(endPrev[1] - V[1], endPrev[0] - V[0]);
+      let dA = Math.atan2(startNext[1] - V[1], startNext[0] - V[0]) - a0;
+      while (dA <= -Math.PI) dA += 2 * Math.PI;
+      while (dA > Math.PI) dA -= 2 * Math.PI;
+      const r = Math.abs(delta);
+      for (let s = 0; s <= segs; s++) {
+        const a = a0 + (dA * s) / segs;
+        out.push([V[0] + r * Math.cos(a), V[1] + r * Math.sin(a)]);
+      }
+    }
+  }
+
+  for (let i = 0; i < n; i++)
+    if (tEnd[i] < tStart[i] - OFFSET_EPS) throw new Error("offsetPolygon: offset collapses the polygon");
+
+  const cleaned = dedupePoints(out);
+  if (cleaned.length < 3 || polySignedArea(cleaned) <= OFFSET_EPS)
+    throw new Error("offsetPolygon: offset collapses the polygon");
+  if (!isSimplePolygon(cleaned))
+    throw new Error("offsetPolygon: offset result self-intersects (reduce |delta| or simplify the profile)");
+  return cleaned;
+}

package/src/framework/geometry/profile.js

@@ -1,23 +1,37 @@
 // Backend-shared 2-D region normalization + tessellation for extrude()/prism(). A contour
-// is EITHER a bare points array (legacy, all straight edges) OR a canonical ArcContour
-// { start:[x,y], segments:[{to}|{to,via}], arc:true } carrying true circular arcs (from
-// roundedProfile). normalizeProfile validates the polymorphic { outer, holes } envelope
-// (bare array = outer only), preserving each contour's shape; tessellateProfile turns the
-// arcs into point rings for the Manifold (mesh) path. The OCCT path consumes the same
-// ArcContour directly (contourDrawing → threePointsArcTo) for true CIRCLE B-rep edges.
-// Legacy point-array contours take the exact former path byte-for-byte — no cache-busting.
+// is EITHER a bare points array (legacy, all straight edges) OR a canonical path contour
+// { start:[x,y], segments:[{to}|{to,via}|{to,c1,c2}] } carrying true circular arcs ({to,via},
+// from roundedProfile) and/or cubic Béziers ({to,c1,c2}, from pathProfile). normalizeProfile
+// validates the polymorphic { outer, holes } envelope (bare array = outer only), preserving
+// each contour's shape; tessellateProfile turns arcs/cubics into point rings for the Manifold
+// (mesh) path at the mesh LOD. The OCCT path consumes the same contour directly (contourDrawing
+// → threePointsArcTo / cubicBezierCurveTo) for true CIRCLE / B-spline B-rep edges. Legacy
+// point-array contours take the exact former path byte-for-byte — no cache-busting.
 
 // An ArcContour is a non-array object carrying arcs symbolically.
 export function isArcContour(c) {
   return !!c && typeof c === "object" && !Array.isArray(c) && (c.arc === true || Array.isArray(c.segments));
 }
 
+// Curves generalize arcs; the symbolic-form predicate is the same. Prefer this name.
+export const isPathContour = isArcContour;
+
 function validateContour(c, role) {
   if (isArcContour(c)) {
     if (!Array.isArray(c.start) || c.start.length < 2)
       throw new Error(`extrude: ${role} arc contour needs a start [x,y]`);
     if (!Array.isArray(c.segments) || c.segments.length < 1)
       throw new Error(`extrude: ${role} arc contour needs ≥1 segment`);
+    for (const s of c.segments) {
+      const hasCubic = s.c1 != null || s.c2 != null;
+      if (hasCubic) {
+        if (s.via != null)
+          throw new Error(`extrude: ${role} segment cannot mix arc (via) and cubic (c1/c2)`);
+        const ok = (p) => Array.isArray(p) && p.length >= 2 && Number.isFinite(p[0]) && Number.isFinite(p[1]);
+        if (!ok(s.c1) || !ok(s.c2))
+          throw new Error(`extrude: ${role} cubic segment needs c1 and c2 as finite [x,y]`);
+      }
+    }
     return;
   }
   if (!Array.isArray(c) || c.length < 3) throw new Error(`extrude: ${role} needs ≥3 points`);
@@ -73,15 +87,50 @@ export function sampleArc(p0, via, p1, segs) {
   return out;
 }
 
+// Flatten the cubic Bézier (p0,c1,c2,p1) into points p1…pN — EXCLUDING the start
+// p0 (the ring already holds it), last point pinned exactly to p1. Adaptive: split
+// at t=½ (de Casteljau) until the control polygon's total unsigned turn is ≤ 2π/segs
+// — the exact generalization of sampleArc's "a point every 2π/segs of sweep", so a
+// cubic tracing a circular arc facets like the arc primitive at the same segs. Summing
+// |turn| at BOTH interior control points also catches S-curves a pure endpoint-tangent
+// test would miss. Depth cap guarantees termination. Pure in (args, segs).
+export function sampleBezier(p0, c1, c2, p1, segs) {
+  const maxTurn = (2 * Math.PI) / Math.max(3, segs);
+  const out = [];
+  const mid = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+  const turn = (u, v) => {
+    const du = Math.hypot(u[0], u[1]), dv = Math.hypot(v[0], v[1]);
+    if (du < 1e-12 || dv < 1e-12) return 0;
+    let c = (u[0] * v[0] + u[1] * v[1]) / (du * dv);
+    if (c > 1) c = 1; else if (c < -1) c = -1;
+    return Math.acos(c);
+  };
+  const recurse = (a, b, c, d, depth) => {
+    const ab = [b[0] - a[0], b[1] - a[1]];
+    const bc = [c[0] - b[0], c[1] - b[1]];
+    const cd = [d[0] - c[0], d[1] - c[1]];
+    if (depth >= 12 || turn(ab, bc) + turn(bc, cd) <= maxTurn) { out.push([d[0], d[1]]); return; }
+    const p01 = mid(a, b), p12 = mid(b, c), p23 = mid(c, d);
+    const p012 = mid(p01, p12), p123 = mid(p12, p23), m = mid(p012, p123);
+    recurse(a, p01, p012, m, depth + 1);
+    recurse(m, p123, p23, d, depth + 1);
+  };
+  recurse(p0, c1, c2, p1, 0);
+  if (out.length === 0) out.push([p1[0], p1[1]]);
+  out[out.length - 1] = [p1[0], p1[1]];   // pin the exact endpoint
+  return out;
+}
+
 // Tessellate a single contour into a CCW point ring. A legacy array is returned unchanged
-// (identical to the former path); an ArcContour is walked start→segment→segment, lines
-// pushing their `to` and arcs pushing their sampled points.
+// (identical to the former path); a path contour is walked start→segment→segment, lines
+// pushing their `to`, arcs and cubics pushing their sampled points (sampleArc/sampleBezier).
 export function tessellateContour(contour, segs) {
   if (Array.isArray(contour)) return contour;
   const ring = [[contour.start[0], contour.start[1]]];
   let prev = contour.start;
   for (const seg of contour.segments) {
-    if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) ring.push(p);
+    if (seg.c1) for (const p of sampleBezier(prev, seg.c1, seg.c2, seg.to, segs)) ring.push(p);
+    else if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) ring.push(p);
     else ring.push([seg.to[0], seg.to[1]]);
     prev = seg.to;
   }

package/src/parts/planter.js

@@ -9,6 +9,8 @@
 // pens, the drainage hole is a real functional choice (planter vs. cup), and dropping
 // Wall below the fdm-pla 1.2 mm minimum trips partforge's min-wall warning.
 
+import { offsetPolygon } from "partforge/geometry";
+
 // A regular n-gon of circumradius R, in the XY plane, as [[x,y],…] for k.prism.
 // A small rotation seats a flat edge toward the viewer so even-sided shapes read right.
 const ngon = (R, n) => {
@@ -69,14 +71,18 @@ export default {
   // build needs, sized so the wall stays even (see build()).
   derive: (p) => {
     const Rout = p.dia / 2;
-    // Offset the inner polygon inward by `wall` along the FACE normals, not the radius:
-    // for a regular n-gon an edge offset of `wall` shrinks the circumradius by
-    // wall / cos(π/n). This keeps the perpendicular wall = `wall` on every flat.
-    // clamp only matters if wall is set past the slider bounds via the API
-    const Rin = Math.max(Rout - p.wall / Math.cos(Math.PI / p.facets), 1);
+    // Inset the outer polygon inward by `wall` along the FACE normals via
+    // offsetPolygon (sharp corners keep the n-gon exact — see the closed-form
+    // pin in test/offset-polygon.test.js). Cap the wall so the inset can never
+    // collapse below circumradius 1 — same clamp as the old closed form (only
+    // matters if wall is set past the slider bounds via the API).
+    const wall = Math.min(p.wall, (Rout - 1) * Math.cos(Math.PI / p.facets));
+    const outerPts = ngon(Rout, p.facets);
+    const innerPts = offsetPolygon(outerPts, -wall, { corners: "sharp" });
+    const Rin = Math.hypot(innerPts[0][0], innerPts[0][1]);   // read back from the geometry
     return {
-      outerPts: ngon(Rout, p.facets),
-      innerPts: ngon(Rin, p.facets),
+      outerPts,
+      innerPts,
       // Inner taper that holds the wall constant top-to-bottom even as the body flares:
       // pick it so inner_radius(top) = outer_radius(top) − wall.
       innerTaper: 1 + (Rout * (p.taper - 1)) / Rin,