forgecad 0.7.0 → 0.8.0

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 ─────────────────────────────────────────────────────────
+// 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(width / 2, depth / 2, wall + (height - wall) / 2 + 0.01);
+  .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.

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 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 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.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;

package/examples/mechanical/robot_hand_2.forge.js

@@ -3,24 +3,24 @@
 // Strategy: build small reliable modules, then combine with parametric kinematics.
 
 // ---- 1) Control params (motion + fabrication) ----
-const baseYaw = param("Base Yaw", 20, { min: -170, max: 170, unit: "°" });
-const shoulderPitch = param("Shoulder Pitch", 35, { min: -25, max: 105, unit: "°" });
-const elbowPitch = param("Elbow Pitch", 55, { min: -15, max: 135, unit: "°" });
-const wristPitch = param("Wrist Pitch", -20, { min: -100, max: 100, unit: "°" });
-const wristRoll = param("Wrist Roll", 10, { min: -180, max: 180, unit: "°" });
+const baseYaw = Param.number("Base Yaw", 20, { min: -170, max: 170, unit: "°" });
+const shoulderPitch = Param.number("Shoulder Pitch", 35, { min: -25, max: 105, unit: "°" });
+const elbowPitch = Param.number("Elbow Pitch", 55, { min: -15, max: 135, unit: "°" });
+const wristPitch = Param.number("Wrist Pitch", -20, { min: -100, max: 100, unit: "°" });
+const wristRoll = Param.number("Wrist Roll", 10, { min: -180, max: 180, unit: "°" });
 
-const upperLen = param("Upper Arm Len", 210, { min: 140, max: 320, unit: "mm" });
-const foreLen = param("Forearm Len", 220, { min: 150, max: 340, unit: "mm" });
-const foreExtension = param("Forearm Ext", 70, { min: 0, max: 150, unit: "mm" });
+const upperLen = Param.number("Upper Arm Len", 210, { min: 140, max: 320, unit: "mm" });
+const foreLen = Param.number("Forearm Len", 220, { min: 150, max: 340, unit: "mm" });
+const foreExtension = Param.number("Forearm Ext", 70, { min: 0, max: 150, unit: "mm" });
 
-const gripperOpen = param("Gripper Open", 55, { min: 0, max: 90, unit: "mm" });
-const fingerCurl = param("Finger Curl", 72, { min: 0, max: 100, unit: "°" });
-const payloadType = param("Payload Type", 2, { min: 1, max: 4, integer: true });
-const payloadSize = param("Payload Size", 36, { min: 20, max: 65, unit: "mm" });
-const carryPayload = param("Carry Payload", 1, { min: 0, max: 1, integer: true });
+const gripperOpen = Param.number("Gripper Open", 55, { min: 0, max: 90, unit: "mm" });
+const fingerCurl = Param.number("Finger Curl", 72, { min: 0, max: 100, unit: "°" });
+const payloadType = Param.number("Payload Type", 2, { min: 1, max: 4, integer: true });
+const payloadSize = Param.number("Payload Size", 36, { min: 20, max: 65, unit: "mm" });
+const carryPayload = Param.number("Carry Payload", 1, { min: 0, max: 1, integer: true });
 
-const exploded = param("Exploded", 0, { min: 0, max: 140, unit: "mm" });
-const sectionEnabled = param("Section Enabled", 0, { min: 0, max: 1, integer: true });
+const exploded = Param.number("Exploded", 0, { min: 0, max: 140, unit: "mm" });
+const sectionEnabled = Param.number("Section Enabled", 0, { min: 0, max: 1, integer: true });
 
 // ---- 2) Math + transform helpers ----
 function rad(deg) {
@@ -602,12 +602,12 @@ const sectionMarginZ = Math.max(30, (sceneBounds.max[2] - sceneBounds.min[2]) *
 const sectionDefaultX = (sceneBounds.min[0] + sceneBounds.max[0]) * 0.5;
 const sectionDefaultZ = (sceneBounds.min[2] + sceneBounds.max[2]) * 0.5;
 
-const sectionX = param("Section X", sectionDefaultX, {
+const sectionX = Param.number("Section X", sectionDefaultX, {
   min: sceneBounds.min[0] - sectionMarginX,
   max: sceneBounds.max[0] + sectionMarginX,
   unit: "mm",
 });
-const sectionZ = param("Section Z", sectionDefaultZ, {
+const sectionZ = Param.number("Section Z", sectionDefaultZ, {
   min: sceneBounds.min[2] - sectionMarginZ,
   max: sceneBounds.max[2] + sectionMarginZ,
   unit: "mm",

package/examples/nurbs-surface.forge.js

@@ -0,0 +1,8 @@
+// Freeform NURBS surface — a gently curved panel
+const grid = [
+  [[0,0,0],  [10,0,2],  [20,0,2],  [30,0,0]],
+  [[0,10,1], [10,10,6], [20,10,6], [30,10,1]],
+  [[0,20,1], [10,20,6], [20,20,6], [30,20,1]],
+  [[0,30,0], [10,30,2], [20,30,2], [30,30,0]],
+];
+return nurbsSurface(grid, { thickness: 1.5 });

package/examples/nurbs-tube.forge.js

@@ -0,0 +1,7 @@
+// NURBS curve swept into a smooth tube
+const curve = nurbs3d(
+  [[0,0,0], [15,8,0], [25,-3,10], [40,5,15], [50,0,5]],
+  { degree: 3 }
+);
+const tube = sweep(circle2d(2), curve);
+return tube;

package/examples/products/bottle.forge.js

@@ -1,13 +1,13 @@
 // Water Bottle — revolve profile with cap
 // Demonstrates: revolve, polygon, difference, smoothing, multi-object
 
-const bodyH = param("Body Height", 180, { min: 120, max: 250, unit: "mm" });
-const bodyR = param("Body Radius", 35, { min: 25, max: 50, unit: "mm" });
-const neckH = param("Neck Height", 30, { min: 15, max: 50, unit: "mm" });
-const neckR = param("Neck Radius", 14, { min: 10, max: 25, unit: "mm" });
-const wall = param("Wall Thickness", 2, { min: 1, max: 5, unit: "mm" });
-const capH = param("Cap Height", 18, { min: 10, max: 30, unit: "mm" });
-const shoulderR = param("Shoulder Curve", 20, { min: 5, max: 40, unit: "mm" });
+const bodyH = Param.number("Body Height", 180, { min: 120, max: 250, unit: "mm" });
+const bodyR = Param.number("Body Radius", 35, { min: 25, max: 50, unit: "mm" });
+const neckH = Param.number("Neck Height", 30, { min: 15, max: 50, unit: "mm" });
+const neckR = Param.number("Neck Radius", 14, { min: 10, max: 25, unit: "mm" });
+const wall = Param.number("Wall Thickness", 2, { min: 1, max: 5, unit: "mm" });
+const capH = Param.number("Cap Height", 18, { min: 10, max: 30, unit: "mm" });
+const shoulderR = Param.number("Shoulder Curve", 20, { min: 5, max: 40, unit: "mm" });
 
 // Outer profile — polygon traced from bottom-center up and around
 // Bottom flat → body → shoulder curve → neck

package/examples/products/chess-set.forge.js

@@ -1,9 +1,9 @@
-const squareSize = param("Square Size", 36, { min: 24, max: 54, unit: "mm" });
-const boardThickness = param("Board Thickness", 14, { min: 8, max: 24, unit: "mm" });
-const borderWidth = param("Border Width", 10, { min: 4, max: 18, unit: "mm" });
-const tileHeight = param("Tile Height", 1.8, { min: 0.8, max: 4, step: 0.1, unit: "mm" });
-const pieceScale = param("Piece Scale", 1, { min: 0.8, max: 1.25, step: 0.01 });
-const pieceLift = param("Piece Lift", 0, { min: 0, max: 16, unit: "mm" });
+const squareSize = Param.number("Square Size", 36, { min: 24, max: 54, unit: "mm" });
+const boardThickness = Param.number("Board Thickness", 14, { min: 8, max: 24, unit: "mm" });
+const borderWidth = Param.number("Border Width", 10, { min: 4, max: 18, unit: "mm" });
+const tileHeight = Param.number("Tile Height", 1.8, { min: 0.8, max: 4, step: 0.1, unit: "mm" });
+const pieceScale = Param.number("Piece Scale", 1, { min: 0.8, max: 1.25, step: 0.01 });
+const pieceLift = Param.number("Piece Lift", 0, { min: 0, max: 16, unit: "mm" });
 
 const boardSize = squareSize * 8;
 const frameSize = boardSize + borderWidth * 2;

package/examples/products/classical-piano.forge.js

@@ -12,15 +12,15 @@
   - Bench
 */
 
-const bodyWidth = param("Body Width", 180, { min: 140, max: 240, unit: "mm" });
-const bodyLength = param("Body Length", 280, { min: 220, max: 360, unit: "mm" });
-const rimHeight = param("Rim Height", 28, { min: 20, max: 40, unit: "mm" });
-const lidThickness = param("Lid Thickness", 6, { min: 4, max: 10, unit: "mm" });
-const lidOpen = param("Lid Angle", 25, { min: 0, max: 50, unit: "°" });
-const legHeight = param("Leg Height", 60, { min: 45, max: 90, unit: "mm" });
-const legTopRadius = param("Leg Top Radius", 8, { min: 5, max: 12, unit: "mm" });
-const keyboardDepth = param("Keyboard Depth", 60, { min: 45, max: 80, unit: "mm" });
-const keyHeight = param("Key Height", 5, { min: 3, max: 8, unit: "mm" });
+const bodyWidth = Param.number("Body Width", 180, { min: 140, max: 240, unit: "mm" });
+const bodyLength = Param.number("Body Length", 280, { min: 220, max: 360, unit: "mm" });
+const rimHeight = Param.number("Rim Height", 28, { min: 20, max: 40, unit: "mm" });
+const lidThickness = Param.number("Lid Thickness", 6, { min: 4, max: 10, unit: "mm" });
+const lidOpen = Param.number("Lid Angle", 25, { min: 0, max: 50, unit: "°" });
+const legHeight = Param.number("Leg Height", 60, { min: 45, max: 90, unit: "mm" });
+const legTopRadius = Param.number("Leg Top Radius", 8, { min: 5, max: 12, unit: "mm" });
+const keyboardDepth = Param.number("Keyboard Depth", 60, { min: 45, max: 80, unit: "mm" });
+const keyHeight = Param.number("Key Height", 5, { min: 3, max: 8, unit: "mm" });
 
 const rimThickness = Math.min(12, bodyWidth * 0.07);
 const keyboardWidth = bodyWidth * 0.9;

package/examples/products/clock.forge.js

@@ -3,23 +3,23 @@
 // Returns named objects to preserve colors and enable individual visibility control
 
 // === Dimensions ===
-const diameter = param("Diameter", 220, { min: 80, max: 400, unit: "mm" });
-const depth = param("Depth", 18, { min: 8, max: 50, unit: "mm" });
-const rimWidth = param("Rim Width", 8, { min: 3, max: 30, unit: "mm" });
+const diameter = Param.number("Diameter", 220, { min: 80, max: 400, unit: "mm" });
+const depth = Param.number("Depth", 18, { min: 8, max: 50, unit: "mm" });
+const rimWidth = Param.number("Rim Width", 8, { min: 3, max: 30, unit: "mm" });
 
 // === Time Settings — Default 10:10:30 (Apple display time) ===
-const hour = param("Hour", 10, { min: 1, max: 12, integer: true });
-const minute = param("Minute", 10, { min: 0, max: 59, integer: true });
-const second = param("Second", 30, { min: 0, max: 59, integer: true });
-const showSecondHand = param("Show Seconds", 1, { min: 0, max: 1, integer: true });
+const hour = Param.number("Hour", 10, { min: 1, max: 12, integer: true });
+const minute = Param.number("Minute", 10, { min: 0, max: 59, integer: true });
+const second = Param.number("Second", 30, { min: 0, max: 59, integer: true });
+const showSecondHand = Param.number("Show Seconds", 1, { min: 0, max: 1, integer: true });
 
 // === Color Customization ===
-const rimColor = param("Rim Color", 0, { min: 0, max: 3, integer: true }); // 0=silver, 1=gold, 2=black, 3=rose
-const faceColor = param("Face Color", 0, { min: 0, max: 2, integer: true }); // 0=white, 1=black, 2=cream
-const markerColor = param("Marker Color", 0, { min: 0, max: 2, integer: true }); // 0=black, 1=white, 2=gold
-const hourHandColor = param("Hour Hand Color", 0, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
-const minuteHandColor = param("Minute Hand Color", 1, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
-const secondHandColor = param("Second Hand Color", 3, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
+const rimColor = Param.number("Rim Color", 0, { min: 0, max: 3, integer: true }); // 0=silver, 1=gold, 2=black, 3=rose
+const faceColor = Param.number("Face Color", 0, { min: 0, max: 2, integer: true }); // 0=white, 1=black, 2=cream
+const markerColor = Param.number("Marker Color", 0, { min: 0, max: 2, integer: true }); // 0=black, 1=white, 2=gold
+const hourHandColor = Param.number("Hour Hand Color", 0, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
+const minuteHandColor = Param.number("Minute Hand Color", 1, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
+const secondHandColor = Param.number("Second Hand Color", 3, { min: 0, max: 3, integer: true }); // 0=black, 1=white, 2=gold, 3=red
 
 // Color palette
 const colors = {
@@ -61,8 +61,8 @@ const face = cylinder(2, innerRadius - 1)
   .color(faceHex);
 
 // === Hour Markers ===
-const markerLength = param("Marker Length", 10, { min: 5, max: 25, unit: "mm" });
-const markerWidth = param("Marker Width", 2.5, { min: 1, max: 6, unit: "mm" });
+const markerLength = Param.number("Marker Length", 10, { min: 5, max: 25, unit: "mm" });
+const markerWidth = Param.number("Marker Width", 2.5, { min: 1, max: 6, unit: "mm" });
 
 const markerShapes = [];
 for (let i = 0; i < 12; i++) {
@@ -86,12 +86,12 @@ for (let i = 0; i < 12; i++) {
 const markers = union(...markerShapes).color(markerHex);
 
 // === Clock Hands ===
-const hourHandLength = param("Hour Hand Length", 55, { min: 25, max: 110, unit: "mm" });
-const hourHandWidth = param("Hour Hand Width", 10, { min: 5, max: 20, unit: "mm" });
-const minuteHandLength = param("Minute Hand Length", 80, { min: 40, max: 160, unit: "mm" });
-const minuteHandWidth = param("Minute Hand Width", 7, { min: 3, max: 14, unit: "mm" });
-const secondHandLength = param("Second Hand Length", 85, { min: 50, max: 170, unit: "mm" });
-const secondHandWidth = param("Second Hand Width", 2, { min: 1, max: 5, unit: "mm" });
+const hourHandLength = Param.number("Hour Hand Length", 55, { min: 25, max: 110, unit: "mm" });
+const hourHandWidth = Param.number("Hour Hand Width", 10, { min: 5, max: 20, unit: "mm" });
+const minuteHandLength = Param.number("Minute Hand Length", 80, { min: 40, max: 160, unit: "mm" });
+const minuteHandWidth = Param.number("Minute Hand Width", 7, { min: 3, max: 14, unit: "mm" });
+const secondHandLength = Param.number("Second Hand Length", 85, { min: 50, max: 170, unit: "mm" });
+const secondHandWidth = Param.number("Second Hand Width", 2, { min: 1, max: 5, unit: "mm" });
 
 // Calculate hand angles (0 degrees = 12 o'clock, clockwise)
 const hourAngle = (hour % 12) * 30 + (minute / 60) * 30;

package/examples/products/cup.forge.js

@@ -1,11 +1,11 @@
 // Cup with larger top than bottom
 
 // Parameters
-const height = param("Height", 80, { min: 40, max: 150, unit: "mm" });
-const topRadius = param("Top Radius", 35, { min: 20, max: 60, unit: "mm" });
-const bottomRadius = param("Bottom Radius", 25, { min: 15, max: 50, unit: "mm" });
-const wallThickness = param("Wall Thickness", 3, { min: 1, max: 8, unit: "mm" });
-const baseThickness = param("Base Thickness", 5, { min: 2, max: 10, unit: "mm" });
+const height = Param.number("Height", 80, { min: 40, max: 150, unit: "mm" });
+const topRadius = Param.number("Top Radius", 35, { min: 20, max: 60, unit: "mm" });
+const bottomRadius = Param.number("Bottom Radius", 25, { min: 15, max: 50, unit: "mm" });
+const wallThickness = Param.number("Wall Thickness", 3, { min: 1, max: 8, unit: "mm" });
+const baseThickness = Param.number("Base Thickness", 5, { min: 2, max: 10, unit: "mm" });
 
 // Outer cup shape - tapered cylinder (truncated cone)
 const outerCup = cylinder(height, bottomRadius, topRadius);

package/examples/products/iphone.forge.js

@@ -2,11 +2,11 @@
 // 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
@@ -15,7 +15,7 @@ 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;
@@ -34,9 +34,9 @@ const screenFill = roundedRect(screenW, screenH, screenR)
   .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;
@@ -47,8 +47,8 @@ let camIsland = roundedRect(camSize, camSize, camR)
   .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,7 +71,7 @@ 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;
 
@@ -82,7 +82,7 @@ const portCut = roundedRect(portW, portH, portH / 2)
 
 // === 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;
 

package/examples/products/laptop.forge.js

@@ -1,14 +1,14 @@
 // 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);
@@ -119,7 +119,7 @@ const screenAtHinge = screenPanel.translate(0, -hingeY, 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));

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";

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';

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecad",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
   "license": "BUSL-1.1",
   "type": "module",
@@ -68,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": {
@@ -87,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",