forgecad 0.6.3 → 0.8.0

package/examples/furniture/bathroom.forge.js

@@ -1,11 +1,11 @@
 // Full Bathroom — parametric room with fixtures
 // Bathtub, sink, toilet, mirror, shower glass panel, towel rack
 
-const roomW = param("Room Width", 2400, { min: 1800, max: 3500, unit: "mm" });
-const roomD = param("Room Depth", 2000, { min: 1500, max: 3000, unit: "mm" });
-const roomH = param("Room Height", 2500, { min: 2200, max: 3000, unit: "mm" });
-const wallT = param("Wall Thickness", 80, { min: 50, max: 150, unit: "mm" });
-const tileH = param("Tile Height", 1200, { min: 800, max: 1800, unit: "mm" });
+const roomW = Param.number("Room Width", 2400, { min: 1800, max: 3500, unit: "mm" });
+const roomD = Param.number("Room Depth", 2000, { min: 1500, max: 3000, unit: "mm" });
+const roomH = Param.number("Room Height", 2500, { min: 2200, max: 3000, unit: "mm" });
+const wallT = Param.number("Wall Thickness", 80, { min: 50, max: 150, unit: "mm" });
+const tileH = Param.number("Tile Height", 1200, { min: 800, max: 1800, unit: "mm" });
 
 // ─── Room shell (floor + 3 walls, front open) ───
 
@@ -21,10 +21,10 @@ const tileStrip = box(roomW - 2 * wallT, 2, tileH)
 
 // ─── Bathtub (left-back corner) ───
 
-const tubL = param("Tub Length", 1500, { min: 1200, max: 1800, unit: "mm" });
-const tubW = param("Tub Width", 700, { min: 550, max: 800, unit: "mm" });
-const tubH = param("Tub Height", 500, { min: 400, max: 600, unit: "mm" });
-const tubWall = param("Tub Wall", 40, { min: 25, max: 60, unit: "mm" });
+const tubL = Param.number("Tub Length", 1500, { min: 1200, max: 1800, unit: "mm" });
+const tubW = Param.number("Tub Width", 700, { min: 550, max: 800, unit: "mm" });
+const tubH = Param.number("Tub Height", 500, { min: 400, max: 600, unit: "mm" });
+const tubWall = Param.number("Tub Wall", 40, { min: 25, max: 60, unit: "mm" });
 
 const tubX = wallT + 20;
 const tubY = roomD - wallT - tubW - 20;
@@ -39,7 +39,7 @@ const bathtub = tubOuter.subtract(tubInner).subtract(tubDrain)
 
 // ─── Shower (above tub) ───
 
-const glassH = param("Glass Height", 1800, { min: 1500, max: 2200, unit: "mm" });
+const glassH = Param.number("Glass Height", 1800, { min: 1500, max: 2200, unit: "mm" });
 const glassT = 8;
 
 // Glass panel at tub edge
@@ -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
@@ -62,8 +62,8 @@ const shower = union(showerArm, showerHead);
 
 // ─── Toilet (right side, against back wall) ───
 
-const toiletW = param("Toilet Width", 380, { min: 340, max: 420, unit: "mm" });
-const toiletD = param("Toilet Depth", 650, { min: 550, max: 750, unit: "mm" });
+const toiletW = Param.number("Toilet Width", 380, { min: 340, max: 420, unit: "mm" });
+const toiletD = Param.number("Toilet Depth", 650, { min: 550, max: 750, unit: "mm" });
 const toiletH = 400;
 
 const toiletX = roomW - wallT - toiletW - 150;
@@ -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
@@ -100,7 +100,7 @@ const toilet = union(bowl, tank, lid, seat);
 
 // ─── Sink (right wall, facing into room) ───
 
-const sinkW = param("Sink Width", 550, { min: 400, max: 700, unit: "mm" });
+const sinkW = Param.number("Sink Width", 550, { min: 400, max: 700, unit: "mm" });
 const sinkD = 420;
 const sinkH = 160;
 const sinkZ = 850;
@@ -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,20 +124,20 @@ 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);
 
 // ─── Mirror (on right wall, above sink) ───
 
-const mirrorW = param("Mirror Width", 600, { min: 400, max: 900, unit: "mm" });
-const mirrorH = param("Mirror Height", 800, { min: 500, max: 1200, unit: "mm" });
+const mirrorW = Param.number("Mirror Width", 600, { min: 400, max: 900, unit: "mm" });
+const mirrorH = Param.number("Mirror Height", 800, { min: 500, max: 1200, unit: "mm" });
 const mirrorT = 5;
 const frameW = 15;
 
@@ -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

@@ -1,20 +1,20 @@
 // Four-Legged Chair — parametric dining chair
 
-const seatW = param("Seat Width", 45, { min: 30, max: 60, unit: "mm" });
-const seatD = param("Seat Depth", 42, { min: 30, max: 55, unit: "mm" });
-const seatT = param("Seat Thickness", 3, { min: 2, max: 6, unit: "mm" });
-const seatH = param("Seat Height", 45, { min: 35, max: 55, unit: "mm" });
+const seatW = Param.number("Seat Width", 45, { min: 30, max: 60, unit: "mm" });
+const seatD = Param.number("Seat Depth", 42, { min: 30, max: 55, unit: "mm" });
+const seatT = Param.number("Seat Thickness", 3, { min: 2, max: 6, unit: "mm" });
+const seatH = Param.number("Seat Height", 45, { min: 35, max: 55, unit: "mm" });
 
-const legW = param("Leg Width", 4, { min: 2, max: 8, unit: "mm" });
-const legInset = param("Leg Inset", 3, { min: 0, max: 10, unit: "mm" });
+const legW = Param.number("Leg Width", 4, { min: 2, max: 8, unit: "mm" });
+const legInset = Param.number("Leg Inset", 3, { min: 0, max: 10, unit: "mm" });
 
-const backH = param("Back Height", 40, { min: 25, max: 60, unit: "mm" });
-const backT = param("Back Thickness", 3, { min: 2, max: 6, unit: "mm" });
-const backTilt = param("Back Tilt", 5, { min: 0, max: 15, unit: "°" });
+const backH = Param.number("Back Height", 40, { min: 25, max: 60, unit: "mm" });
+const backT = Param.number("Back Thickness", 3, { min: 2, max: 6, unit: "mm" });
+const backTilt = Param.number("Back Tilt", 5, { min: 0, max: 15, unit: "°" });
 
-const stretcher = param("Stretchers", 1, { min: 0, max: 1, step: 1 });
-const stretcherH = param("Stretcher Height", 12, { min: 5, max: 30, unit: "mm" });
-const stretcherW = param("Stretcher Width", 2, { min: 1, max: 4, unit: "mm" });
+const stretcher = Param.number("Stretchers", 1, { min: 0, max: 1, step: 1 });
+const stretcherH = Param.number("Stretcher Height", 12, { min: 5, max: 30, unit: "mm" });
+const stretcherW = Param.number("Stretcher Width", 2, { min: 1, max: 4, unit: "mm" });
 
 // --- Seat ---
 const seat = box(seatW, seatD, seatT).translate(0, 0, seatH);
@@ -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/furniture/picture-frame.forge.js

@@ -1,11 +1,11 @@
 // Picture Frame — parametric wall frame with optional mat border
 
-const frameW = param("Frame Width", 120, { min: 60, max: 250, unit: "mm" });
-const frameH = param("Frame Height", 160, { min: 80, max: 300, unit: "mm" });
-const border = param("Border Width", 12, { min: 5, max: 30, unit: "mm" });
-const depth = param("Frame Depth", 8, { min: 3, max: 20, unit: "mm" });
-const mat = param("Mat Width", 8, { min: 0, max: 20, unit: "mm" });
-const matDepth = param("Mat Depth", 2, { min: 1, max: 5, unit: "mm" });
+const frameW = Param.number("Frame Width", 120, { min: 60, max: 250, unit: "mm" });
+const frameH = Param.number("Frame Height", 160, { min: 80, max: 300, unit: "mm" });
+const border = Param.number("Border Width", 12, { min: 5, max: 30, unit: "mm" });
+const depth = Param.number("Frame Depth", 8, { min: 3, max: 20, unit: "mm" });
+const mat = Param.number("Mat Width", 8, { min: 0, max: 20, unit: "mm" });
+const matDepth = Param.number("Mat Depth", 2, { min: 1, max: 5, unit: "mm" });
 
 // Outer frame
 const outer = box(frameW, frameH, depth);

package/examples/furniture/shoe-rack-doors.forge.js

@@ -3,17 +3,17 @@
 // 4 doors (2 per shelf level), hinged at the outer edges.
 // Each pair shares one angle slider for synchronized open/close.
 
-const width = param("Width", 800, { min: 500, max: 1200, unit: "mm" });
-const depth = param("Depth", 350, { min: 250, max: 500, unit: "mm" });
-const totalH = param("Total Height", 500, { min: 350, max: 650, unit: "mm" });
+const width = Param.number("Width", 800, { min: 500, max: 1200, unit: "mm" });
+const depth = Param.number("Depth", 350, { min: 250, max: 500, unit: "mm" });
+const totalH = Param.number("Total Height", 500, { min: 350, max: 650, unit: "mm" });
 
-const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+const boardT = Param.number("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
 
-const seatPad = param("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
-const seatOverhang = param("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
+const seatPad = Param.number("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
+const seatOverhang = Param.number("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
 
-const doorT = param("Door Thickness", 8, { min: 4, max: 15, unit: "mm" });
-const doorGap = param("Door Gap", 2, { min: 1, max: 5, unit: "mm" });
+const doorT = Param.number("Door Thickness", 8, { min: 4, max: 15, unit: "mm" });
+const doorGap = Param.number("Door Gap", 2, { min: 1, max: 5, unit: "mm" });
 
 // Derived
 const innerW = width - 2 * boardT;

package/examples/furniture/shoe-rack.forge.js

@@ -3,16 +3,16 @@
 // Structure: two side panels, bottom board, 2 shelves, top board,
 // back panel for rigidity, and a cushion on top for sitting.
 
-const width = param("Width", 800, { min: 500, max: 1200, unit: "mm" });
-const depth = param("Depth", 350, { min: 250, max: 500, unit: "mm" });
-const totalH = param("Total Height", 500, { min: 350, max: 650, unit: "mm" });
+const width = Param.number("Width", 800, { min: 500, max: 1200, unit: "mm" });
+const depth = Param.number("Depth", 350, { min: 250, max: 500, unit: "mm" });
+const totalH = Param.number("Total Height", 500, { min: 350, max: 650, unit: "mm" });
 
-const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+const boardT = Param.number("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
 
-const seatPad = param("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
-const seatOverhang = param("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
+const seatPad = Param.number("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
+const seatOverhang = Param.number("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
 
-const divider = param("Center Divider", 1, { min: 0, max: 1, step: 1 });
+const divider = Param.number("Center Divider", 1, { min: 0, max: 1, step: 1 });
 
 // Derived
 const innerW = width - 2 * boardT;

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

@@ -1,13 +1,13 @@
 // Table Lamp — base + stem + shade (multi-file: imports shade profile)
 
-const baseR = param("Base Radius", 25, { min: 15, max: 40, unit: "mm" });
-const baseH = param("Base Height", 6, { min: 3, max: 12, unit: "mm" });
-const stemR = param("Stem Radius", 4, { min: 2, max: 8, unit: "mm" });
-const stemH = param("Stem Height", 60, { min: 30, max: 100, unit: "mm" });
-const shadeTopR = param("Shade Top Radius", 15, { min: 8, max: 30, unit: "mm" });
-const shadeBottomR = param("Shade Bottom Radius", 30, { min: 15, max: 50, unit: "mm" });
-const shadeH = param("Shade Height", 35, { min: 20, max: 60, unit: "mm" });
-const shadeWall = param("Shade Wall", 1.5, { min: 0.5, max: 4, unit: "mm" });
+const baseR = Param.number("Base Radius", 25, { min: 15, max: 40, unit: "mm" });
+const baseH = Param.number("Base Height", 6, { min: 3, max: 12, unit: "mm" });
+const stemR = Param.number("Stem Radius", 4, { min: 2, max: 8, unit: "mm" });
+const stemH = Param.number("Stem Height", 60, { min: 30, max: 100, unit: "mm" });
+const shadeTopR = Param.number("Shade Top Radius", 15, { min: 8, max: 30, unit: "mm" });
+const shadeBottomR = Param.number("Shade Bottom Radius", 30, { min: 15, max: 50, unit: "mm" });
+const shadeH = Param.number("Shade Height", 35, { min: 20, max: 60, unit: "mm" });
+const shadeWall = Param.number("Shade Wall", 1.5, { min: 0.5, max: 4, unit: "mm" });
 
 // --- Base: flat cylinder ---
 const base = cylinder(baseH, baseR);

package/examples/gcode/lissajous-vase.forge.js

@@ -5,10 +5,10 @@
  * Creates beautiful organic-looking walls with a continuously changing profile.
  */
 
-const a = param('a', 3, 1, 7);     // X frequency
-const b = param('b', 2, 1, 7);     // Y frequency
-const baseRadius = param('radius', 25, 10, 50);
-const height = param('height', 100, 30, 200);
+const a = Param.number('a', 3, 1, 7);     // X frequency
+const b = Param.number('b', 2, 1, 7);     // Y frequency
+const baseRadius = Param.number('radius', 25, 10, 50);
+const height = Param.number('height', 100, 30, 200);
 const layerHeight = 0.2;
 
 const g = gcode({ nozzle: 0.4, layerHeight, printSpeed: 1800 });

package/examples/gcode/math-surface.forge.js

@@ -7,9 +7,9 @@
  * The surface function creates an undulating bowl shape.
  */
 
-const outerRadius = param('radius', 40, 15, 60);
-const amplitude = param('amplitude', 8, 1, 20);
-const waves = param('waves', 4, 1, 8);
+const outerRadius = Param.number('radius', 40, 15, 60);
+const amplitude = Param.number('amplitude', 8, 1, 20);
+const waves = Param.number('waves', 4, 1, 8);
 const layerHeight = 0.3;
 const lineSpacing = 0.6; // spacing between concentric passes
 

package/examples/gcode/parametric-vase.forge.js

@@ -7,10 +7,10 @@
  * Try tweaking: amplitude, frequency, baseRadius, height, layerHeight.
  */
 
-const amplitude = param('amplitude', 8, 1, 20);
-const frequency = param('frequency', 6, 1, 20);
-const baseRadius = param('radius', 25, 10, 60);
-const height = param('height', 80, 20, 200);
+const amplitude = Param.number('amplitude', 8, 1, 20);
+const frequency = Param.number('frequency', 6, 1, 20);
+const baseRadius = Param.number('radius', 25, 10, 60);
+const height = Param.number('height', 80, 20, 200);
 const layerHeight = 0.2;
 const nozzle = 0.4;
 

package/examples/gcode/spiral-tower.forge.js

@@ -5,10 +5,10 @@
  * Each layer is a hexagon that twists slightly more than the last.
  */
 
-const sides = param('sides', 6, 3, 12);
-const radius = param('radius', 20, 10, 40);
-const height = param('height', 60, 20, 120);
-const twistDeg = param('twist', 90, 0, 360);
+const sides = Param.number('sides', 6, 3, 12);
+const radius = Param.number('radius', 20, 10, 40);
+const height = Param.number('height', 60, 20, 120);
+const twistDeg = Param.number('twist', 90, 0, 360);
 const layerHeight = 0.2;
 
 const g = gcode({ nozzle: 0.4, layerHeight, printSpeed: 1800 });

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

@@ -36,9 +36,9 @@ scene({
   fog: { color: '#0a0612', near: 350, far: 900 },
 
   postProcessing: {
-    bloom: { intensity: param('bloom', 1.2, 0, 3), threshold: 0.6, radius: 0.5 },
+    bloom: { intensity: Param.number('bloom', 1.2, 0, 3), threshold: 0.6, radius: 0.5 },
     vignette: { darkness: 0.7, offset: 0.3 },
-    toneMappingExposure: param('exposure', 1.3, 0.5, 3),
+    toneMappingExposure: Param.number('exposure', 1.3, 0.5, 3),
   },
 
   capture: {
@@ -50,11 +50,11 @@ scene({
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
-const seed = param('seed', 42, 0, 100);
-const crystalCount = param('crystals', 12, 3, 24);
-const maxHeight = param('maxHeight', 120, 40, 200);
-const baseRadius = param('baseRadius', 80, 30, 150);
-const taperFactor = param('taper', 0.3, 0.1, 0.8);
+const seed = Param.number('seed', 42, 0, 100);
+const crystalCount = Param.number('crystals', 12, 3, 24);
+const maxHeight = Param.number('maxHeight', 120, 40, 200);
+const baseRadius = Param.number('baseRadius', 80, 30, 150);
+const taperFactor = Param.number('taper', 0.3, 0.1, 0.8);
 
 // ---------------------------------------------------------------------------
 // PRNG
@@ -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

@@ -32,10 +32,10 @@ scene({
   fog: { color: '#0a1628', near: 200, far: 550 },
 
   postProcessing: {
-    bloom: { intensity: param('bloom', 1.2, 0, 4), threshold: 0.5, radius: 0.6 },
+    bloom: { intensity: Param.number('bloom', 1.2, 0, 4), threshold: 0.5, radius: 0.6 },
     vignette: { darkness: 0.7, offset: 0.3 },
     grain: { intensity: 0.04 },
-    toneMappingExposure: param('exposure', 1.4, 0.5, 3),
+    toneMappingExposure: Param.number('exposure', 1.4, 0.5, 3),
   },
 
   capture: {
@@ -47,10 +47,10 @@ scene({
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
-const seed = param('seed', 23, 0, 100);
-const spireCount = param('spires', 14, 4, 30);
-const maxHeight = param('maxHeight', 100, 40, 160);
-const spread = param('spread', 55, 20, 100);
+const seed = Param.number('seed', 23, 0, 100);
+const spireCount = Param.number('spires', 14, 4, 30);
+const maxHeight = Param.number('maxHeight', 100, 40, 160);
+const spread = Param.number('spread', 55, 20, 100);
 
 // ---------------------------------------------------------------------------
 // PRNG
@@ -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

@@ -4,7 +4,7 @@
  * A spiraling tower of boxes arranged in a golden-ratio pattern,
  * like a computational sunflower reaching for the sky.
  *
- * Demonstrates: scene(), param() integration, dramatic lighting,
+ * Demonstrates: scene(), Param.number() integration, dramatic lighting,
  * bloom post-processing, and fog depth.
  */
 
@@ -31,9 +31,9 @@ scene({
   fog: { color: '#050510', near: 300, far: 800 },
 
   postProcessing: {
-    bloom: { intensity: param('bloom', 0.8, 0, 3), threshold: 0.7, radius: 0.6 },
+    bloom: { intensity: Param.number('bloom', 0.8, 0, 3), threshold: 0.7, radius: 0.6 },
     vignette: { darkness: 0.6, offset: 0.4 },
-    toneMappingExposure: param('exposure', 1.4, 0.5, 3),
+    toneMappingExposure: Param.number('exposure', 1.4, 0.5, 3),
   },
 
   capture: {
@@ -45,11 +45,11 @@ scene({
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
-const count = param('elements', 120, 20, 300);
-const towerHeight = param('height', 200, 50, 400);
-const spiralTightness = param('tightness', 2.5, 0.5, 6);
-const maxRadius = param('radius', 60, 20, 120);
-const elementScale = param('scale', 1.0, 0.3, 2.0);
+const count = Param.number('elements', 120, 20, 300);
+const towerHeight = Param.number('height', 200, 50, 400);
+const spiralTightness = Param.number('tightness', 2.5, 0.5, 6);
+const maxRadius = Param.number('radius', 60, 20, 120);
+const elementScale = Param.number('scale', 1.0, 0.3, 2.0);
 
 // ---------------------------------------------------------------------------
 // Golden Ratio Spiral
@@ -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' });
 

package/examples/generative/molten-forge.forge.js

@@ -32,10 +32,10 @@ scene({
   fog: { color: '#0a0000', near: 200, far: 500 },
 
   postProcessing: {
-    bloom: { intensity: param('bloom', 2.0, 0, 5), threshold: 0.3, radius: 0.8 },
+    bloom: { intensity: Param.number('bloom', 2.0, 0, 5), threshold: 0.3, radius: 0.8 },
     vignette: { darkness: 0.9, offset: 0.2 },
     grain: { intensity: 0.06 },
-    toneMappingExposure: param('exposure', 1.8, 0.5, 4),
+    toneMappingExposure: Param.number('exposure', 1.8, 0.5, 4),
   },
 
   capture: {
@@ -48,10 +48,10 @@ scene({
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
-const seed = param('seed', 42, 0, 100);
-const pillarCount = param('pillars', 18, 5, 40);
-const maxHeight = param('maxHeight', 90, 30, 150);
-const baseRadius = param('baseRadius', 50, 20, 100);
+const seed = Param.number('seed', 42, 0, 100);
+const pillarCount = Param.number('pillars', 18, 5, 40);
+const maxHeight = Param.number('maxHeight', 90, 30, 150);
+const baseRadius = Param.number('baseRadius', 50, 20, 100);
 
 // ---------------------------------------------------------------------------
 // PRNG

package/examples/generative/neon-coral.forge.js

@@ -32,10 +32,10 @@ scene({
   fog: { color: '#000814', near: 250, far: 600 },
 
   postProcessing: {
-    bloom: { intensity: param('bloom', 1.5, 0, 4), threshold: 0.5, radius: 0.7 },
+    bloom: { intensity: Param.number('bloom', 1.5, 0, 4), threshold: 0.5, radius: 0.7 },
     vignette: { darkness: 0.8, offset: 0.25 },
     grain: { intensity: 0.08 },
-    toneMappingExposure: param('exposure', 1.5, 0.5, 4),
+    toneMappingExposure: Param.number('exposure', 1.5, 0.5, 4),
   },
 
   capture: {
@@ -48,11 +48,11 @@ scene({
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
-const seed = param('seed', 7, 0, 100);
-const stalkCount = param('stalks', 25, 5, 60);
-const maxStalkH = param('maxHeight', 80, 30, 150);
-const clusterSpread = param('spread', 60, 20, 120);
-const tipScale = param('tipSize', 1.5, 0.5, 3);
+const seed = Param.number('seed', 7, 0, 100);
+const stalkCount = Param.number('stalks', 25, 5, 60);
+const maxStalkH = Param.number('maxHeight', 80, 30, 150);
+const clusterSpread = Param.number('spread', 60, 20, 120);
+const tipScale = Param.number('tipSize', 1.5, 0.5, 3);
 
 // ---------------------------------------------------------------------------
 // PRNG