forgecad 0.1.0

package/examples/3d-printer.forge.js

@@ -0,0 +1,328 @@
+// CoreXY 3D Printer — Bambu-style with proper clearances
+// Z-up, Y = depth (front/back), X = width (left/right)
+//
+// Printing model: bed starts near nozzle, lowers as layers build up.
+// Bed Z param represents current print progress (high = start, low = done).
+
+// ─── Parameters ───
+const bedW = param("Bed Width", 220, { min: 180, max: 300, unit: "mm" });
+const bedD = param("Bed Depth", 220, { min: 180, max: 300, unit: "mm" });
+const bedThick = param("Bed Thickness", 4, { min: 3, max: 8, unit: "mm" });
+const frameMargin = param("Frame Margin", 40, { min: 20, max: 80, unit: "mm" });
+const beam = param("Beam Size", 20, { min: 15, max: 30, unit: "mm" });
+const frameH = param("Frame Height", 400, { min: 320, max: 520, unit: "mm" });
+
+// ─── Derived frame ───
+const frameW = bedW + 2 * frameMargin;
+const frameD = bedD + 2 * frameMargin;
+const innerW = frameW - 2 * beam;
+const innerD = frameD - 2 * beam;
+const railR = 4;
+
+// Gantry sits near the top of the frame
+const gantryZ = frameH - 80;
+const nozzleToRail = 55;
+const nozzleZ = gantryZ - nozzleToRail;
+
+// Bed starts near nozzle tip and lowers during printing.
+const bedTopMax = nozzleZ - 1;
+const bedTopMin = beam + bedThick + 80;
+const bedZ = param("Bed Z (print progress)", bedTopMax, {
+  min: bedTopMin, max: bedTopMax, unit: "mm",
+});
+
+// Gantry XY travel
+const gantryTravel = innerD / 2 - 30;
+const gantryY = param("Gantry Y", 0, { min: -gantryTravel, max: gantryTravel, unit: "mm" });
+const headTravel = innerW / 2 - 50;
+const headX = param("Nozzle X", 0, { min: -headTravel, max: headTravel, unit: "mm" });
+
+// ─── Colors ───
+const C = {
+  frame: "#555555", bed: "#c45c1a", glass: "#6bb6ff",
+  carriage: "#888888", rail: "#c0c0c0", lead: "#999999",
+  belt: "#222222", motor: "#444444", electronics: "#666666",
+  screen: "#00ccff", nozzle: "#b87333", hotend: "#999999",
+  fan: "#333333", spool: "#dddddd", filament: "#cc4444",
+  buildVol: "#33ccff",
+};
+
+const parts = [];
+const add = (name, shape, color) =>
+  parts.push({ name, shape: color ? shape.color(color) : shape });
+
+// ─── Frame ───
+const fp = [];
+const bz = beam / 2;
+const tz = frameH - beam / 2;
+const pH = frameH - 2 * beam;
+const pZ = beam + pH / 2;
+const hw = frameW / 2 - beam / 2;
+const hd = frameD / 2 - beam / 2;
+
+for (const z of [bz, tz]) {
+  for (const sy of [-1, 1])
+    fp.push(box(frameW, beam, beam, true).translate(0, sy * hd, z));
+  for (const sx of [-1, 1])
+    fp.push(box(beam, frameD - 2 * beam, beam, true).translate(sx * hw, 0, z));
+}
+for (const sx of [-1, 1])
+  for (const sy of [-1, 1])
+    fp.push(box(beam, beam, pH, true).translate(sx * hw, sy * hd, pZ));
+
+add("Frame", union(...fp), C.frame);
+
+// ─── Z-Axis: rails + lead screws at rear corners ───
+// Z rails only extend from bottom beam to just below gantry zone
+const zRailInsetX = 25;
+const zRailX = innerW / 2 - zRailInsetX;
+const zRailY = innerD / 2 - 5; // flush with rear inner wall
+const zTopClearance = gantryZ - 40; // stop well below gantry
+const zLen = zTopClearance - beam - 10;
+const zBase = beam + 10;
+
+add("Z Rails", union(
+  cylinder(zLen, railR).translate(-zRailX, zRailY, zBase),
+  cylinder(zLen, railR).translate(zRailX, zRailY, zBase),
+), C.rail);
+
+const leadY = zRailY - 10; // lead screws just forward of rails, but behind bed edge
+add("Lead Screws", union(
+  cylinder(zLen - 10, 4).translate(-zRailX, leadY, zBase),
+  cylinder(zLen - 10, 4).translate(zRailX, leadY, zBase),
+), C.lead);
+
+add("Z Motors", union(
+  box(42, 42, 40, true).translate(-zRailX, leadY, beam + 20),
+  box(42, 42, 40, true).translate(zRailX, leadY, beam + 20),
+), C.motor);
+
+// ─── Bed Assembly (moves in Z) ───
+const glassThick = 2;
+const glassTopZ = bedZ;
+const bedPlateTopZ = glassTopZ - glassThick;
+const bedPlateCenterZ = bedPlateTopZ - bedThick / 2;
+
+const bedPlate = box(bedW, bedD, bedThick, true).translate(0, 0, bedPlateCenterZ);
+const glass = box(bedW - 6, bedD - 6, glassThick, true)
+  .translate(0, 0, bedPlateTopZ + glassThick / 2);
+
+const carriageThick = 8;
+const springH = 12;
+const carriageZ = bedPlateCenterZ - bedThick / 2 - springH - carriageThick / 2;
+
+// Carriage narrower in Y so it doesn't extend past the Z rail Y position
+const bedCarriage = box(bedW + 20, bedD - 40, carriageThick, true)
+  .translate(0, 0, carriageZ);
+
+add("Z Bearings", union(
+  box(24, 24, 16, true).translate(-zRailX, zRailY, carriageZ),
+  box(24, 24, 16, true).translate(zRailX, zRailY, carriageZ),
+), C.carriage);
+
+add("Lead Nuts", union(
+  cylinder(8, 6).translate(-zRailX, leadY, carriageZ),
+  cylinder(8, 6).translate(zRailX, leadY, carriageZ),
+), C.lead);
+
+const spX = bedW / 2 - 25;
+const spY = bedD / 2 - 25;
+const springs = [];
+for (const sx of [-1, 1])
+  for (const sy of [-1, 1])
+    springs.push(cylinder(springH, 3).translate(
+      sx * spX, sy * spY, bedPlateCenterZ - bedThick / 2 - springH));
+
+add("Bed Plate", bedPlate, C.bed);
+add("Glass Surface", glass, C.glass);
+add("Bed Carriage", bedCarriage, C.carriage);
+add("Leveling Springs", union(...springs), C.lead);
+
+// ─── XY Gantry ───
+const yRailLen = innerD - 30;
+const yRailX = innerW / 2 - 15;
+
+add("Y Rails", union(
+  cylinder(yRailLen, railR).pointAlong([0, 1, 0]).translate(-yRailX, -yRailLen / 2, gantryZ),
+  cylinder(yRailLen, railR).pointAlong([0, 1, 0]).translate(yRailX, -yRailLen / 2, gantryZ),
+), C.rail);
+
+add("Y Carriages", union(
+  box(28, 32, 18, true).translate(-yRailX, gantryY, gantryZ),
+  box(28, 32, 18, true).translate(yRailX, gantryY, gantryZ),
+), C.carriage);
+
+const xRailLen = yRailX * 2 - 30;
+add("X Rail", cylinder(xRailLen, railR).pointAlong([1, 0, 0])
+  .translate(-xRailLen / 2, gantryY, gantryZ), C.rail);
+
+// X beam at gantry level — supports the X rail from behind
+add("X Beam", box(xRailLen, beam, beam, true)
+  .translate(0, gantryY, gantryZ), C.frame);
+
+// ─── CoreXY Belts ───
+const beltZ = gantryZ + 22;
+add("XY Belts", union(
+  box(xRailLen, 2, 3, true).translate(0, gantryY + 8, beltZ),
+  box(xRailLen, 2, 3, true).translate(0, gantryY - 8, beltZ),
+  box(2, yRailLen, 3, true).translate(-yRailX, 0, beltZ),
+  box(2, yRailLen, 3, true).translate(yRailX, 0, beltZ),
+), C.belt);
+
+// XY motors inside frame at top-rear
+const motorSize = 42;
+const motorY = innerD / 2 - motorSize / 2 - 5;
+add("XY Motors", union(
+  box(motorSize, motorSize, motorSize, true).translate(-yRailX, motorY, gantryZ + 30),
+  box(motorSize, motorSize, motorSize, true).translate(yRailX, motorY, gantryZ + 30),
+), C.motor);
+
+add("XY Idlers", union(
+  cylinder(8, 6).pointAlong([0, 1, 0]).translate(-yRailX, -yRailLen / 2, beltZ),
+  cylinder(8, 6).pointAlong([0, 1, 0]).translate(yRailX, -yRailLen / 2, beltZ),
+  cylinder(8, 6).pointAlong([0, 1, 0]).translate(-yRailX, yRailLen / 2, beltZ),
+  cylinder(8, 6).pointAlong([0, 1, 0]).translate(yRailX, yRailLen / 2, beltZ),
+), C.lead);
+
+// ─── Print Head / Extruder ───
+const hx = headX;
+const hy = gantryY;
+
+add("Nozzle", cylinder(6, 0.4, 2).translate(hx, hy, nozzleZ), C.nozzle);
+add("Heater Block", box(12, 12, 8, true).translate(hx, hy, nozzleZ + 10), C.hotend);
+add("Heatbreak", cylinder(6, 1.5).translate(hx, hy, nozzleZ + 14), C.lead);
+add("Heatsink", cylinder(12, 6).translate(hx, hy, nozzleZ + 22), C.hotend);
+
+const headCarriage = box(46, 28, 36, true).translate(hx, hy, gantryZ - 18);
+add("Extruder Carriage", headCarriage, C.carriage);
+
+add("Part Fan", box(18, 8, 16, true)
+  .onFace(headCarriage, 'front', { v: -5, protrude: 5 }), C.fan);
+
+// Extruder motor — compact, sits just above gantry plane
+const extruderMotorZ = gantryZ + 5;
+add("Extruder Motor", box(30, 30, 20, true)
+  .translate(hx, hy, extruderMotorZ), C.motor);
+
+// ─── Spool Holder (behind frame, on top) ───
+const spoolW = 60;
+const spoolR = 35;
+const spoolY = frameD / 2 + spoolR + 15;
+const spoolZ = frameH;
+
+const spoolRod = cylinder(spoolW + 20, 3).pointAlong([1, 0, 0])
+  .translate(-(spoolW + 20) / 2, spoolY, spoolZ);
+add("Spool Rod", spoolRod, C.lead);
+
+const spoolShell = cylinder(spoolW, spoolR)
+  .subtract(cylinder(spoolW + 2, spoolR - 4).translate(0, 0, -1))
+  .pointAlong([1, 0, 0])
+  .translate(-spoolW / 2, spoolY, spoolZ);
+add("Spool Shell", spoolShell, C.spool);
+add("Filament Roll", cylinder(spoolW - 4, spoolR - 6).pointAlong([1, 0, 0])
+  .translate(-spoolW / 2 + 2, spoolY, spoolZ), C.filament);
+add("Spool Hub", cylinder(spoolW, 8).pointAlong([1, 0, 0])
+  .translate(-spoolW / 2, spoolY, spoolZ), C.lead);
+
+add("Spool Supports", union(
+  box(10, 20, 50, true).translate(-spoolW / 2 - 15, frameD / 2 - beam / 2, frameH - 25),
+  box(10, 20, 50, true).translate(spoolW / 2 + 15, frameD / 2 - beam / 2, frameH - 25),
+), C.frame);
+
+// ─── Filament Path ───
+// Simple path: spool → over rear frame beam → down into extruder
+const filR = 1.5;
+const filBendR = 30;
+
+// Guide tube: spool to top of frame (fixed portion)
+const filFixedPath = lib.pipeRoute(
+  [
+    [0, spoolY, spoolZ],                     // spool center
+    [0, frameD / 2 - beam, frameH + 20],     // up and forward over rear beam
+    [0, 0, frameH + 20],                     // across top to center
+    [hx, hy, extruderMotorZ + 12],           // straight to extruder motor top
+  ],
+  filR,
+  { bendRadius: 25, wall: 0.4, segments: 16 }
+);
+add("Filament Guide Tube", filFixedPath, C.bowden);
+
+// ─── Electronics ───
+add("PSU", box(100, 60, 40, true)
+  .translate(frameW / 2 - 55, -frameD / 2 + 35, 25), C.electronics);
+
+add("Control Board", box(70, 40, 25, true)
+  .translate(-frameW / 2 + 40, -frameD / 2 + 25, 18), C.electronics);
+
+add("Display", box(50, 3, 25, true)
+  .translate(-frameW / 2 + 40, -frameD / 2 + 1, frameH / 3), C.screen);
+
+// ─── Build Volume wireframe ───
+const buildH = Math.max(20, nozzleZ - bedTopMin - 5);
+const bvr = 0.6;
+const bvW = bedW - 10, bvD = bedD - 10;
+const bvEdges = [];
+const x0 = -bvW / 2, x1 = bvW / 2;
+const y0 = -bvD / 2, y1 = bvD / 2;
+const z0b = bedTopMin + 5, z1b = z0b + buildH;
+for (const y of [y0, y1]) for (const z of [z0b, z1b])
+  bvEdges.push(cylinder(bvW, bvr).pointAlong([1, 0, 0]).translate(x0, y, z));
+for (const x of [x0, x1]) for (const z of [z0b, z1b])
+  bvEdges.push(cylinder(bvD, bvr).pointAlong([0, 1, 0]).translate(x, y0, z));
+for (const x of [x0, x1]) for (const y of [y0, y1])
+  bvEdges.push(cylinder(buildH, bvr).translate(x, y, z0b));
+
+add("Build Volume", union(...bvEdges), C.buildVol);
+
+// ─── Cut Planes ───
+cutPlane("Front Section", [0, -1, 0], 0);
+cutPlane("Side Section", [1, 0, 0], 0);
+cutPlane("Top Section", [0, 0, 1], gantryZ);
+
+// Assembly groups — intentional overlaps within groups are not flagged
+return [
+  { name: "Structure", group: [
+    parts.find(p => p.name === "Frame"),
+    parts.find(p => p.name === "Spool Supports"),
+    parts.find(p => p.name === "PSU"),
+    parts.find(p => p.name === "Control Board"),
+    parts.find(p => p.name === "Display"),
+  ]},
+  { name: "Z Axis", group: [
+    parts.find(p => p.name === "Z Rails"),
+    parts.find(p => p.name === "Lead Screws"),
+    parts.find(p => p.name === "Z Motors"),
+    parts.find(p => p.name === "Z Bearings"),
+    parts.find(p => p.name === "Lead Nuts"),
+  ]},
+  { name: "Bed Assembly", group: [
+    parts.find(p => p.name === "Bed Plate"),
+    parts.find(p => p.name === "Glass Surface"),
+    parts.find(p => p.name === "Bed Carriage"),
+    parts.find(p => p.name === "Leveling Springs"),
+  ]},
+  { name: "XY Gantry + Head", group: [
+    parts.find(p => p.name === "Y Rails"),
+    parts.find(p => p.name === "Y Carriages"),
+    parts.find(p => p.name === "X Rail"),
+    parts.find(p => p.name === "X Beam"),
+    parts.find(p => p.name === "XY Belts"),
+    parts.find(p => p.name === "XY Motors"),
+    parts.find(p => p.name === "XY Idlers"),
+    parts.find(p => p.name === "Nozzle"),
+    parts.find(p => p.name === "Heater Block"),
+    parts.find(p => p.name === "Heatbreak"),
+    parts.find(p => p.name === "Heatsink"),
+    parts.find(p => p.name === "Extruder Carriage"),
+    parts.find(p => p.name === "Part Fan"),
+    parts.find(p => p.name === "Extruder Motor"),
+  ]},
+  { name: "Spool + Filament", group: [
+    parts.find(p => p.name === "Spool Rod"),
+    parts.find(p => p.name === "Spool Shell"),
+    parts.find(p => p.name === "Filament Roll"),
+    parts.find(p => p.name === "Spool Hub"),
+    parts.find(p => p.name === "Filament Guide Tube"),
+  ]},
+  parts.find(p => p.name === "Build Volume"),
+];

package/examples/5-figen-robot-hand.forge.js

@@ -0,0 +1,283 @@
+// Robot Hand — functional, buildable concept
+// Z-up, Y depth (front = -Y)
+
+const scale = param("Scale", 1.0, { min: 0.7, max: 1.3, step: 0.05 });
+const curl = param("Finger Curl", 40, { min: 0, max: 70, unit: "°" });
+const thumbCurl = param("Thumb Curl", 35, { min: 0, max: 70, unit: "°" });
+const spread = param("Finger Spread", 8, { min: 0, max: 20, unit: "°" });
+
+// --- Dimensions ---
+const palmW = 90 * scale;
+const palmD = 70 * scale;
+const palmH = 18 * scale;
+const fingerT = 12 * scale;
+const gap = 2 * scale;
+
+const baseY = -palmD / 2 - gap;
+const baseZ = palmH / 2 + fingerT / 2 + 2 * scale;
+
+// --- Colors ---
+const colors = {
+    palm: '#d8cbb2',
+    palmPad: '#2a2a2a',
+    knuckle: '#aaaaaa',
+    wrist: '#666666',
+    motor: '#444444',
+    spool: '#cc9933',
+    segment: '#e6e6e6',
+    pad: '#222222',
+    pin: '#9aa1a8',
+    tendon: '#c9a227',
+    cable: '#999999',
+};
+
+// --- Helper functions ---
+function rotX(p, pivot, deg) {
+    const rad = deg * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const x = p[0] - pivot[0];
+    const y = p[1] - pivot[1];
+    const z = p[2] - pivot[2];
+    const y2 = y * cos - z * sin;
+    const z2 = y * sin + z * cos;
+    return [pivot[0] + x, pivot[1] + y2, pivot[2] + z2];
+}
+
+function centerOf(shape) {
+    const bb = shape.boundingBox();
+    return [
+        (bb.min[0] + bb.max[0]) / 2,
+        (bb.min[1] + bb.max[1]) / 2,
+        (bb.min[2] + bb.max[2]) / 2,
+    ];
+}
+
+// --- Finger builder ---
+function makeFinger(opts) {
+    const {
+        name,
+        base,
+        lengths,
+        widths,
+        thickness,
+        angles,
+        yaw = 0,
+        colors,
+    } = opts;
+
+    const [L1, L2, L3] = lengths;
+    const [W1, W2, W3] = widths;
+    const t = thickness;
+    const [a1, a2, a3] = angles;
+
+    const basePivot = base;
+    const midPivot0 = [basePivot[0], basePivot[1] - L1, basePivot[2]];
+    const tipPivot0 = [basePivot[0], basePivot[1] - L1 - L2, basePivot[2]];
+
+    // Straight segments in world space
+    let s1 = box(W1, L1, t, true)
+        .translate(basePivot[0], basePivot[1] - L1 / 2, basePivot[2])
+        .color(colors.segment);
+    let s2 = box(W2, L2, t, true)
+        .translate(basePivot[0], basePivot[1] - L1 - L2 / 2, basePivot[2])
+        .color(colors.segment);
+    let s3 = box(W3, L3, t, true)
+        .translate(basePivot[0], basePivot[1] - L1 - L2 - L3 / 2, basePivot[2])
+        .color(colors.segment);
+
+    // Pads (rubber contact)
+    const padT = t * 0.18;
+    let pad1 = box(W1 * 0.7, L1 * 0.45, padT, true)
+        .color(colors.pad)
+        .onFace(s1, 'bottom', { v: -L1 * 0.15, protrude: padT / 2 });
+    let pad2 = box(W2 * 0.65, L2 * 0.45, padT, true)
+        .color(colors.pad)
+        .onFace(s2, 'bottom', { v: -L2 * 0.15, protrude: padT / 2 });
+    let pad3 = box(W3 * 0.8, L3 * 0.6, padT, true)
+        .color(colors.pad)
+        .onFace(s3, 'bottom', { v: -L3 * 0.1, protrude: padT / 2 });
+
+    // Tendon guides (raised top rails)
+    const rodT = t * 0.12;
+    let rod1 = box(W1 * 0.2, L1 * 0.9, rodT, true)
+        .color(colors.tendon)
+        .onFace(s1, 'top', { v: -L1 * 0.05, protrude: rodT / 2 });
+    let rod2 = box(W2 * 0.2, L2 * 0.9, rodT, true)
+        .color(colors.tendon)
+        .onFace(s2, 'top', { v: -L2 * 0.05, protrude: rodT / 2 });
+    let rod3 = box(W3 * 0.2, L3 * 0.85, rodT, true)
+        .color(colors.tendon)
+        .onFace(s3, 'top', { v: -L3 * 0.05, protrude: rodT / 2 });
+
+    // Pivots after rotation
+    const midPivot1 = rotX(midPivot0, basePivot, a1);
+    const tipPivot1 = rotX(tipPivot0, basePivot, a1);
+    const tipPivot2 = rotX(tipPivot1, midPivot1, a2);
+
+    const seg1 = (shape) => shape.rotateAround([1, 0, 0], a1, basePivot);
+    const seg2 = (shape) => shape
+        .rotateAround([1, 0, 0], a1, basePivot)
+        .rotateAround([1, 0, 0], a2, midPivot1);
+    const seg3 = (shape) => shape
+        .rotateAround([1, 0, 0], a1, basePivot)
+        .rotateAround([1, 0, 0], a2, midPivot1)
+        .rotateAround([1, 0, 0], a3, tipPivot2);
+
+    s1 = seg1(s1); s2 = seg2(s2); s3 = seg3(s3);
+    pad1 = seg1(pad1); pad2 = seg2(pad2); pad3 = seg3(pad3);
+    rod1 = seg1(rod1); rod2 = seg2(rod2); rod3 = seg3(rod3);
+
+    // Joint pins
+    const pinLen = Math.max(W1, W2, W3) + 8 * scale;
+    const pinR = t * 0.15;
+    const pinBase = cylinder(pinLen, pinR).pointAlong([1, 0, 0]).color(colors.pin);
+    let pin1 = pinBase.translate(basePivot[0] - pinLen / 2, basePivot[1], basePivot[2]);
+    let pin2 = pinBase.translate(midPivot1[0] - pinLen / 2, midPivot1[1], midPivot1[2]);
+    let pin3 = pinBase.translate(tipPivot2[0] - pinLen / 2, tipPivot2[1], tipPivot2[2]);
+
+    // Yoke block at base
+    let yoke = box(W1 * 1.1, 6 * scale, t * 0.8, true)
+        .translate(basePivot[0], basePivot[1] + 3 * scale, basePivot[2])
+        .color(colors.knuckle);
+    yoke = seg1(yoke);
+
+    // Apply yaw (splay)
+    if (yaw !== 0) {
+        const yawRot = (shape) => shape.rotateAround([0, 0, 1], yaw, basePivot);
+        s1 = yawRot(s1); s2 = yawRot(s2); s3 = yawRot(s3);
+        pad1 = yawRot(pad1); pad2 = yawRot(pad2); pad3 = yawRot(pad3);
+        rod1 = yawRot(rod1); rod2 = yawRot(rod2); rod3 = yawRot(rod3);
+        pin1 = yawRot(pin1); pin2 = yawRot(pin2); pin3 = yawRot(pin3);
+        yoke = yawRot(yoke);
+    }
+
+    return {
+        name,
+        group: [
+            { name: `${name} Prox`, shape: s1 },
+            { name: `${name} Mid`, shape: s2 },
+            { name: `${name} Tip`, shape: s3 },
+            { name: `${name} Pad 1`, shape: pad1 },
+            { name: `${name} Pad 2`, shape: pad2 },
+            { name: `${name} Pad 3`, shape: pad3 },
+            { name: `${name} Tendon 1`, shape: rod1 },
+            { name: `${name} Tendon 2`, shape: rod2 },
+            { name: `${name} Tendon 3`, shape: rod3 },
+            { name: `${name} Pin Base`, shape: pin1 },
+            { name: `${name} Pin Mid`, shape: pin2 },
+            { name: `${name} Pin Tip`, shape: pin3 },
+            { name: `${name} Yoke`, shape: yoke },
+        ],
+    };
+}
+
+// --- Palm assembly ---
+const palm = box(palmW, palmD, palmH, true).color(colors.palm);
+const palmPad = box(palmW * 0.6, 3 * scale, palmH * 0.5, true)
+    .color(colors.palmPad)
+    .onFace(palm, 'front', { v: -palmH * 0.05, protrude: 1 * scale });
+
+const knuckleBar = box(palmW * 0.9, 10 * scale, 6 * scale, true)
+    .color(colors.knuckle)
+    .onFace(palm, 'top', { v: -palmD / 2 + 8 * scale, protrude: 3 * scale });
+
+const wristLen = 60 * scale;
+const wristR = 14 * scale;
+const wrist = cylinder(wristLen, wristR)
+    .pointAlong([0, 1, 0])
+    .color(colors.wrist)
+    .attachTo(palm, 'back', 'front', [0, 0, -palmH * 0.2]);
+
+const motorW = 40 * scale;
+const motorD = 28 * scale;
+const motorH = 20 * scale;
+const motor = box(motorW, motorD, motorH, true)
+    .color(colors.motor)
+    .attachTo(palm, 'bottom', 'top', [0, palmD / 2 - motorD / 2 - 4 * scale, -2 * scale]);
+
+const spoolLen = palmW * 0.7;
+const spoolR = 6 * scale;
+const spool = cylinder(spoolLen, spoolR)
+    .pointAlong([1, 0, 0])
+    .color(colors.spool)
+    .attachTo(motor, 'top', 'bottom', [0, -motorD * 0.25, spoolR * 0.2]);
+
+// --- Fingers ---
+const fingerDefs = [
+    { name: 'Index', x: -palmW * 0.28, lengths: [32, 24, 18], widths: [16, 14, 13], yaw: -spread * 0.4 },
+    { name: 'Middle', x: -palmW * 0.08, lengths: [35, 26, 20], widths: [17, 15, 14], yaw: -spread * 0.15 },
+    { name: 'Ring', x: palmW * 0.12, lengths: [33, 24, 19], widths: [16, 14, 13], yaw: spread * 0.2 },
+    { name: 'Pinky', x: palmW * 0.30, lengths: [28, 20, 16], widths: [14, 12, 11], yaw: spread * 0.45 },
+];
+
+const fingerGroups = fingerDefs.map(def => makeFinger({
+    name: def.name,
+    base: [def.x, baseY, baseZ],
+    lengths: def.lengths.map(v => v * scale),
+    widths: def.widths.map(v => v * scale),
+    thickness: fingerT,
+    angles: [curl * 0.6, curl * 0.9, curl * 1.1],
+    yaw: def.yaw,
+    colors,
+}));
+
+// Thumb (angled, shorter)
+const thumb = makeFinger({
+    name: 'Thumb',
+    base: [-palmW * 0.45, -palmD * 0.1, baseZ - fingerT * 0.2],
+    lengths: [26, 18, 14].map(v => v * scale),
+    widths: [18, 16, 14].map(v => v * scale),
+    thickness: fingerT * 0.9,
+    angles: [thumbCurl * 0.6, thumbCurl * 0.8, thumbCurl * 0.9],
+    yaw: -50,
+    colors,
+});
+
+// --- Tendon cables from spool to finger bases ---
+const spoolCenter = centerOf(spool);
+const spoolBB = spool.boundingBox();
+const cableR = 1.2 * scale;
+const cableTopZ = palmH / 2 + fingerT + 20 * scale;
+
+const fingerBases = [
+    ...fingerDefs.map(def => [def.x, baseY, baseZ]),
+    [-palmW * 0.45, -palmD * 0.1, baseZ - fingerT * 0.2],
+];
+
+const cableCount = fingerBases.length;
+const cables = fingerBases.map((end, i) => {
+    const t = (i + 1) / (cableCount + 1);
+    const startX = spoolBB.min[0] + t * (spoolBB.max[0] - spoolBB.min[0]);
+    const start = [startX, spoolCenter[1], spoolCenter[2] + spoolR * 0.8];
+    const midBack = [startX, palmD / 2 + 6 * scale, cableTopZ];
+    const midPalm = [end[0], 0, cableTopZ];
+    const endPt = [end[0], end[1] + 6 * scale, end[2] + fingerT * 0.6];
+
+    return lib.pipeRoute([start, midBack, midPalm, endPt], cableR, { bendRadius: 10 * scale })
+        .color(colors.cable);
+});
+
+// --- Grasp target object ---
+const graspObject = hull3d(
+    sphere(18 * scale).translate(0, baseY - 45 * scale, baseZ + 6 * scale),
+    box(32 * scale, 20 * scale, 26 * scale, true).translate(12 * scale, baseY - 65 * scale, baseZ + 2 * scale)
+).color('#88ccee');
+
+// --- Return scene ---
+return [
+    {
+        name: 'Palm Assembly', group: [
+            { name: 'Palm', shape: palm },
+            { name: 'Palm Grip', shape: palmPad },
+            { name: 'Knuckle Bar', shape: knuckleBar },
+            { name: 'Wrist', shape: wrist },
+            { name: 'Motor', shape: motor },
+            { name: 'Spool', shape: spool },
+            ...cables.map((c, i) => ({ name: `Cable ${i + 1}`, shape: c })),
+        ]
+    },
+    ...fingerGroups,
+    thumb,
+    //   { name: 'Grasp Object', shape: graspObject },
+];