forgecad 0.1.0

package/examples/compiler-corpus/README.md

@@ -0,0 +1,88 @@
+# Compiler Regression Corpus
+
+These parts are the curated multi-feature corpus behind `forgecad check compiler`,
+the focused `forgecad check query-propagation` snapshots, and `forgecad check brep`.
+They are intentionally ordinary mechanical parts instead of isolated geometry
+tricks, so lowerer regressions show up in workflows that look like real
+product-design code.
+
+Each file is deterministic: no randomness, no params, fixed named solid result(s).
+
+## Coverage Map
+
+| Part | Main workflow families |
+| --- | --- |
+| `enclosure-shell-cuts.forge.js` | `shell()`, face-driven cuts, mirrored feet, boolean chain |
+| `motor-mount-plate.forge.js` | circular pattern, mirrored ears, deterministic boolean pockets |
+| `sensor-bracket.forge.js` | mirrored ribs, upright `onFace()` cuts, repeated detail holes |
+| `edge-finished-mount.forge.js` | tracked-edge fillet/chamfer, downstream hole/cut edits, boolean chain |
+| `fastener-plate-variants.forge.js` | counterbores, countersinks, planar `upToFace`, created-face propagation |
+| `folded-service-panel-cover.forge.js` | compiler-owned sheet metal, named panel/flange/bend descendants, folded + flat outputs |
+| `projection-relay-cover.forge.js` | `projectToPlane()` replay from repeated union descendants |
+| `service-panel-cover.forge.js` | repeated bosses plus richer hole/cut details plus projection replay |
+| `trimmed-access-cover.forge.js` | `trimByPlane()`, plane-cap ownership, later union edits |
+
+## Parts
+
+### `enclosure-shell-cuts.forge.js`
+
+Guards:
+- shell lowering inside an enclosure-style boolean workflow
+- `onFace()`-driven subtractive features that need semantic workplane placement in the compiler graph
+- mirrored mounting feet that stay exact-exportable after later subtracts
+
+### `motor-mount-plate.forge.js`
+
+Guards:
+- `circularPattern()` around a real bolt circle instead of a toy transform demo
+- stacked analytic bore cutters inside an exact-exportable boolean workflow, not compiler-owned counterbore features yet
+- mirrored tabs and center pocket booleans that must remain deterministic
+
+### `sensor-bracket.forge.js`
+
+Guards:
+- mirrored reinforcement ribs inside a larger bracket union
+- front/side face cuts placed with `onFace()` on an upright wall
+- repeated indicator-hole cutters plus raw mounting bores in the same boolean tree
+
+### `edge-finished-mount.forge.js`
+
+Guards:
+- tracked-edge `filletEdge()` plus later propagated-edge `chamferEdge()` lowering on the defended vertical-edge subset
+- mirrored additive features staying exact-exportable while the selected preserved edge keeps one unique propagated lineage
+- downstream `hole()` / `cutout()` edits that still target the original tracked body owner after the broadened edge-finish flow
+
+### `fastener-plate-variants.forge.js`
+
+Guards:
+- compiler-owned counterbore and countersink holes inside a normal fastener-plate workflow
+- `upToFace` hole/cut extents lowering through both Manifold and CadQuery/OCCT from the shared feature family
+- defended created-face/query semantics staying inspectable after multiple richer hole rewrites
+
+### `folded-service-panel-cover.forge.js`
+
+Guards:
+- compiler-owned `sheetMetal()` intent lowering to both the folded cover and the flat pattern from one semantic model
+- named `panel`, `flange-*`, and `bend-*` descendants staying inspectable after panel/flange cutouts split those regions
+- exact export and query-propagation coverage for a manufacturable-looking sheet-metal cover instead of an isolated toy bend
+
+### `projection-relay-cover.forge.js`
+
+Guards:
+- `projectToPlane()` replay after a repeated top-edge boss chain has already been merged through a supported union
+- projection-driven downstream lips staying exact-exportable instead of collapsing back to runtime-only geometry
+- downstream placement still using defended face-query lineage from the base plate instead of anonymous heuristics
+
+### `service-panel-cover.forge.js`
+
+Guards:
+- repeated top-side bosses staying compiler-owned before later richer hole/cut rewrites hit the same part
+- counterbores, countersinks, and a face-driven display pocket remaining exact-exportable in one ordinary service-cover workflow
+- projection-driven gasket geometry replaying from a hole/cut/union source instead of dropping back to runtime-only silhouette logic
+
+### `trimmed-access-cover.forge.js`
+
+Guards:
+- `trimByPlane()` exposing the defended `plane-cap` created-face query inside a normal cover-style workflow
+- earlier `hole()` / `cutout()` rewrites still surfacing explicit split-face ambiguity and unsupported created-edge diagnostics
+- later union edits staying reviewable after the trim-created face lands

package/examples/compiler-corpus/edge-finished-mount.forge.js

@@ -0,0 +1,18 @@
+const base = box(84, 54, 24, true);
+
+const pocket = roundedRect(20, 10, 2, true)
+  .onFace(base, 'top', { u: 12, v: -8, selfAnchor: 'center' });
+
+const bossSeed = roundedRect(14, 8, 1.5, true)
+  .onFace(base, 'top', { u: -18, v: 8, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(8);
+
+const once = filletEdge(base.toShape(), base.edge('vert-br'), 6, [-1, -1]);
+const bosses = mirrorCopy(bossSeed, [1, 0, 0]);
+
+const body = chamferEdge(once.add(bosses), base.edge('vert-bl'), 4, [1, -1])
+  .hole(base.face('top'), { diameter: 6, u: -18, v: 10, depth: 9 })
+  .cutout(pocket, { depth: 5 })
+  .subtract(cylinder(28, 4, undefined, undefined, true).translate(0, -20, 0));
+
+return [{ name: 'Edge Finished Mount', shape: body }];

package/examples/compiler-corpus/enclosure-shell-cuts.forge.js

@@ -0,0 +1,24 @@
+// Guard part: shell + face-driven cuts + mirrored feet in one ordinary enclosure workflow.
+
+const base = roundedRect(120, 80, 10, true).extrude(36);
+const shell = base.shell(3, { openFaces: ['top'] });
+
+const displayCut = roundedRect(34, 18, 3, true)
+  .onFace(base, 'front', { u: 0, v: 8, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(10);
+
+const cableCut = circle2d(7)
+  .onFace(base, 'right', { u: -12, v: -8, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(10);
+
+const foot = roundedRect(18, 18, 4, true)
+  .onFace(base, 'bottom', { u: 36, v: 20, protrude: 0, selfAnchor: 'center' })
+  .extrude(6);
+
+const feet = mirrorCopy(mirrorCopy(foot, [1, 0, 0]), [0, 1, 0]);
+
+const enclosure = union(shell, feet)
+  .subtract(displayCut)
+  .subtract(cableCut);
+
+return [{ name: 'Enclosure Shell Cuts', shape: enclosure }];

package/examples/compiler-corpus/fastener-plate-variants.forge.js

@@ -0,0 +1,42 @@
+// Guard part: counterbore/countersink hole variants plus an up-to-face service pocket in one ordinary plate workflow.
+
+const plate = roundedRect(118, 76, 8, true).extrude(18);
+const entryFace = plate.face('top');
+const exitFace = plate.face('bottom');
+const pocketExitFace = plate.toShape().face('side-top');
+
+const servicePocket = roundedRect(34, 18, 4, true)
+  .onFace(plate, 'front', { u: 0, v: -2, selfAnchor: 'center' });
+
+const fastenerPlate = plate
+  .hole(entryFace, {
+    diameter: 6.2,
+    u: -34,
+    v: 20,
+    upToFace: exitFace,
+    counterbore: { diameter: 11.5, depth: 4 },
+  })
+  .hole(entryFace, {
+    diameter: 6.2,
+    u: 34,
+    v: 20,
+    upToFace: exitFace,
+    counterbore: { diameter: 11.5, depth: 4 },
+  })
+  .hole(entryFace, {
+    diameter: 4.3,
+    u: -34,
+    v: -20,
+    upToFace: exitFace,
+    countersink: { diameter: 9, angleDeg: 90 },
+  })
+  .hole(entryFace, {
+    diameter: 4.3,
+    u: 34,
+    v: -20,
+    upToFace: exitFace,
+    countersink: { diameter: 9, angleDeg: 90 },
+  })
+  .cutout(servicePocket, { upToFace: pocketExitFace });
+
+return [{ name: 'Fastener Plate Variants', shape: fastenerPlate }];

package/examples/compiler-corpus/folded-service-panel-cover.forge.js

@@ -0,0 +1,5 @@
+// Guard part: compiler-owned sheet-metal semantics drive both the folded cover and its flat pattern.
+
+import { buildFoldedServicePanelCoverScene } from '../api/folded-service-panel-cover.js';
+
+return buildFoldedServicePanelCoverScene();

package/examples/compiler-corpus/motor-mount-plate.forge.js

@@ -0,0 +1,32 @@
+// Guard part: patterned fastener holes, mirrored ears, and deterministic boolean pockets.
+
+const plate = roundedRect(132, 96, 12, true).extrude(10);
+const ear = roundedRect(28, 42, 8, true)
+  .extrude(10)
+  .translate(0, 62, 0);
+const body = union(plate, mirrorCopy(ear, [0, 1, 0]));
+
+const counterboredHole = union(
+  cylinder(14, 2.25, undefined, undefined, true),
+  cylinder(4, 4.25, undefined, undefined, true).translate(0, 0, 5),
+);
+const centerBore = cylinder(14, 24, undefined, undefined, true);
+const bolt = counterboredHole.translate(32, 0, 0);
+const boltCircle = circularPattern(bolt, 4);
+
+const earSlot = roundedRect(16, 8, 3, true)
+  .extrude(14, { center: true })
+  .translate(0, 62, 5);
+const earSlots = mirrorCopy(earSlot, [0, 1, 0]);
+
+const lighteningPocket = roundedRect(54, 22, 5, true)
+  .extrude(12, { center: true })
+  .translate(0, 0, 5);
+
+const motorMount = body
+  .subtract(centerBore)
+  .subtract(boltCircle)
+  .subtract(earSlots)
+  .subtract(lighteningPocket);
+
+return [{ name: 'Motor Mount Plate', shape: motorMount }];

package/examples/compiler-corpus/projection-relay-cover.forge.js

@@ -0,0 +1,16 @@
+const plate = roundedRect(96, 56, 6, true).extrude(12);
+
+const bossSeed = roundedRect(18, 12, 2.5, true)
+  .onFace(plate, 'top', { u: -28, v: 24, protrude: 0.5, selfAnchor: 'center' })
+  .extrude(7);
+
+const bosses = linearPattern(bossSeed, 3, 28, 0, 0);
+const cover = union(plate, bosses);
+
+const projected = projectToPlane(cover, { plane: 'XY' });
+const lip = projected
+  .offset(2)
+  .onFace(plate.face('top'), { protrude: 0.5, selfAnchor: 'center' })
+  .extrude(1.2);
+
+return [{ name: 'Projection Relay Cover', shape: union(cover, lip) }];

package/examples/compiler-corpus/sensor-bracket.forge.js

@@ -0,0 +1,35 @@
+// Guard part: mirrored ribs, face-mounted cuts, and repeated wall details in one bracket.
+
+const base = roundedRect(100, 54, 4, true).extrude(10);
+const upright = roundedRect(100, 10, 4, true)
+  .extrude(56)
+  .translate(0, 22, 10);
+const rib = box(10, 24, 36, true).translate(36, 10, 28);
+const ribs = mirrorCopy(rib, [1, 0, 0]);
+
+const mountHole = union(
+  cylinder(14, 2.25, undefined, undefined, true),
+  cylinder(3.5, 4.25, undefined, undefined, true).translate(0, 0, 5.25),
+).translate(28, 0, 5);
+const mountHoles = mirrorCopy(mountHole, [1, 0, 0]);
+
+const sensorWindow = roundedRect(36, 16, 3, true)
+  .onFace(upright, 'front', { u: 0, v: 6, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(12);
+
+const cablePort = roundedRect(18, 8, 2, true)
+  .onFace(upright, 'right', { u: 10, v: -8, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(12);
+
+const indicatorHole = circle2d(2.5)
+  .onFace(upright, 'front', { u: -16, v: -12, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(12);
+const indicatorArray = linearPattern(indicatorHole, 3, 16, 0);
+
+const bracket = union(base, upright, ribs)
+  .subtract(mountHoles)
+  .subtract(sensorWindow)
+  .subtract(cablePort)
+  .subtract(indicatorArray);
+
+return [{ name: 'Sensor Bracket', shape: bracket }];

package/examples/compiler-corpus/service-panel-cover.forge.js

@@ -0,0 +1,53 @@
+// Guard part: repeated bosses, richer hole variants, projection replay, and a face-driven cut in one service-cover workflow.
+
+const plate = roundedRect(124, 78, 8, true).extrude(12);
+
+const bossSeed = roundedRect(18, 10, 2, true)
+  .onFace(plate, 'top', { u: -30, v: 22, protrude: 0.5, selfAnchor: 'center' })
+  .extrude(7);
+const bosses = linearPattern(bossSeed, 3, 30, 0, 0);
+
+const displayPocket = roundedRect(30, 14, 3, true)
+  .onFace(plate, 'top', { u: 0, v: 4, protrude: 0.25, selfAnchor: 'center' });
+
+const topFace = plate.face('top');
+const bottomFace = plate.face('bottom');
+
+const cover = union(plate, bosses)
+  .hole(topFace, {
+    diameter: 5.2,
+    u: -46,
+    v: -22,
+    upToFace: bottomFace,
+    countersink: { diameter: 10.5, angleDeg: 90 },
+  })
+  .hole(topFace, {
+    diameter: 5.2,
+    u: 46,
+    v: -22,
+    upToFace: bottomFace,
+    countersink: { diameter: 10.5, angleDeg: 90 },
+  })
+  .hole(topFace, {
+    diameter: 4.5,
+    u: -30,
+    v: 22,
+    upToFace: bottomFace,
+    counterbore: { diameter: 9, depth: 3 },
+  })
+  .hole(topFace, {
+    diameter: 4.5,
+    u: 30,
+    v: 22,
+    upToFace: bottomFace,
+    counterbore: { diameter: 9, depth: 3 },
+  })
+  .cutout(displayPocket, { depth: 4 });
+
+const projected = projectToPlane(cover, { plane: 'XY' });
+const gasket = projected
+  .offset(1.8)
+  .onFace(topFace, { protrude: 0.5, selfAnchor: 'center' })
+  .extrude(1.2);
+
+return [{ name: 'Service Panel Cover', shape: union(cover, gasket) }];

package/examples/compiler-corpus/trimmed-access-cover.forge.js

@@ -0,0 +1,26 @@
+// Guard part: trim-created plane cap plus upstream hole/cut rewrites in one ordinary cover workflow.
+
+const base = roundedRect(104, 68, 8, true).extrude(18);
+
+const gusset = roundedRect(20, 8, 2, true)
+  .onFace(base, 'front', { u: -22, v: 4, protrude: 0.25, selfAnchor: 'center' })
+  .extrude(10);
+
+const merged = union(base, gusset);
+
+const servicePocket = roundedRect(22, 12, 2, true)
+  .onFace(base, 'top', { u: 18, v: -10, protrude: 0.25, selfAnchor: 'center' });
+
+const preTrim = merged
+  .hole(base.face('top'), { diameter: 6, u: -24, v: 12, depth: 9 })
+  .cutout(servicePocket, { depth: 6 });
+
+const trimmed = preTrim.trimByPlane([0, 1, 0], 6);
+
+const latch = roundedRect(16, 10, 2, true)
+  .extrude(8, { center: true })
+  .translate(0, 28, 8);
+
+const cover = union(trimmed, latch);
+
+return [{ name: 'Trimmed Access Cover', shape: cover }];

package/examples/cup.forge.js

@@ -0,0 +1,25 @@
+// 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" });
+
+// Outer cup shape - tapered cylinder (truncated cone)
+const outerCup = cylinder(height, bottomRadius, topRadius);
+
+// Inner hollow shape - slightly smaller, shorter to leave a base
+const innerHeight = height - baseThickness;
+const innerTopRadius = topRadius - wallThickness;
+const innerBottomRadius = bottomRadius - wallThickness;
+
+// Create hollow interior by subtracting inner cone
+const innerCup = cylinder(innerHeight, innerBottomRadius, innerTopRadius)
+  .translate(0, 0, baseThickness);
+
+// Final cup with hollow interior
+const cup = outerCup.subtract(innerCup);
+
+return cup;

package/examples/cut-plane-demo.forge.js

@@ -0,0 +1,28 @@
+// Cut Plane Demo — toggle section views in the View Panel
+//
+// cutPlane(name, normal, offsetOrOptions?, options?)
+//   normal: direction pointing toward the side that gets removed
+//   offset: distance from origin along the normal where the cut happens
+//   exclude: object name(s) to keep uncut for this plane
+
+const size = param("Size", 60, { min: 20, max: 120, unit: "mm" });
+const holeR = param("Hole Radius", 12, { min: 4, max: 25, unit: "mm" });
+const cutZ = param("Cut Z", 10, { min: -60, max: 60, unit: "mm" });
+const cutY = param("Cut Y", 0, { min: -60, max: 60, unit: "mm" });
+
+// Define cut planes — they appear as toggles in the View Panel
+cutPlane("Horizontal Section", [0, 0, 1], cutZ, { exclude: "Probe" }); // removes top half except Probe
+cutPlane("Front Section", [0, -1, 0], cutY, { exclude: "Probe" });      // removes front half except Probe
+
+// Build a box with a cylindrical hole
+const body = box(size, size, size, true);
+const hole = cylinder(size + 2, holeR, holeR, 32, true);
+const part = body.subtract(hole).color("#8aa7c8");
+const probe = cylinder(size + 14, Math.max(2, holeR * 0.22), undefined, 32, true)
+  .translate(size * 0.3, size * 0.18, 0)
+  .color("#efaa6d");
+
+return [
+  { name: "Body", shape: part },
+  { name: "Probe", shape: probe },
+];

package/examples/door-with-hinges.forge.js

@@ -0,0 +1,54 @@
+// Door with hinges — the door pivots around the hinge axis using joint().
+// Drag the "Door Angle" slider to open/close the door.
+
+const doorW = param("Door Width", 80, { min: 40, max: 120, unit: "mm" });
+const doorH = param("Door Height", 200, { min: 100, max: 300, unit: "mm" });
+const doorT = param("Door Thickness", 4, { min: 2, max: 10, unit: "mm" });
+
+const frameW = param("Frame Width", 8, { min: 4, max: 15, unit: "mm" });
+const frameD = param("Frame Depth", 6, { min: 3, max: 12, unit: "mm" });
+
+const hingeR = param("Hinge Radius", 3, { min: 1.5, max: 6, unit: "mm" });
+const hingeH = param("Hinge Height", 16, { min: 8, max: 30, unit: "mm" });
+
+// ── Door frame (stationary U-shape) ──
+const frame = union(
+  box(frameW, frameD, doorH),                                        // left
+  box(frameW, frameD, doorH).translate(doorW + frameW, 0, 0),       // right
+  box(doorW + 2 * frameW, frameD, frameW).translate(0, 0, doorH),   // top
+).color("#8B7355");
+
+// ── Hinge barrels ──
+const hingePivot = [frameW, 0, 0];  // pivot axis runs along Z at this XY
+const hingeZ1 = doorH * 0.15;
+const hingeZ2 = doorH * 0.85;
+const hinge1 = cylinder(hingeH, hingeR).translate(frameW, 0, hingeZ1 - hingeH / 2).color("#888888");
+const hinge2 = cylinder(hingeH, hingeR).translate(frameW, 0, hingeZ2 - hingeH / 2).color("#888888");
+
+// ── Door panel ──
+// Position at frame edge, then use joint() to rotate around hinge axis
+const doorPanel = box(doorW, doorT, doorH)
+  .translate(frameW, -doorT / 2, 0)
+  .color("#C4A46C");
+
+// joint() auto-creates the "Door Angle" slider and rotates around the pivot
+const rotatedDoor = joint("Door Angle", doorPanel, [frameW, 0, 0], {
+  axis: [0, 0, 1],
+  min: -170,
+  max: 0,
+  default: -45,
+  reverse: true
+});
+
+// ── Phase 1 demo: diagonal intersection to find door center ──
+const doorRect = rectangle(0, 0, doorW, doorH);
+const [d1, d2] = doorRect.diagonals();
+const doorCenter = d1.intersect(d2);
+console.log("Door center (from diagonals):", doorCenter.x.toFixed(1), doorCenter.y.toFixed(1));
+
+return [
+  { name: "Frame", shape: frame },
+  { name: "Door", shape: rotatedDoor },
+  { name: "Hinge Bottom", shape: hinge1 },
+  { name: "Hinge Top", shape: hinge2 },
+];

package/examples/frame.sketch.js

@@ -0,0 +1,4 @@
+// 2D Sketch
+const size = param("size", 50, {unit: "mm"});
+let result = rect(size, size, true);
+return result;

package/examples/headphone-hanger-profile.sketch.js

@@ -0,0 +1,18 @@
+// Headphone Hanger — stroke approach
+// Draw centerline, thicken it. Done.
+
+const plateW = param("Plate Width", 50, { min: 30, max: 80, unit: "mm" });
+const t = param("Thickness", 4, { min: 2, max: 8, unit: "mm" });
+const armLen = param("Arm Length", 70, { min: 40, max: 120, unit: "mm" });
+const hookLen = param("Hook Length", 20, { min: 10, max: 40, unit: "mm" });
+const hookAngle = param("Hook Angle", 47, { min: 15, max: 60, unit: "°" });
+const hookP2Length = param("Hook p2 length", 20, { min: 10, max: 40, unit: "mm" });
+
+return path()
+  .moveTo(0, 0)
+  .lineH(plateW)
+  .lineV(-armLen)
+  .lineAngled(hookLen, 270 - hookAngle)
+  .lineH(-hookP2Length)
+  .lineAngled(hookLen, 90+hookAngle)
+  .stroke(t);

package/examples/headphone-hanger-v2.forge.js

@@ -0,0 +1,88 @@
+// Headphone Hanger — under-desk clamp mount
+// 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" });
+
+// The clamp is a C-shape that grips the desk edge.
+// Top jaw sits on top of desk, bottom jaw presses from below.
+// A vertical arm drops down, then curves into the hook.
+
+// --- Top jaw (sits on desk surface) ---
+const topJaw = box(width, clampDepth, thick);
+
+// --- Vertical back (connects top to bottom jaw) ---
+const backWall = box(width, thick, deskThick + thick * 2)
+  .translate(0, 0, -deskThick - thick);
+
+// --- Bottom jaw (presses up against desk bottom) ---
+const bottomJaw = box(width, clampDepth * 0.6, thick)
+  .translate(0, 0, -deskThick - thick);
+
+// --- Pad on bottom jaw (rubber contact, slightly inset) ---
+const pad = box(width - 10, clampDepth * 0.5, padThick)
+  .translate(5, 5, -deskThick);
+
+// --- Vertical arm dropping down from bottom jaw ---
+const armTop = -deskThick - thick;
+const arm = box(width, thick, hookDrop)
+  .translate(0, clampDepth * 0.6 - thick, armTop - hookDrop);
+
+// --- Hook (curved part at bottom) ---
+// Use revolve to make a clean quarter-torus for the curve
+const hookZ = armTop - hookDrop;
+const armY = clampDepth * 0.6 - thick;
+
+// Quarter-torus: revolve a rect(width x thick) around an axis at hookCurveR distance
+// The profile sits at X = hookCurveR (distance from revolution axis = Y)
+// revolve() goes around Y axis, so profile X = radial, profile Y = height
+const curveProfile = rect(thick, width).translate(hookCurveR, 0);
+const curvePiece = curveProfile.revolve(90)
+  // revolve produces shape around Y axis; rotate to align:
+  // we need the arc to go from -Z (down) to +Y (forward)
+  .rotate(90, 0, 90)   // align width along X
+  .rotate(180, 0, 0)  // flip so arc opens downward-to-forward
+  .translate(0, clampDepth * 0.6 + hookCurveR, hookZ);
+
+// Straight hook tip extending forward
+const tipY = armY + thick + hookCurveR;
+const tipZ = hookZ - hookCurveR - thick;
+const hookTip = box(width, hookLen - hookCurveR, thick)
+  .translate(0, tipY, tipZ);
+
+// Small upward lip at the end to prevent headphones from sliding off
+const lipHeight = 8;
+const hookLip = box(width, thick, lipHeight)
+  .translate(0, tipY + hookLen - hookCurveR - thick, tipZ + thick);
+
+// --- Bolt holes for tightening clamp (optional) ---
+const boltHoles = [];
+if (boltHoleD > 0) {
+  // Two holes through the top jaw
+  const holeSpacing = width * 0.6;
+  for (let i = -1; i <= 1; i += 2) {
+    boltHoles.push(
+      cylinder(thick + 2, boltHoleD / 2)
+        .translate(width / 2 + i * holeSpacing / 2, clampDepth * 0.3, -1)
+    );
+  }
+}
+
+// --- Assembly ---
+let clamp = union(topJaw, backWall, bottomJaw, arm, curvePiece, hookTip, hookLip);
+if (boltHoles.length > 0) {
+  clamp = clamp.subtract(union(...boltHoles));
+}
+
+return [
+  { name: "Clamp + Hook", shape: clamp, color: "#445566" },
+  { name: "Desk Pad", shape: pad, color: "#338855" },
+];

package/examples/headphone-hanger.forge.js

@@ -0,0 +1,5 @@
+const sketch = importSketch("headphone-hanger-profile.sketch.js");
+
+console.log(sketch);
+
+return sketch.extrude(40);

package/examples/iphone-stand.forge.js

@@ -0,0 +1,72 @@
+// Foldable iPhone Stand — two-piece with hinge
+// A base plate and a back support that folds flat for travel.
+
+const standW = param("Stand Width", 85, { min: 70, max: 120, unit: "mm" });
+const thick = param("Thickness", 4, { min: 2, max: 8, unit: "mm" });
+const baseLen = param("Base Length", 80, { min: 50, max: 120, unit: "mm" });
+const backH = param("Back Height", 70, { min: 40, max: 120, unit: "mm" });
+const lipH = param("Lip Height", 12, { min: 5, max: 25, unit: "mm" });
+const lipAngle = param("Lip Angle", 80, { min: 60, max: 90, unit: "°" });
+const foldAngle = param("Fold Angle", 65, { min: 0, max: 90, unit: "°" });
+const hingeR = param("Hinge Radius", 3, { min: 2, max: 6, unit: "mm" });
+const cableHoleD = param("Cable Hole", 12, { min: 0, max: 20, unit: "mm" });
+const gripSlots = param("Grip Slots", 3, { min: 0, max: 5 });
+
+// --- Base plate (centered on XY, bottom at Z=0) ---
+const base = roundedRect(standW, baseLen, 3, true).extrude(thick);
+
+// --- Front lip (holds the phone) ---
+// Build at origin: sits on XZ plane, thick in Y, lipH tall in Z
+// Then tilt backward, then move to front edge
+const lipRaw = box(standW - 10, thick, lipH, true)
+  .translate(0, 0, lipH / 2);                  // lift so bottom edge is at Z=0
+const lipTilted = lipRaw.rotate(-(90 - lipAngle), 0, 0);  // tilt back
+const lip = lipTilted.translate(0, -baseLen / 2, thick);   // move to front edge, on top of base
+
+// --- Grip slots (cross-wise along X to prevent phone sliding forward) ---
+const slotParts = [];
+if (gripSlots > 0) {
+  const slotSpacing = (baseLen * 0.5) / (gripSlots + 1);
+  for (let i = 0; i < gripSlots; i++) {
+    const sy = -baseLen / 4 + slotSpacing * (i + 1);
+    slotParts.push(
+      box(standW * 0.6, 2, thick + 2, true)
+        .translate(0, sy, thick / 2)
+    );
+  }
+}
+
+// --- Cable hole (near front lip where phone bottom rests) ---
+let baseFinal = union(base, lip);
+if (slotParts.length > 0) {
+  baseFinal = baseFinal.subtract(union(...slotParts));
+}
+if (cableHoleD > 0) {
+  const cableHole = cylinder(thick + 2, cableHoleD / 2)
+    .translate(0, -baseLen / 4, -1);
+  baseFinal = baseFinal.subtract(cableHole);
+}
+
+// --- Back support (foldable) ---
+// Build panel at origin standing up in Z, then rotate around its bottom edge, then translate to hinge
+const backPanel = box(standW - 6, thick, backH, true)
+  .translate(0, 0, backH / 2);                    // bottom edge at Z=0
+const backRotated = backPanel
+  .rotate(-foldAngle, 0, 0)                        // fold: 0°=vertical, 90°=flat
+  .translate(0, baseLen / 2, thick);               // move to back edge of base
+
+// --- Hinge cylinders (decorative pivots along X axis) ---
+const hingeLen = 10;
+const hingeLeft = cylinder(hingeLen, hingeR, hingeR)
+  .rotate(0, 90, 0)
+  .translate(-standW / 2 + 8, baseLen / 2, thick);
+const hingeRight = cylinder(hingeLen, hingeR, hingeR)
+  .rotate(0, 90, 0)
+  .translate(standW / 2 - 8 - hingeLen, baseLen / 2, thick);
+
+return [
+  { name: "Base", shape: baseFinal, color: "#556677" },
+  { name: "Back Support", shape: backRotated, color: "#778899" },
+  { name: "Hinge L", shape: hingeLeft, color: "#aabbcc" },
+  { name: "Hinge R", shape: hingeRight, color: "#aabbcc" },
+];