forgecad 0.6.3 → 0.8.0

package/examples/mechanical/3d-printer.forge.js

@@ -5,12 +5,12 @@
 // Bed Z param represents current print progress (high = start, low = done).
 
 // ─── Parameters ───
-const bedW = param("Bed Width", 220, { min: 180, max: 300, unit: "mm" });
-const bedD = param("Bed Depth", 220, { min: 180, max: 300, unit: "mm" });
-const bedThick = param("Bed Thickness", 4, { min: 3, max: 8, unit: "mm" });
-const frameMargin = param("Frame Margin", 40, { min: 20, max: 80, unit: "mm" });
-const beam = param("Beam Size", 20, { min: 15, max: 30, unit: "mm" });
-const frameH = param("Frame Height", 400, { min: 320, max: 520, unit: "mm" });
+const bedW = Param.number("Bed Width", 220, { min: 180, max: 300, unit: "mm" });
+const bedD = Param.number("Bed Depth", 220, { min: 180, max: 300, unit: "mm" });
+const bedThick = Param.number("Bed Thickness", 4, { min: 3, max: 8, unit: "mm" });
+const frameMargin = Param.number("Frame Margin", 40, { min: 20, max: 80, unit: "mm" });
+const beam = Param.number("Beam Size", 20, { min: 15, max: 30, unit: "mm" });
+const frameH = Param.number("Frame Height", 400, { min: 320, max: 520, unit: "mm" });
 
 // ─── Derived frame ───
 const frameW = bedW + 2 * frameMargin;
@@ -27,15 +27,15 @@ const nozzleZ = gantryZ - nozzleToRail;
 // Bed starts near nozzle tip and lowers during printing.
 const bedTopMax = nozzleZ - 1;
 const bedTopMin = beam + bedThick + 80;
-const bedZ = param("Bed Z (print progress)", bedTopMax, {
+const bedZ = Param.number("Bed Z (print progress)", bedTopMax, {
   min: bedTopMin, max: bedTopMax, unit: "mm",
 });
 
 // Gantry XY travel
 const gantryTravel = innerD / 2 - 30;
-const gantryY = param("Gantry Y", 0, { min: -gantryTravel, max: gantryTravel, unit: "mm" });
+const gantryY = Param.number("Gantry Y", 0, { min: -gantryTravel, max: gantryTravel, unit: "mm" });
 const headTravel = innerW / 2 - 50;
-const headX = param("Nozzle X", 0, { min: -headTravel, max: headTravel, unit: "mm" });
+const headX = Param.number("Nozzle X", 0, { min: -headTravel, max: headTravel, unit: "mm" });
 
 // ─── Colors ───
 const C = {
@@ -62,13 +62,13 @@ const hd = frameD / 2 - beam / 2;
 
 for (const z of [bz, tz]) {
   for (const sy of [-1, 1])
-    fp.push(box(frameW, beam, beam, true).translate(0, sy * hd, z));
+    fp.push(box(frameW, beam, beam).translate(0, sy * hd, z));
   for (const sx of [-1, 1])
-    fp.push(box(beam, frameD - 2 * beam, beam, true).translate(sx * hw, 0, z));
+    fp.push(box(beam, frameD - 2 * beam, beam).translate(sx * hw, 0, z));
 }
 for (const sx of [-1, 1])
   for (const sy of [-1, 1])
-    fp.push(box(beam, beam, pH, true).translate(sx * hw, sy * hd, pZ));
+    fp.push(box(beam, beam, pH).translate(sx * hw, sy * hd, pZ));
 
 add("Frame", union(...fp), C.frame);
 
@@ -93,8 +93,8 @@ add("Lead Screws", union(
 ), C.lead);
 
 add("Z Motors", union(
-  box(42, 42, 40, true).translate(-zRailX, leadY, beam + 20),
-  box(42, 42, 40, true).translate(zRailX, leadY, beam + 20),
+  box(42, 42, 40).translate(-zRailX, leadY, beam + 20),
+  box(42, 42, 40).translate(zRailX, leadY, beam + 20),
 ), C.motor);
 
 // ─── Bed Assembly (moves in Z) ───
@@ -103,8 +103,8 @@ const glassTopZ = bedZ;
 const bedPlateTopZ = glassTopZ - glassThick;
 const bedPlateCenterZ = bedPlateTopZ - bedThick / 2;
 
-const bedPlate = box(bedW, bedD, bedThick, true).translate(0, 0, bedPlateCenterZ);
-const glass = box(bedW - 6, bedD - 6, glassThick, true)
+const bedPlate = box(bedW, bedD, bedThick).translate(0, 0, bedPlateCenterZ);
+const glass = box(bedW - 6, bedD - 6, glassThick)
   .translate(0, 0, bedPlateTopZ + glassThick / 2);
 
 const carriageThick = 8;
@@ -112,12 +112,12 @@ const springH = 12;
 const carriageZ = bedPlateCenterZ - bedThick / 2 - springH - carriageThick / 2;
 
 // Carriage narrower in Y so it doesn't extend past the Z rail Y position
-const bedCarriage = box(bedW + 20, bedD - 40, carriageThick, true)
+const bedCarriage = box(bedW + 20, bedD - 40, carriageThick)
   .translate(0, 0, carriageZ);
 
 add("Z Bearings", union(
-  box(24, 24, 16, true).translate(-zRailX, zRailY, carriageZ),
-  box(24, 24, 16, true).translate(zRailX, zRailY, carriageZ),
+  box(24, 24, 16).translate(-zRailX, zRailY, carriageZ),
+  box(24, 24, 16).translate(zRailX, zRailY, carriageZ),
 ), C.carriage);
 
 add("Lead Nuts", union(
@@ -148,8 +148,8 @@ add("Y Rails", union(
 ), C.rail);
 
 add("Y Carriages", union(
-  box(28, 32, 18, true).translate(-yRailX, gantryY, gantryZ),
-  box(28, 32, 18, true).translate(yRailX, gantryY, gantryZ),
+  box(28, 32, 18).translate(-yRailX, gantryY, gantryZ),
+  box(28, 32, 18).translate(yRailX, gantryY, gantryZ),
 ), C.carriage);
 
 const xRailLen = yRailX * 2 - 30;
@@ -157,24 +157,24 @@ add("X Rail", cylinder(xRailLen, railR).pointAlong([1, 0, 0])
   .translate(-xRailLen / 2, gantryY, gantryZ), C.rail);
 
 // X beam at gantry level — supports the X rail from behind
-add("X Beam", box(xRailLen, beam, beam, true)
+add("X Beam", box(xRailLen, beam, beam)
   .translate(0, gantryY, gantryZ), C.frame);
 
 // ─── CoreXY Belts ───
 const beltZ = gantryZ + 22;
 add("XY Belts", union(
-  box(xRailLen, 2, 3, true).translate(0, gantryY + 8, beltZ),
-  box(xRailLen, 2, 3, true).translate(0, gantryY - 8, beltZ),
-  box(2, yRailLen, 3, true).translate(-yRailX, 0, beltZ),
-  box(2, yRailLen, 3, true).translate(yRailX, 0, beltZ),
+  box(xRailLen, 2, 3).translate(0, gantryY + 8, beltZ),
+  box(xRailLen, 2, 3).translate(0, gantryY - 8, beltZ),
+  box(2, yRailLen, 3).translate(-yRailX, 0, beltZ),
+  box(2, yRailLen, 3).translate(yRailX, 0, beltZ),
 ), C.belt);
 
 // XY motors inside frame at top-rear
 const motorSize = 42;
 const motorY = innerD / 2 - motorSize / 2 - 5;
 add("XY Motors", union(
-  box(motorSize, motorSize, motorSize, true).translate(-yRailX, motorY, gantryZ + 30),
-  box(motorSize, motorSize, motorSize, true).translate(yRailX, motorY, gantryZ + 30),
+  box(motorSize, motorSize, motorSize).translate(-yRailX, motorY, gantryZ + 30),
+  box(motorSize, motorSize, motorSize).translate(yRailX, motorY, gantryZ + 30),
 ), C.motor);
 
 add("XY Idlers", union(
@@ -189,19 +189,19 @@ const hx = headX;
 const hy = gantryY;
 
 add("Nozzle", cylinder(6, 0.4, 2).translate(hx, hy, nozzleZ), C.nozzle);
-add("Heater Block", box(12, 12, 8, true).translate(hx, hy, nozzleZ + 10), C.hotend);
+add("Heater Block", box(12, 12, 8).translate(hx, hy, nozzleZ + 10), C.hotend);
 add("Heatbreak", cylinder(6, 1.5).translate(hx, hy, nozzleZ + 14), C.lead);
 add("Heatsink", cylinder(12, 6).translate(hx, hy, nozzleZ + 22), C.hotend);
 
-const headCarriage = box(46, 28, 36, true).translate(hx, hy, gantryZ - 18);
+const headCarriage = box(46, 28, 36).translate(hx, hy, gantryZ - 18);
 add("Extruder Carriage", headCarriage, C.carriage);
 
-add("Part Fan", box(18, 8, 16, true)
+add("Part Fan", box(18, 8, 16)
   .onFace(headCarriage, 'front', { v: -5, protrude: 5 }), C.fan);
 
 // Extruder motor — compact, sits just above gantry plane
 const extruderMotorZ = gantryZ + 5;
-add("Extruder Motor", box(30, 30, 20, true)
+add("Extruder Motor", box(30, 30, 20)
   .translate(hx, hy, extruderMotorZ), C.motor);
 
 // ─── Spool Holder (behind frame, on top) ───
@@ -225,8 +225,8 @@ add("Spool Hub", cylinder(spoolW, 8).pointAlong([1, 0, 0])
   .translate(-spoolW / 2, spoolY, spoolZ), C.lead);
 
 add("Spool Supports", union(
-  box(10, 20, 50, true).translate(-spoolW / 2 - 15, frameD / 2 - beam / 2, frameH - 25),
-  box(10, 20, 50, true).translate(spoolW / 2 + 15, frameD / 2 - beam / 2, frameH - 25),
+  box(10, 20, 50).translate(-spoolW / 2 - 15, frameD / 2 - beam / 2, frameH - 25),
+  box(10, 20, 50).translate(spoolW / 2 + 15, frameD / 2 - beam / 2, frameH - 25),
 ), C.frame);
 
 // ─── Filament Path ───
@@ -248,13 +248,13 @@ const filFixedPath = lib.pipeRoute(
 add("Filament Guide Tube", filFixedPath, C.bowden);
 
 // ─── Electronics ───
-add("PSU", box(100, 60, 40, true)
+add("PSU", box(100, 60, 40)
   .translate(frameW / 2 - 55, -frameD / 2 + 35, 25), C.electronics);
 
-add("Control Board", box(70, 40, 25, true)
+add("Control Board", box(70, 40, 25)
   .translate(-frameW / 2 + 40, -frameD / 2 + 25, 18), C.electronics);
 
-add("Display", box(50, 3, 25, true)
+add("Display", box(50, 3, 25)
   .translate(-frameW / 2 + 40, -frameD / 2 + 1, frameH / 3), C.screen);
 
 // ─── Build Volume wireframe ───

package/examples/mechanical/5-finger-robot-hand.forge.js

@@ -1,10 +1,10 @@
 // Robot Hand — functional, buildable concept
 // Z-up, Y depth (front = -Y)
 
-const scale = param("Scale", 1.0, { min: 0.7, max: 1.3, step: 0.05 });
-const curl = param("Finger Curl", 40, { min: 0, max: 70, unit: "°" });
-const thumbCurl = param("Thumb Curl", 35, { min: 0, max: 70, unit: "°" });
-const spread = param("Finger Spread", 8, { min: 0, max: 20, unit: "°" });
+const scale = Param.number("Scale", 1.0, { min: 0.7, max: 1.3, step: 0.05 });
+const curl = Param.number("Finger Curl", 40, { min: 0, max: 70, unit: "°" });
+const thumbCurl = Param.number("Thumb Curl", 35, { min: 0, max: 70, unit: "°" });
+const spread = Param.number("Finger Spread", 8, { min: 0, max: 20, unit: "°" });
 
 // --- Dimensions ---
 const palmW = 90 * scale;
@@ -76,37 +76,37 @@ function makeFinger(opts) {
     const tipPivot0 = [basePivot[0], basePivot[1] - L1 - L2, basePivot[2]];
 
     // Straight segments in world space
-    let s1 = box(W1, L1, t, true)
+    let s1 = box(W1, L1, t)
         .translate(basePivot[0], basePivot[1] - L1 / 2, basePivot[2])
         .color(colors.segment);
-    let s2 = box(W2, L2, t, true)
+    let s2 = box(W2, L2, t)
         .translate(basePivot[0], basePivot[1] - L1 - L2 / 2, basePivot[2])
         .color(colors.segment);
-    let s3 = box(W3, L3, t, true)
+    let s3 = box(W3, L3, t)
         .translate(basePivot[0], basePivot[1] - L1 - L2 - L3 / 2, basePivot[2])
         .color(colors.segment);
 
     // Pads (rubber contact)
     const padT = t * 0.18;
-    let pad1 = box(W1 * 0.7, L1 * 0.45, padT, true)
+    let pad1 = box(W1 * 0.7, L1 * 0.45, padT)
         .color(colors.pad)
         .onFace(s1, 'bottom', { v: -L1 * 0.15, protrude: padT / 2 });
-    let pad2 = box(W2 * 0.65, L2 * 0.45, padT, true)
+    let pad2 = box(W2 * 0.65, L2 * 0.45, padT)
         .color(colors.pad)
         .onFace(s2, 'bottom', { v: -L2 * 0.15, protrude: padT / 2 });
-    let pad3 = box(W3 * 0.8, L3 * 0.6, padT, true)
+    let pad3 = box(W3 * 0.8, L3 * 0.6, padT)
         .color(colors.pad)
         .onFace(s3, 'bottom', { v: -L3 * 0.1, protrude: padT / 2 });
 
     // Tendon guides (raised top rails)
     const rodT = t * 0.12;
-    let rod1 = box(W1 * 0.2, L1 * 0.9, rodT, true)
+    let rod1 = box(W1 * 0.2, L1 * 0.9, rodT)
         .color(colors.tendon)
         .onFace(s1, 'top', { v: -L1 * 0.05, protrude: rodT / 2 });
-    let rod2 = box(W2 * 0.2, L2 * 0.9, rodT, true)
+    let rod2 = box(W2 * 0.2, L2 * 0.9, rodT)
         .color(colors.tendon)
         .onFace(s2, 'top', { v: -L2 * 0.05, protrude: rodT / 2 });
-    let rod3 = box(W3 * 0.2, L3 * 0.85, rodT, true)
+    let rod3 = box(W3 * 0.2, L3 * 0.85, rodT)
         .color(colors.tendon)
         .onFace(s3, 'top', { v: -L3 * 0.05, protrude: rodT / 2 });
 
@@ -137,7 +137,7 @@ function makeFinger(opts) {
     let pin3 = pinBase.translate(tipPivot2[0] - pinLen / 2, tipPivot2[1], tipPivot2[2]);
 
     // Yoke block at base
-    let yoke = box(W1 * 1.1, 6 * scale, t * 0.8, true)
+    let yoke = box(W1 * 1.1, 6 * scale, t * 0.8)
         .translate(basePivot[0], basePivot[1] + 3 * scale, basePivot[2])
         .color(colors.knuckle);
     yoke = seg1(yoke);
@@ -173,12 +173,12 @@ function makeFinger(opts) {
 }
 
 // --- Palm assembly ---
-const palm = box(palmW, palmD, palmH, true).color(colors.palm);
-const palmPad = box(palmW * 0.6, 3 * scale, palmH * 0.5, true)
+const palm = box(palmW, palmD, palmH).color(colors.palm);
+const palmPad = box(palmW * 0.6, 3 * scale, palmH * 0.5)
     .color(colors.palmPad)
     .onFace(palm, 'front', { v: -palmH * 0.05, protrude: 1 * scale });
 
-const knuckleBar = box(palmW * 0.9, 10 * scale, 6 * scale, true)
+const knuckleBar = box(palmW * 0.9, 10 * scale, 6 * scale)
     .color(colors.knuckle)
     .onFace(palm, 'top', { v: -palmD / 2 + 8 * scale, protrude: 3 * scale });
 
@@ -192,7 +192,7 @@ const wrist = cylinder(wristLen, wristR)
 const motorW = 40 * scale;
 const motorD = 28 * scale;
 const motorH = 20 * scale;
-const motor = box(motorW, motorD, motorH, true)
+const motor = box(motorW, motorD, motorH)
     .color(colors.motor)
     .attachTo(palm, 'bottom', 'top', [0, palmD / 2 - motorD / 2 - 4 * scale, -2 * scale]);
 
@@ -261,7 +261,7 @@ const cables = fingerBases.map((end, i) => {
 // --- Grasp target object ---
 const graspObject = union(
     sphere(18 * scale).translate(0, baseY - 45 * scale, baseZ + 6 * scale),
-    box(32 * scale, 20 * scale, 26 * scale, true).translate(12 * scale, baseY - 65 * scale, baseZ + 2 * scale)
+    box(32 * scale, 20 * scale, 26 * scale).translate(12 * scale, baseY - 65 * scale, baseZ + 2 * scale)
 ).color('#88ccee');
 
 // --- Return scene ---

package/examples/mechanical/airplane-propeller.forge.js

@@ -18,13 +18,13 @@
 //   Camber:     4% at root → 1.5% at tip (Cl margin at low-speed root)
 
 // ─── Design Parameters ──────────────────────────────────────────
-const diameter    = param("Diameter",       1900, { min: 1200, max: 2600, unit: "mm" });
-const numBlades   = param("Blades",            3, { min: 2,    max: 6,    integer: true });
-const pitchAngle  = param("Pitch @75%R",      22, { min: 10,   max: 40,   unit: "°" });
-const maxChord    = param("Max Chord",       155, { min: 80,   max: 250,  unit: "mm" });
-const hubDiameter = param("Hub Diameter",    140, { min: 80,   max: 220,  unit: "mm" });
-const meshRes     = param("Mesh Resolution", 2.5, { min: 1.0,  max: 5.0,  step: 0.5, unit: "mm" });
-const showSections = boolParam("Show Airfoil Sections", false);
+const diameter    = Param.number("Diameter",       1900, { min: 1200, max: 2600, unit: "mm" });
+const numBlades   = Param.number("Blades",            3, { min: 2,    max: 6,    integer: true });
+const pitchAngle  = Param.number("Pitch @75%R",      22, { min: 10,   max: 40,   unit: "°" });
+const maxChord    = Param.number("Max Chord",       155, { min: 80,   max: 250,  unit: "mm" });
+const hubDiameter = Param.number("Hub Diameter",    140, { min: 80,   max: 220,  unit: "mm" });
+const meshRes     = Param.number("Mesh Resolution", 2.5, { min: 1.0,  max: 5.0,  step: 0.5, unit: "mm" });
+const showSections = Param.bool("Show Airfoil Sections", false);
 
 const R    = diameter / 2;
 const rHub = hubDiameter / 2;
@@ -191,7 +191,7 @@ for (let i = 0; i <= NUM_STATIONS; i++) {
 const bladeRaw = loft(profiles, heights, { edgeLength: meshRes });
 
 // Rotate blade from Z-axis (span) to X-axis (radial in propeller disk)
-const blade = bladeRaw.rotateAround([0, 0, 0], 0, 90, 0);
+const blade = bladeRaw.rotateY(90);
 
 // ─── Spinner / Hub ──────────────────────────────────────────────
 //
@@ -257,7 +257,7 @@ if (showSections) {
     pts = rotate2D(pts, 90 + twist);
 
     const section = polygon(pts).extrude(2)
-      .rotate(0, 90, 0)
+      .rotateY(90)
       .translate(r, 0, 0)
       .color('#ff4422');
 

package/examples/mechanical/bolt-and-nut.forge.js

@@ -3,16 +3,16 @@
 // lib.bolt() and lib.nut() use Manifold's native extrude+twist
 // to sweep a thread tooth profile helically — clean geometry, no SDF grid.
 
-const diameter = param("Diameter", 8, { min: 4, max: 20, unit: "mm" });
-const length = param("Length", 30, { min: 10, max: 60, unit: "mm" });
-const pitch = param("Pitch", 1.25, { min: 0.5, max: 3, step: 0.25, unit: "mm" });
-const headH = param("Head Height", 5, { min: 3, max: 12, unit: "mm" });
-const headAF = param("Head AF", 13, { min: 7, max: 30, unit: "mm" });
-const nutHeight = param("Nut Height", 6.5, { min: 3, max: 12, unit: "mm" });
-const nutAF = param("Nut AF", 13, { min: 7, max: 30, unit: "mm" });
-const showNut = param("Show Nut", 1, { min: 0, max: 1, step: 1 });
-const nutPos = param("Nut Position", 5, { min: 0, max: 30, unit: "mm" });
-const segments = param("Segments", 36, { min: 12, max: 72, step: 4, integer: true });
+const diameter = Param.number("Diameter", 8, { min: 4, max: 20, unit: "mm" });
+const length = Param.number("Length", 30, { min: 10, max: 60, unit: "mm" });
+const pitch = Param.number("Pitch", 1.25, { min: 0.5, max: 3, step: 0.25, unit: "mm" });
+const headH = Param.number("Head Height", 5, { min: 3, max: 12, unit: "mm" });
+const headAF = Param.number("Head AF", 13, { min: 7, max: 30, unit: "mm" });
+const nutHeight = Param.number("Nut Height", 6.5, { min: 3, max: 12, unit: "mm" });
+const nutAF = Param.number("Nut AF", 13, { min: 7, max: 30, unit: "mm" });
+const showNut = Param.number("Show Nut", 1, { min: 0, max: 1, step: 1 });
+const nutPos = Param.number("Nut Position", 5, { min: 0, max: 30, unit: "mm" });
+const segments = Param.number("Segments", 36, { min: 12, max: 72, step: 4, integer: true });
 
 const boltShape = lib.bolt(diameter, length, {
   pitch,

package/examples/mechanical/door-with-hinges.forge.js

@@ -1,15 +1,15 @@
 // Door with hinges — the door pivots around the hinge axis using joint().
 // Drag the "Door Angle" slider to open/close the door.
 
-const doorW = param("Door Width", 80, { min: 40, max: 120, unit: "mm" });
-const doorH = param("Door Height", 200, { min: 100, max: 300, unit: "mm" });
-const doorT = param("Door Thickness", 4, { min: 2, max: 10, unit: "mm" });
+const doorW = Param.number("Door Width", 80, { min: 40, max: 120, unit: "mm" });
+const doorH = Param.number("Door Height", 200, { min: 100, max: 300, unit: "mm" });
+const doorT = Param.number("Door Thickness", 4, { min: 2, max: 10, unit: "mm" });
 
-const frameW = param("Frame Width", 8, { min: 4, max: 15, unit: "mm" });
-const frameD = param("Frame Depth", 6, { min: 3, max: 12, unit: "mm" });
+const frameW = Param.number("Frame Width", 8, { min: 4, max: 15, unit: "mm" });
+const frameD = Param.number("Frame Depth", 6, { min: 3, max: 12, unit: "mm" });
 
-const hingeR = param("Hinge Radius", 3, { min: 1.5, max: 6, unit: "mm" });
-const hingeH = param("Hinge Height", 16, { min: 8, max: 30, unit: "mm" });
+const hingeR = Param.number("Hinge Radius", 3, { min: 1.5, max: 6, unit: "mm" });
+const hingeH = Param.number("Hinge Height", 16, { min: 8, max: 30, unit: "mm" });
 
 // ── Door frame (stationary U-shape) ──
 const frame = union(

package/examples/mechanical/fillet-enclosure.forge.js

@@ -1,19 +1,20 @@
 // Filleted Electronics Enclosure — practical engineering part
 // Demonstrates: fillet() for professional-looking product design
 
-const width = param("Width", 80, { min: 50, max: 120, unit: "mm" });
-const depth = param("Depth", 50, { min: 30, max: 80, unit: "mm" });
-const height = param("Height", 25, { min: 15, max: 40, unit: "mm" });
-const wall = param("Wall", 2.5, { min: 1.5, max: 4, unit: "mm" });
-const outerR = param("Outer Fillet", 4, { min: 1, max: 10, unit: "mm" });
+const width = Param.number("Width", 80, { min: 50, max: 120, unit: "mm" });
+const depth = Param.number("Depth", 50, { min: 30, max: 80, unit: "mm" });
+const height = Param.number("Height", 25, { min: 15, max: 40, unit: "mm" });
+const wall = Param.number("Wall", 2.5, { min: 1.5, max: 4, unit: "mm" });
+const outerR = Param.number("Outer Fillet", 4, { min: 1, max: 10, unit: "mm" });
 
 // ── Outer shell with rounded vertical edges ─────────────────────────────────
 const outer = box(width, depth, height);
 let enclosure = fillet(outer, outerR, { parallel: [0, 0, 1], convex: true });
 
 // ── Hollow interior ─────────────────────────────────────────────────────────
-const cavity = box(width - wall * 2, depth - wall * 2, height - wall, true)
-  .translate(width / 2, depth / 2, wall + (height - wall) / 2 + 0.01);
+// box() is XY-centered, Z starts at 0 — cavity just needs a Z shift
+const cavity = box(width - wall * 2, depth - wall * 2, height - wall)
+  .translate(0, 0, wall + 0.01);
 enclosure = difference(enclosure, cavity);
 
 // ── Screw bosses ────────────────────────────────────────────────────────────
@@ -27,12 +28,15 @@ function screwBoss(x, y) {
   return difference(boss, hole);
 }
 
+// Positions relative to centered box: -width/2..+width/2
+const hw = width / 2;
+const hd = depth / 2;
 enclosure = union(
   enclosure,
-  screwBoss(inset, inset),
-  screwBoss(width - inset, inset),
-  screwBoss(inset, depth - inset),
-  screwBoss(width - inset, depth - inset),
+  screwBoss(-hw + inset, -hd + inset),
+  screwBoss( hw - inset, -hd + inset),
+  screwBoss(-hw + inset,  hd - inset),
+  screwBoss( hw - inset,  hd - inset),
 );
 
 return enclosure;

package/examples/mechanical/headphone-hanger-v2.forge.js

@@ -2,15 +2,15 @@
 // Clamps to the bottom edge of a desk, hook hangs below.
 // Designed for actual 3D printing / building.
 
-const deskThick = param("Desk Thickness", 25, { min: 15, max: 50, unit: "mm" });
-const clampDepth = param("Clamp Depth", 40, { min: 25, max: 70, unit: "mm" });
-const width = param("Width", 50, { min: 30, max: 80, unit: "mm" });
-const thick = param("Material Thick", 5, { min: 3, max: 10, unit: "mm" });
-const hookDrop = param("Hook Drop", 60, { min: 30, max: 100, unit: "mm" });
-const hookLen = param("Hook Length", 35, { min: 15, max: 60, unit: "mm" });
-const hookCurveR = param("Hook Curve R", 15, { min: 5, max: 30, unit: "mm" });
-const padThick = param("Pad Thickness", 2, { min: 1, max: 5, unit: "mm" });
-const boltHoleD = param("Bolt Hole", 5, { min: 0, max: 8, unit: "mm" });
+const deskThick = Param.number("Desk Thickness", 25, { min: 15, max: 50, unit: "mm" });
+const clampDepth = Param.number("Clamp Depth", 40, { min: 25, max: 70, unit: "mm" });
+const width = Param.number("Width", 50, { min: 30, max: 80, unit: "mm" });
+const thick = Param.number("Material Thick", 5, { min: 3, max: 10, unit: "mm" });
+const hookDrop = Param.number("Hook Drop", 60, { min: 30, max: 100, unit: "mm" });
+const hookLen = Param.number("Hook Length", 35, { min: 15, max: 60, unit: "mm" });
+const hookCurveR = Param.number("Hook Curve R", 15, { min: 5, max: 30, unit: "mm" });
+const padThick = Param.number("Pad Thickness", 2, { min: 1, max: 5, unit: "mm" });
+const boltHoleD = Param.number("Bolt Hole", 5, { min: 0, max: 8, unit: "mm" });
 
 // The clamp is a C-shape that grips the desk edge.
 // Top jaw sits on top of desk, bottom jaw presses from below.
@@ -48,8 +48,8 @@ const curveProfile = rect(thick, width).translate(hookCurveR, 0);
 const curvePiece = curveProfile.revolve(90)
   // revolve produces shape around Y axis; rotate to align:
   // we need the arc to go from -Z (down) to +Y (forward)
-  .rotateAround([0, 0, 0], 90, 0, 90)   // align width along X
-  .rotateAround([0, 0, 0], 180, 0, 0)  // flip so arc opens downward-to-forward
+  .rotateX(90).rotateZ(90)   // align width along X
+  .rotateX(180)  // flip so arc opens downward-to-forward
   .translate(0, clampDepth * 0.6 + hookCurveR, hookZ);
 
 // Straight hook tip extending forward

package/examples/mechanical/robot_hand.forge.js

@@ -5,16 +5,16 @@
 // 3) Mount included: base, mast, wrist clevis
 // 4) Iterative construction: build primitives -> segments -> fingers -> full assembly
 
-const grip = param("Grip", 55, { min: 0, max: 100, unit: "%" });
-const fingerSpread = param("Finger Spread", 18, { min: 0, max: 35, unit: "°" });
-const thumbOpposition = param("Thumb Opposition", 42, { min: 20, max: 70, unit: "°" });
-const wristPitch = param("Wrist Pitch", 8, { min: -35, max: 45, unit: "°" });
-const explode = param("Explode", 0, { min: 0, max: 26, unit: "mm" });
+const grip = Param.number("Grip", 55, { min: 0, max: 100, unit: "%" });
+const fingerSpread = Param.number("Finger Spread", 18, { min: 0, max: 35, unit: "°" });
+const thumbOpposition = Param.number("Thumb Opposition", 42, { min: 20, max: 70, unit: "°" });
+const wristPitch = Param.number("Wrist Pitch", 8, { min: -35, max: 45, unit: "°" });
+const explode = Param.number("Explode", 0, { min: 0, max: 26, unit: "mm" });
 
-const scale = param("Scale", 1.0, { min: 0.75, max: 1.25, step: 0.01 });
-const pinD = param("Pin Diameter", 3.2, { min: 2.0, max: 5.0, step: 0.1, unit: "mm" }) * scale;
-const jointClearance = param("Joint Clearance", 0.32, { min: 0.2, max: 0.7, step: 0.02, unit: "mm" }) * scale;
-const wall = param("Min Wall", 2.4, { min: 1.6, max: 4.0, step: 0.1, unit: "mm" }) * scale;
+const scale = Param.number("Scale", 1.0, { min: 0.75, max: 1.25, step: 0.01 });
+const pinD = Param.number("Pin Diameter", 3.2, { min: 2.0, max: 5.0, step: 0.1, unit: "mm" }) * scale;
+const jointClearance = Param.number("Joint Clearance", 0.32, { min: 0.2, max: 0.7, step: 0.02, unit: "mm" }) * scale;
+const wall = Param.number("Min Wall", 2.4, { min: 1.6, max: 4.0, step: 0.1, unit: "mm" }) * scale;
 
 // Core hand dimensions
 const palmW = 84 * scale;
@@ -61,9 +61,9 @@ function localToWorld(localPt, basePt, yawDeg) {
 
 // Clevis mount with pin bore centered at origin
 function makeClevis(width, height, depth, gap, lugW, boreR) {
-  const left = box(lugW, depth, height, true).translate(-(gap * 0.5 + lugW * 0.5), -depth * 0.5, 0);
-  const right = box(lugW, depth, height, true).translate(gap * 0.5 + lugW * 0.5, -depth * 0.5, 0);
-  const bridge = box(width, depth * 0.55, height * 0.55, true).translate(0, -depth * 0.78, 0);
+  const left = box(lugW, depth, height).translate(-(gap * 0.5 + lugW * 0.5), -depth * 0.5, 0);
+  const right = box(lugW, depth, height).translate(gap * 0.5 + lugW * 0.5, -depth * 0.5, 0);
+  const bridge = box(width, depth * 0.55, height * 0.55).translate(0, -depth * 0.78, 0);
   const raw = union(left, right, bridge);
   const bore = cylinder(width + 2, boreR).pointAlong([1, 0, 0]);
   return raw.subtract(bore);
@@ -73,7 +73,7 @@ function makeClevis(width, height, depth, gap, lugW, boreR) {
 function makeHingeEar(width, height, depth, boreR) {
   const ear = union(
     cylinder(width * 0.62, height * 0.45).pointAlong([1, 0, 0]).translate(0, 0, 0),
-    box(width * 0.62, depth * 0.9, height * 0.85, true).translate(0, depth * 0.45, 0)
+    box(width * 0.62, depth * 0.9, height * 0.85).translate(0, depth * 0.45, 0)
   );
   const bore = cylinder(width + 2, boreR).pointAlong([1, 0, 0]);
   return ear.subtract(bore);
@@ -88,8 +88,8 @@ function makePhalanxPart(length, width, thick, hasFrontClevis, frontScale = 1.0)
   const baseEar = makeHingeEar(width, thick, lugDepth, pinR + jointClearance * 0.6)
     .translate(0, 0, 0);
 
-  const topRib = box(width * 0.36, length * 0.72, thick * 0.22, true).translate(0, length * 0.52, thick * 0.28);
-  const bottomRib = box(width * 0.36, length * 0.72, thick * 0.18, true).translate(0, length * 0.52, -thick * 0.28);
+  const topRib = box(width * 0.36, length * 0.72, thick * 0.22).translate(0, length * 0.52, thick * 0.28);
+  const bottomRib = box(width * 0.36, length * 0.72, thick * 0.18).translate(0, length * 0.52, -thick * 0.28);
 
   let part = union(body, baseEar, topRib, bottomRib);
 
@@ -157,8 +157,8 @@ function makeFingerAssembly(opts) {
 
     const worldBase = localToWorld([0, py, pz], basePivot, yawDeg);
     const part = localPart
-      .rotateAround([0, 0, 0], accum, 0, 0)
-      .rotateAround([0, 0, 0], 0, 0, yawDeg)
+      .rotateX(accum)
+      .rotateZ(yawDeg)
       .translate(worldBase[0], worldBase[1], worldBase[2])
       .translate(0, 0, explode * i * 0.08);
 
@@ -170,7 +170,7 @@ function makeFingerAssembly(opts) {
     const pinLen = segW + wall * 2.4;
     const pin = cylinder(pinLen, pinR * 0.92)
       .pointAlong([1, 0, 0])
-      .rotateAround([0, 0, 0], 0, 0, yawDeg)
+      .rotateZ(yawDeg)
       .translate(worldBase[0], worldBase[1], worldBase[2])
       .translate(0, 0, explode * i * 0.08)
       .color('#B0B7C3');
@@ -220,7 +220,7 @@ function makeFingerAssembly(opts) {
 
 // Build palm with integrated finger clevises and wrist lug
 function makePalm() {
-  const palmCore = roundedRect(palmW, palmD, 10 * scale, true).extrude(palmT, { center: true })
+  const palmCore = roundedRect(palmW, palmD, 10 * scale).extrude(palmT, { center: true })
     .translate(0, palmD * 0.5, 0);
 
   const palmHoles = union(
@@ -246,11 +246,11 @@ function makePalm() {
   }
 
   const thumbClevis = makeClevis(thumbWidth, segmentThick * 0.86, lugDepth, lugGap, lugWidth, pinR + jointClearance)
-    .rotateAround([0, 0, 0], 0, 0, -thumbOpposition)
+    .rotateZ(-thumbOpposition)
     .translate(palmW * 0.45, palmD * 0.24, 0);
 
   const wristEar = makeHingeEar(palmW * 0.45, segmentThick, lugDepth * 1.05, pinR + jointClearance)
-    .rotateAround([0, 0, 0], 0, 180, 0)
+    .rotateY(180)
     .translate(0, 0, 0);
 
   palm = union(palm, thumbClevis, wristEar);
@@ -267,7 +267,7 @@ function makeMount() {
   const mastD = 34 * scale;
   const mastH = 86 * scale;
 
-  let base = roundedRect(baseW, baseD, 8 * scale, true).extrude(baseT, { center: true }).translate(0, -36 * scale, -mastH * 0.52);
+  let base = roundedRect(baseW, baseD, 8 * scale).extrude(baseT, { center: true }).translate(0, -36 * scale, -mastH * 0.52);
 
   const slotSketchA = slot(20 * scale, 7 * scale).translate(-baseW * 0.28, -36 * scale);
   const slotSketchB = slot(20 * scale, 7 * scale).translate(baseW * 0.28, -36 * scale);
@@ -281,10 +281,10 @@ function makeMount() {
   );
   base = base.subtract(slots);
 
-  const mast = box(mastW, mastD, mastH, true).translate(0, -8 * scale, -mastH * 0.02);
+  const mast = box(mastW, mastD, mastH).translate(0, -8 * scale, -mastH * 0.02);
   const gussetL = polygon([[0, 0], [26 * scale, 0], [0, 28 * scale]])
     .extrude(6 * scale, { center: true })
-    .rotateAround([0, 0, 0], 90, 0, 90)
+    .rotateX(90).rotateZ(90)
     .translate(-mastW * 0.5 - 3 * scale, -18 * scale, -mastH * 0.28);
   const gussetR = gussetL.mirrorThrough([0, 0, 0], [1, 0, 0]);