forgecad 0.1.0

package/examples/shelf/shelf-unit.forge.js

@@ -0,0 +1,62 @@
+// Tool Shelf — multi-shelf unit with identical containers
+// Demonstrates importPart() for reusing the same container across shelves
+
+const shelfW = param("Shelf Width", 800, { min: 400, max: 1200, unit: "mm" });
+const shelfD = param("Shelf Depth", 200, { min: 150, max: 350, unit: "mm" });
+const totalH = param("Total Height", 1200, { min: 600, max: 1800, unit: "mm" });
+const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+const rows = param("Shelf Rows", 4, { min: 2, max: 6, integer: true });
+const cols = param("Containers/Row", 3, { min: 1, max: 6, integer: true });
+
+// Container dimensions (must match container.forge.js defaults or be close)
+const containerW = 120;
+const containerD = 180;
+const containerH = 100;
+const lipH = 5;
+
+// Derived
+const innerW = shelfW - 2 * boardT;
+const rowH = (totalH - boardT) / rows; // spacing between shelves
+
+// --- Side panels ---
+const leftPanel = box(boardT, shelfD, totalH);
+const rightPanel = box(boardT, shelfD, totalH).translate(shelfW - boardT, 0, 0);
+
+// --- Shelf boards (horizontal) ---
+const shelfBoards = [];
+for (let i = 0; i <= rows; i++) {
+  shelfBoards.push(
+    box(innerW, shelfD, boardT).translate(boardT, 0, i * rowH)
+  );
+}
+
+// --- Back panel (thin, full height) ---
+const backPanel = box(innerW, boardT / 2, totalH)
+  .translate(boardT, shelfD - boardT / 2, 0);
+
+const frame = union(leftPanel, rightPanel, backPanel, ...shelfBoards);
+
+// --- Import and place containers ---
+const container = importPart("shelf/container.forge.js");
+
+const containers = [];
+const gapX = (innerW - cols * (containerW + lipH * 2)) / (cols + 1);
+const gapY = 5; // small gap from front edge
+
+for (let row = 0; row < rows; row++) {
+  const shelfZ = row * rowH + boardT; // top of shelf board
+  for (let col = 0; col < cols; col++) {
+    const cx = boardT + gapX * (col + 1) + col * (containerW + lipH * 2) + lipH;
+    const cy = gapY;
+    containers.push(
+      container.translate(cx, cy, shelfZ)
+    );
+  }
+}
+
+const allContainers = union(...containers);
+
+return [
+  { name: "Frame", shape: frame, color: "#b08050" },
+  { name: "Containers", shape: allContainers, color: "#4477aa" },
+];

package/examples/shoe-rack-doors.forge.js

@@ -0,0 +1,107 @@
+// Shoe Rack with Doors — 2-level shelves, sitting area, openable cabinet doors
+//
+// 4 doors (2 per shelf level), hinged at the outer edges.
+// Each pair shares one angle slider for synchronized open/close.
+
+const width = param("Width", 800, { min: 500, max: 1200, unit: "mm" });
+const depth = param("Depth", 350, { min: 250, max: 500, unit: "mm" });
+const totalH = param("Total Height", 500, { min: 350, max: 650, unit: "mm" });
+
+const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+
+const seatPad = param("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
+const seatOverhang = param("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
+
+const doorT = param("Door Thickness", 8, { min: 4, max: 15, unit: "mm" });
+const doorGap = param("Door Gap", 2, { min: 1, max: 5, unit: "mm" });
+
+// Derived
+const innerW = width - 2 * boardT;
+const shelfCount = 2;
+const shelfSpacing = (totalH - boardT) / (shelfCount + 1);
+const halfInnerW = innerW / 2;
+
+// ── Frame (same as shoe-rack.forge.js + center divider always on) ──
+const leftPanel = box(boardT, depth, totalH);
+const rightPanel = box(boardT, depth, totalH).translate(width - boardT, 0, 0);
+const bottom = box(innerW, depth, boardT).translate(boardT, 0, 0);
+const topBoard = box(width, depth, boardT).translate(0, 0, totalH - boardT);
+const backPanel = box(innerW, boardT / 2, totalH - boardT)
+  .translate(boardT, depth - boardT / 2, 0);
+const divider = box(boardT, depth, totalH - boardT)
+  .translate(width / 2 - boardT / 2, 0, 0);
+
+const shelves = [];
+for (let i = 1; i <= shelfCount; i++) {
+  shelves.push(
+    box(innerW, depth, boardT).translate(boardT, 0, i * shelfSpacing)
+  );
+}
+
+const frame = union(
+  leftPanel, rightPanel, bottom, topBoard, backPanel, divider, ...shelves
+);
+
+// ── Cushion ──
+const cushionW = width + 2 * seatOverhang;
+const cushionD = depth + seatOverhang;
+const cushion = box(cushionW, cushionD, seatPad)
+  .translate(-seatOverhang, 0, totalH);
+
+// ── Doors ──
+// Each compartment gets one door. Door width = half inner width minus gaps.
+const doorW = halfInnerW - boardT / 2 - doorGap;
+
+// Door positions: [pivotX, hingeSign, shelfIndex]
+// hingeSign: -1 = hinged on left edge (opens left), +1 = hinged on right edge (opens right)
+const doorDefs = [
+  // Bottom-left: hinged at left panel, opens outward (negative Z rotation)
+  { pivotX: boardT, sign: -1, level: 0 },
+  // Bottom-right: hinged at right panel, opens outward (positive Z rotation)
+  { pivotX: width - boardT, sign: 1, level: 0 },
+  // Top-left
+  { pivotX: boardT, sign: -1, level: 1 },
+  // Top-right
+  { pivotX: width - boardT, sign: 1, level: 1 },
+];
+
+const doorParts = [];
+
+for (const d of doorDefs) {
+  const z = d.level * shelfSpacing + boardT + doorGap;
+  const doorH = shelfSpacing - boardT - 2 * doorGap;
+
+  // Left-hinged: door extends to the right of pivot
+  // Right-hinged: door extends to the left of pivot
+  const doorX = d.sign === -1
+    ? d.pivotX                    // left hinge: door starts at pivot, goes right
+    : d.pivotX - doorW;           // right hinge: door ends at pivot, starts left
+
+  const panel = box(doorW, doorT, doorH)
+    .translate(doorX, -doorT, z);
+
+  const label = d.level === 0 ? "Bottom" : "Top";
+  const side = d.sign === -1 ? "Left" : "Right";
+
+  // Left doors: rotate negative (outward = clockwise from top = negative Z)
+  // Right doors: rotate positive (outward = counter-clockwise from top)
+  const minA = d.sign === -1 ? -120 : 0;
+  const maxA = d.sign === -1 ? 0 : 120;
+  const defA = 0;
+
+  const opened = joint(`${label} ${side} Door`, panel, [d.pivotX, 0, 0], {
+    axis: [0, 0, 1],
+    min: minA,
+    max: maxA,
+    default: defA,
+    reverse: d.sign === -1,
+  });
+
+  doorParts.push({ name: `${label} ${side} Door`, shape: opened, color: "#a07850" });
+}
+
+return [
+  { name: "Frame", shape: frame, color: "#c4956a" },
+  { name: "Cushion", shape: cushion, color: "#5a4a3a" },
+  ...doorParts,
+];

package/examples/shoe-rack.forge.js

@@ -0,0 +1,65 @@
+// Shoe Rack with Sitting Area — 2-level shelves + padded seat on top
+//
+// Structure: two side panels, bottom board, 2 shelves, top board,
+// back panel for rigidity, and a cushion on top for sitting.
+
+const width = param("Width", 800, { min: 500, max: 1200, unit: "mm" });
+const depth = param("Depth", 350, { min: 250, max: 500, unit: "mm" });
+const totalH = param("Total Height", 500, { min: 350, max: 650, unit: "mm" });
+
+const boardT = param("Board Thickness", 18, { min: 12, max: 25, unit: "mm" });
+
+const seatPad = param("Seat Padding", 30, { min: 15, max: 60, unit: "mm" });
+const seatOverhang = param("Seat Overhang", 10, { min: 0, max: 30, unit: "mm" });
+
+const divider = param("Center Divider", 1, { min: 0, max: 1, step: 1 });
+
+// Derived
+const innerW = width - 2 * boardT;
+const shelfCount = 2;
+const shelfSpacing = (totalH - boardT) / (shelfCount + 1);
+
+// --- Side panels ---
+const leftPanel = box(boardT, depth, totalH);
+const rightPanel = box(boardT, depth, totalH).translate(width - boardT, 0, 0);
+
+// --- Bottom board ---
+const bottom = box(innerW, depth, boardT).translate(boardT, 0, 0);
+
+// --- Shelves ---
+const shelves = [];
+for (let i = 1; i <= shelfCount; i++) {
+  shelves.push(
+    box(innerW, depth, boardT).translate(boardT, 0, i * shelfSpacing)
+  );
+}
+
+// --- Top board (seat base) ---
+const topBoard = box(width, depth, boardT).translate(0, 0, totalH - boardT);
+
+// --- Back panel (thin, full height, for rigidity) ---
+const backPanel = box(innerW, boardT / 2, totalH - boardT)
+  .translate(boardT, depth - boardT / 2, 0);
+
+// --- Optional center divider ---
+const parts = [leftPanel, rightPanel, bottom, topBoard, backPanel, ...shelves];
+
+if (divider >= 1) {
+  const divH = totalH - boardT; // from bottom to underside of top board
+  parts.push(
+    box(boardT, depth, divH).translate(width / 2 - boardT / 2, 0, 0)
+  );
+}
+
+// --- Seat cushion (overhangs front and sides) ---
+const cushionW = width + 2 * seatOverhang;
+const cushionD = depth + seatOverhang;
+const cushion = box(cushionW, cushionD, seatPad)
+  .translate(-seatOverhang, 0, totalH);
+
+const frame = union(...parts);
+
+return [
+  { name: "Frame", shape: frame, color: "#c4956a" },
+  { name: "Cushion", shape: cushion, color: "#5a4a3a" },
+];

package/examples/spiderman-cake.forge.js

@@ -0,0 +1,92 @@
+// Spider-Man Birthday Cake
+// A multi-tiered cake with Spider-Man colors and decorations.
+
+const tierHeight = param("Tier Height", 30, { min: 20, max: 50, unit: "mm" });
+const baseRadius = param("Base Radius", 60, { min: 40, max: 100, unit: "mm" });
+
+// Colors
+const spideyRed = '#e60000';
+const spideyBlue = '#0055aa';
+const spideyBlack = '#111111';
+const spideyWhite = '#ffffff';
+const candleYellow = '#ffff44';
+const flameOrange = '#ff8800';
+
+const cake = [];
+
+// --- Bottom Tier (Blue) ---
+const bottomTier = cylinder(tierHeight, baseRadius).color(spideyBlue);
+cake.push({ name: "Bottom Tier", shape: bottomTier });
+
+// --- Middle Tier (Red with Webbing) ---
+const midRadius = baseRadius * 0.75;
+const midTier = cylinder(tierHeight, midRadius).color(spideyRed)
+  .attachTo(bottomTier, 'top', 'bottom');
+
+// Vertical webbing lines for middle tier
+const webLine = cylinder(tierHeight, 0.6).color(spideyBlack);
+const midWebs = circularPattern(webLine.translate(midRadius - 0.2, 0, 0), 12)
+  .attachTo(bottomTier, 'top', 'bottom');
+
+cake.push({ name: "Middle Tier", shape: midTier });
+cake.push({ name: "Middle Webbing", shape: midWebs });
+
+// --- Top Tier (Red with Eyes) ---
+const topRadius = midRadius * 0.7;
+const topTier = cylinder(tierHeight, topRadius).color(spideyRed)
+  .attachTo(midTier, 'top', 'bottom');
+
+// Vertical webbing lines for top tier
+const topWebs = circularPattern(webLine.translate(topRadius - 0.2, 0, 0), 12)
+  .attachTo(midTier, 'top', 'bottom');
+
+// Spider-Man Eyes (simplified as angled boxes on the front)
+const eyeW = topRadius * 0.4;
+const eyeH = tierHeight * 0.6;
+const eyeT = 2;
+
+const leftEye = box(eyeW, eyeT, eyeH, true).color(spideyWhite)
+  .rotate(0, 0, 20)
+  .onFace(topTier, 'front', { u: -topRadius * 0.35, v: 0, protrude: 1 });
+
+const rightEye = box(eyeW, eyeT, eyeH, true).color(spideyWhite)
+  .rotate(0, 0, -20)
+  .onFace(topTier, 'front', { u: topRadius * 0.35, v: 0, protrude: 1 });
+
+cake.push({ name: "Top Tier", shape: topTier });
+cake.push({ name: "Top Webbing", shape: topWebs });
+cake.push({ name: "Left Eye", shape: leftEye });
+cake.push({ name: "Right Eye", shape: rightEye });
+
+// --- Candles on Top ---
+const candleR = 2;
+const candleH = 15;
+const candleCount = 6;
+
+for (let i = 0; i < candleCount; i++) {
+  const angle = (i / candleCount) * 360;
+  const rad = topRadius * 0.6;
+  const x = rad * Math.cos(angle * Math.PI / 180);
+  const y = rad * Math.sin(angle * Math.PI / 180);
+
+  const candleBody = cylinder(candleH, candleR).color(candleYellow)
+    .attachTo(topTier, 'top', 'bottom', [x, y, 0]);
+
+  const flame = sphere(2.5).color(flameOrange)
+    .attachTo(candleBody, 'top', 'bottom', [0, 0, 1]);
+
+  cake.push({
+    name: `Candle ${i + 1}`,
+    group: [
+      { name: "Body", shape: candleBody },
+      { name: "Flame", shape: flame }
+    ]
+  });
+}
+
+// --- Cake Board ---
+const board = cylinder(3, baseRadius + 10).color('#eeeeee')
+  .attachTo(bottomTier, 'bottom', 'top');
+cake.push({ name: "Cake Board", shape: board });
+
+return cake;

package/examples/table-lamp.forge.js

@@ -0,0 +1,33 @@
+// Table Lamp — base + stem + shade (multi-file: imports shade profile)
+
+const baseR = param("Base Radius", 25, { min: 15, max: 40, unit: "mm" });
+const baseH = param("Base Height", 6, { min: 3, max: 12, unit: "mm" });
+const stemR = param("Stem Radius", 4, { min: 2, max: 8, unit: "mm" });
+const stemH = param("Stem Height", 60, { min: 30, max: 100, unit: "mm" });
+const shadeTopR = param("Shade Top Radius", 15, { min: 8, max: 30, unit: "mm" });
+const shadeBottomR = param("Shade Bottom Radius", 30, { min: 15, max: 50, unit: "mm" });
+const shadeH = param("Shade Height", 35, { min: 20, max: 60, unit: "mm" });
+const shadeWall = param("Shade Wall", 1.5, { min: 0.5, max: 4, unit: "mm" });
+
+// --- Base: flat cylinder ---
+const base = cylinder(baseH, baseR);
+
+// --- Stem: thin cylinder rising from base center ---
+const stem = cylinder(stemH, stemR).translate(0, 0, baseH);
+
+// --- Shade: revolve the imported profile ---
+const shadeProfile = importSketch("lamp-shade.sketch.js", {
+  "Top Radius": shadeTopR,
+  "Bottom Radius": shadeBottomR,
+  "Shade Height": shadeH,
+  "Wall Thickness": shadeWall,
+});
+const shade = shadeProfile.revolve();
+const shadeZ = baseH + stemH;
+const shadePlaced = shade.translate(0, 0, shadeZ);
+
+return [
+  { name: "Base", shape: base, color: "#2a2a2a" },
+  { name: "Stem", shape: stem, color: "#888888" },
+  { name: "Shade", shape: shadePlaced, color: "#f5e6c8" },
+];

package/examples/table.forge.js

@@ -0,0 +1,44 @@
+// Four-Legged Table — parametric dining/work table
+
+const topW = param("Top Width", 120, { min: 60, max: 200, unit: "mm" });
+const topD = param("Top Depth", 80, { min: 40, max: 150, unit: "mm" });
+const topH = param("Top Thickness", 4, { min: 2, max: 10, unit: "mm" });
+const tableH = param("Table Height", 75, { min: 50, max: 110, unit: "mm" });
+const legSide = param("Leg Width", 5, { min: 3, max: 12, unit: "mm" });
+const inset = param("Leg Inset", 5, { min: 0, max: 20, unit: "mm" });
+const stretcher = param("Stretcher", 1, { min: 0, max: 1, step: 1 });
+const stretcherH = param("Stretcher Height", 15, { min: 5, max: 40, unit: "mm" });
+const stretcherW = param("Stretcher Width", 3, { min: 1, max: 6, unit: "mm" });
+
+const legH = tableH - topH;
+
+// Tabletop
+const top = box(topW, topD, topH).translate(0, 0, legH);
+
+// Leg positions: inset from each corner
+const legPositions = [
+  [inset, inset],
+  [topW - inset - legSide, inset],
+  [inset, topD - inset - legSide],
+  [topW - inset - legSide, topD - inset - legSide],
+];
+
+const legs = union(
+  ...legPositions.map(([x, y]) =>
+    box(legSide, legSide, legH).translate(x, y, 0)
+  )
+);
+
+// Optional stretchers between legs (long sides)
+const parts = [top, legs];
+
+if (stretcher >= 1) {
+  const strLen = topD - 2 * inset - 2 * legSide + stretcherW;
+  const leftStr = box(stretcherW, strLen, stretcherW)
+    .translate(inset + legSide / 2 - stretcherW / 2, inset + legSide, stretcherH);
+  const rightStr = box(stretcherW, strLen, stretcherW)
+    .translate(topW - inset - legSide / 2 - stretcherW / 2, inset + legSide, stretcherH);
+  parts.push(leftStr, rightStr);
+}
+
+return union(...parts);

package/examples/test-colors.forge.js

@@ -0,0 +1,19 @@
+// Test color support
+
+const redBox = box(20, 20, 20).color("#ff0000").translate(-25, 0, 0);
+const blueSphere = sphere(12).color("#0000ff").translate(25, 0, 0);
+
+// Union should preserve first operand color (red)
+const combined = redBox.add(blueSphere).translate(0, 30, 0);
+
+// Sketch colors
+const greenRect = rect(30, 10).color("#00ff00").translate(0, -30);
+const yellowCircle = circle2d(10).color("#ffff00").translate(0, -30);
+
+return [
+    { name: "Red Box", shape: redBox },
+    { name: "Blue Sphere", shape: blueSphere },
+    { name: "Combined (Red)", shape: combined },
+    { name: "Green Rect", sketch: greenRect },
+    { name: "Yellow Circle", sketch: yellowCircle }
+];

package/examples/tv-stand.forge.js

@@ -0,0 +1,21 @@
+// Flat-Screen TV with Stand — Entity-based API demo
+// Rectangle2D for named geometry, TrackedShape for topology
+
+const tvWidth = param("TV Width", 1200, { min: 800, max: 1600, unit: "mm" });
+const tvHeight = param("TV Height", 700, { min: 500, max: 1000, unit: "mm" });
+const tvThick = param("TV Thickness", 40, { min: 20, max: 80, unit: "mm" });
+
+const standW = param("Stand Width", 400, { min: 200, max: 600, unit: "mm" });
+const standD = param("Stand Depth", 250, { min: 150, max: 400, unit: "mm" });
+const standH = param("Stand Height", 60, { min: 30, max: 120, unit: "mm" });
+
+// TV panel: wide in X, thin in Y, tall in Z
+const panelRect = Rectangle2D.fromCenterAndDimensions(point(0, 0), tvWidth, tvThick);
+const panel = panelRect.extrude(tvHeight).moveBy(0, 0, standH);
+
+// Stand: wider in Y (depth), centered
+const standRect = Rectangle2D.fromCenterAndDimensions(point(0, 0), standW, standD);
+const stand = standRect.extrude(standH);
+
+// union() auto-unwraps TrackedShape
+return union(stand, panel);

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "forgecad",
+  "version": "0.1.0",
+  "description": "Code-first parametric CAD for JavaScript/TypeScript, in the browser and CLI.",
+  "license": "BUSL-1.1",
+  "type": "module",
+  "bin": {
+    "forgecad": "./dist-cli/forgecad.js"
+  },
+  "files": [
+    "dist-cli/forgecad.js",
+    "dist",
+    "dist-skill",
+    "examples",
+    "!examples/todo.md",
+    "!examples/robot_hand_2_api_feedback.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "vite -- ./examples",
+    "dev:blank": "vite",
+    "build": "tsc && vite build && npm run build:cli",
+    "build:cli": "tsup cli/forgecad.ts --format esm --platform node --target node20 --out-dir dist-cli --clean --sourcemap --external typescript",
+    "test": "npm run test:prepare && node dist-cli/forgecad.js check suite",
+    "test:prepare": "tsc --noEmit && npm run build:cli",
+    "test:compiler": "npm run test:prepare && node dist-cli/forgecad.js check compiler",
+    "test:compiler:update": "npm run test:prepare && node dist-cli/forgecad.js check compiler --update",
+    "test:query-propagation": "npm run test:prepare && node dist-cli/forgecad.js check query-propagation",
+    "test:query-propagation:update": "npm run test:prepare && node dist-cli/forgecad.js check query-propagation --update",
+    "test:examples": "npm run test:prepare && node dist-cli/forgecad.js check examples",
+    "test:brep": "npm run test:prepare && node dist-cli/forgecad.js check brep",
+    "test:api": "npm run test:prepare && node dist-cli/forgecad.js check api",
+    "build:skill:forgecad": "node scripts/build-forgecad-skill.mjs",
+    "prepare": "npm run build:cli",
+    "prepublishOnly": "npm run build && npm run build:skill:forgecad",
+    "preview": "vite preview",
+    "prune:branches": "uv run cli/forge-prune-local-branches.py",
+    "meta:init": "bash scripts/local-meta.sh init",
+    "meta:status": "bash scripts/local-meta.sh status",
+    "meta:path": "bash scripts/local-meta.sh path"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.0",
+    "gifenc": "^1.0.3",
+    "manifold-3d": "^3.3.2",
+    "pngjs": "^7.0.0",
+    "puppeteer-core": "^24.37.2",
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "@react-three/drei": "^10.0.6",
+    "@react-three/fiber": "^9.1.2",
+    "@types/react": "^19.1.6",
+    "@types/react-dom": "^19.1.6",
+    "@types/three": "^0.175.0",
+    "@vitejs/plugin-react": "^4.5.2",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "three": "^0.175.0",
+    "tsup": "^8.5.0",
+    "vite": "^6.3.5",
+    "zustand": "^5.0.5"
+  }
+}