forgecad 0.6.3 → 0.8.0

package/examples/api/colors-union-vs-array.forge.js

@@ -7,17 +7,17 @@ const size = 25;
 const gap = 5;
 
 // --- Three colored boxes ---
-const red   = box(size, size, size, true).color('#cc4444');
-const green = box(size, size, size, true).color('#44cc44').translate(size + gap, 0, 0);
-const blue  = box(size, size, size, true).color('#4444cc').translate(2 * (size + gap), 0, 0);
+const red   = box(size, size, size).color('#cc4444');
+const green = box(size, size, size).color('#44cc44').translate(size + gap, 0, 0);
+const blue  = box(size, size, size).color('#4444cc').translate(2 * (size + gap), 0, 0);
 
 // BAD: union kills individual colors — result is all red (first shape's color)
 const merged = union(red, green, blue).translate(-80, 0, 0);
 
 // GOOD: separate objects keep their colors
-const redSep   = box(size, size, size, true).color('#cc4444').translate(80, 0, 0);
-const greenSep = box(size, size, size, true).color('#44cc44').translate(80 + size + gap, 0, 0);
-const blueSep  = box(size, size, size, true).color('#4444cc').translate(80 + 2 * (size + gap), 0, 0);
+const redSep   = box(size, size, size).color('#cc4444').translate(80, 0, 0);
+const greenSep = box(size, size, size).color('#44cc44').translate(80 + size + gap, 0, 0);
+const blueSep  = box(size, size, size).color('#4444cc').translate(80 + 2 * (size + gap), 0, 0);
 
 return [
   { name: "❌ Union (all one color)", shape: merged },

package/examples/api/connector-assembly.forge.js

@@ -9,20 +9,22 @@ const doorW = 60, doorH = 100, doorT = 4;
 const frameT = 8, frameD = 10;
 
 // ── Door with hinge connectors ─────────────────────────────────────────────
+// Hinge axes point "outward" from each part. When connectors mate,
+// they meet face-to-face (anti-parallel), producing the shared rotation axis.
 
-const door = box(doorW, doorT, doorH, true)
+const door = box(doorW, doorT, doorH)
   .translate(doorW / 2, 0, 0)
   .withConnectors({
     hinge_top: connector.male("hinge_pin", {
       origin: [0, 0, doorH * 0.3],
-      axis: [0, 0, 1],
+      axis: [0, 0, -1],
       kind: "revolute",
       min: 0,
       max: 110,
     }),
     hinge_bottom: connector.male("hinge_pin", {
       origin: [0, 0, -doorH * 0.3],
-      axis: [0, 0, 1],
+      axis: [0, 0, -1],
       kind: "revolute",
       min: 0,
       max: 110,
@@ -32,11 +34,11 @@ const door = box(doorW, doorT, doorH, true)
 
 // ── Frame with matching hinge connectors ───────────────────────────────────
 
-const leftPost = box(frameT, frameD, doorH + frameT, true)
+const leftPost = box(frameT, frameD, doorH + frameT)
   .translate(-(doorW / 2 + frameT / 2), 0, frameT / 4);
-const rightPost = box(frameT, frameD, doorH + frameT, true)
+const rightPost = box(frameT, frameD, doorH + frameT)
   .translate(doorW / 2 + frameT / 2, 0, frameT / 4);
-const lintel = box(doorW + frameT * 2, frameD, frameT, true)
+const lintel = box(doorW + frameT * 2, frameD, frameT)
   .translate(0, 0, doorH / 2 + frameT / 2);
 
 const frame = union(leftPost, rightPost, lintel)

package/examples/api/connector-basics.forge.js

@@ -6,16 +6,16 @@
 // - matchTo() single-pair connector matching
 // - Auto-bubbling: connectors on named group children are accessible via "ChildName.connectorName"
 
-const panelH = param("Panel Height", 200, { min: 100, max: 400, unit: "mm" });
-const panelD = param("Panel Depth", 120, { min: 60, max: 200, unit: "mm" });
-const panelT = param("Panel Thickness", 12, { unit: "mm" });
-const shelfCount = param("Shelves", 3, { min: 1, max: 6 });
-const cabinetW = param("Cabinet Width", 180, { min: 100, max: 400, unit: "mm" });
+const panelH = Param.number("Panel Height", 200, { min: 100, max: 400, unit: "mm" });
+const panelD = Param.number("Panel Depth", 120, { min: 60, max: 200, unit: "mm" });
+const panelT = Param.number("Panel Thickness", 12, { unit: "mm" });
+const shelfCount = Param.number("Shelves", 3, { min: 1, max: 6 });
+const cabinetW = Param.number("Cabinet Width", 180, { min: 100, max: 400, unit: "mm" });
 
 // ── Side Panel with shelf slots ────────────────────────────────────────────
 
 function makeSidePanel(facingDir) {
-  const panel = box(panelT, panelD, panelH, true);
+  const panel = box(panelT, panelD, panelH);
   const connectors = {};
 
   for (let i = 0; i < shelfCount; i++) {
@@ -47,7 +47,7 @@ console.log("Cabinet connectors:", cabinet.connectorNames());
 
 const shelfW = cabinetW - panelT;
 const shelfT = 10;
-const shelf = box(shelfW, panelD - 10, shelfT, true)
+const shelf = box(shelfW, panelD - 10, shelfT)
   .withConnectors({
     left_tab: connector.male("dovetail", {
       origin: [-shelfW / 2, 0, 0],

package/examples/api/constrained-sketch-mechanical.forge.js

@@ -11,10 +11,10 @@
  *   4. Connecting rod    — constrained trapezoid with symmetric sides
  */
 
-const W  = param('width',  60, { min: 30, max: 120, unit: 'mm' });
-const H  = param('height', 40, { min: 20, max: 80, unit: 'mm' });
-const T  = param('thick',   8, { min: 3, max: 20, unit: 'mm' });
-const R  = param('radius', 10, { min: 5, max: 25, unit: 'mm' });
+const W  = Param.number('width',  60, { min: 30, max: 120, unit: 'mm' });
+const H  = Param.number('height', 40, { min: 20, max: 80, unit: 'mm' });
+const T  = Param.number('thick',   8, { min: 3, max: 20, unit: 'mm' });
+const R  = Param.number('radius', 10, { min: 5, max: 25, unit: 'mm' });
 
 // ─── 1. Slotted plate ─────────────────────────────────────────────────────────
 const slottedPlate = (() => {

package/examples/api/elbow-test.forge.js

@@ -1,7 +1,7 @@
 // Test lib.elbow() — pipe bend primitive
-const pipeR = param("Pipe Radius", 5, { min: 2, max: 15, unit: "mm" });
-const bendR = param("Bend Radius", 25, { min: 10, max: 60, unit: "mm" });
-const angle = param("Angle", 90, { min: 15, max: 180, unit: "°" });
+const pipeR = Param.number("Pipe Radius", 5, { min: 2, max: 15, unit: "mm" });
+const bendR = Param.number("Bend Radius", 25, { min: 10, max: 60, unit: "mm" });
+const angle = Param.number("Angle", 90, { min: 15, max: 180, unit: "°" });
 
 // Basic elbow at default orientation
 const basic = lib.elbow(pipeR, bendR, angle).color('#B87333');

package/examples/api/extrude-options.forge.js

@@ -1,12 +1,12 @@
-// Extrude options — twist, taper, center.
+// Extrude options — twist, taper, scaleTop.
 //
 // .extrude(height) is the basic form.
-// Options: { twist, divisions, scaleTop, center }
+// Options: { twist, divisions, scaleTop }
 
-const r = param("Radius", 20, { min: 10, max: 40, unit: "mm" });
-const h = param("Height", 60, { min: 20, max: 120, unit: "mm" });
-const twist = param("Twist", 90, { min: 0, max: 360, unit: "°" });
-const taper = param("Taper", 0.5, { min: 0.1, max: 1.0 });
+const r = Param.number("Radius", 20, { min: 10, max: 40, unit: "mm" });
+const h = Param.number("Height", 60, { min: 20, max: 120, unit: "mm" });
+const twist = Param.number("Twist", 90, { min: 0, max: 360, unit: "°" });
+const taper = Param.number("Taper", 0.5, { min: 0.1, max: 1.0 });
 const spacing = 60;
 
 // 1. Plain extrude
@@ -23,22 +23,16 @@ const tapered = circle2d(r).extrude(h, { scaleTop: taper })
   .translate(2 * spacing, 0, 0)
   .color('#44cc88');
 
-// 4. Centered extrude — shape is centered along Z instead of starting at Z=0
-const centered = rect(r * 1.5, r, true).extrude(h, { center: true })
-  .translate(3 * spacing, 0, 0)
-  .color('#cc44cc');
-
-// 5. Combined: twist + taper
+// 4. Combined: twist + taper
 const combo = star(5, r, r * 0.5).extrude(h, {
   twist: twist,
   scaleTop: taper,
   divisions: 32,
-}).translate(4 * spacing, 0, 0).color('#cccc44');
+}).translate(3 * spacing, 0, 0).color('#cccc44');
 
 return [
   { name: "Plain", shape: plain },
   { name: "Twisted", shape: twisted },
   { name: "Tapered", shape: tapered },
-  { name: "Centered (Z)", shape: centered },
   { name: "Twist + Taper", shape: combo },
 ];

package/examples/api/feature-created-faces.forge.js

@@ -1,20 +1,18 @@
-const shellBase = roundedRect(90, 56, 6, true).extrude(28);
+const shellBase = roundedRect(90, 56, 6).extrude(28);
 const cup = shellBase.shell(2.5, { openFaces: ['top'] }).color('#6f7b86');
-const innerWallPad = roundedRect(16, 9, 1.8, true)
+const innerWallPad = roundedRect(16, 9, 1.8)
   .onFace(cup, 'inner-side-right', { u: 0, v: -3, protrude: 0.05, selfAnchor: 'center' })
   .extrude(1.4)
-  // .toShape()
   .color('#f2b16a');
 
-const holeBase = roundedRect(72, 44, 5, true).extrude(20);
+const holeBase = roundedRect(72, 44, 5).extrude(20);
 const drilled = holeBase.hole('top', { diameter: 8, u: 16, v: -8, depth: 10 }).color('#7a8792');
 const floorBoss = circle2d(3)
   .onFace(drilled, 'floor', { u: 0, v: 0, protrude: 0.05, selfAnchor: 'center' })
   .extrude(1.2)
-  // .toShape()
   .color('#d46452');
 
-const counterboreBase = roundedRect(72, 44, 5, true).extrude(20);
+const counterboreBase = roundedRect(72, 44, 5).extrude(20);
 const counterboreExitFace = counterboreBase.face('bottom');
 const counterbored = counterboreBase.hole('top', {
   diameter: 6,
@@ -26,17 +24,15 @@ const counterbored = counterboreBase.hole('top', {
 const shoulderPad = rect(4, 3)
   .onFace(counterbored, 'counterbore-floor', { u: 0, v: 0, protrude: 0.05, selfAnchor: 'center' })
   .extrude(0.9)
-  // .toShape()
   .color('#f0c36c');
 
-const cutBase = roundedRect(78, 46, 5, true).extrude(22);
-const pocket = roundedRect(20, 12, 2, true)
+const cutBase = roundedRect(78, 46, 5).extrude(22);
+const pocket = roundedRect(20, 12, 2)
   .onFace(cutBase, 'front', { u: 0, v: 4, selfAnchor: 'center' });
 const cut = cutBase.cutout(pocket, { depth: 8 }).color('#64707d');
 const wallTab = rect(5, 4)
   .onFace(cut, 'wall-right', { u: 0, v: 0, protrude: 0.05, selfAnchor: 'center' })
   .extrude(1)
-  // .toShape()
   .color('#5ba6d6');
 
 return [

package/examples/api/fillet-showcase.forge.js

@@ -1,7 +1,7 @@
 // Fillet Showcase — the new fillet() API
 // Demonstrates: fillet(), edge queries, multi-edge, curved edges
 
-const r = param("Fillet Radius", 3, { min: 0.5, max: 8, unit: "mm" });
+const r = Param.number("Fillet Radius", 3, { min: 0.5, max: 8, unit: "mm" });
 
 // ── 1. Basic: fillet all edges of a box ─────────────────────────────────────
 const simpleBox = box(30, 20, 15);
@@ -16,7 +16,7 @@ const vertFilleted = fillet(tallBox, r, { parallel: [0, 0, 1], convex: true });
 
 // ── 4. Boolean result: fillet the sharp edges after a cut ────────────────────
 const base = box(40, 30, 20);
-const cutter = cylinder(25, 10, 10, 32, true).translate(20, 15, 10);
+const cutter = cylinder(25, 10, 10, 32).translate(20, 15, 10);
 const cutPart = difference(base, cutter);
 const cutFilleted = fillet(cutPart, 2, { convex: true, minLength: 3 });
 

package/examples/api/folded-service-panel-cover.forge.js

@@ -40,8 +40,8 @@ export function buildFoldedServicePanelCoverPart() {
     .flange('right', { length: 18, angleDeg: 90 })
     .flange('bottom', { length: 18, angleDeg: 90 })
     .flange('left', { length: 18, angleDeg: 90 })
-    .cutout('panel', rect(72, 36, true), { selfAnchor: 'center' })
-    .cutout('flange-right', roundedRect(26, 10, 5, true), { selfAnchor: 'center' });
+    .cutout('panel', rect(72, 36), { selfAnchor: 'center' })
+    .cutout('flange-right', roundedRect(26, 10, 5), { selfAnchor: 'center' });
 
   const holes = [
     mountingHole(2.2, -68, -37),

package/examples/api/gears-tier1.forge.js

@@ -1,10 +1,10 @@
 // Tier 1 gears demo: spur pair + ring gear + rack gear
 
-const moduleSize = param("Module", 1.25, { min: 0.6, max: 3.0, step: 0.05 });
-const pinionTeeth = param("Pinion Teeth", 14, { min: 8, max: 28, integer: true });
-const drivenTeeth = param("Driven Teeth", 42, { min: 16, max: 90, integer: true });
-const backlash = param("Backlash", 0.05, { min: 0, max: 0.2, step: 0.01, unit: "mm" });
-const faceWidth = param("Face Width", 10, { min: 4, max: 18, unit: "mm" });
+const moduleSize = Param.number("Module", 1.25, { min: 0.6, max: 3.0, step: 0.05 });
+const pinionTeeth = Param.number("Pinion Teeth", 14, { min: 8, max: 28, integer: true });
+const drivenTeeth = Param.number("Driven Teeth", 42, { min: 16, max: 90, integer: true });
+const backlash = Param.number("Backlash", 0.05, { min: 0, max: 0.2, step: 0.01, unit: "mm" });
+const faceWidth = Param.number("Face Width", 10, { min: 4, max: 18, unit: "mm" });
 
 const pair = lib.gearPair({
   pinion: {

package/examples/api/group-test.forge.js

@@ -1,6 +1,6 @@
 // Test assembly grouping — nested group format
-const baseW = param("Base Width", 100, { min: 60, max: 200, unit: "mm" });
-const baseD = param("Base Depth", 80, { min: 40, max: 150, unit: "mm" });
+const baseW = Param.number("Base Width", 100, { min: 60, max: 200, unit: "mm" });
+const baseD = Param.number("Base Depth", 80, { min: 40, max: 150, unit: "mm" });
 
 // Bed assembly
 const bedPlate = box(baseW, baseD, 5).color('#666666');
@@ -14,7 +14,7 @@ const crossBar = box(baseW + 20, 5, 5).translate(-10, baseD / 2, 63).color('#aaa
 
 // Extruder (intentionally overlaps crossbar — intra-group collision)
 const nozzle = cylinder(15, 4).translate(baseW / 2, baseD / 2, 48).color('#ff8800');
-const heatsink = box(20, 20, 10, true).translate(baseW / 2, baseD / 2, 60).color('#cccccc');
+const heatsink = box(20, 20, 10).translate(baseW / 2, baseD / 2, 60).color('#cccccc');
 
 return [
   { name: "Bed Assembly", group: [

package/examples/api/group-vs-union.forge.js

@@ -6,7 +6,7 @@
 // Use union when you need a single solid (e.g., to subtract from something).
 // Use group when you want parts to move together but stay visually distinct.
 
-const base = box(60, 60, 5, true).color('#888888');
+const base = box(60, 60, 5).color('#888888');
 const col = cylinder(30, 5).color('#cc4444')
   .attachTo(base, 'top', 'bottom');
 

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

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

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

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

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

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

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

@@ -3,9 +3,9 @@
 // Imports an external STL mesh and intersects it with a parametric
 // slat pattern to create a layered sculpture effect.
 
-const slatCount = param("Slat count", 16, { min: 4, max: 40 });
-const slatThickness = param("Slat thickness", 1.2, { min: 0.4, max: 3, unit: "mm" });
-const gap = param("Gap", 1.5, { min: 0.5, max: 5, unit: "mm" });
+const slatCount = Param.number("Slat count", 16, { min: 4, max: 40 });
+const slatThickness = Param.number("Slat thickness", 1.2, { min: 0.4, max: 3, unit: "mm" });
+const gap = Param.number("Gap", 1.5, { min: 0.5, max: 5, unit: "mm" });
 
 // Import an external mesh file
 const mesh = importMesh("assets/sphere.stl");
@@ -19,7 +19,7 @@ const slats = [];
 for (let i = 0; i < slatCount; i++) {
   const y = center[1] - (slatCount - 1) * pitch / 2 + i * pitch;
   slats.push(
-    box(size[0] + 10, slatThickness, size[2] + 10, true)
+    box(size[0] + 10, slatThickness, size[2] + 10)
       .translate(center[0], y, center[2])
   );
 }

package/examples/api/patterns.forge.js

@@ -1,8 +1,8 @@
 // Patterns — linearPattern and circularPattern for repeating shapes.
 
-const count = param("Count", 6, { min: 2, max: 12, integer: true });
-const spacing = param("Spacing", 20, { min: 10, max: 40, unit: "mm" });
-const radius = param("Ring Radius", 40, { min: 20, max: 80, unit: "mm" });
+const count = Param.number("Count", 6, { min: 2, max: 12, integer: true });
+const spacing = Param.number("Spacing", 20, { min: 10, max: 40, unit: "mm" });
+const radius = Param.number("Ring Radius", 40, { min: 20, max: 80, unit: "mm" });
 
 // --- linearPattern: repeat along a direction ---
 const peg = cylinder(15, 4).color('#4488cc');

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

@@ -1,14 +1,14 @@
 // pointAlong() — orient a cylinder's axis without thinking about Euler angles.
 //
 // Cylinders default to Z-up. To lay one along X or Y:
-//   ❌ cylinder(80, 5).rotate(90, 0, 0)   — which axis? confusing
+//   ❌ cylinder(80, 5).rotateX(90)         — works, but less readable
 //   ✅ cylinder(80, 5).pointAlong([0, 1, 0]) — "point along Y"
 //
 // After pointAlong, the cylinder starts at origin and extends in that direction.
 // Always call pointAlong BEFORE translate/attachTo.
 
-const len = param("Length", 80, { min: 30, max: 150, unit: "mm" });
-const r = param("Radius", 5, { min: 2, max: 15, unit: "mm" });
+const len = Param.number("Length", 80, { min: 30, max: 150, unit: "mm" });
+const r = Param.number("Radius", 5, { min: 2, max: 15, unit: "mm" });
 const spacing = 40;
 
 // Default: along +Z (up)

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

@@ -4,10 +4,10 @@
 // - direct 3D helper (`lib.profile2020BSlot6`)
 // - parameterized technical dimensions
 
-const length = param("Length", 220, { min: 40, max: 800, unit: "mm" });
-const slotDepth = param("Slot Depth", 5.5, { min: 4.6, max: 6.6, step: 0.1, unit: "mm" });
-const slotInner = param("Slot Inner Width", 8.2, { min: 7, max: 10.5, step: 0.1, unit: "mm" });
-const centerBore = param("Center Bore", 5.5, { min: 0, max: 6.5, step: 0.1, unit: "mm" });
+const length = Param.number("Length", 220, { min: 40, max: 800, unit: "mm" });
+const slotDepth = Param.number("Slot Depth", 5.5, { min: 4.6, max: 6.6, step: 0.1, unit: "mm" });
+const slotInner = Param.number("Slot Inner Width", 8.2, { min: 7, max: 10.5, step: 0.1, unit: "mm" });
+const centerBore = Param.number("Center Bore", 5.5, { min: 0, max: 6.5, step: 0.1, unit: "mm" });
 
 const profile2d = lib.profile2020BSlot6Profile({
   slotInnerWidth: slotInner,
@@ -16,7 +16,6 @@ const profile2d = lib.profile2020BSlot6Profile({
 });
 
 const extrusion = lib.profile2020BSlot6(length, {
-  center: true,
   slotDepth,
   slotInnerWidth: slotInner,
   centerBoreDia: centerBore,

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

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

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

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

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

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

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

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

package/examples/api/sketch-rounding-strategies.forge.js

@@ -1,7 +1,7 @@
 // Compare common sketch-rounding strategies on the same roof profile.
 // Only the selective fillet keeps the lower roof corners sharp.
 
-const radius = param("Radius", 14, { min: 4, max: 24, unit: "mm" });
+const radius = Param.number("Radius", 14, { min: 4, max: 24, unit: "mm" });
 const gap = 120;
 const bodyWidth = 90;
 const bodyHeight = 44;

package/examples/api/smooth-curve-connections.forge.js

@@ -10,7 +10,7 @@
  * Drag the Blend Weight slider to shift the blend shape!
  */
 
-const blendWeight = param('Blend Weight', 0.5, { min: 0.1, max: 0.9, step: 0.05 });
+const blendWeight = Param.number('Blend Weight', 0.5, { min: 0.1, max: 0.9, step: 0.05 });
 
 // ─── 1. Gothic arch — two arcs meeting at a point ──────────────────────────
 // Two arcs sharing a crown point — smooth by construction since both

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

@@ -2,14 +2,14 @@
 // Demonstrates transitionCurve(), transitionSurface(), connectEdges(),
 // and weighted blending (G1 + G2 continuity).
 
-const weight = param("Weight A", 1.0, { min: 0.1, max: 5.0, step: 0.1 });
-const weightB = param("Weight B", 1.0, { min: 0.1, max: 5.0, step: 0.1 });
-const radius = param("Tube Radius", 1.5, { min: 0.3, max: 5, unit: "mm" });
+const weight = Param.number("Weight A", 1.0, { min: 0.1, max: 5.0, step: 0.1 });
+const weightB = Param.number("Weight B", 1.0, { min: 0.1, max: 5.0, step: 0.1 });
+const radius = Param.number("Tube Radius", 1.5, { min: 0.3, max: 5, unit: "mm" });
 
 // Small anchor block at a point (visual reference for where the tube connects)
 function anchor(pos) {
   const s = 3;
-  return box(s, s, s, true).translate(pos[0], pos[1], pos[2]);
+  return box(s, s, s).translate(pos[0], pos[1], pos[2]);
 }
 
 // ── 1. L-bend: 90-degree pipe turn ──────────────────────────────