forgecad 0.7.0 → 0.8.0

package/dist-skill/docs-dev/generated/viewport.md

@@ -9,7 +9,7 @@ Cut planes, exploded views, joint animations, and scene configuration.
 
 ## Contents
 
-- [Viewport & Runtime](#viewport-runtime) — `jointsView`, `explodeView`, `cutPlane`, `cutPlane`, `scene`, `viewConfig`, `showLabels`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`
+- [Viewport & Runtime](#viewport-runtime) — `jointsView`, `explodeView`, `cutPlane`, `cutPlane`, `mock`, `scene`, `viewConfig`, `showLabels`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`, `highlight`
 - [RouteBuilder](#routebuilder)
 - [route](#route)
 
@@ -167,6 +167,33 @@ cutPlane(name: string, normal: [ number, number, number ], offset?: number, opti
 cutPlane(name: string, normal: [ number, number, number ], options?: CutPlaneOptions): void
 ```
 
+#### `mock()` — Register a mock (context) object for visualization and collision checking.
+
+Mock objects appear in the viewport and spatial analysis when you run a file directly, but are excluded when the file is imported via [`require()`](/docs/core#require). This lets you model the surrounding context — walls, bolts, mating parts — without polluting the module's exports.
+
+The shape is returned unchanged, so you can reference it for alignment, dimensioning, and `verify` checks.
+
+Mock objects participate in `forgecad run` collision detection and spatial analysis. Their names appear with a `(mock)` suffix in reports.
+
+In the viewport, mock objects render at reduced opacity so they are visually distinct from real geometry.
+
+```ts
+// bracket.forge.js
+const wall = mock(box(100, 200, 10).translate(0, 0, -5), "wall");
+const bolt = mock(cylinder(3, 15).translate(10, 15, 0), "bolt");
+
+const bracket = box(20, 30, 5);
+verify.notColliding("bracket vs wall", bracket, wall);
+
+return bracket;
+// When imported: only bracket is exported
+// When run directly: bracket + wall + bolt all visible
+```
+
+```ts
+mock<T extends Shape>(shape: T, name?: string): T
+```
+
 #### `scene()` — Configure the scene environment for the current script execution.
 
 Controls camera position, lighting rig, background color or gradient, atmospheric fog, environment maps, post-processing effects, and capture parameters for the `forgecad capture` command. Multiple calls merge — later values override earlier ones on a per-key basis, so you can split configuration across multiple `scene()` calls.
@@ -177,7 +204,7 @@ Setting `camera.position` overrides auto-framing — the viewport will no longer
 
 Post-processing effects (`bloom`, `vignette`, `grain`) work in the browser viewport only. The CLI applies camera, lights, background, fog, and `toneMappingExposure` but skips shader effects.
 
-All numeric values accept [`param()`](/docs/core#param) expressions.
+All numeric values accept `param()` expressions.
 
 ```js
 scene({

package/dist-skill/docs-dev/guides/joint-design.md

@@ -0,0 +1,78 @@
+---
+skill-group: recipes
+skill-order: 5
+---
+
+# Joint Design Recipes
+
+How to build mechanical joints — clevis-tongue hinges, ball-and-socket, dovetails — that actually rotate without binding and stop where they should.
+
+## The Cavity Rule
+
+Every mechanical joint has a **cavity** in one part and a **tenon** in the other. The cavity must be a real empty volume — not a gap implied by the absence of two separate solids.
+
+If two adjacent parts in an assembly show a collision volume larger than the expected clearance volume in `forgecad run`, one part is missing its cavity. Both parts have solid material at the same joint position. This will look fine at rest pose but will block rotation and produce confusing joint behavior.
+
+```ts
+// BAD — body has a stadium cap at both ends; the "slot" between two clevis tines
+// is just empty space next to a solid body cap. The next phalanx's tongue knuckle
+// has nowhere to go (it intersects the previous body's cap).
+const body  = stadiumBar(L);            // cap at X=0 AND X=L
+const tine1 = box(...).translate(L,  Y_OFF, 0);
+const tine2 = box(...).translate(L, -Y_OFF, 0);
+let phalanx = union(body, tine1, tine2);
+
+// GOOD — body ends FLAT before the joint. Tines extend forward to the pivot.
+// The X = L-KNUCK_R..L+KNUCK_R volume between the tines is genuinely empty.
+const body = box(L - KNUCK_R, TONG_T, H, true).translate((L - KNUCK_R) / 2, 0, 0);
+const tongueKnuckle = knuckleDisc(0, 0, TONG_T);  // proximal cap only
+let phalanx = union(tongueKnuckle, body, tine1, tine2, ...tineCaps);
+```
+
+After applying the cavity rule, `forgecad run` collision volume between adjacent parts in a clevis-tongue chain should drop to **zero** (or a few mm³ of clearance overlap). If it doesn't, there's still solid material where there should be a cavity.
+
+## Connecting Cantilevers
+
+A clevis tine arm at Y=±Y_OFF is geometrically separate from a body at Y=±TONG_T/2. With Y_OFF > TONG_T/2 + clearance, there is a **physical gap** between them. The tines float — they would snap off as soon as load is applied.
+
+Always add a **yoke**: a short slab spanning the full clevis width, sitting between the body's flat distal end and the tines' attachment point. The yoke fills the Y gap so material is continuous from the body through to each tine.
+
+```ts
+const yokeLen   = 3;                                  // a few mm of structural overlap
+const yokeStart = L - KNUCK_R - yokeLen;
+const totalY    = (Y_OFF + TINE_T / 2) * 2;           // full clevis width
+const yoke = box(yokeLen, totalY, H, true)
+  .translate(yokeStart + yokeLen / 2, 0, 0);
+phalanx = union(phalanx, yoke);
+```
+
+## Hard Stops vs Slider Limits
+
+`addRevolute({ min: 0, max: 90 })` sets **slider limits** — the viewport won't let the user drag past them, but the geometry permits any rotation. There is no physical stop.
+
+For a **geometric** hard stop (parts can't backbend past extension, or can't curl past full closure), add a small protrusion on one part that interferes with the other at the limit angle:
+
+- **Extension stop at 0°** (typical for fingers, knees, elbows): add a small "lip" on the dorsal side of the proximal end of the child phalanx, sized so it just touches the parent's distal dorsal corner at 0°. Negative rotation (backbending) is then blocked by part-on-part contact.
+- **Flexion stop at θmax**: add a similar lip on the palmar side, or rely on the body-to-body collision when bodies meet.
+
+Verify with `forgecad run` at the limit poses — the contact pair should show ~0 mm³ collision (just touching), and rotation past the limit should report a non-zero collision volume.
+
+## Knuckle Sizing
+
+For a clevis-tongue joint with body height H, the tongue knuckle radius and clevis tine knuckle radius must satisfy:
+
+```
+KNUCK_R >= H / 2
+```
+
+If the knuckle radius is smaller than the body's half-height, the body's corners protrude beyond the knuckle envelope. When the joint rotates, those corners sweep through space outside the cylindrical envelope and collide with the adjacent part.
+
+Setting `KNUCK_R = H / 2` exactly makes the body cross-section a stadium that perfectly fits the knuckle envelope.
+
+## Verification Workflow
+
+1. Build the joint at rest pose. Run `forgecad run`. Check collision volumes.
+2. If adjacent parts in the joint show > clearance-volume of overlap → missing cavity (apply the cavity rule).
+3. Render with `--focus PartName` to inspect each part in isolation. The clevis end should clearly show a gap between the tines (the cavity).
+4. Render at curl angles (set joint debug params) at 30°, 60°, 90°. No new collisions should appear from rotation.
+5. Render at -10° (backbend test). Either no rotation possible (geometric stop in place) or rotation occurs and you need to add a stop.

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

@@ -8,9 +8,9 @@
 //   2 words = edge midpoint: 'top-front', 'back-left', etc.
 //   3 words = corner:        'top-front-left', 'bottom-back-right', etc.
 
-const baseW = param("Base Width", 100, { min: 50, max: 200, unit: "mm" });
-const baseD = param("Base Depth", 80, { min: 40, max: 150, unit: "mm" });
-const baseH = param("Base Height", 10, { min: 5, max: 30, unit: "mm" });
+const baseW = Param.number("Base Width", 100, { min: 50, max: 200, unit: "mm" });
+const baseD = Param.number("Base Depth", 80, { min: 40, max: 150, unit: "mm" });
+const baseH = Param.number("Base Height", 10, { min: 5, max: 30, unit: "mm" });
 
 const base = box(baseW, baseD, baseH).color('#888888');
 

package/examples/api/bill-of-materials.forge.js

@@ -1,14 +1,14 @@
 // API demo: script-declared bill of materials that gets auto-summed in report export
 
-const frameWidth = param('Frame Width', 900, { min: 300, max: 1800, unit: 'mm' });
-const frameDepth = param('Frame Depth', 500, { min: 200, max: 1200, unit: 'mm' });
-const legHeight = param('Leg Height', 720, { min: 300, max: 1200, unit: 'mm' });
-const tubeW = param('Tube Width', 30, { min: 15, max: 80, unit: 'mm' });
-const tubeH = param('Tube Height', 20, { min: 10, max: 80, unit: 'mm' });
-
-const frontBolts = param('Front Bolts', 8, { min: 0, max: 64, integer: true });
-const rearBolts = param('Rear Bolts', 8, { min: 0, max: 64, integer: true });
-const boltLength = param('Bolt Length', 16, { min: 6, max: 60, unit: 'mm' });
+const frameWidth = Param.number('Frame Width', 900, { min: 300, max: 1800, unit: 'mm' });
+const frameDepth = Param.number('Frame Depth', 500, { min: 200, max: 1200, unit: 'mm' });
+const legHeight = Param.number('Leg Height', 720, { min: 300, max: 1200, unit: 'mm' });
+const tubeW = Param.number('Tube Width', 30, { min: 15, max: 80, unit: 'mm' });
+const tubeH = Param.number('Tube Height', 20, { min: 10, max: 80, unit: 'mm' });
+
+const frontBolts = Param.number('Front Bolts', 8, { min: 0, max: 64, integer: true });
+const rearBolts = Param.number('Rear Bolts', 8, { min: 0, max: 64, integer: true });
+const boltLength = Param.number('Bolt Length', 16, { min: 6, max: 60, unit: 'mm' });
 
 const wall = 2;
 const longTubeMm = frameWidth * 2;

package/examples/api/bolt-pattern.forge.js

@@ -1,10 +1,10 @@
 // Bolt Pattern — circularPattern + linearPattern demo
 
-const baseR = param("Base Radius", 40, { min: 20, max: 80, unit: "mm" });
-const baseH = param("Base Height", 10, { min: 5, max: 20, unit: "mm" });
-const boltR = param("Bolt Radius", 3, { min: 1, max: 6, unit: "mm" });
-const boltCount = param("Bolt Count", 6, { min: 3, max: 12 });
-const boltCircleR = param("Bolt Circle", 30, { min: 15, max: 70, unit: "mm" });
+const baseR = Param.number("Base Radius", 40, { min: 20, max: 80, unit: "mm" });
+const baseH = Param.number("Base Height", 10, { min: 5, max: 20, unit: "mm" });
+const boltR = Param.number("Bolt Radius", 3, { min: 1, max: 6, unit: "mm" });
+const boltCount = Param.number("Bolt Count", 6, { min: 3, max: 12 });
+const boltCircleR = Param.number("Bolt Circle", 30, { min: 15, max: 70, unit: "mm" });
 
 // Base plate
 const base = circle2d(baseR).extrude(baseH);

package/examples/api/boolean-operations.forge.js

@@ -9,8 +9,8 @@
 // and the helper functions also accept arrays:
 // difference([a, b, c]), union([a, b, c]), intersection([a, b, c])
 
-const size = param("Size", 30, { min: 15, max: 50, unit: "mm" });
-const overlap = param("Overlap", 15, { min: 0, max: 30, unit: "mm" });
+const size = Param.number("Size", 30, { min: 15, max: 50, unit: "mm" });
+const overlap = Param.number("Overlap", 15, { min: 0, max: 30, unit: "mm" });
 const spacing = 80;
 
 // Two overlapping shapes for each demo

package/examples/api/bounding-box-visualizer.forge.js

@@ -36,7 +36,7 @@ function vizBBox(shape) {
 // --- Demo shapes ---
 
 // A rotated box — bbox is larger than the shape itself
-const angle = param("Rotation", 30, { min: 0, max: 90, unit: "°" });
+const angle = Param.number("Rotation", 30, { min: 0, max: 90, unit: "°" });
 const rotBox = box(40, 30, 20).rotateZ(angle).color('#4488cc');
 const rotBBox = vizBBox(rotBox).color('#cc4444');
 

package/examples/api/clone-duplicate.forge.js

@@ -1,6 +1,6 @@
 // clone() / duplicate() — explicit copy helpers for Shape, TrackedShape, Sketch, and ShapeGroup.
 
-const spacing = param("Spacing", 90, { min: 40, max: 180, unit: "mm" });
+const spacing = Param.number("Spacing", 90, { min: 40, max: 180, unit: "mm" });
 
 // --- Shape clone ---
 const block = box(36, 20, 12).color("#4a90e2");

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)
   .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,

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

@@ -6,11 +6,11 @@
 // - 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 ────────────────────────────────────────────
 

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

@@ -3,10 +3,10 @@
 // .extrude(height) is the basic form.
 // 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

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

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

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

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

@@ -7,8 +7,8 @@
 // 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,

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,9 +2,9 @@
 // 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) {

package/examples/constraints/01-fully-constrained-rect.forge.js

@@ -21,7 +21,7 @@ sk.horizontal(bottom);
 sk.vertical(right);
 sk.parallel(bottom, top);
 sk.parallel(right, left);
-sk.length(bottom, param("width", 40, { unit: "mm" }));
-sk.length(right, param("height", 30, { unit: "mm" }));
+sk.length(bottom, Param.number("width", 40, { unit: "mm" }));
+sk.length(right, Param.number("height", 30, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/02-underconstrained-triangle.forge.js

@@ -17,6 +17,6 @@ sk.addLoop([p1, p2, p3]);
 // Only constrain shape, not position
 sk.equal(l1, l2);
 sk.equal(l1, l3);
-sk.length(l1, param("side", 20, { unit: "mm" }));
+sk.length(l1, Param.number("side", 20, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/03-redundant-constraints.forge.js

@@ -24,7 +24,7 @@ sk.absoluteAngle(lBottom, 0);  // line must be at 0 degrees (= horizontal)
 sk.vertical(lRight);
 sk.vertical(lLeft);
 sk.horizontal(lTop);
-sk.length(lBottom, param("width", 10, { unit: "mm" }));
-sk.length(lRight, param("height", 5, { unit: "mm" }));
+sk.length(lBottom, Param.number("width", 10, { unit: "mm" }));
+sk.length(lRight, Param.number("height", 5, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/05-parallel-with-linedistance.forge.js

@@ -20,10 +20,10 @@ sk.addLoop([p1, p2, p4, p3]);
 sk.fix(p1);
 sk.horizontal(bottom);
 sk.vertical(left);
-sk.length(bottom, param("width", 20, { unit: "mm" }));
+sk.length(bottom, Param.number("width", 20, { unit: "mm" }));
 
 // lineDistance already implies parallel:
-sk.lineDistance(bottom, top, param("height", 10, { unit: "mm" }));
+sk.lineDistance(bottom, top, Param.number("height", 10, { unit: "mm" }));
 sk.parallel(bottom, top);  // redundant — lineDistance already forces parallel
 
 sk.parallel(left, right);

package/examples/constraints/06-complex-spectrogram.forge.js

@@ -1,4 +1,4 @@
-const width = param('width', 39);
+const width = Param.number('width', 39);
 
 /** Create an open polyline of `count` segments from startPoint to endPoint. */
 function polyline(sk, startPoint, endPoint, count) {

package/examples/constraints/07-perpendicular-chain.forge.js

@@ -20,9 +20,9 @@ sk.absoluteAngle(l1, 0);
 sk.perpendicular(l1, l2);
 sk.perpendicular(l2, l3);
 sk.perpendicular(l3, l4);
-sk.length(l1, param("seg1", 20, { unit: "mm" }));
-sk.length(l2, param("seg2", 15, { unit: "mm" }));
-sk.length(l3, param("seg3", 15, { unit: "mm" }));
-sk.length(l4, param("seg4", 15, { unit: "mm" }));
+sk.length(l1, Param.number("seg1", 20, { unit: "mm" }));
+sk.length(l2, Param.number("seg2", 15, { unit: "mm" }));
+sk.length(l3, Param.number("seg3", 15, { unit: "mm" }));
+sk.length(l4, Param.number("seg4", 15, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/08-symmetric-bracket.forge.js

@@ -47,9 +47,9 @@ sk.vertical(lLeft);
 sk.horizontal(lLeftTop);
 sk.vertical(lLeftUp);
 
-sk.length(lBottom, param("base_width", 50, { unit: "mm" }));
-sk.length(lLeft, param("leg_height", 20, { unit: "mm" }));
-sk.length(lLeftTop, param("step_width", 15, { unit: "mm" }));
-sk.length(lLeftUp, param("top_height", 20, { unit: "mm" }));
+sk.length(lBottom, Param.number("base_width", 50, { unit: "mm" }));
+sk.length(lLeft, Param.number("leg_height", 20, { unit: "mm" }));
+sk.length(lLeftTop, Param.number("step_width", 15, { unit: "mm" }));
+sk.length(lLeftUp, Param.number("top_height", 20, { unit: "mm" }));
 
 return sk.solve();

package/examples/constraints/09-stress-spiral.forge.js

@@ -6,7 +6,7 @@
 const sk = constrainedSketch();
 
 const N = 50; // number of segments
-const SEG_LEN = param("seg_len", 5, { unit: "mm" });
+const SEG_LEN = Param.number("seg_len", 5, { unit: "mm" });
 
 // Build a spiral: each segment turns 90° left from the previous,
 // with increasing runs (1,1,2,2,3,3,4,4,...) to form a square spiral.

package/examples/constraints/10-stress-honeycomb.forge.js

@@ -8,7 +8,7 @@ const sk = constrainedSketch();
 
 const COLS = 3;
 const ROWS = 2;
-const SIDE = param("cell_size", 8, { unit: "mm" });
+const SIDE = Param.number("cell_size", 8, { unit: "mm" });
 
 // Flat-top hex: vertex 0 at 0° (right), CCW
 const vAngles = [0, 60, 120, 180, 240, 300].map(d => d * Math.PI / 180);

package/examples/constraints/11-surface-grid.forge.js

@@ -6,8 +6,8 @@
 
 const sk = constrainedSketch();
 
-const W = param("width", 150, { unit: "mm" });
-const H = param("height", 100, { unit: "mm" });
+const W = Param.number("width", 150, { unit: "mm" });
+const H = Param.number("height", 100, { unit: "mm" });
 
 // Outer box corners
 const p00 = sk.point(0, 0);

package/examples/constraints/12-surface-nested.forge.js

@@ -6,10 +6,10 @@
 
 const sk = constrainedSketch();
 
-const OW = param("outer_w", 120, { unit: "mm" });
-const OH = param("outer_h", 100, { unit: "mm" });
-const IW = param("inner_w", 60, { unit: "mm" });
-const IH = param("inner_h", 50, { unit: "mm" });
+const OW = Param.number("outer_w", 120, { unit: "mm" });
+const OH = Param.number("outer_h", 100, { unit: "mm" });
+const IW = Param.number("inner_w", 60, { unit: "mm" });
+const IH = Param.number("inner_h", 50, { unit: "mm" });
 
 // Outer rectangle
 const o1 = sk.point(0, 0);

package/examples/constraints/13-surface-complex.forge.js

@@ -5,7 +5,7 @@
 
 const sk = constrainedSketch();
 
-const SIZE = param("size", 60, { unit: "mm" });
+const SIZE = Param.number("size", 60, { unit: "mm" });
 
 // L-shape vertices (going CCW)
 //   (0,60)────(60,60)

package/examples/exact-arc-housing.forge.js

@@ -0,0 +1,12 @@
+// Bearing housing with exact circular arc (not polyline-approximated)
+const profile = path()
+  .moveTo(0, 0)
+  .lineTo(50, 0)
+  .lineTo(50, 10)
+  .exactArcTo(40, 20, { radius: 10 })
+  .lineTo(0, 20)
+  .close();
+
+const housing = profile.extrude(30);
+const bore = cylinder(30, 8).translate(25, 10, 0);
+return difference(housing, bore);