forgecad 0.1.0

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

@@ -0,0 +1,56 @@
+// Sketch on face — place 2D profiles onto canonical or tracked planar faces,
+// then extrude along that face normal.
+
+const body = box(140, 70, 44, true).color('#d5dbe3');
+
+const frontBadge = roundedRect(30, 12, 2.5, true)
+  .subtract(circle2d(2.5).translate(-8, 0))
+  .subtract(circle2d(2.5).translate(8, 0))
+  .onFace(body, 'front', { v: 10, protrude: 0.05 })
+  .extrude(2.4)
+  .color('#1d2733');
+
+const topVent = union2d(
+  rect(56, 6, true),
+  rect(56, 6, true).translate(0, 10),
+  rect(56, 6, true).translate(0, -10),
+)
+  .onFace(body, 'top', { v: 8, protrude: 0.05 })
+  .extrude(1.5)
+  .color('#55697e');
+
+const sidePort = roundedRect(22, 10, 3, true)
+  .onFace(body, 'right', { u: -8, v: 0, protrude: 0.05 })
+  .extrude(3)
+  .color('#20262e');
+
+const trackedPanel = Rectangle2D.from3Points(
+  point(-34, -18),
+  point(30, -6),
+  point(18, 26),
+)
+  .extrude(18)
+  .translate(0, 92, 0)
+  .color('#c4ccd6');
+
+const trackedSideBadge = roundedRect(22, 8, 2, true)
+  .onFace(trackedPanel, 'side-right', { v: -2, protrude: 0.05 })
+  .extrude(1.4)
+  .color('#27313c');
+
+const trackedTopCap = circle2d(5)
+  .onFace(trackedPanel.face('top'), { u: 12, protrude: 0.05 })
+  .extrude(1.2)
+  .color('#5a6c7c');
+
+cutPlane('Center X', [1, 0, 0], 0);
+
+return [
+  { name: 'Body', shape: body },
+  { name: 'Front Badge', shape: frontBadge },
+  { name: 'Top Vent', shape: topVent },
+  { name: 'Side Port', shape: sidePort },
+  { name: 'Tracked Panel', shape: trackedPanel },
+  { name: 'Tracked Side Badge', shape: trackedSideBadge },
+  { name: 'Tracked Top Cap', shape: trackedTopCap },
+];

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

@@ -0,0 +1,56 @@
+// 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 gap = 120;
+const bodyWidth = 90;
+const bodyHeight = 44;
+const shoulderInset = 24;
+const shoulderRise = 30;
+const peakRise = 42;
+
+const roofPoints = [
+  [0, 0],
+  [bodyWidth, 0],
+  [bodyWidth, bodyHeight],
+  [bodyWidth - shoulderInset, bodyHeight + shoulderRise],
+  [bodyWidth / 2, bodyHeight + peakRise],
+  [shoulderInset, bodyHeight + shoulderRise],
+  [0, bodyHeight],
+];
+
+const roofRidge = [
+  [0, bodyHeight],
+  [shoulderInset, bodyHeight + shoulderRise],
+  [bodyWidth / 2, bodyHeight + peakRise],
+  [bodyWidth - shoulderInset, bodyHeight + shoulderRise],
+  [bodyWidth, bodyHeight],
+];
+
+const rawProfile = polygon(roofPoints).color('#7b858c');
+const roundedAllCorners = rawProfile.offset(-radius, 'Round').offset(radius, 'Round').color('#d4862d');
+const strokedCenterline = union2d(
+  rect(bodyWidth, bodyHeight),
+  stroke(roofRidge, radius * 2, 'Round'),
+).color('#2a9d8f');
+const hulledCircles = union2d(
+  rect(bodyWidth, bodyHeight),
+  hull2d(
+    circle2d(radius).translate(shoulderInset, bodyHeight + shoulderRise),
+    circle2d(radius).translate(bodyWidth / 2, bodyHeight + peakRise),
+    circle2d(radius).translate(bodyWidth - shoulderInset, bodyHeight + shoulderRise),
+  ),
+).color('#7f5af0');
+const selectiveFillet = filletCorners(roofPoints, [
+  { index: 3, radius },
+  { index: 4, radius },
+  { index: 5, radius },
+]).color('#e63946');
+
+return [
+  { name: "Raw polygon", sketch: rawProfile },
+  { name: "offset(-r).offset(+r)", sketch: roundedAllCorners.translate(gap, 0) },
+  { name: "stroke(..., 'Round')", sketch: strokedCenterline.translate(gap * 2, 0) },
+  { name: "hull2d() of circles", sketch: hulledCircles.translate(gap * 3, 0) },
+  { name: "filletCorners()", sketch: selectiveFillet.translate(gap * 4, 0) },
+];

package/examples/api/spatial-recipes.forge.js

@@ -0,0 +1,129 @@
+// Spatial Recipes — common arrangements for multi-part assemblies.
+//
+// ForgeCAD coordinate system:
+//   X = left/right    (+X = right)
+//   Y = forward/back  (+Y = forward, −Y = back toward camera)
+//   Z = up/down       (+Z = up)
+//
+// "front" anchor = −Y face (faces the camera in default view)
+// "back"  anchor = +Y face
+//
+// These recipes show how to position parts relative to each other
+// using attachTo() and onFace() so you never need manual coordinate math.
+
+const recipe = param("Recipe", 1, { min: 1, max: 3, integer: true });
+
+if (recipe === 1) {
+  // ─── Recipe 1: Wall separating two spaces ───
+  // Wall is thin along Y. Indoor side = −Y. Outdoor side = +Y.
+
+  const wallThick = 15;
+  const wall = box(200, wallThick, 150, true).color('#C4A77D');
+
+  // Indoor unit: its back face meets the wall's front face
+  const indoor = box(120, 30, 50, true).color('#F5F5F5')
+    .attachTo(wall, 'front', 'back', [0, -5, 0]);
+
+  // Outdoor unit: its front face meets the wall's back face
+  const outdoor = box(140, 40, 60, true).color('#888888')
+    .attachTo(wall, 'back', 'front', [0, 5, -10]);
+
+  // Pipe hole through wall — orient along Y (same as wall thickness)
+  const hole = cylinder(wallThick + 2, 10).pointAlong([0, 1, 0]);
+  const wallWithHole = wall.subtract(hole);
+
+  // Pipe spanning both sides — also along Y, centered at same XZ as hole
+  const pipe = cylinder(100, 4).pointAlong([0, 1, 0]).color('#B87333');
+
+  return [
+    { name: "Wall", shape: wallWithHole },
+    { name: "Indoor Unit", shape: indoor },
+    { name: "Outdoor Unit", shape: outdoor },
+    { name: "Pipe", shape: pipe },
+  ];
+}
+
+if (recipe === 2) {
+  // ─── Recipe 2: Surface details using onFace() ───
+  // onFace(parent, face, {u, v, protrude}) places a child on a parent's face.
+  //   u, v = position within the face (from center)
+  //   protrude = how far it sticks out (positive = outward)
+  //
+  // Face coordinate mapping:
+  //   front/back: u = left/right (X), v = up/down (Z)
+  //   left/right: u = forward/back (Y), v = up/down (Z)
+  //   top/bottom: u = left/right (X), v = forward/back (Y)
+
+  const body = box(100, 40, 60, true).color('#F5F5F5');
+
+  // Vent slits on front face, near bottom
+  const vent = box(80, 2, 12, true).color('#333333')
+    .onFace(body, 'front', { v: -15, protrude: 2 });
+
+  // Display panel on front face, near top-right
+  const display = box(35, 1.5, 8, true).color('#00ddee')
+    .onFace(body, 'front', { u: 20, v: 15, protrude: 1 });
+
+  // Button on front face, top-left area
+  const button = box(6, 2, 6, true).color('#44cc44')
+    .onFace(body, 'front', { u: -30, v: 18, protrude: 2 });
+
+  // Side vent on left face
+  const sideVent = box(2, 30, 40, true).color('#666666')
+    .onFace(body, 'left', { protrude: 1 });
+
+  // Fan on top, protruding 5mm
+  const fan = cylinder(10, 40).color('#333333')
+    .onFace(body, 'top', { protrude: 5 });
+
+  return [
+    { name: "Body", shape: body },
+    { name: "Front Vent", shape: vent },
+    { name: "Display", shape: display },
+    { name: "Button", shape: button },
+    { name: "Side Vent", shape: sideVent },
+    { name: "Top Fan", shape: fan },
+  ];
+}
+
+if (recipe === 3) {
+  // ─── Recipe 3: Full AC outdoor condenser ───
+  // Combines attachTo() for stacking and onFace() for surface details
+
+  const body = box(140, 50, 70, true).color('#888888');
+
+  // Fan housing on top — cylinder defaults to Z-up, correct for top placement
+  const fan = cylinder(10, 50).color('#333333')
+    .onFace(body, 'top', { protrude: 2 });
+
+  // Fan grill (flat disc on top of fan)
+  const grill = cylinder(2, 52).color('#777777')
+    .attachTo(fan, 'top', 'bottom');
+
+  // Pipe ports on front face — orient along Y (pointing outward from front)
+  const pipe1 = cylinder(20, 5).pointAlong([0, -1, 0]).color('#B87333')
+    .onFace(body, 'front', { u: -15, v: -10, protrude: 2 });
+
+  const pipe2 = cylinder(20, 3).pointAlong([0, -1, 0]).color('#B87333')
+    .onFace(body, 'front', { u: 15, v: -10, protrude: 2 });
+
+  // Side louvers on right face
+  const louver = box(2, 3, 50, true).color('#666666')
+    .onFace(body, 'right', { protrude: 1 });
+
+  // Feet on bottom
+  const foot = box(20, 15, 5, true).color('#222222');
+  const footL = foot.attachTo(body, 'bottom-left', 'top-left', [10, 5, -1]);
+  const footR = foot.attachTo(body, 'bottom-right', 'top-right', [-10, 5, -1]);
+
+  return [
+    { name: "Body", shape: body },
+    { name: "Fan", shape: fan },
+    { name: "Grill", shape: grill },
+    { name: "Pipe 1", shape: pipe1 },
+    { name: "Pipe 2", shape: pipe2 },
+    { name: "Louver", shape: louver },
+    { name: "Foot L", shape: footL },
+    { name: "Foot R", shape: footR },
+  ];
+}

package/examples/bathroom.forge.js

@@ -0,0 +1,197 @@
+// Full Bathroom — parametric room with fixtures
+// Bathtub, sink, toilet, mirror, shower glass panel, towel rack
+
+const roomW = param("Room Width", 2400, { min: 1800, max: 3500, unit: "mm" });
+const roomD = param("Room Depth", 2000, { min: 1500, max: 3000, unit: "mm" });
+const roomH = param("Room Height", 2500, { min: 2200, max: 3000, unit: "mm" });
+const wallT = param("Wall Thickness", 80, { min: 50, max: 150, unit: "mm" });
+const tileH = param("Tile Height", 1200, { min: 800, max: 1800, unit: "mm" });
+
+// ─── Room shell (floor + 3 walls, front open) ───
+
+const floor = box(roomW, roomD, wallT);
+const wallBack = box(roomW, wallT, roomH).translate(0, roomD - wallT, wallT);
+const wallLeft = box(wallT, roomD, roomH).translate(0, 0, wallT);
+const wallRight = box(wallT, roomD, roomH).translate(roomW - wallT, 0, wallT);
+const room = union(floor, wallBack, wallLeft, wallRight);
+
+// Tile strip on back wall
+const tileStrip = box(roomW - 2 * wallT, 2, tileH)
+  .translate(wallT, roomD - wallT - 1, wallT);
+
+// ─── Bathtub (left-back corner) ───
+
+const tubL = param("Tub Length", 1500, { min: 1200, max: 1800, unit: "mm" });
+const tubW = param("Tub Width", 700, { min: 550, max: 800, unit: "mm" });
+const tubH = param("Tub Height", 500, { min: 400, max: 600, unit: "mm" });
+const tubWall = param("Tub Wall", 40, { min: 25, max: 60, unit: "mm" });
+
+const tubX = wallT + 20;
+const tubY = roomD - wallT - tubW - 20;
+
+const tubOuter = box(tubL, tubW, tubH);
+const tubInner = box(tubL - 2 * tubWall, tubW - 2 * tubWall, tubH - tubWall)
+  .translate(tubWall, tubWall, tubWall);
+const tubDrain = cylinder(tubWall + 2, 25)
+  .translate(tubL / 2, tubW / 2, 0);
+const bathtub = tubOuter.subtract(tubInner).subtract(tubDrain)
+  .translate(tubX, tubY, wallT);
+
+// ─── Shower (above tub) ───
+
+const glassH = param("Glass Height", 1800, { min: 1500, max: 2200, unit: "mm" });
+const glassT = 8;
+
+// Glass panel at tub edge
+const showerGlass = box(glassT, tubW, glassH)
+  .translate(tubX + tubL, tubY, wallT);
+
+// Shower arm — horizontal pipe from back wall
+const armLen = 250;
+const showerArmX = tubX + tubL * 0.6;
+const showerArmZ = wallT + glassH - 150;
+const showerArm = cylinder(armLen, 12)
+  .rotate(90, 0, 0)
+  .translate(showerArmX, roomD - wallT, showerArmZ);
+
+// Shower head — disc at end of arm
+const showerHead = cylinder(15, 55, 55)
+  .translate(showerArmX, roomD - wallT - armLen, showerArmZ - 7);
+
+const shower = union(showerArm, showerHead);
+
+// ─── Toilet (right side, against back wall) ───
+
+const toiletW = param("Toilet Width", 380, { min: 340, max: 420, unit: "mm" });
+const toiletD = param("Toilet Depth", 650, { min: 550, max: 750, unit: "mm" });
+const toiletH = 400;
+
+const toiletX = roomW - wallT - toiletW - 150;
+const toiletY = roomD - wallT - toiletD - 20;
+const toiletCX = toiletX + toiletW / 2;
+const toiletCY = toiletY + toiletD * 0.4; // bowl center forward of midpoint
+
+// Bowl — tapered cylinder, hollowed
+const bowlR = toiletW / 2;
+const bowlOuter = cylinder(toiletH, bowlR, bowlR * 0.85);
+const bowlInner = cylinder(toiletH - 40, bowlR - 30, bowlR * 0.85 - 30)
+  .translate(0, 0, 40);
+const bowl = bowlOuter.subtract(bowlInner)
+  .translate(toiletCX, toiletCY, wallT);
+
+// Tank — box behind the bowl
+const tankW = toiletW * 0.85;
+const tankD = 150;
+const tankH = 320;
+const tank = box(tankW, tankD, tankH, true)
+  .translate(toiletCX, toiletY + toiletD - tankD / 2 - 10, wallT + toiletH / 2 + tankH / 2 - 80);
+
+// Lid — flat slab on top of tank
+const lid = box(tankW + 10, tankD + 10, 15, true)
+  .translate(toiletCX, toiletY + toiletD - tankD / 2 - 10, wallT + toiletH / 2 + tankH - 80 + 7);
+
+// Seat — flat ring on top of bowl
+const seatOuter = cylinder(18, bowlR - 5, bowlR * 0.85 - 5);
+const seatInner = cylinder(20, bowlR - 30, bowlR * 0.85 - 30).translate(0, 0, -1);
+const seat = seatOuter.subtract(seatInner)
+  .translate(toiletCX, toiletCY, wallT + toiletH - 18);
+
+const toilet = union(bowl, tank, lid, seat);
+
+// ─── Sink (right wall, facing into room) ───
+
+const sinkW = param("Sink Width", 550, { min: 400, max: 700, unit: "mm" });
+const sinkD = 420;
+const sinkH = 160;
+const sinkZ = 850;
+
+// Sink centered on right wall, facing left (into room)
+const sinkCX = roomW - wallT - sinkD / 2 - 30;
+const sinkCY = roomD * 0.35;
+
+const basinOuter = box(sinkD, sinkW, sinkH, true);
+const basinInner = box(sinkD - 50, sinkW - 50, sinkH - 25, true).translate(0, 0, 12);
+const drain = cylinder(27, 18).translate(0, 0, -sinkH / 2);
+const basin = basinOuter.subtract(basinInner).subtract(drain)
+  .translate(sinkCX, sinkCY, wallT + sinkZ + sinkH / 2);
+
+// Pedestal
+const pedestal = box(80, 80, sinkZ, true)
+  .translate(sinkCX, sinkCY, wallT + sinkZ / 2);
+
+// Faucet — vertical stem + curved spout
+const faucetX = sinkCX + sinkD / 2 - 40;
+const faucetZ = wallT + sinkZ + sinkH;
+const faucetStem = cylinder(100, 10)
+  .translate(faucetX, sinkCY, faucetZ);
+const faucetSpout = box(80, 16, 16, true)
+  .translate(faucetX - 40, sinkCY, faucetZ + 100);
+// Handles
+const handleL = box(30, 8, 8, true)
+  .translate(faucetX, sinkCY - 30, faucetZ + 50);
+const handleR = box(30, 8, 8, true)
+  .translate(faucetX, sinkCY + 30, faucetZ + 50);
+
+const sink = union(basin, pedestal, faucetStem, faucetSpout, handleL, handleR);
+
+// ─── Mirror (on right wall, above sink) ───
+
+const mirrorW = param("Mirror Width", 600, { min: 400, max: 900, unit: "mm" });
+const mirrorH = param("Mirror Height", 800, { min: 500, max: 1200, unit: "mm" });
+const mirrorT = 5;
+const frameW = 15;
+
+const mirrorZ = wallT + sinkZ + sinkH + 150;
+const mirrorCY = sinkCY;
+
+// Frame — flat rectangle with cutout
+const frameOuter = box(frameW, mirrorW + 2 * frameW, mirrorH + 2 * frameW);
+const frameInner = box(frameW + 2, mirrorW, mirrorH).translate(-1, frameW, frameW);
+const frame = frameOuter.subtract(frameInner)
+  .translate(roomW - wallT - frameW, mirrorCY - mirrorW / 2 - frameW, mirrorZ);
+
+// Mirror surface
+const mirrorSurface = box(mirrorT, mirrorW, mirrorH)
+  .translate(roomW - wallT - mirrorT - 1, mirrorCY - mirrorW / 2, mirrorZ);
+
+// ─── Towel rack (left wall) ───
+
+const rackZ = 1100;
+const rackLen = 600;
+const barR = 8;
+const bracketSize = 25;
+const rackY = roomD * 0.4;
+
+const bracketL = box(70, bracketSize, bracketSize)
+  .translate(wallT, rackY - rackLen / 2, wallT + rackZ);
+const bracketR = box(70, bracketSize, bracketSize)
+  .translate(wallT, rackY + rackLen / 2 - bracketSize, wallT + rackZ);
+const towelBar = cylinder(rackLen - bracketSize * 2, barR)
+  .rotate(-90, 0, 0)
+  .translate(wallT + 50, rackY - rackLen / 2 + bracketSize, wallT + rackZ + bracketSize / 2);
+
+const towelRack = union(bracketL, bracketR, towelBar);
+
+// ─── Bath mat (in front of tub) ───
+
+const matW = 700;
+const matD = 450;
+const matH = 8;
+const bathMat = box(matW, matD, matH, true)
+  .translate(tubX + tubL / 2, tubY - matD / 2 - 30, wallT + matH / 2);
+
+// ─── Assemble ───
+
+return [
+  { name: "Room",         shape: room,          color: "#e8e0d4" },
+  { name: "Tile Strip",   shape: tileStrip,     color: "#5a8a9a" },
+  { name: "Bathtub",      shape: bathtub,       color: "#f0f0f0" },
+  { name: "Shower Glass", shape: showerGlass,   color: "#aaddee" },
+  { name: "Shower Head",  shape: shower,        color: "#b0b0b0" },
+  { name: "Toilet",       shape: toilet,        color: "#f5f5f0" },
+  { name: "Sink",         shape: sink,          color: "#f0f0f0" },
+  { name: "Mirror Frame", shape: frame,         color: "#2a2a2a" },
+  { name: "Mirror",       shape: mirrorSurface, color: "#b8ccd8" },
+  { name: "Towel Rack",   shape: towelRack,     color: "#707070" },
+  { name: "Bath Mat",     shape: bathMat,       color: "#6b9e7a" },
+];

package/examples/bolt-and-nut.forge.js

@@ -0,0 +1,39 @@
+// Bolt and Nut — helical threads via twisted extrusion
+//
+// lib.bolt() and lib.nut() use Manifold's native extrude+twist
+// to sweep a thread tooth profile helically — clean geometry, no SDF grid.
+
+const diameter = param("Diameter", 8, { min: 4, max: 20, unit: "mm" });
+const length = param("Length", 30, { min: 10, max: 60, unit: "mm" });
+const pitch = param("Pitch", 1.25, { min: 0.5, max: 3, step: 0.25, unit: "mm" });
+const headH = param("Head Height", 5, { min: 3, max: 12, unit: "mm" });
+const headAF = param("Head AF", 13, { min: 7, max: 30, unit: "mm" });
+const nutHeight = param("Nut Height", 6.5, { min: 3, max: 12, unit: "mm" });
+const nutAF = param("Nut AF", 13, { min: 7, max: 30, unit: "mm" });
+const showNut = param("Show Nut", 1, { min: 0, max: 1, step: 1 });
+const nutPos = param("Nut Position", 5, { min: 0, max: 30, unit: "mm" });
+const segments = param("Segments", 36, { min: 12, max: 72, step: 4, integer: true });
+
+const boltShape = lib.bolt(diameter, length, {
+  pitch,
+  headHeight: headH,
+  headAcrossFlats: headAF,
+  segments,
+});
+
+const result = [
+  { name: "Bolt", shape: boltShape, color: "#aaaaaa" },
+];
+
+if (showNut >= 1) {
+  const nutShape = lib.nut(diameter, {
+    pitch,
+    height: nutHeight,
+    acrossFlats: nutAF,
+    segments,
+  }).translate(0, 0, -length + nutPos + nutHeight / 2);
+
+  result.push({ name: "Nut", shape: nutShape, color: "#999999" });
+}
+
+return result;

package/examples/bolt-pattern.forge.js

@@ -0,0 +1,18 @@
+// 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" });
+
+// Base plate
+const base = circle2d(baseR).extrude(baseH);
+
+// Single bolt hole
+const hole = circle2d(boltR).extrude(baseH + 2).translate(boltCircleR, 0, -1);
+
+// Circular pattern of holes
+const holes = circularPattern(hole, boltCount);
+
+return base.subtract(holes);

package/examples/bottle.forge.js

@@ -0,0 +1,101 @@
+// 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" });
+
+// Outer profile — polygon traced from bottom-center up and around
+// Bottom flat → body → shoulder curve → neck
+const steps = 12;
+const outerPts = [];
+
+// Bottom center
+outerPts.push([0, 0]);
+// Bottom edge
+outerPts.push([bodyR, 0]);
+// Body straight up
+outerPts.push([bodyR, bodyH - shoulderR]);
+
+// Shoulder curve (quarter circle from body to neck)
+for (let i = 0; i <= steps; i++) {
+  const t = (i / steps) * Math.PI / 2;
+  const x = neckR + (bodyR - neckR) * Math.cos(t);
+  const y = bodyH - shoulderR + shoulderR * Math.sin(t);
+  outerPts.push([x, y]);
+}
+
+// Neck top
+outerPts.push([neckR, bodyH + neckH]);
+// Back to center at top
+outerPts.push([0, bodyH + neckH]);
+
+const outerProfile = polygon(outerPts);
+const outerBody = outerProfile.revolve();
+
+// Inner profile — offset inward by wall thickness
+const innerPts = [];
+const innerBodyR = bodyR - wall;
+const innerNeckR = neckR - wall;
+
+innerPts.push([0, wall]); // bottom floor
+innerPts.push([innerBodyR, wall]);
+innerPts.push([innerBodyR, bodyH - shoulderR]);
+
+for (let i = 0; i <= steps; i++) {
+  const t = (i / steps) * Math.PI / 2;
+  const x = innerNeckR + (innerBodyR - innerNeckR) * Math.cos(t);
+  const y = bodyH - shoulderR + shoulderR * Math.sin(t);
+  innerPts.push([x, y]);
+}
+
+innerPts.push([innerNeckR, bodyH + neckH + 1]); // extend past top
+innerPts.push([0, bodyH + neckH + 1]);
+
+const innerProfile = polygon(innerPts);
+const innerBody = innerProfile.revolve();
+
+const bottle = outerBody.subtract(innerBody);
+
+// Thread ridge on neck (simple ring)
+const threadZ = bodyH + neckH * 0.3;
+const threadRing = cylinder(2, neckR + 1.5, neckR + 1.5)
+  .subtract(cylinder(4, neckR - 0.5, neckR - 0.5).translate(0, 0, -1))
+  .translate(0, 0, threadZ);
+
+const threadRing2 = cylinder(2, neckR + 1.5, neckR + 1.5)
+  .subtract(cylinder(4, neckR - 0.5, neckR - 0.5).translate(0, 0, -1))
+  .translate(0, 0, threadZ + 5);
+
+const bottleWithThreads = union(bottle, threadRing, threadRing2);
+
+// Cap — hollow cylinder that sits on top of neck
+const capOuterR = neckR + 3;
+const capOuter = cylinder(capH, capOuterR, capOuterR);
+const capInner = cylinder(capH - 2, neckR + 0.5, neckR + 0.5).translate(0, 0, 2);
+const cap = capOuter.subtract(capInner)
+  .translate(0, 0, bodyH + neckH);
+
+// Grip ridges on cap (vertical grooves)
+const ridgeCount = 24;
+const ridges = [];
+for (let i = 0; i < ridgeCount; i++) {
+  const angle = (i / ridgeCount) * 360;
+  const rad = angle * Math.PI / 180;
+  const rx = (capOuterR + 0.5) * Math.cos(rad);
+  const ry = (capOuterR + 0.5) * Math.sin(rad);
+  ridges.push(
+    box(1.5, 1.5, capH - 4, true)
+      .translate(rx, ry, bodyH + neckH + capH / 2)
+  );
+}
+const capWithGrip = difference(cap, ...ridges);
+
+return [
+  { name: "Bottle", shape: bottleWithThreads, color: "#88ccee" },
+  { name: "Cap", shape: capWithGrip, color: "#2255aa" },
+];

package/examples/chair.forge.js

@@ -0,0 +1,62 @@
+// Four-Legged Chair — parametric dining chair
+
+const seatW = param("Seat Width", 45, { min: 30, max: 60, unit: "mm" });
+const seatD = param("Seat Depth", 42, { min: 30, max: 55, unit: "mm" });
+const seatT = param("Seat Thickness", 3, { min: 2, max: 6, unit: "mm" });
+const seatH = param("Seat Height", 45, { min: 35, max: 55, unit: "mm" });
+
+const legW = param("Leg Width", 4, { min: 2, max: 8, unit: "mm" });
+const legInset = param("Leg Inset", 3, { min: 0, max: 10, unit: "mm" });
+
+const backH = param("Back Height", 40, { min: 25, max: 60, unit: "mm" });
+const backT = param("Back Thickness", 3, { min: 2, max: 6, unit: "mm" });
+const backTilt = param("Back Tilt", 5, { min: 0, max: 15, unit: "°" });
+
+const stretcher = param("Stretchers", 1, { min: 0, max: 1, step: 1 });
+const stretcherH = param("Stretcher Height", 12, { min: 5, max: 30, unit: "mm" });
+const stretcherW = param("Stretcher Width", 2, { min: 1, max: 4, unit: "mm" });
+
+// --- Seat ---
+const seat = box(seatW, seatD, seatT).translate(0, 0, seatH);
+
+// --- Legs ---
+const legPositions = [
+  [legInset, legInset],                              // front-left
+  [seatW - legInset - legW, legInset],               // front-right
+  [legInset, seatD - legInset - legW],               // back-left
+  [seatW - legInset - legW, seatD - legInset - legW] // back-right
+];
+
+const legs = union(
+  ...legPositions.map(([x, y]) =>
+    box(legW, legW, seatH).translate(x, y, 0)
+  )
+);
+
+// --- Backrest ---
+// Tilted slightly backward — rotate around X then position at back edge
+const backPanel = box(seatW, backT, backH)
+  .translate(-seatW / 2, -backT / 2, 0)  // center for rotation
+  .rotate(-backTilt, 0, 0)
+  .translate(seatW / 2, seatD - legInset - legW / 2, seatH + seatT);
+
+// --- Stretchers (side rails between legs) ---
+const parts = [seat, legs, backPanel];
+
+if (stretcher >= 1) {
+  // Side stretchers (along Y, connecting front-back legs)
+  const sideLen = seatD - 2 * legInset - legW;
+  const leftStr = box(stretcherW, sideLen, stretcherW)
+    .translate(legInset + legW / 2 - stretcherW / 2, legInset + legW, stretcherH);
+  const rightStr = box(stretcherW, sideLen, stretcherW)
+    .translate(seatW - legInset - legW / 2 - stretcherW / 2, legInset + legW, stretcherH);
+
+  // Front stretcher (along X, connecting front legs)
+  const frontLen = seatW - 2 * legInset - legW;
+  const frontStr = box(frontLen, stretcherW, stretcherW)
+    .translate(legInset + legW, legInset + legW / 2 - stretcherW / 2, stretcherH);
+
+  parts.push(leftStr, rightStr, frontStr);
+}
+
+return union(...parts);