forgecad 0.6.3 → 0.8.0

package/examples/products/iphone.forge.js

@@ -2,53 +2,53 @@
 // Tests ForgeCAD's sketch→extrude + smoothing workflow
 
 // === Dimensions (roughly iPhone 15 Pro proportions) ===
-const w = param("Width", 71.6, { min: 60, max: 80, unit: "mm" });
-const h = param("Height", 146.6, { min: 120, max: 170, unit: "mm" });
-const d = param("Depth", 8.25, { min: 6, max: 12, unit: "mm" });
-const cornerR = param("Corner Radius", 10, { min: 2, max: 20, unit: "mm" });
-const edgeR = param("Edge Radius", 1.5, { min: 0, max: 3, step: 0.1, unit: "mm" });
+const w = Param.number("Width", 71.6, { min: 60, max: 80, unit: "mm" });
+const h = Param.number("Height", 146.6, { min: 120, max: 170, unit: "mm" });
+const d = Param.number("Depth", 8.25, { min: 6, max: 12, unit: "mm" });
+const cornerR = Param.number("Corner Radius", 10, { min: 2, max: 20, unit: "mm" });
+const edgeR = Param.number("Edge Radius", 1.5, { min: 0, max: 3, step: 0.1, unit: "mm" });
 
 // === Body ===
 // Rounded-rect profile extruded to phone depth, then subdivision-smoothed
 // to round the 90° edges where top/bottom meet sides.
-const bodyProfile = roundedRect(w, h, cornerR, true);
-let body = bodyProfile.extrude(d, { center: true });
+const bodyProfile = roundedRect(w, h, cornerR);
+let body = bodyProfile.extrude(d).translate(0, 0, -d / 2);
 
 // === Screen cutout (top +Z face = phone screen side) ===
-const screenInset = param("Screen Inset", 2, { min: 1, max: 5, unit: "mm" });
+const screenInset = Param.number("Screen Inset", 2, { min: 1, max: 5, unit: "mm" });
 const screenDepth = 0.4;
 const screenW = w - screenInset * 2;
 const screenH = h - screenInset * 2;
 const screenR = Math.max(cornerR - screenInset, 1);
 
-const screenCut = roundedRect(screenW, screenH, screenR, true)
+const screenCut = roundedRect(screenW, screenH, screenR)
   .extrude(screenDepth + 1)
   .translate(0, 0, d / 2 - screenDepth);
 
 body = body.subtract(screenCut);
 
 // Dark screen surface filling the cutout
-const screenFill = roundedRect(screenW, screenH, screenR, true)
+const screenFill = roundedRect(screenW, screenH, screenR)
   .color('#111111')
   .extrude(0.15)
   .translate(0, 0, d / 2 - screenDepth);
 
 // === Camera island (bottom -Z face = phone back, upper-left area) ===
-const camSize = param("Camera Island", 36, { min: 25, max: 45, unit: "mm" });
+const camSize = Param.number("Camera Island", 36, { min: 25, max: 45, unit: "mm" });
 const camR = 8;
-const camBump = param("Camera Bump", 1.5, { min: 0.5, max: 3, unit: "mm" });
+const camBump = Param.number("Camera Bump", 1.5, { min: 0.5, max: 3, unit: "mm" });
 const camEdgeInset = 4;
 const camX = -w / 2 + camSize / 2 + camEdgeInset;
 const camY = h / 2 - camSize / 2 - camEdgeInset;
 
-let camIsland = roundedRect(camSize, camSize, camR, true)
+let camIsland = roundedRect(camSize, camSize, camR)
   .translate(camX, camY)
   .extrude(camBump)
   .translate(0, 0, -d / 2 - camBump);
 
 // Camera lenses — 3 in L-pattern, positioned via entity geometry
-const lensR = param("Lens Radius", 6, { min: 3, max: 10, unit: "mm" });
-const lensGap = param("Lens Gap", 3, { min: 1, max: 8, unit: "mm" });
+const lensR = Param.number("Lens Radius", 6, { min: 3, max: 10, unit: "mm" });
+const lensGap = Param.number("Lens Gap", 3, { min: 1, max: 8, unit: "mm" });
 
 // Use Rectangle2D entity to derive lens positions from island bounds
 const camRect = Rectangle2D.fromCenterAndDimensions(point(camX, camY), camSize, camSize);
@@ -71,18 +71,18 @@ camIsland = camIsland.subtract(makeLens(lens1), makeLens(lens2), makeLens(lens3)
 
 // === Charging port (front -Y face = phone bottom edge) ===
 // pointAlong([0,1,0]) orients the extrusion along +Y so it cuts INTO the body
-const portW = param("Port Width", 9, { min: 6, max: 14, unit: "mm" });
+const portW = Param.number("Port Width", 9, { min: 6, max: 14, unit: "mm" });
 const portH = 3;
 const portDepth = 4;
 
-const portCut = roundedRect(portW, portH, portH / 2, true)
+const portCut = roundedRect(portW, portH, portH / 2)
   .extrude(portDepth)
   .pointAlong([0, 1, 0])
   .translate(0, -h / 2, 0);
 
 // === Speaker & mic grille (front -Y face) ===
 const holeR = 0.5;
-const holeCount = param("Speaker Holes", 6, { min: 3, max: 10, integer: true });
+const holeCount = Param.number("Speaker Holes", 6, { min: 3, max: 10, integer: true });
 const holeSpacing = 2.2;
 const grillX0 = portW / 2 + 5;
 
@@ -111,11 +111,11 @@ const btnInset = 0.4;
 const btnThick = 1.6;
 
 const makeBtn = (bw, by, side) => {
-  const btn = roundedRect(bw, btnThick, 0.5, true).extrude(btnInset);
+  const btn = roundedRect(bw, btnThick, 0.5).extrude(btnInset);
   const x = side === 'left'
     ? -w / 2 - edgeR - btnInset
     : w / 2 + edgeR + btnInset;
-  return btn.rotateAround([0, 0, 0], 90, 0, 90).translate(x, by, 0);
+  return btn.rotateX(90).rotateZ(90).translate(x, by, 0);
 };
 
 const volUp = makeBtn(14, h / 2 - 35, 'left');

package/examples/products/laptop.forge.js

@@ -1,24 +1,24 @@
 // Laptop — parametric with opening hinge
 // Demonstrates: joint(), multi-object, roundedRect, boolean ops
 
-const w = param("Width", 320, { min: 250, max: 400, unit: "mm" });
-const d = param("Depth", 220, { min: 170, max: 300, unit: "mm" });
-const baseH = param("Base Height", 15, { min: 8, max: 25, unit: "mm" });
-const lidH = param("Lid Height", 6, { min: 3, max: 12, unit: "mm" });
-const cornerR = param("Corner Radius", 10, { min: 3, max: 25, unit: "mm" });
-const screenInset = param("Screen Bezel", 8, { min: 3, max: 20, unit: "mm" });
-const kbInsetX = param("KB Inset X", 25, { min: 10, max: 50, unit: "mm" });
-const kbInsetY = param("KB Inset Y", 15, { min: 8, max: 40, unit: "mm" });
+const w = Param.number("Width", 320, { min: 250, max: 400, unit: "mm" });
+const d = Param.number("Depth", 220, { min: 170, max: 300, unit: "mm" });
+const baseH = Param.number("Base Height", 15, { min: 8, max: 25, unit: "mm" });
+const lidH = Param.number("Lid Height", 6, { min: 3, max: 12, unit: "mm" });
+const cornerR = Param.number("Corner Radius", 10, { min: 3, max: 25, unit: "mm" });
+const screenInset = Param.number("Screen Bezel", 8, { min: 3, max: 20, unit: "mm" });
+const kbInsetX = Param.number("KB Inset X", 25, { min: 10, max: 50, unit: "mm" });
+const kbInsetY = Param.number("KB Inset Y", 15, { min: 8, max: 40, unit: "mm" });
 
 // ─── Base ───
-const baseProfile = roundedRect(w, d, cornerR, true);
+const baseProfile = roundedRect(w, d, cornerR);
 let base = baseProfile.extrude(baseH);
 
 // Keyboard recess
 const kbW = w - kbInsetX * 2;
 const kbD = d * 0.55;
 const kbDepth = 1.5;
-const kbRecess = roundedRect(kbW, kbD, 4, true)
+const kbRecess = roundedRect(kbW, kbD, 4)
   .extrude(kbDepth + 1)
   .translate(0, d * 0.1, baseH - kbDepth);
 base = base.subtract(kbRecess);
@@ -26,7 +26,7 @@ base = base.subtract(kbRecess);
 // Trackpad recess
 const tpW = w * 0.3;
 const tpD = d * 0.22;
-const tpRecess = roundedRect(tpW, tpD, 3, true)
+const tpRecess = roundedRect(tpW, tpD, 3)
   .extrude(kbDepth + 1)
   .translate(0, -d * 0.28, baseH - kbDepth);
 base = base.subtract(tpRecess);
@@ -45,7 +45,7 @@ const keys = [];
 for (let r = 0; r < keyRows; r++) {
   for (let c = 0; c < keyCols; c++) {
     keys.push(
-      roundedRect(keyW, keyH, 1, true)
+      roundedRect(keyW, keyH, 1)
         .extrude(1)
         .translate(keyStartX + c * keyStep, keyStartY + r * keyStep, baseH - kbDepth - 0.5)
     );
@@ -54,17 +54,17 @@ for (let r = 0; r < keyRows; r++) {
 const keyboard = union(...keys);
 
 // Ports — left side
-const usbC1 = roundedRect(9, 3.5, 1.5, true).extrude(8)
-  .rotateAround([0, 0, 0], 0, 0, 90)
+const usbC1 = roundedRect(9, 3.5, 1.5).extrude(8)
+  .rotateZ(90)
   .translate(-w / 2, -d * 0.1, baseH * 0.4);
-const usbC2 = roundedRect(9, 3.5, 1.5, true).extrude(8)
-  .rotateAround([0, 0, 0], 0, 0, 90)
+const usbC2 = roundedRect(9, 3.5, 1.5).extrude(8)
+  .rotateZ(90)
   .translate(-w / 2, d * 0.05, baseH * 0.4);
 base = base.subtract(usbC1).subtract(usbC2);
 
 // Headphone jack — right side
 const hpJack = cylinder(8, 2)
-  .rotateAround([0, 0, 0], 0, 90, 0)
+  .rotateY(90)
   .translate(w / 2, -d * 0.1, baseH * 0.5);
 base = base.subtract(hpJack);
 
@@ -75,7 +75,7 @@ const ventW = w * 0.4;
 const ventGap = 3;
 for (let i = 0; i < ventCount; i++) {
   ventSlots.push(
-    roundedRect(ventW, 1.5, 0.5, true)
+    roundedRect(ventW, 1.5, 0.5)
       .extrude(2)
       .translate(0, -d * 0.1 + i * ventGap, -1)
   );
@@ -83,14 +83,14 @@ for (let i = 0; i < ventCount; i++) {
 base = difference(base, ...ventSlots);
 
 // ─── Lid ───
-const lidProfile = roundedRect(w, d, cornerR, true);
+const lidProfile = roundedRect(w, d, cornerR);
 let lid = lidProfile.extrude(lidH);
 
 // Screen cutout (inset from inner face)
 const screenW = w - screenInset * 2;
 const screenD = d - screenInset * 2;
 const screenCutDepth = 1;
-const screenCut = roundedRect(screenW, screenD, cornerR - screenInset / 2, true)
+const screenCut = roundedRect(screenW, screenD, cornerR - screenInset / 2)
   .extrude(screenCutDepth + 1)
   .translate(0, 0, -0.5);
 lid = lid.subtract(screenCut);
@@ -101,7 +101,7 @@ const cameraDot = cylinder(lidH + 2, 2)
 lid = lid.subtract(cameraDot);
 
 // Screen panel (thin slab filling the cutout)
-const screenPanel = roundedRect(screenW - 1, screenD - 1, cornerR - screenInset / 2 - 1, true)
+const screenPanel = roundedRect(screenW - 1, screenD - 1, cornerR - screenInset / 2 - 1)
   .extrude(screenCutDepth)
   .translate(0, 0, 0);
 
@@ -112,14 +112,14 @@ const hingeZ = baseH;
 
 // Position lid at hinge point, then use joint to rotate
 const lidAtHinge = lid.translate(0, -hingeY, 0)
-  .rotateAround([0, 0, 0], 180, 0, 0)
+  .rotateX(180)
   .translate(0, hingeY, hingeZ);
 
 const screenAtHinge = screenPanel.translate(0, -hingeY, 0)
-  .rotateAround([0, 0, 0], 180, 0, 0)
+  .rotateX(180)
   .translate(0, hingeY, hingeZ);
 
-const lidAngle = param("Lid Angle", 110, { min: 0, max: 135, unit: "°" });
+const lidAngle = Param.number("Lid Angle", 110, { min: 0, max: 135, unit: "°" });
 
 const openLid = lidAtHinge.rotateAroundAxis([1, 0, 0], lidAngle, [0, hingeY, hingeZ]);
 const openScreen = screenAtHinge.rotateAroundAxis([1, 0, 0], lidAngle, [0, hingeY, hingeZ]);

package/examples/products/laser-cut-box.forge.js

@@ -20,12 +20,12 @@
 //   joints re-adapt because they reference the panel edge lengths.
 
 // ── Parameters ─────────────────────────────────────────────────────
-const t    = param('Thickness', 3,   { min: 2, max: 6, step: 0.5 });
-const w    = param('Width',     100, { min: 40, max: 300 });
-const d    = param('Depth',     80,  { min: 40, max: 200 });
-const h    = param('Height',    50,  { min: 20, max: 150 });
-const fold = param('Fold',      1,   { min: 0, max: 1, step: 0.01 });
-const kerf = param('Kerf',      0.2, { min: 0, max: 0.5, step: 0.05 });
+const t    = Param.number('Thickness', 3,   { min: 2, max: 6, step: 0.5 });
+const w    = Param.number('Width',     100, { min: 40, max: 300 });
+const d    = Param.number('Depth',     80,  { min: 40, max: 200 });
+const h    = Param.number('Height',    50,  { min: 20, max: 150 });
+const fold = Param.number('Fold',      1,   { min: 0, max: 1, step: 0.01 });
+const kerf = Param.number('Kerf',      0.2, { min: 0, max: 0.5, step: 0.05 });
 
 // ── Create flat panels ─────────────────────────────────────────────
 // Each panel is a named rectangle with four edges: bottom, right, top, left.

package/examples/products/laser-cut-tray.forge.js

@@ -15,12 +15,12 @@
 //   • Step-by-step assembly instructions
 
 // ── Parameters ─────────────────────────────────────────────────────────
-const t    = param('Thickness', 3,   { min: 2,  max: 6,   step: 0.5  });
-const w    = param('Width',     200, { min: 80, max: 400            });
-const d    = param('Depth',     120, { min: 60, max: 250            });
-const h    = param('Height',     50, { min: 20, max: 120            });
-const fold = param('Fold',        1, { min: 0,  max: 1,   step: 0.01 });
-const kerf = param('Kerf',      0.2, { min: 0,  max: 0.5, step: 0.05 });
+const t    = Param.number('Thickness', 3,   { min: 2,  max: 6,   step: 0.5  });
+const w    = Param.number('Width',     200, { min: 80, max: 400            });
+const d    = Param.number('Depth',     120, { min: 60, max: 250            });
+const h    = Param.number('Height',     50, { min: 20, max: 120            });
+const fold = Param.number('Fold',        1, { min: 0,  max: 1,   step: 0.01 });
+const kerf = Param.number('Kerf',      0.2, { min: 0,  max: 0.5, step: 0.05 });
 
 // ── Flat panels ─────────────────────────────────────────────────────────
 // Named edges: bottom, right, top, left — CCW winding, origin at corner.

package/examples/products/liquid-soap-dispenser.forge.js

@@ -1,11 +1,11 @@
 // Liquid Soap Dispenser — staged dispense animation without fluid simulation.
 // Move "Dispense Progress" from 0 → 100 to preview one pump cycle.
 
-const bodyH = param("Bottle Height", 130, { min: 90, max: 180, unit: "mm" });
-const bodyR = param("Bottle Radius", 34, { min: 24, max: 45, unit: "mm" });
-const wall = param("Wall Thickness", 2.8, { min: 1.5, max: 5, unit: "mm" });
-const pumpStroke = param("Pump Stroke", 10, { min: 4, max: 18, unit: "mm" });
-const progressPct = param("Dispense Progress", 0, { min: 0, max: 100, unit: "%" });
+const bodyH = Param.number("Bottle Height", 130, { min: 90, max: 180, unit: "mm" });
+const bodyR = Param.number("Bottle Radius", 34, { min: 24, max: 45, unit: "mm" });
+const wall = Param.number("Wall Thickness", 2.8, { min: 1.5, max: 5, unit: "mm" });
+const pumpStroke = Param.number("Pump Stroke", 10, { min: 4, max: 18, unit: "mm" });
+const progressPct = Param.number("Dispense Progress", 0, { min: 0, max: 100, unit: "%" });
 
 const progress = progressPct / 100;
 const clamp01 = (v) => Math.max(0, Math.min(1, v));
@@ -41,30 +41,30 @@ const nozzleTipX = nozzleRootX + nozzleL;
 const nozzleZ = headZ + 1;
 
 // Bottle shell + neck.
-const bottleOuter = cylinder(bodyH, bodyR, bodyR, undefined, true)
+const bottleOuter = cylinder(bodyH, bodyR, bodyR)
   .translate(0, 0, bodyH * 0.5);
-const bottleInner = cylinder(bodyH - wall * 1.4, bodyR - wall, bodyR - wall, undefined, true)
+const bottleInner = cylinder(bodyH - wall * 1.4, bodyR - wall, bodyR - wall)
   .translate(0, 0, wall + (bodyH - wall * 1.4) * 0.5);
 const bottleShell = bottleOuter.subtract(bottleInner);
 
-const neckOuter = cylinder(neckH, neckR, neckR, undefined, true).translate(0, 0, bodyH + neckH * 0.5 - 2);
-const neckHole = cylinder(neckH + 6, chamberR - 2.5, chamberR - 2.5, undefined, true)
+const neckOuter = cylinder(neckH, neckR, neckR).translate(0, 0, bodyH + neckH * 0.5 - 2);
+const neckHole = cylinder(neckH + 6, chamberR - 2.5, chamberR - 2.5)
   .translate(0, 0, bodyH + neckH * 0.5 - 2);
 const bottle = union(bottleShell, neckOuter).subtract(neckHole);
 
 // Pump chamber.
-const chamberOuter = cylinder(chamberH, chamberR, chamberR, undefined, true)
+const chamberOuter = cylinder(chamberH, chamberR, chamberR)
   .translate(0, 0, chamberBottomZ + chamberH * 0.5);
-const chamberInner = cylinder(chamberH - 4, chamberInnerR, chamberInnerR, undefined, true)
+const chamberInner = cylinder(chamberH - 4, chamberInnerR, chamberInnerR)
   .translate(0, 0, chamberBottomZ + chamberH * 0.5 + 1.2);
 const chamberShell = chamberOuter.subtract(chamberInner);
 
 // Pump head + nozzle.
-const head = box(headW, headD, headH, true).translate(0, 0, headZ);
-const nozzleOuter = cylinder(nozzleL, nozzleR, nozzleR * 0.92, undefined, true)
+const head = box(headW, headD, headH).translate(0, 0, headZ);
+const nozzleOuter = cylinder(nozzleL, nozzleR, nozzleR * 0.92)
   .pointAlong([1, 0, 0])
   .translate(nozzleCenterX, 0, nozzleZ);
-const nozzleInner = cylinder(nozzleL + 2, 1.5, 1.35, undefined, true)
+const nozzleInner = cylinder(nozzleL + 2, 1.5, 1.35)
   .pointAlong([1, 0, 0])
   .translate(nozzleCenterX, 0, nozzleZ);
 const nozzle = nozzleOuter.subtract(nozzleInner);
@@ -72,12 +72,12 @@ const nozzle = nozzleOuter.subtract(nozzleInner);
 // Stem + piston (moves with the head).
 const pistonH = 7;
 const pistonZ = chamberTopZ - 8 - press * pumpStroke * 0.9;
-const piston = cylinder(pistonH, chamberR - 3.1, chamberR - 3.1, undefined, true).translate(0, 0, pistonZ);
+const piston = cylinder(pistonH, chamberR - 3.1, chamberR - 3.1).translate(0, 0, pistonZ);
 
 const stemTopZ = headZ - headH * 0.5;
 const stemBottomZ = pistonZ + pistonH * 0.5;
 const stemLen = Math.max(8, stemTopZ - stemBottomZ);
-const stem = cylinder(stemLen, 2.2, 2.2, undefined, true).translate(0, 0, (stemTopZ + stemBottomZ) * 0.5);
+const stem = cylinder(stemLen, 2.2, 2.2).translate(0, 0, (stemTopZ + stemBottomZ) * 0.5);
 
 // Return spring shown as compressed ring stack.
 const springBottomZ = chamberBottomZ + 8;
@@ -88,8 +88,8 @@ const springRings = [];
 for (let i = 0; i < springTurns; i++) {
   const t = i / Math.max(1, springTurns - 1);
   const z = springBottomZ + t * springSpan;
-  const ringOuter = cylinder(1.2, chamberR - 4.2, chamberR - 4.2, undefined, true).translate(0, 0, z);
-  const ringInner = cylinder(2.4, chamberR - 5.3, chamberR - 5.3, undefined, true).translate(0, 0, z);
+  const ringOuter = cylinder(1.2, chamberR - 4.2, chamberR - 4.2).translate(0, 0, z);
+  const ringInner = cylinder(2.4, chamberR - 5.3, chamberR - 5.3).translate(0, 0, z);
   springRings.push(ringOuter.subtract(ringInner));
 }
 const spring = union(...springRings);
@@ -98,8 +98,8 @@ const spring = union(...springRings);
 const tubeBottomZ = 8;
 const tubeTopZ = chamberBottomZ + 6;
 const tubeLen = tubeTopZ - tubeBottomZ;
-const tubeOuter = cylinder(tubeLen, 2.5, 2.5, undefined, true).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
-const tubeInner = cylinder(tubeLen + 2, 1.2, 1.2, undefined, true).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
+const tubeOuter = cylinder(tubeLen, 2.5, 2.5).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
+const tubeInner = cylinder(tubeLen + 2, 1.2, 1.2).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
 const dipTube = tubeOuter.subtract(tubeInner);
 
 // Check valves: inlet opens during release, outlet opens during press.
@@ -120,18 +120,18 @@ const reservoir = cylinder(reservoirLevel, bodyR - wall - 1, bodyR - wall - 1)
   .translate(0, 0, 4 + reservoirLevel * 0.5);
 
 const tubeSlugH = 6 + drawPhase * (tubeLen - 10);
-const tubeLiquid = cylinder(tubeSlugH, 1.1, 1.1, undefined, true)
+const tubeLiquid = cylinder(tubeSlugH, 1.1, 1.1)
   .translate(0, 0, tubeBottomZ + tubeSlugH * 0.5);
 
 const chamberLiquidH = Math.max(2, 9 + drawPhase * 17 - pushPhase * 16);
-const chamberLiquid = cylinder(chamberLiquidH, chamberR - 4.8, chamberR - 4.8, undefined, true)
+const chamberLiquid = cylinder(chamberLiquidH, chamberR - 4.8, chamberR - 4.8)
   .translate(0, 0, chamberBottomZ + 4 + chamberLiquidH * 0.5);
 
 const flowIn = clamp01((progress - 0.45) / 0.2);
 const flowOut = 1 - clamp01((progress - 0.8) / 0.15);
 const nozzleFlow = clamp01(flowIn * flowOut);
 const nozzleLiquidLen = Math.max(1, 1 + nozzleFlow * (nozzleL - 3));
-const nozzleLiquid = cylinder(nozzleLiquidLen, 1.05, 0.95, undefined, true)
+const nozzleLiquid = cylinder(nozzleLiquidLen, 1.05, 0.95)
   .pointAlong([1, 0, 0])
   .translate(nozzleRootX + nozzleLiquidLen * 0.5, 0, nozzleZ);
 

package/examples/products/origami-fish.forge.js

@@ -1,12 +1,12 @@
 // Origami Fish
 // Stylized folded-paper fish inspired by a side-view crane-fish form.
 
-const scale = param("Scale", 1.25, { min: 0.7, max: 1.9, step: 0.05 });
-const paper = param("Paper Thickness", 0.9, { min: 0.4, max: 2, step: 0.05, unit: "mm" });
-const fold = param("Fold", 30, { min: 0, max: 65, unit: "°" });
-const tailSpread = param("Tail Spread", 34, { min: 10, max: 70, unit: "°" });
-const tailDrop = param("Tail Drop", 26, { min: 0, max: 55, unit: "°" });
-const showStand = param("Show Stand", 1, { min: 0, max: 1, integer: true });
+const scale = Param.number("Scale", 1.25, { min: 0.7, max: 1.9, step: 0.05 });
+const paper = Param.number("Paper Thickness", 0.9, { min: 0.4, max: 2, step: 0.05, unit: "mm" });
+const fold = Param.number("Fold", 30, { min: 0, max: 65, unit: "°" });
+const tailSpread = Param.number("Tail Spread", 34, { min: 10, max: 70, unit: "°" });
+const tailDrop = Param.number("Tail Drop", 26, { min: 0, max: 55, unit: "°" });
+const showStand = Param.number("Show Stand", 1, { min: 0, max: 1, integer: true });
 
 const redMain = "#c51f3a";
 const redLight = "#d8324f";
@@ -16,23 +16,25 @@ const S = (v) => v * scale;
 const toPts = (pts) => pts.map(([x, y]) => [S(x), S(y)]);
 
 function pose(shape) {
-  return shape.rotateAround([0, 0, 0], 14, -8, 20).translate(S(6), S(0), S(36));
+  return shape.rotateX(14).rotateY(-8).rotateZ(20).translate(S(6), S(0), S(36));
 }
 
 function panel(name, pts, color, rotate = [0, 0, 0], translate = [0, 0, 0]) {
   const shape = polygon(toPts(pts))
-    .extrude(paper, { center: true })
+    .extrude(paper)
+    .translate(0, 0, -paper / 2)
     .color(color)
-    .rotateAround([0, 0, 0], rotate[0], rotate[1], rotate[2])
+    .rotateX(rotate[0]).rotateY(rotate[1]).rotateZ(rotate[2])
     .translate(S(translate[0]), S(translate[1]), S(translate[2]));
   return { name, shape: pose(shape) };
 }
 
 function ridge(name, pts, width, color, rotate = [0, 0, 0], translate = [0, 0, 0]) {
   const shape = stroke(toPts(pts), S(width), "Round")
-    .extrude(paper * 0.9, { center: true })
+    .extrude(paper * 0.9)
+    .translate(0, 0, -paper * 0.45)
     .color(color)
-    .rotateAround([0, 0, 0], rotate[0], rotate[1], rotate[2])
+    .rotateX(rotate[0]).rotateY(rotate[1]).rotateZ(rotate[2])
     .translate(S(translate[0]), S(translate[1]), S(translate[2]));
   return { name, shape: pose(shape) };
 }
@@ -130,7 +132,7 @@ if (showStand === 1) {
     .color("#6f6f77")
     .translate(S(0), S(-4), S(-52));
 
-  const clip = cylinder(S(7), S(2.6), S(1.2), 28, true)
+  const clip = cylinder(S(7), S(2.6), S(1.2), 28)
     .pointAlong([0, 1, 0])
     .color("#56565d")
     .translate(S(1), S(-4), S(34));

package/examples/products/spiderman-cake.forge.js

@@ -1,8 +1,8 @@
 // Spider-Man Birthday Cake
 // A multi-tiered cake with Spider-Man colors and decorations.
 
-const tierHeight = param("Tier Height", 30, { min: 20, max: 50, unit: "mm" });
-const baseRadius = param("Base Radius", 60, { min: 40, max: 100, unit: "mm" });
+const tierHeight = Param.number("Tier Height", 30, { min: 20, max: 50, unit: "mm" });
+const baseRadius = Param.number("Base Radius", 60, { min: 40, max: 100, unit: "mm" });
 
 // Colors
 const spideyRed = '#e60000';
@@ -45,12 +45,12 @@ const eyeW = topRadius * 0.4;
 const eyeH = tierHeight * 0.6;
 const eyeT = 2;
 
-const leftEye = box(eyeW, eyeT, eyeH, true).color(spideyWhite)
-  .rotateAround([0, 0, 0], 0, 0, 20)
+const leftEye = box(eyeW, eyeT, eyeH).color(spideyWhite)
+  .rotateZ(20)
   .onFace(topTier, 'front', { u: -topRadius * 0.35, v: 0, protrude: 1 });
 
-const rightEye = box(eyeW, eyeT, eyeH, true).color(spideyWhite)
-  .rotateAround([0, 0, 0], 0, 0, -20)
+const rightEye = box(eyeW, eyeT, eyeH).color(spideyWhite)
+  .rotateZ(-20)
   .onFace(topTier, 'front', { u: topRadius * 0.35, v: 0, protrude: 1 });
 
 cake.push({ name: "Top Tier", shape: topTier });

package/examples/shelf/container.forge.js

@@ -1,11 +1,11 @@
 // Storage Container — parametric open-top bin
 // Used by shelf-unit.forge.js via require()
 
-const w = param("Container Width", 120, { min: 60, max: 200, unit: "mm" });
-const d = param("Container Depth", 180, { min: 100, max: 300, unit: "mm" });
-const h = param("Container Height", 100, { min: 50, max: 200, unit: "mm" });
-const wall = param("Wall", 3, { min: 1.5, max: 6, unit: "mm" });
-const lipH = param("Lip Height", 5, { min: 2, max: 10, unit: "mm" });
+const w = Param.number("Container Width", 120, { min: 60, max: 200, unit: "mm" });
+const d = Param.number("Container Depth", 180, { min: 100, max: 300, unit: "mm" });
+const h = Param.number("Container Height", 100, { min: 50, max: 200, unit: "mm" });
+const wall = Param.number("Wall", 3, { min: 1.5, max: 6, unit: "mm" });
+const lipH = Param.number("Lip Height", 5, { min: 2, max: 10, unit: "mm" });
 
 // Outer shell
 const outer = box(w, d, h);

package/examples/shelf/shelf-unit.forge.js

@@ -1,12 +1,12 @@
 // Tool Shelf — multi-shelf unit with identical containers
 // Demonstrates require() for reusing the same container across shelves
 
-const shelfW = param("Shelf Width", 800, { min: 400, max: 1200, unit: "mm" });
-const shelfD = param("Shelf Depth", 200, { min: 150, max: 350, unit: "mm" });
-const totalH = param("Total Height", 1200, { min: 600, max: 1800, unit: "mm" });
-const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
-const rows = param("Shelf Rows", 4, { min: 2, max: 6, integer: true });
-const cols = param("Containers/Row", 3, { min: 1, max: 6, integer: true });
+const shelfW = Param.number("Shelf Width", 800, { min: 400, max: 1200, unit: "mm" });
+const shelfD = Param.number("Shelf Depth", 200, { min: 150, max: 350, unit: "mm" });
+const totalH = Param.number("Total Height", 1200, { min: 600, max: 1800, unit: "mm" });
+const boardT = Param.number("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+const rows = Param.number("Shelf Rows", 4, { min: 2, max: 6, integer: true });
+const cols = Param.number("Containers/Row", 3, { min: 1, max: 6, integer: true });
 
 // Container dimensions (must match container.forge.js defaults or be close)
 const containerW = 120;

package/examples/toolbox/bolted-joint.forge.js

@@ -7,11 +7,11 @@
 //   - BOM listing fastener quantities
 //   - Optional exploded view
 
-const plateW    = param("Plate Width",  60, { min: 40, max: 120, unit: "mm" });
-const plateD    = param("Plate Depth",  40, { min: 30, max:  80, unit: "mm" });
-const topThick  = param("Top Thick",     8, { min:  4, max:  20, unit: "mm" });
-const botThick  = param("Bot Thick",     8, { min:  4, max:  20, unit: "mm" });
-const exploded  = param("Explode",       0, { min:  0, max:  1,  step: 1 });
+const plateW    = Param.number("Plate Width",  60, { min: 40, max: 120, unit: "mm" });
+const plateD    = Param.number("Plate Depth",  40, { min: 30, max:  80, unit: "mm" });
+const topThick  = Param.number("Top Thick",     8, { min:  4, max:  20, unit: "mm" });
+const botThick  = Param.number("Bot Thick",     8, { min:  4, max:  20, unit: "mm" });
+const exploded  = Param.number("Explode",       0, { min:  0, max:  1,  step: 1 });
 
 // Bolt-circle inset from plate edge
 const inset = 10;
@@ -32,7 +32,7 @@ const hw      = lib.fastenerSet("M5", grip + 4);
 const { dims } = hw;
 
 // --- Top plate: clearance holes (normal fit) ---
-let topPlate = box(plateW, plateD, topThick, true);
+let topPlate = box(plateW, plateD, topThick);
 for (const [x, y] of boltPositions) {
   topPlate = topPlate.subtract(
     hw.clearanceHole.translate(x, y, 0),
@@ -47,7 +47,7 @@ const botCenter  = -(topThick / 2 + botThick / 2);
 const botFace    =  botCenter - botThick / 2;   // bottom face of bottom plate
 
 // --- Bottom plate: tapped holes ---
-let botPlate = box(plateW, plateD, botThick, true).translate(0, 0, botCenter);
+let botPlate = box(plateW, plateD, botThick).translate(0, 0, botCenter);
 for (const [x, y] of boltPositions) {
   botPlate = botPlate.subtract(
     hw.tappedHole.translate(x, y, botCenter),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.6.3",
+  "version": "0.8.0",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "BUSL-1.1",
   "type": "module",
@@ -8,7 +8,7 @@
     "forgecad": "./dist-cli/forgecad.js"
   },
   "files": [
-    "dist-cli/forgecad.js",
+    "dist-cli",
     "dist",
     "dist-skill",
     "examples",
@@ -38,14 +38,16 @@
     "build:hosted": "npm run build:solver && npm run build:skill:forgecad && tsc && npm run build:sitemap && FORGE_HOSTED=true vite build",
     "dev:cli": "tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --sourcemap --external typescript",
     "build:cli": "tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --clean --sourcemap --external typescript",
+    "build:backend": "tsup apps/backend/src/server.ts --format esm --platform node --target node20 --out-dir dist-backend --clean --sourcemap",
     "build:binary": "node scripts/build-binary.mjs",
     "build:binary:all": "node scripts/build-binary.mjs --all",
     "lint": "npx biome check .",
     "lint:fix": "npx biome check . --write",
     "format": "npx biome format . --write",
-    "test": "npm run test:prepare && npm run test:unit && node dist-cli/forgecad.js check suite",
+    "test": "npm run test:prepare && node dist-cli/forgecad.js check suite --profile local",
+    "test:full": "npm run test:prepare && node dist-cli/forgecad.js check suite",
     "test:unit": "vitest run",
-    "test:prepare": "tsc --noEmit && npm run build:cli",
+    "test:prepare": "npm run build:solver:if-missing && tsc --noEmit && npm run build:cli",
     "test:compiler": "npm run test:prepare && node dist-cli/forgecad.js check compiler",
     "test:compiler:update": "npm run test:prepare && node dist-cli/forgecad.js check compiler --update",
     "test:query-propagation": "npm run test:prepare && node dist-cli/forgecad.js check query-propagation",
@@ -66,6 +68,7 @@
     "meta:path": "bash scripts/local-meta.sh path",
     "gen:types": "node scripts/gen-forge-types.mjs",
     "gen:docs": "node scripts/gen-api-docs.mjs",
+    "gen:cli-docs": "node scripts/gen-cli-docs.mjs",
     "refresh": "node scripts/refresh.mjs"
   },
   "dependencies": {
@@ -85,6 +88,7 @@
     "lz-string": "^1.5.0",
     "manifold-3d": "^3.4.0",
     "meshoptimizer": "^1.0.1",
+    "mp4-muxer": "^5.2.1",
     "nanoid": "^5.1.7",
     "opencascade.js": "2.0.0-beta.b5ff984",
     "opentype.js": "^1.3.4",
@@ -95,6 +99,7 @@
     "puppeteer-core": "^24.37.2",
     "react-router-dom": "^7.13.2",
     "resend": "^6.9.4",
+    "stripe": "^21.0.1",
     "typescript": "^5.8.3",
     "zod": "^4.3.6"
   },