forgecad 0.1.0

package/examples/api/notebook-assembly-debug.forge-notebook.json

@@ -0,0 +1,90 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "mechanism-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const upperLen = 90;\n",
+        "const foreLen = 75;\n",
+        "\n",
+        "const mech = assembly(\"Notebook Debug Arm\")\n",
+        "  .addPart(\"Base\", box(44, 44, 18, true).color(\"#6e7f96\"))\n",
+        "  .addPart(\n",
+        "    \"Upper Arm\",\n",
+        "    box(upperLen, 18, 18).translate(0, -9, -9).color(\"#d0a24c\"),\n",
+        "  )\n",
+        "  .addPart(\n",
+        "    \"Forearm\",\n",
+        "    box(foreLen, 14, 14).translate(0, -7, -7).color(\"#b86656\"),\n",
+        "  )\n",
+        "  .addJoint(\"shoulder\", \"revolute\", \"Base\", \"Upper Arm\", {\n",
+        "    axis: [0, 1, 0],\n",
+        "    min: -45,\n",
+        "    max: 110,\n",
+        "    default: 25,\n",
+        "    frame: Transform.identity().translate(0, 0, 18),\n",
+        "  })\n",
+        "  .addJoint(\"elbow\", \"revolute\", \"Upper Arm\", \"Forearm\", {\n",
+        "    axis: [0, -1, 0],\n",
+        "    min: -10,\n",
+        "    max: 135,\n",
+        "    default: 35,\n",
+        "    frame: Transform.identity().translate(upperLen, 0, 0),\n",
+        "  });\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "collision-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const solved = mech.solve({ shoulder: 38, elbow: 72 });\n",
+        "const collisions = solved.collisionReport({\n",
+        "  minOverlapVolume: 0.5,\n",
+        "  ignorePairs: [[\"Upper Arm\", \"Forearm\"]],\n",
+        "});\n",
+        "\n",
+        "console.log(\"Collision report\", collisions);\n",
+        "show(solved.toScene());\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "preview-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const sweepFrames = mech.sweepJoint(\"elbow\", -10, 135, 14, { shoulder: 38 });\n",
+        "const collidingSteps = sweepFrames.filter((step) => step.collisions.length > 0).length;\n",
+        "\n",
+        "console.log(\"Sweep collisions\", collidingSteps, \"of\", sweepFrames.length);\n",
+        "show(mech.solve({ shoulder: 38, elbow: 90 }).toScene());\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "forgecad": {
+      "format": "forgecad-notebook/v1",
+      "previewCellId": "preview-cell",
+      "title": "Notebook Assembly Debug"
+    },
+    "kernelspec": {
+      "display_name": "ForgeCAD",
+      "language": "javascript",
+      "name": "forgecad"
+    },
+    "language_info": {
+      "name": "javascript",
+      "file_extension": ".js",
+      "mimetype": "text/javascript"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

package/examples/api/notebook-iteration.forge-notebook.json

@@ -0,0 +1,75 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "setup-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const width = param(\"Width\", 120, { min: 80, max: 180, unit: \"mm\" });\n",
+        "const depth = param(\"Depth\", 80, { min: 50, max: 140, unit: \"mm\" });\n",
+        "const height = param(\"Height\", 14, { min: 8, max: 30, unit: \"mm\" });\n",
+        "\n",
+        "const base = roundedRect(width, depth, 10)\n",
+        "  .extrude(height)\n",
+        "  .color(\"#5f87c6\");\n",
+        "\n",
+        "show(base);\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "inspect-pocket-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const pocket = roundedRect(width - 24, depth - 24, 8)\n",
+        "  .extrude(height - 3)\n",
+        "  .translate(12, 12, 3)\n",
+        "  .color(\"#d67a61\");\n",
+        "\n",
+        "show([\n",
+        "  { name: \"Base\", shape: base },\n",
+        "  { name: \"Pocket\", shape: pocket },\n",
+        "]);\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "preview-cell",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "const part = base.subtract(pocket);\n",
+        "\n",
+        "dim([0, 0, 0], [width, 0, 0], { label: \"Width\" });\n",
+        "dim([0, 0, 0], [0, depth, 0], { label: \"Depth\", offset: 14 });\n",
+        "cutPlane(\"Center Section\", [1, 0, 0], width / 2);\n",
+        "\n",
+        "return part;\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "forgecad": {
+      "format": "forgecad-notebook/v1",
+      "previewCellId": "preview-cell",
+      "title": "Notebook Iteration"
+    },
+    "kernelspec": {
+      "display_name": "ForgeCAD",
+      "language": "javascript",
+      "name": "forgecad"
+    },
+    "language_info": {
+      "name": "javascript",
+      "file_extension": ".js",
+      "mimetype": "text/javascript"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

package/examples/api/patterns.forge.js

@@ -0,0 +1,32 @@
+// Patterns — linearPattern and circularPattern for repeating shapes.
+
+const count = param("Count", 6, { min: 2, max: 12, integer: true });
+const spacing = param("Spacing", 20, { min: 10, max: 40, unit: "mm" });
+const radius = param("Ring Radius", 40, { min: 20, max: 80, unit: "mm" });
+
+// --- linearPattern: repeat along a direction ---
+const peg = cylinder(15, 4).color('#4488cc');
+const row = linearPattern(peg, count, spacing, 0);
+
+// --- circularPattern: repeat around Z axis ---
+const hole = cylinder(8, 3).translate(radius, 0, 0).color('#cc4444');
+const ring = circularPattern(hole, count);
+
+// --- mirrorCopy: mirror + union with original ---
+const halfBracket = box(40, 10, 20).color('#44cc88');
+const fullBracket = mirrorCopy(halfBracket, [1, 0, 0]).translate(0, 0, 40);
+
+// Show a base plate with the circular holes subtracted
+const plate = cylinder(10, radius + 15).color('#888888').translate(0, 80, 0);
+const holeRing = circularPattern(
+  cylinder(12, 3).translate(radius, 0, -1),
+  count
+).translate(0, 80, 0);
+const drilled = plate.subtract(holeRing);
+
+return [
+  { name: "Linear Pattern", shape: row },
+  { name: "Circular Pattern", shape: ring },
+  { name: "Mirror Copy", shape: fullBracket },
+  { name: "Drilled Plate", shape: drilled },
+];

package/examples/api/pointAlong-orientation.forge.js

@@ -0,0 +1,52 @@
+// pointAlong() — orient a cylinder's axis without thinking about Euler angles.
+//
+// Cylinders default to Z-up. To lay one along X or Y:
+//   ❌ cylinder(80, 5).rotate(90, 0, 0)   — which axis? confusing
+//   ✅ cylinder(80, 5).pointAlong([0, 1, 0]) — "point along Y"
+//
+// After pointAlong, the cylinder starts at origin and extends in that direction.
+// Always call pointAlong BEFORE translate/attachTo.
+
+const len = param("Length", 80, { min: 30, max: 150, unit: "mm" });
+const r = param("Radius", 5, { min: 2, max: 15, unit: "mm" });
+const spacing = 40;
+
+// Default: along +Z (up)
+const zCyl = cylinder(len, r).color('#4444cc')
+  .translate(0, 0, 0);
+const zTip = sphere(r * 1.5).color('#6666ff')
+  .translate(0, 0, len);
+
+// Along +X (right)
+const xCyl = cylinder(len, r).color('#cc4444')
+  .pointAlong([1, 0, 0])
+  .translate(0, spacing, 0);
+const xTip = sphere(r * 1.5).color('#ff6666')
+  .translate(len, spacing, 0);
+
+// Along +Y (forward)
+const yCyl = cylinder(len, r).color('#44cc44')
+  .pointAlong([0, 1, 0])
+  .translate(0, 0, 0)
+  .translate(spacing, 0, 0);
+const yTip = sphere(r * 1.5).color('#66ff66')
+  .translate(spacing, len, 0);
+
+// Along diagonal [1, 1, 1]
+const dCyl = cylinder(len, r).color('#cccc44')
+  .pointAlong([1, 1, 1])
+  .translate(spacing, spacing, 0);
+const dLen = len / Math.sqrt(3); // projected length per axis
+const dTip = sphere(r * 1.5).color('#ffff66')
+  .translate(spacing + dLen, spacing + dLen, dLen);
+
+return [
+  { name: "Z-axis (default)", shape: zCyl },
+  { name: "Z tip", shape: zTip },
+  { name: "X-axis (pointAlong [1,0,0])", shape: xCyl },
+  { name: "X tip", shape: xTip },
+  { name: "Y-axis (pointAlong [0,1,0])", shape: yCyl },
+  { name: "Y tip", shape: yTip },
+  { name: "Diagonal (pointAlong [1,1,1])", shape: dCyl },
+  { name: "Diagonal tip", shape: dTip },
+];

package/examples/api/profile-2020-b-slot6.forge.js

@@ -0,0 +1,36 @@
+// 20x20 B-type slot 6 profile extrusion.
+// Demonstrates:
+// - algorithmic 2D profile generation (`lib.tSlotProfile`)
+// - direct 3D helper (`lib.profile2020BSlot6`)
+// - parameterized technical dimensions
+
+const length = param("Length", 220, { min: 40, max: 800, unit: "mm" });
+const slotDepth = param("Slot Depth", 5.5, { min: 4.6, max: 6.6, step: 0.1, unit: "mm" });
+const slotInner = param("Slot Inner Width", 8.2, { min: 7, max: 10.5, step: 0.1, unit: "mm" });
+const centerBore = param("Center Bore", 5.5, { min: 0, max: 6.5, step: 0.1, unit: "mm" });
+
+const profile2d = lib.profile2020BSlot6Profile({
+  slotInnerWidth: slotInner,
+  slotDepth,
+  centerBoreDia: centerBore,
+});
+
+const extrusion = lib.profile2020BSlot6(length, {
+  center: true,
+  slotDepth,
+  slotInnerWidth: slotInner,
+  centerBoreDia: centerBore,
+}).color('#98a7b8');
+
+// Visual dimensions
+dim([-10, -10, 0], [10, -10, 0], { label: "20 mm", offset: -8, color: "#ffaa44" });
+dim([10, -10, 0], [10, 10, 0], { label: "20 mm", offset: 10, color: "#ffaa44" });
+dim([0, 0, -length / 2], [0, 0, length / 2], { label: "Length", offset: 16, color: "#66ccff" });
+if (centerBore > 0) {
+  dim([-centerBore / 2, 0, 0], [centerBore / 2, 0, 0], { label: "Center bore", offset: -14, color: "#88dd88" });
+}
+
+return [
+  { name: "2D Profile", sketch: profile2d.translate(-34, 0), color: "#f3c98b" },
+  { name: "3D Extrusion", shape: extrusion.translate(36, 0, 0), color: "#98a7b8" },
+];

package/examples/api/rotate-around-to.forge.js

@@ -0,0 +1,31 @@
+// rotateAroundTo() — solve the angle around an axis from geometry instead of manual trig.
+
+function makeArm(color) {
+  return box(80, 8, 8, true)
+    .translate(40, 0, 0)
+    .color(color)
+    .withReferences({
+      points: {
+        tip: [80, 0, 0],
+      },
+    });
+}
+
+function makeScene(offsetX, targetPoint, options, color) {
+  const pivot = [offsetX, 0, 0];
+  const arm = makeArm('#7c8794').translate(offsetX, 0, 0);
+  const solved = arm.rotateAroundTo([0, 0, 1], pivot, 'tip', targetPoint, options).color(color);
+
+  return [
+    { name: `${color} Axis`, shape: cylinder(90, 1.4).translate(offsetX, 0, 45).color('#999999') },
+    { name: `${color} Pivot`, shape: cylinder(6, 8).translate(offsetX, 0, -3).color('#555555') },
+    { name: `${color} Start`, shape: arm.translate(0, 0, -7) },
+    { name: `${color} Solved`, shape: solved.translate(0, 0, 7) },
+    { name: `${color} Target`, shape: sphere(3).translate(targetPoint[0], targetPoint[1], targetPoint[2]).color('#cc4444') },
+  ];
+}
+
+return [
+  ...makeScene(-70, [-38, 32, 24], { mode: 'plane' }, '#4a90e2'),
+  ...makeScene(70, [102, 32, 0], { mode: 'line' }, '#4cc48a'),
+];

package/examples/api/runtime-joints-view.forge.js

@@ -0,0 +1,116 @@
+// Runtime joints demo
+// Move the "Joints" sliders in the View Panel for smooth articulation,
+// or use the Animation controls (play/pause + scrub), all without recompute.
+// Demonstrates linked joints via couplings (Ankle is driven by Hip + Knee).
+
+const body = box(150, 70, 36, true).translate(0, 0, 40).color('#6e7b88');
+
+const upperLen = 84;
+const lowerLen = 86;
+const footLen = 48;
+
+const upper = box(upperLen, 18, 18).translate(0, -9, -9).color('#7da2d6');
+const lower = box(lowerLen, 16, 16).translate(0, -8, -8).color('#8db3e4');
+const foot = box(footLen, 24, 10, true).translate(footLen * 0.5 - 8, 0, -10).color('#9dbfe8');
+
+const leg = assembly('Leg Runtime Demo')
+  .addPart('Body', body)
+  .addPart('Upper Leg', upper)
+  .addPart('Lower Leg', lower)
+  .addPart('Foot', foot)
+  .addRevolute('hip', 'Body', 'Upper Leg', {
+    axis: [0, -1, 0],
+    frame: Transform.identity().translate(34, 24, 40),
+  })
+  .addRevolute('knee', 'Upper Leg', 'Lower Leg', {
+    axis: [0, -1, 0],
+    frame: Transform.identity().translate(upperLen, 0, 0),
+  })
+  .addRevolute('ankle', 'Lower Leg', 'Foot', {
+    axis: [0, -1, 0],
+    frame: Transform.identity().translate(lowerLen, 0, 0),
+  });
+
+const solved = leg.solve({
+  hip: 0,
+  knee: 0,
+  ankle: 0,
+});
+
+viewConfig({
+  jointOverlay: {
+    axisColor: '#13dfff',
+    arcColor: '#ff7a1a',
+    zeroColor: '#ffe26a',
+    axisArrowLengthScale: 0.16,
+    axisArrowRadiusScale: 0.052,
+    arcArrowLengthScale: 0.12,
+    arcArrowRadiusScale: 0.038,
+    arcLineRadiusScale: 0.02,
+  },
+});
+
+jointsView({
+  joints: [
+    {
+      name: 'Hip',
+      child: 'Upper Leg',
+      parent: 'Body',
+      type: 'revolute',
+      axis: [0, -1, 0],
+      pivot: [34, 24, 40],
+      min: -50,
+      max: 80,
+      default: 10,
+    },
+    {
+      name: 'Knee',
+      child: 'Lower Leg',
+      parent: 'Upper Leg',
+      type: 'revolute',
+      axis: [0, -1, 0],
+      pivot: [34 + upperLen, 24, 40],
+      min: -5,
+      max: 125,
+      default: 40,
+    },
+    {
+      name: 'Ankle',
+      child: 'Foot',
+      parent: 'Lower Leg',
+      type: 'revolute',
+      axis: [0, -1, 0],
+      pivot: [34 + upperLen + lowerLen, 24, 40],
+      min: -40,
+      max: 55,
+      default: -10,
+    },
+  ],
+  couplings: [
+    {
+      joint: 'Ankle',
+      terms: [
+        { joint: 'Knee', ratio: -0.35 },
+        { joint: 'Hip', ratio: 0.18 },
+      ],
+      offset: 6,
+    },
+  ],
+  animations: [
+    {
+      name: 'Step',
+      duration: 1.8,
+      loop: true,
+      keyframes: [
+        { at: 0.0, values: { Hip: 18, Knee: 42 } },
+        { at: 0.25, values: { Hip: -20, Knee: 22 } },
+        { at: 0.5, values: { Hip: 8, Knee: 86 } },
+        { at: 0.75, values: { Hip: 24, Knee: 34 } },
+        { at: 1.0, values: { Hip: 18, Knee: 42 } },
+      ],
+    },
+  ],
+  defaultAnimation: 'Step',
+});
+
+return solved.toScene();

package/examples/api/sdf-rover-demo.forge.js

@@ -0,0 +1,159 @@
+// SDF export demo: four-wheel differential-drive rover with a demo world.
+// Run:
+//   forgecad export sdf examples/api/sdf-rover-demo.forge.js
+//
+// Then launch Gazebo against the generated package:
+//   export GZ_SIM_RESOURCE_PATH="examples/api/sdf-rover-demo.forge.sdfpkg/models${GZ_SIM_RESOURCE_PATH:+:$GZ_SIM_RESOURCE_PATH}"
+//   gz sim -s -r examples/api/sdf-rover-demo.forge.sdfpkg/worlds/forge_scout_trial.sdf
+//   gz sim -g examples/api/sdf-rover-demo.forge.sdfpkg/worlds/forge_scout_trial.sdf
+//
+// Click the 3D view and use W/X/A/D or Q/E/Z/C to drive. S or Space stops the rover.
+
+const chassisLength = 430;
+const chassisWidth = 260;
+const chassisHeight = 58;
+const roofLength = 210;
+const roofWidth = 150;
+const roofHeight = 46;
+const bumperLength = 150;
+const bumperWidth = 300;
+const bumperDepth = 24;
+
+const wheelRadius = 72;
+const wheelWidth = 34;
+const wheelTrack = 320;
+const wheelbase = 250;
+const groundClearance = 26;
+const bodyZ = wheelRadius + groundClearance + chassisHeight * 0.5;
+
+const baseDeck = box(chassisLength, chassisWidth, chassisHeight, true)
+  .translate(0, 0, bodyZ);
+
+const roofPod = box(roofLength, roofWidth, roofHeight, true)
+  .translate(20, 0, bodyZ + 40);
+
+const bumper = hull3d(
+  box(54, bumperWidth, bumperDepth, true).translate(chassisLength * 0.5 - 18, 0, wheelRadius + 6),
+  box(bumperLength, bumperWidth - 42, bumperDepth * 0.7, true).translate(chassisLength * 0.5 + 46, 0, wheelRadius - 10),
+).color('#c8742b');
+
+const sensorMast = union(
+  cylinder(92, 10, undefined, 40, true).translate(58, 0, bodyZ + 78),
+  box(78, 34, 26, true).translate(88, 0, bodyZ + 126),
+).color('#d7dee8');
+
+const chassis = union(baseDeck, roofPod)
+  .color('#60707d');
+
+const wheelTire = difference(
+  cylinder(wheelWidth, wheelRadius, undefined, 64, true).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth + 2, wheelRadius * 0.56, undefined, 48, true).pointAlong([0, 1, 0]),
+).color('#1d2329');
+
+const wheelRim = union(
+  cylinder(wheelWidth * 0.86, wheelRadius * 0.52, undefined, 40, true).pointAlong([0, 1, 0]),
+  cylinder(wheelWidth * 1.02, wheelRadius * 0.16, undefined, 28, true).pointAlong([0, 1, 0]),
+).color('#b8c5d3');
+
+const wheel = group(
+  { name: "Tire", shape: wheelTire },
+  { name: "Rim", shape: wheelRim }
+);
+
+const rover = assembly('Forge Scout Rover')
+  .addPart('Chassis', group(
+    { name: "Deck", shape: chassis },
+    { name: "Bumper", shape: bumper },
+    { name: "Sensor Mast", shape: sensorMast }
+  ), {
+    metadata: {
+      material: 'PETG-CF',
+      process: 'FDM',
+      massKg: 13.5,
+      notes: 'Battery bay lives under the roof pod.',
+    },
+  })
+  .addPart('Front Left Wheel', wheel, {
+    metadata: { material: 'TPU + PLA hub', massKg: 0.95 },
+  })
+  .addPart('Front Right Wheel', wheel, {
+    metadata: { material: 'TPU + PLA hub', massKg: 0.95 },
+  })
+  .addPart('Rear Left Wheel', wheel, {
+    metadata: { material: 'TPU + PLA hub', massKg: 0.95 },
+  })
+  .addPart('Rear Right Wheel', wheel, {
+    metadata: { material: 'TPU + PLA hub', massKg: 0.95 },
+  })
+  .addRevolute('frontLeftWheel', 'Chassis', 'Front Left Wheel', {
+    axis: [0, 1, 0],
+    frame: Transform.identity().translate(wheelbase * 0.5, wheelTrack * 0.5, wheelRadius),
+    effort: 22,
+    velocity: 1320,
+    damping: 0.12,
+    friction: 0.03,
+  })
+  .addRevolute('frontRightWheel', 'Chassis', 'Front Right Wheel', {
+    axis: [0, 1, 0],
+    frame: Transform.identity().translate(wheelbase * 0.5, -wheelTrack * 0.5, wheelRadius),
+    effort: 22,
+    velocity: 1320,
+    damping: 0.12,
+    friction: 0.03,
+  })
+  .addRevolute('rearLeftWheel', 'Chassis', 'Rear Left Wheel', {
+    axis: [0, 1, 0],
+    frame: Transform.identity().translate(-wheelbase * 0.5, wheelTrack * 0.5, wheelRadius),
+    effort: 22,
+    velocity: 1320,
+    damping: 0.12,
+    friction: 0.03,
+  })
+  .addRevolute('rearRightWheel', 'Chassis', 'Rear Right Wheel', {
+    axis: [0, 1, 0],
+    frame: Transform.identity().translate(-wheelbase * 0.5, -wheelTrack * 0.5, wheelRadius),
+    effort: 22,
+    velocity: 1320,
+    damping: 0.12,
+    friction: 0.03,
+  });
+
+robotExport({
+  assembly: rover,
+  modelName: 'Forge Scout Rover',
+  links: {
+    Chassis: { massKg: 13.5 },
+    'Front Left Wheel': { massKg: 0.95 },
+    'Front Right Wheel': { massKg: 0.95 },
+    'Rear Left Wheel': { massKg: 0.95 },
+    'Rear Right Wheel': { massKg: 0.95 },
+  },
+  plugins: {
+    diffDrive: {
+      leftJoints: ['frontLeftWheel', 'rearLeftWheel'],
+      rightJoints: ['frontRightWheel', 'rearRightWheel'],
+      wheelSeparationMm: wheelTrack,
+      wheelRadiusMm: wheelRadius,
+      maxLinearVelocity: 1.8,
+      maxAngularVelocity: 2.8,
+      linearAcceleration: 1.6,
+      angularAcceleration: 3.2,
+    },
+    jointStatePublisher: {
+      enabled: true,
+      updateRate: 30,
+    },
+  },
+  world: {
+    generateDemoWorld: true,
+    name: 'Forge Scout Trial',
+    spawnPose: [-1800, 0, 120, 0, 0, 0],
+    keyboardTeleop: {
+      enabled: true,
+      linearStep: 0.9,
+      angularStep: 1.35,
+    },
+  },
+});
+
+return rover.solve().toScene();

package/examples/api/section-plane-visualization.forge.js

@@ -0,0 +1,38 @@
+// Section Plane Visualization — renderer-side guides for active cut planes.
+//
+// How to use:
+// 1) Toggle planes in View Panel -> Cut Planes
+// 2) Adjust View Panel -> Section Visuals (fill, border, normal axis)
+// 3) "Probe" is excluded from both cuts, so it stays intact for alignment checks.
+//
+// No helper solids are needed in your model. Guides are viewport-only overlays.
+
+const width = param("Width", 120, { min: 80, max: 180, unit: "mm" });
+const depth = param("Depth", 80, { min: 50, max: 140, unit: "mm" });
+const height = param("Height", 70, { min: 40, max: 120, unit: "mm" });
+const wall = param("Wall", 8, { min: 3, max: 16, unit: "mm" });
+
+const cutX = param("Cut X", 0, { min: -80, max: 80, unit: "mm" });
+const cutZ = param("Cut Z", 10, { min: -30, max: 80, unit: "mm" });
+
+cutPlane("Internal X", [1, 0, 0], cutX, { exclude: "Probe" });
+cutPlane("Internal Z", [0, 0, 1], cutZ, { exclude: "Probe" });
+
+const shell = box(width, depth, height, true);
+const cavity = box(width - wall * 2, depth - wall * 2, height - wall * 1.6, true).translate(0, 0, wall * 0.2);
+const passX = cylinder(width + 8, Math.min(depth, height) * 0.12, undefined, 48, true).rotate(0, 90, 0);
+const passY = cylinder(depth + 8, Math.min(width, height) * 0.09, undefined, 48, true).rotate(90, 0, 0).translate(0, 0, 12);
+const probe = cylinder(height + 20, 2.5, undefined, 36, true)
+  .translate(width * 0.22, depth * 0.18, 0)
+  .color("#f3a847");
+
+const housing = shell
+  .subtract(cavity)
+  .subtract(passX)
+  .subtract(passY)
+  .color("#8aa7c8");
+
+return [
+  { name: "Housing", shape: housing },
+  { name: "Probe", shape: probe },
+];

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

@@ -0,0 +1,48 @@
+// 2D sketch basics — primitives, booleans, offset, then extrude to 3D.
+
+const wall = param("Wall", 3, { min: 1, max: 8, unit: "mm" });
+const height = param("Height", 30, { min: 10, max: 80, unit: "mm" });
+
+// --- Sketch primitives ---
+const r = rect(40, 30);
+const c = circle2d(15).translate(20, 15);
+const hex = ngon(6, 12).translate(70, 15);
+const rounded = roundedRect(40, 30, 5).translate(100, 0);
+const oblong = slot(40, 15).translate(0, -30);
+
+// --- 2D booleans ---
+// Subtract circle from rectangle → plate with hole
+const plateSketch = rect(50, 40).subtract(circle2d(10).translate(25, 20));
+
+// --- Offset: inflate/deflate contours ---
+const outer = ngon(6, 20);
+const inner = outer.offset(-wall);
+const shellSketch = outer.subtract(inner); // hollow hexagon
+
+// --- Extrude to 3D ---
+const plate3d = plateSketch.extrude(height).translate(0, 60, 0).color('#4488cc');
+const shell3d = shellSketch.extrude(height).translate(70, 60, 0).color('#cc8844');
+
+// --- Path builder ---
+const bracket = path()
+  .moveTo(0, 0)
+  .lineH(30)
+  .lineV(40)
+  .lineH(-10)
+  .lineV(-30)
+  .lineH(-20)
+  .close()
+  .extrude(5)
+  .translate(130, 60, 0)
+  .color('#44cc88');
+
+return [
+  { name: "Rect", sketch: r },
+  { name: "Circle", sketch: c },
+  { name: "Hexagon", sketch: hex },
+  { name: "Rounded Rect", sketch: rounded },
+  { name: "Slot", sketch: oblong },
+  { name: "Plate (extruded)", shape: plate3d },
+  { name: "Shell (offset + extrude)", shape: shell3d },
+  { name: "Bracket (path + extrude)", shape: bracket },
+];