forgecad 0.6.3 → 0.7.0

package/examples/api/highlight-debug.forge.js

@@ -29,4 +29,8 @@ highlight(b.edge('top-right'), { color: 'blue', label: 'top-right edge' });
 // Shape highlight — transparent colored overlay on the entire shape
 highlight(b, { color: '#ff00ff' });
 
+// Intermediary shape highlight — snapshot a temporary shape that is not returned
+const temporary = b.translate(40, 0, 0);
+highlight(temporary, { color: '#00ffff', label: 'temporary snapshot' });
+
 return b;

package/examples/api/js-module-pillars.js

@@ -16,7 +16,7 @@ export default class PillarPair {
   }
 
   build() {
-    const pillar = box(6, 6, this.height, true);
+    const pillar = box(6, 6, this.height);
     return union(
       pillar.translate(-this.spacing / 2, 0, this.height / 2),
       pillar.translate(this.spacing / 2, 0, this.height / 2),

package/examples/api/js-module-scene.js

@@ -2,8 +2,8 @@ import { box, union } from "forgecad";
 import PillarPair, { capHeight } from "./js-module-pillars.js";
 
 export function buildAssembly() {
-  const base = box(40, 18, 4, true);
+  const base = box(40, 18, 4);
   const pillars = new PillarPair(24, 12).build().translate(0, 0, 2);
-  const cap = box(14, 18, capHeight, true).translate(0, 0, 17);
+  const cap = box(14, 18, capHeight).translate(0, 0, 17);
   return union(base, pillars, cap).color("#d6a86a");
 }

package/examples/api/mesh-import-slats.forge.js

@@ -19,7 +19,7 @@ const slats = [];
 for (let i = 0; i < slatCount; i++) {
   const y = center[1] - (slatCount - 1) * pitch / 2 + i * pitch;
   slats.push(
-    box(size[0] + 10, slatThickness, size[2] + 10, true)
+    box(size[0] + 10, slatThickness, size[2] + 10)
       .translate(center[0], y, center[2])
   );
 }

package/examples/api/pointAlong-orientation.forge.js

@@ -1,7 +1,7 @@
 // pointAlong() — orient a cylinder's axis without thinking about Euler angles.
 //
 // Cylinders default to Z-up. To lay one along X or Y:
-//   ❌ cylinder(80, 5).rotate(90, 0, 0)   — which axis? confusing
+//   ❌ cylinder(80, 5).rotateX(90)         — works, but less readable
 //   ✅ cylinder(80, 5).pointAlong([0, 1, 0]) — "point along Y"
 //
 // After pointAlong, the cylinder starts at origin and extends in that direction.

package/examples/api/profile-2020-b-slot6.forge.js

@@ -16,7 +16,6 @@ const profile2d = lib.profile2020BSlot6Profile({
 });
 
 const extrusion = lib.profile2020BSlot6(length, {
-  center: true,
   slotDepth,
   slotInnerWidth: slotInner,
   centerBoreDia: centerBore,

package/examples/api/route-perimeter-flange.forge.js

@@ -29,7 +29,7 @@ let body = constrainedSketch()
 // Subtract center bore
 body = body.subtract(circle2d(R_CORE_IN))
 
-const solidCutRectangle = rect(200, 8, true);
+const solidCutRectangle = rect(200, 8);
 const solidRing = circle2d(R_CORE)
   .subtract(circle2d(R_CORE_IN))
   .subtract(solidCutRectangle)

package/examples/api/sdf-rover-demo.forge.js

@@ -26,33 +26,33 @@ const wheelbase = 250;
 const groundClearance = 26;
 const bodyZ = wheelRadius + groundClearance + chassisHeight * 0.5;
 
-const baseDeck = box(chassisLength, chassisWidth, chassisHeight, true)
+const baseDeck = box(chassisLength, chassisWidth, chassisHeight)
   .translate(0, 0, bodyZ);
 
-const roofPod = box(roofLength, roofWidth, roofHeight, true)
+const roofPod = box(roofLength, roofWidth, roofHeight)
   .translate(20, 0, bodyZ + 40);
 
 const bumper = union(
-  box(54, bumperWidth, bumperDepth, true).translate(chassisLength * 0.5 - 18, 0, wheelRadius + 6),
-  box(bumperLength, bumperWidth - 42, bumperDepth * 0.7, true).translate(chassisLength * 0.5 + 46, 0, wheelRadius - 10),
+  box(54, bumperWidth, bumperDepth).translate(chassisLength * 0.5 - 18, 0, wheelRadius + 6),
+  box(bumperLength, bumperWidth - 42, bumperDepth * 0.7).translate(chassisLength * 0.5 + 46, 0, wheelRadius - 10),
 ).color('#c8742b');
 
 const sensorMast = union(
-  cylinder(92, 10, undefined, 40, true).translate(58, 0, bodyZ + 78),
-  box(78, 34, 26, true).translate(88, 0, bodyZ + 126),
+  cylinder(92, 10, undefined, 40).translate(58, 0, bodyZ + 78),
+  box(78, 34, 26).translate(88, 0, bodyZ + 126),
 ).color('#d7dee8');
 
 const chassis = union(baseDeck, roofPod)
   .color('#60707d');
 
 const wheelTire = difference(
-  cylinder(wheelWidth, wheelRadius, undefined, 64, true).pointAlong([0, 1, 0]),
-  cylinder(wheelWidth + 2, wheelRadius * 0.56, undefined, 48, true).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth, wheelRadius, undefined, 64).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth + 2, wheelRadius * 0.56, undefined, 48).pointAlong([0, 1, 0]),
 ).color('#1d2329');
 
 const wheelRim = union(
-  cylinder(wheelWidth * 0.86, wheelRadius * 0.52, undefined, 40, true).pointAlong([0, 1, 0]),
-  cylinder(wheelWidth * 1.02, wheelRadius * 0.16, undefined, 28, true).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth * 0.86, wheelRadius * 0.52, undefined, 40).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth * 1.02, wheelRadius * 0.16, undefined, 28).pointAlong([0, 1, 0]),
 ).color('#b8c5d3');
 
 const wheel = group(

package/examples/api/sketch-on-face-demo.forge.js

@@ -8,7 +8,7 @@
 const W = 80, D = 50, H = 30;
 
 // ── Base enclosure ────────────────────────────────────────────────────────────
-const body = roundedRect(W, D, 4, true)
+const body = roundedRect(W, D, 4)
   .extrude(H)
   .color('#c8cdd6');
 
@@ -41,7 +41,7 @@ const vents = ribSketch
   .color('#1a1a2e');
 
 // ── Badge recess on the front face ────────────────────────────────────────────
-const badge = roundedRect(36, 12, 2, true)
+const badge = roundedRect(36, 12, 2)
   .onFace(body, 'front', { v: 4, protrude: 0.05 })
   .extrude(1.5)
   .color('#2563eb');

package/examples/api/sketch-regions.forge.js

@@ -22,8 +22,8 @@
 // A "T" cross-section: wide base + narrow stem. The boolean creates one
 // connected region; we pick it with the regions() API.
 
-const base = rect(120, 20, true);                   // centered at origin
-const stem = rect(30, 50, true).translate(0, 35);   // stem centered above base
+const base = rect(120, 20);                   // centered at origin
+const stem = rect(30, 50).translate(0, 35);   // stem centered above base
 const tShape = base.add(stem);
 const [tRegion] = tShape.regions();                  // one connected T region
 const tPart = tRegion.extrude(6);                    // extrude the T profile
@@ -32,8 +32,8 @@ const tPart = tRegion.extrude(6);                    // extrude the T profile
 // A 100×40 plate with a 60×20 hole punched in the center, leaving a frame.
 // Pick the frame ring as one region using a corner seed.
 
-const plate = rect(100, 40, true);                   // centered at origin
-const hole  = rect(60, 20, true);                    // centered cutout
+const plate = rect(100, 40);                   // centered at origin
+const hole  = rect(60, 20);                    // centered cutout
 const frame = plate.subtract(hole);
 
 // The seed [45, 15] is in the top-right corner — inside the frame wall, outside the hole.

package/examples/api/transition-curves.forge.js

@@ -9,7 +9,7 @@ const radius = param("Tube Radius", 1.5, { min: 0.3, max: 5, unit: "mm" });
 // Small anchor block at a point (visual reference for where the tube connects)
 function anchor(pos) {
   const s = 3;
-  return box(s, s, s, true).translate(pos[0], pos[1], pos[2]);
+  return box(s, s, s).translate(pos[0], pos[1], pos[2]);
 }
 
 // ── 1. L-bend: 90-degree pipe turn ──────────────────────────────

package/examples/api/variable-sweep-pure-sdf-test.forge.js

@@ -0,0 +1,162 @@
+// Pure-SDF reference for the variableSweep taper test.
+// If this renders with clean sidewalls while variable-sweep-test.forge.js does not,
+// the artifact is in variableSweep()'s spine field construction rather than the
+// shared SDF meshing pipeline.
+
+const controlPoints = [
+  [0, 0, 0],
+  [20, 0, 10],
+  [40, 10, 20],
+  [60, 10, 30],
+];
+
+const spine = spline3d(controlPoints, { tension: 0.4 });
+const pathPoints = spine.sample(160);
+
+const cumulativeLengths = [0];
+for (let index = 1; index < pathPoints.length; index += 1) {
+  const [ax, ay, az] = pathPoints[index - 1];
+  const [bx, by, bz] = pathPoints[index];
+  cumulativeLengths.push(
+    cumulativeLengths[cumulativeLengths.length - 1] + Math.hypot(bx - ax, by - ay, bz - az),
+  );
+}
+const totalLength = cumulativeLengths[cumulativeLengths.length - 1];
+
+const smallRadius = 3;
+const largeRadius = 8;
+const maxRadius = largeRadius;
+const pad = maxRadius + 4;
+
+let minX = Infinity;
+let minY = Infinity;
+let minZ = Infinity;
+let maxX = -Infinity;
+let maxY = -Infinity;
+let maxZ = -Infinity;
+for (const [x, y, z] of pathPoints) {
+  minX = Math.min(minX, x);
+  minY = Math.min(minY, y);
+  minZ = Math.min(minZ, z);
+  maxX = Math.max(maxX, x);
+  maxY = Math.max(maxY, y);
+  maxZ = Math.max(maxZ, z);
+}
+
+const embeddedPath = JSON.stringify(pathPoints);
+const embeddedArc = JSON.stringify(cumulativeLengths);
+
+const pureSweepSdf = new Function(`
+  return (x, y, z) => (() => {
+    const pts = ${embeddedPath};
+    const arc = ${embeddedArc};
+    const totalLength = ${totalLength};
+    const smallRadius = ${smallRadius};
+    const largeRadius = ${largeRadius};
+
+    function clamp(v, lo, hi) {
+      return Math.max(lo, Math.min(hi, v));
+    }
+
+    function catmullScalar(p0, p1, p2, p3, t0, t1, t2, t3, t) {
+      const dt = Math.max(t2 - t1, 1e-9);
+      const local = clamp((t - t1) / dt, 0, 1);
+      const tt = local * local;
+      const ttt = tt * local;
+      const m1 = (p2 - p0) / Math.max(t2 - t0, 1e-9);
+      const m2 = (p3 - p1) / Math.max(t3 - t1, 1e-9);
+      const h00 = 2 * ttt - 3 * tt + 1;
+      const h10 = ttt - 2 * tt + local;
+      const h01 = -2 * ttt + 3 * tt;
+      const h11 = ttt - tt;
+      return h00 * p1 + h10 * dt * m1 + h01 * p2 + h11 * dt * m2;
+    }
+
+    function radiusAt(t) {
+      const tc = clamp(t, 0, 1);
+      if (tc <= 0) return smallRadius;
+      if (tc >= 1) return smallRadius;
+      if (tc <= 0.5) return catmullScalar(smallRadius, smallRadius, largeRadius, smallRadius, -0.5, 0, 0.5, 1, tc);
+      return catmullScalar(smallRadius, largeRadius, smallRadius, smallRadius, 0, 0.5, 1, 1.5, tc);
+    }
+
+    let bestDist2 = Infinity;
+    let bestIndex = 0;
+    let bestSegmentT = 0;
+    let bestPoint = pts[0];
+
+    for (let index = 0; index < pts.length - 1; index += 1) {
+      const a = pts[index];
+      const b = pts[index + 1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len2 = dx * dx + dy * dy + dz * dz;
+      if (len2 < 1e-12) continue;
+
+      const px = x - a[0];
+      const py = y - a[1];
+      const pz = z - a[2];
+      const segT = clamp((px * dx + py * dy + pz * dz) / len2, 0, 1);
+      const qx = a[0] + dx * segT;
+      const qy = a[1] + dy * segT;
+      const qz = a[2] + dz * segT;
+      const rx = x - qx;
+      const ry = y - qy;
+      const rz = z - qz;
+      const dist2 = rx * rx + ry * ry + rz * rz;
+
+      if (dist2 < bestDist2) {
+        bestDist2 = dist2;
+        bestIndex = index;
+        bestSegmentT = segT;
+        bestPoint = [qx, qy, qz];
+      }
+    }
+
+    const radiusT = (arc[bestIndex] + (arc[bestIndex + 1] - arc[bestIndex]) * bestSegmentT) / Math.max(totalLength, 1e-9);
+    let sdfValue = Math.sqrt(bestDist2) - radiusAt(radiusT);
+
+    if (bestIndex === 0 && bestSegmentT <= 1e-6) {
+      const a = pts[0];
+      const b = pts[1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (len > 1e-9) {
+        const tx = dx / len;
+        const ty = dy / len;
+        const tz = dz / len;
+        const startCap = -((x - a[0]) * tx + (y - a[1]) * ty + (z - a[2]) * tz);
+        sdfValue = Math.max(sdfValue, startCap);
+      }
+    } else if (bestIndex === pts.length - 2 && bestSegmentT >= 1 - 1e-6) {
+      const a = pts[pts.length - 2];
+      const b = pts[pts.length - 1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (len > 1e-9) {
+        const tx = dx / len;
+        const ty = dy / len;
+        const tz = dz / len;
+        const endCap = (x - b[0]) * tx + (y - b[1]) * ty + (z - b[2]) * tz;
+        sdfValue = Math.max(sdfValue, endCap);
+      }
+    }
+
+    return sdfValue;
+  })();
+`)();
+
+const tapered = sdf.fromFunction(
+  pureSweepSdf,
+  {
+    min: [minX - pad, minY - pad, minZ - pad],
+    max: [maxX + pad, maxY + pad, maxZ + pad],
+  },
+).toShape({ edgeLength: 0.8 });
+
+return tapered.color('#8899aa');

package/examples/api/variable-sweep-test.forge.js

@@ -8,8 +8,8 @@ const spine = spline3d([
   [60, 10, 30],
 ], { tension: 0.4 });
 
-const smallCircle = circle2d(3, 24);
-const largeCircle = circle2d(8, 24);
+const smallCircle = circle2d(3);
+const largeCircle = circle2d(8);
 
 const tapered = variableSweep(spine, [
   { t: 0.0, profile: smallCircle },

package/examples/api/wood-joinery.forge.js

@@ -0,0 +1,60 @@
+// Wood Joinery — dado, rabbet, mortise & tenon
+// Demonstrates joint cuts and assembled positioning.
+
+const t = 18; // stock thickness
+
+// ─── BOOKCASE CORNER ───────────────────────────────────────────
+// Side panel lies flat: width=250 (X, depth), height=400 (Y, vertical), thickness=18 (Z, face)
+const side = Wood.board(250, 400, t, { species: 'birch' });
+const shelf = Wood.board(250, 300, t, { species: 'birch' });
+
+// Dado: channel across the face of side for shelf to sit in
+Wood.dado(side, shelf, { fromBottom: 150 });
+
+// Rabbet: step on the back face for a back panel
+Wood.rabbet(side, { edge: 'back', width: 6, depth: 9 });
+
+// Assemble the bookcase corner:
+// Side panel stands upright — rotate so Y (400mm) becomes vertical (Z)
+const sideAssembled = side.shape.rotateX(90).color('#c4956a');
+
+// Shelf sits in the dado channel
+// After side.rotateX(90): side is in XZ plane, dado channel is at Z = -200 + 150 + 9 = -41
+// Shelf needs its 18mm thickness edge in the dado
+const shelfAssembled = shelf.shape
+  .rotateX(90)        // stand upright
+  .rotateZ(90)        // perpendicular to side
+  .translate(0, t, -200 + 150 + t / 2)
+  .color('#b8864e');
+
+// ─── TABLE JOINT: MORTISE & TENON ──────────────────────────────
+// Leg: width=45 (X), height=400 (Y, vertical), thickness=45 (Z, face for mortise)
+// The mortise cuts into Z (45mm face), positioned along Y (400mm height)
+const leg = Wood.board(45, 400, 45, { species: 'oak' });
+const apron = Wood.board(300, 80, 20, { species: 'oak' });
+
+Wood.mortiseAndTenon(leg, apron, {
+  style: 'blind',
+  position: { fromTop: 25 },
+  cornerRadius: 4,
+});
+
+// Tenon defaults: thickness = 20/3 ≈ 6.7mm, width = min(48, 320) = 48mm, length = 45*2/3 = 30mm
+
+// Assemble: leg stands on its Y-axis (already vertical), apron connects to face
+const legAssembled = leg.shape
+  .translate(500, 0, 0)
+  .color('#a07040');
+
+// Apron: tenon protrudes from +X end. Rotate so it points into the leg's Z-face.
+const apronAssembled = apron.shape
+  .rotateY(90)                        // tenon now points +Z (into leg face)
+  .translate(500, 200 - 25 - 24, 45)  // align with mortise position on leg
+  .color('#8b6030');
+
+return [
+  { name: 'Side (dado + rabbet)', shape: sideAssembled },
+  { name: 'Shelf', shape: shelfAssembled },
+  { name: 'Leg (mortise)', shape: legAssembled },
+  { name: 'Apron (tenon)', shape: apronAssembled },
+];

package/examples/compiler-corpus/enclosure-shell-cuts.forge.js

@@ -1,9 +1,9 @@
 // Guard part: shell + face-driven cuts + mirrored feet in one ordinary enclosure workflow.
 
-const base = roundedRect(120, 80, 10, true).extrude(36);
+const base = roundedRect(120, 80, 10).extrude(36);
 const shell = base.shell(3, { openFaces: ['top'] });
 
-const displayCut = roundedRect(34, 18, 3, true)
+const displayCut = roundedRect(34, 18, 3)
   .onFace(base, 'front', { u: 0, v: 8, protrude: 0.25, selfAnchor: 'center' })
   .extrude(10);
 
@@ -11,7 +11,7 @@ const cableCut = circle2d(7)
   .onFace(base, 'right', { u: -12, v: -8, protrude: 0.25, selfAnchor: 'center' })
   .extrude(10);
 
-const foot = roundedRect(18, 18, 4, true)
+const foot = roundedRect(18, 18, 4)
   .onFace(base, 'bottom', { u: 36, v: 20, protrude: 0, selfAnchor: 'center' })
   .extrude(6);
 

package/examples/compiler-corpus/fastener-plate-variants.forge.js

@@ -1,11 +1,11 @@
 // Guard part: counterbore/countersink hole variants plus an up-to-face service pocket in one ordinary plate workflow.
 
-const plate = roundedRect(118, 76, 8, true).extrude(18);
+const plate = roundedRect(118, 76, 8).extrude(18);
 const entryFace = plate.face('top');
 const exitFace = plate.face('bottom');
 const pocketExitFace = plate.face('side-top');
 
-const servicePocket = roundedRect(34, 18, 4, true)
+const servicePocket = roundedRect(34, 18, 4)
   .onFace(plate, 'front', { u: 0, v: -2, selfAnchor: 'center' });
 
 const fastenerPlate = plate

package/examples/experiments/drone-arm.forge.js

@@ -0,0 +1,53 @@
+// Smooth drone arm: flat rectangular mount → organic taper → circular motor mount
+// Tests: cross-section morphing, S-curve sweep, shell, G2 transitions
+
+// --- Spine: gentle S-curve from origin to motor mount ---
+const armLength = 120;
+const spine = spline3d([
+  [0, 0, 0],
+  [armLength * 0.3, 0, 8],
+  [armLength * 0.7, 0, -5],
+  [armLength, 0, 3],
+], { tension: 0.3 });
+
+// --- Cross-sections ---
+
+// Mount end: flat rectangle with rounded corners
+const mountProfile = roundedRect(20, 6, 1.5);
+
+// Mid-section: transitional rounded rectangle
+const midProfile = roundedRect(14, 10, 4);
+
+// Motor end: circle
+const motorProfile = circle2d(8);
+
+// --- Variable sweep: morph between profiles along spine ---
+const solidArm = variableSweep(spine, [
+  { t: 0, profile: mountProfile },
+  { t: 0.4, profile: midProfile },
+  { t: 1, profile: motorProfile },
+], { edgeLength: 1.5 });
+
+// --- Hollow it out ---
+const arm = solidArm.shell(1.5);
+
+// --- Mounting holes at the flat end ---
+const mountHole = cylinder(10, 2).translate(0, 0, -5);
+const mountHoles = union(
+  mountHole.translate(-6, 0, 0),
+  mountHole.translate(6, 0, 0),
+);
+
+// --- Motor mount ring at the far end ---
+// Place at the end of the spine
+const motorRing = difference(
+  cylinder(4, 10),
+  cylinder(4, 7),
+).translate(armLength, 0, 3);
+
+const result = difference(
+  union(arm, motorRing),
+  mountHoles,
+);
+
+return result;

package/examples/furniture/adjustable-table.forge.js

@@ -75,7 +75,7 @@ for (const [lx, ly] of legPositions) {
       // Through-hole in Y direction
       pinHoles.push(
         cylinder(outerLeg + 2, pinHoleR)
-          .rotateAround([0, 0, 0], 90, 0, 0)
+          .rotateX(90)
           .translate(legCenterX, ly - 1, pz)
       );
     }
@@ -105,7 +105,7 @@ const shaftY = inset + outerLeg / 2;
 const shaftZ = legH - outerLegH + 25;
 const shaftLen = topW - 2 * inset;
 const shaft = cylinder(shaftLen, 0.8)
-  .rotateAround([0, 0, 0], 0, 90, 0)
+  .rotateY(90)
   .translate(inset, shaftY, shaftZ);
 
 // Crank handle (on the right side)

package/examples/furniture/bathroom.forge.js

@@ -51,7 +51,7 @@ const armLen = 250;
 const showerArmX = tubX + tubL * 0.6;
 const showerArmZ = wallT + glassH - 150;
 const showerArm = cylinder(armLen, 12)
-  .rotateAround([0, 0, 0], 90, 0, 0)
+  .rotateX(90)
   .translate(showerArmX, roomD - wallT, showerArmZ);
 
 // Shower head — disc at end of arm
@@ -83,11 +83,11 @@ const bowl = bowlOuter.subtract(bowlInner)
 const tankW = toiletW * 0.85;
 const tankD = 150;
 const tankH = 320;
-const tank = box(tankW, tankD, tankH, true)
+const tank = box(tankW, tankD, tankH)
   .translate(toiletCX, toiletY + toiletD - tankD / 2 - 10, wallT + toiletH / 2 + tankH / 2 - 80);
 
 // Lid — flat slab on top of tank
-const lid = box(tankW + 10, tankD + 10, 15, true)
+const lid = box(tankW + 10, tankD + 10, 15)
   .translate(toiletCX, toiletY + toiletD - tankD / 2 - 10, wallT + toiletH / 2 + tankH - 80 + 7);
 
 // Seat — flat ring on top of bowl
@@ -109,14 +109,14 @@ const sinkZ = 850;
 const sinkCX = roomW - wallT - sinkD / 2 - 30;
 const sinkCY = roomD * 0.35;
 
-const basinOuter = box(sinkD, sinkW, sinkH, true);
-const basinInner = box(sinkD - 50, sinkW - 50, sinkH - 25, true).translate(0, 0, 12);
+const basinOuter = box(sinkD, sinkW, sinkH);
+const basinInner = box(sinkD - 50, sinkW - 50, sinkH - 25).translate(0, 0, 12);
 const drain = cylinder(27, 18).translate(0, 0, -sinkH / 2);
 const basin = basinOuter.subtract(basinInner).subtract(drain)
   .translate(sinkCX, sinkCY, wallT + sinkZ + sinkH / 2);
 
 // Pedestal
-const pedestal = box(80, 80, sinkZ, true)
+const pedestal = box(80, 80, sinkZ)
   .translate(sinkCX, sinkCY, wallT + sinkZ / 2);
 
 // Faucet — vertical stem + curved spout
@@ -124,12 +124,12 @@ const faucetX = sinkCX + sinkD / 2 - 40;
 const faucetZ = wallT + sinkZ + sinkH;
 const faucetStem = cylinder(100, 10)
   .translate(faucetX, sinkCY, faucetZ);
-const faucetSpout = box(80, 16, 16, true)
+const faucetSpout = box(80, 16, 16)
   .translate(faucetX - 40, sinkCY, faucetZ + 100);
 // Handles
-const handleL = box(30, 8, 8, true)
+const handleL = box(30, 8, 8)
   .translate(faucetX, sinkCY - 30, faucetZ + 50);
-const handleR = box(30, 8, 8, true)
+const handleR = box(30, 8, 8)
   .translate(faucetX, sinkCY + 30, faucetZ + 50);
 
 const sink = union(basin, pedestal, faucetStem, faucetSpout, handleL, handleR);
@@ -167,7 +167,7 @@ const bracketL = box(70, bracketSize, bracketSize)
 const bracketR = box(70, bracketSize, bracketSize)
   .translate(wallT, rackY + rackLen / 2 - bracketSize, wallT + rackZ);
 const towelBar = cylinder(rackLen - bracketSize * 2, barR)
-  .rotateAround([0, 0, 0], -90, 0, 0)
+  .rotateX(-90)
   .translate(wallT + 50, rackY - rackLen / 2 + bracketSize, wallT + rackZ + bracketSize / 2);
 
 const towelRack = union(bracketL, bracketR, towelBar);
@@ -177,7 +177,7 @@ const towelRack = union(bracketL, bracketR, towelBar);
 const matW = 700;
 const matD = 450;
 const matH = 8;
-const bathMat = box(matW, matD, matH, true)
+const bathMat = box(matW, matD, matH)
   .translate(tubX + tubL / 2, tubY - matD / 2 - 30, wallT + matH / 2);
 
 // ─── Assemble ───

package/examples/furniture/chair.forge.js

@@ -37,7 +37,7 @@ const legs = union(
 // Tilted slightly backward — rotate around X then position at back edge
 const backPanel = box(seatW, backT, backH)
   .translate(-seatW / 2, -backT / 2, 0)  // center for rotation
-  .rotateAround([0, 0, 0], -backTilt, 0, 0)
+  .rotateX(-backTilt)
   .translate(seatW / 2, seatD - legInset - legW / 2, seatH + seatT);
 
 // --- Stretchers (side rails between legs) ---

package/examples/generative/crystal-growth.forge.js

@@ -103,7 +103,7 @@ const mainW = rand(14, 20);
 crystals.push({
   name: 'Main Crystal',
   shape: crystal(mainH, mainW)
-    .rotate(0, 0, rand(0, 360))
+    .rotateZ(rand(0, 360))
     .translate(rand(-5, 5), rand(-5, 5), 0),
   color: '#a855f7',
 });
@@ -118,7 +118,7 @@ for (let i = 0; i < crystalCount - 1; i++) {
   crystals.push({
     name: `Crystal ${i + 2}`,
     shape: crystal(h, w)
-      .rotate(rand(-8, 8), rand(-12, 12), rand(0, 360))
+      .rotateX(rand(-8, 8)).rotateY(rand(-12, 12)).rotateZ(rand(0, 360))
       .translate(Math.cos(angle) * dist, Math.sin(angle) * dist, 0),
     color: pickColor(),
   });

package/examples/generative/frost-spires.forge.js

@@ -127,7 +127,7 @@ for (let i = 0; i < spireCount; i++) {
     shape: ngon(6, r)
       .extrude(h)
       .translate(px, py, 0)
-      .rotate(0, 0, rand(0, 60))
+      .rotateZ(rand(0, 60))
       .material({
         opacity: rand(0.4, 0.75),
         metalness: 0.0,
@@ -145,7 +145,7 @@ for (let i = 0; i < spireCount; i++) {
       shape: ngon(6, r * 0.4)
         .extrude(h * 0.7)
         .translate(px, py, h * 0.1)
-        .rotate(0, 0, rand(0, 60))
+        .rotateZ(rand(0, 60))
         .material({
           emissive: pick(glowColors),
           emissiveIntensity: rand(1, 3),
@@ -183,7 +183,7 @@ for (let i = 0; i < 10; i++) {
     shape: ngon(6, size)
       .extrude(size * rand(0.3, 0.8))
       .translate(Math.cos(angle) * dist, Math.sin(angle) * dist, 0)
-      .rotate(rand(-15, 15), rand(-15, 15), rand(0, 60))
+      .rotateX(rand(-15, 15)).rotateY(rand(-15, 15)).rotateZ(rand(0, 60))
       .material({
         opacity: rand(0.4, 0.7),
         metalness: 0.0,

package/examples/generative/golden-spiral-tower.forge.js

@@ -91,15 +91,15 @@ for (let i = 0; i < count; i++) {
   const lum = 45 + t * 15;           // slightly brighter at top
   const r255 = hslToHex(hue, sat, lum);
 
-  const element = box(s, s * 0.6, s * 1.2, true)
-    .rotate(0, 0, facingDeg)
+  const element = box(s, s * 0.6, s * 1.2)
+    .rotateZ(facingDeg)
     .translate(Math.cos(angle) * r, Math.sin(angle) * r, z);
 
   shapes.push({ name: `Petal ${i + 1}`, shape: element, color: r255 });
 }
 
 // Central spine
-const spine = box(6, 6, towerHeight * 0.9, true)
+const spine = box(6, 6, towerHeight * 0.9)
   .translate(0, 0, towerHeight * 0.45);
 shapes.push({ name: 'Spine', shape: spine, color: '#1a1a2e' });