@tscircuit/3d-viewer 0.0.407 → 0.0.409

package/dist/index.js

@@ -6436,7 +6436,7 @@ var require_interpolateBetween2DPointsForY = __commonJS({
 var require_intersect = __commonJS({
   "node_modules/@jscad/modeling/src/maths/utils/intersect.js"(exports, module) {
     "use strict";
-    var intersect = (p1, p2, p3, p4) => {
+    var intersect3 = (p1, p2, p3, p4) => {
       if (p1[0] === p2[0] && p1[1] === p2[1] || p3[0] === p4[0] && p3[1] === p4[1]) {
         return void 0;
       }
@@ -6453,7 +6453,7 @@ var require_intersect = __commonJS({
       const y = p1[1] + ua * (p2[1] - p1[1]);
       return [x, y];
     };
-    module.exports = intersect;
+    module.exports = intersect3;
   }
 });
 
@@ -11424,7 +11424,7 @@ var require_intersectGeom3 = __commonJS({
     var flatten = require_flatten();
     var retessellate = require_retessellate();
     var intersectSub = require_intersectGeom3Sub();
-    var intersect = (...geometries2) => {
+    var intersect3 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       let newgeometry = geometries2.shift();
       geometries2.forEach((geometry) => {
@@ -11433,7 +11433,7 @@ var require_intersectGeom3 = __commonJS({
       newgeometry = retessellate(newgeometry);
       return newgeometry;
     };
-    module.exports = intersect;
+    module.exports = intersect3;
   }
 });
 
@@ -11447,14 +11447,14 @@ var require_intersectGeom2 = __commonJS({
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
     var intersectGeom3 = require_intersectGeom3();
-    var intersect = (...geometries2) => {
+    var intersect3 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       const newgeometries = geometries2.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = intersectGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
       return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3));
     };
-    module.exports = intersect;
+    module.exports = intersect3;
   }
 });
 
@@ -11468,7 +11468,7 @@ var require_intersect2 = __commonJS({
     var geom3 = require_geom3();
     var intersectGeom2 = require_intersectGeom2();
     var intersectGeom3 = require_intersectGeom3();
-    var intersect = (...geometries2) => {
+    var intersect3 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       if (geometries2.length === 0) throw new Error("wrong number of arguments");
       if (!areAllShapesTheSameType(geometries2)) {
@@ -11479,7 +11479,7 @@ var require_intersect2 = __commonJS({
       if (geom3.isA(geometry)) return intersectGeom3(geometries2);
       return geometry;
     };
-    module.exports = intersect;
+    module.exports = intersect3;
   }
 });
 
@@ -11787,7 +11787,7 @@ var require_offsetFromPoints = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/offsetFromPoints.js"(exports, module) {
     "use strict";
     var { EPS, TAU } = require_constants();
-    var intersect = require_intersect();
+    var intersect3 = require_intersect();
     var line22 = require_line2();
     var vec2 = require_vec2();
     var area = require_area();
@@ -11822,7 +11822,7 @@ var require_offsetFromPoints = __commonJS({
         const currentSegment = [n0, n1];
         if (previousSegment != null) {
           if (closed || !closed && j !== 0) {
-            const ip = intersect(previousSegment[0], previousSegment[1], currentSegment[0], currentSegment[1]);
+            const ip = intersect3(previousSegment[0], previousSegment[1], currentSegment[0], currentSegment[1]);
             if (ip) {
               newPoints.pop();
               currentSegment[0] = ip;
@@ -11839,7 +11839,7 @@ var require_offsetFromPoints = __commonJS({
       if (closed && previousSegment != null) {
         const n0 = newPoints[0];
         const n1 = newPoints[1];
-        const ip = intersect(previousSegment[0], previousSegment[1], n0, n1);
+        const ip = intersect3(previousSegment[0], previousSegment[1], n0, n1);
         if (ip) {
           newPoints[0] = ip;
           newPoints.pop();
@@ -12269,7 +12269,7 @@ var require_expand = __commonJS({
     var expandGeom2 = require_expandGeom2();
     var expandGeom3 = require_expandGeom3();
     var expandPath2 = require_expandPath2();
-    var expand3 = (options, ...objects) => {
+    var expand4 = (options, ...objects) => {
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
       const results = objects.map((object) => {
@@ -12280,7 +12280,7 @@ var require_expand = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = expand3;
+    module.exports = expand4;
   }
 });
 
@@ -12478,7 +12478,7 @@ var require_extrudeRectangularPath2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/extrudeRectangularPath2.js"(exports, module) {
     "use strict";
     var path2 = require_path2();
-    var expand3 = require_expand();
+    var expand4 = require_expand();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeRectangularPath2 = (options, geometry) => {
       const defaults = {
@@ -12490,7 +12490,7 @@ var require_extrudeRectangularPath2 = __commonJS({
       options.offset = [0, 0, height10];
       const points = path2.toPoints(geometry);
       if (points.length === 0) throw new Error("the given geometry cannot be empty");
-      const newgeometry = expand3(options, geometry);
+      const newgeometry = expand4(options, geometry);
       return extrudeLinearGeom2(options, newgeometry);
     };
     module.exports = extrudeRectangularPath2;
@@ -12504,7 +12504,7 @@ var require_extrudeRectangularGeom2 = __commonJS({
     var { area } = require_utils();
     var geom2 = require_geom2();
     var path2 = require_path2();
-    var expand3 = require_expand();
+    var expand4 = require_expand();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeRectangularGeom2 = (options, geometry) => {
       const defaults = {
@@ -12518,7 +12518,7 @@ var require_extrudeRectangularGeom2 = __commonJS({
       if (outlines.length === 0) throw new Error("the given geometry cannot be empty");
       const newparts = outlines.map((outline) => {
         if (area(outline) < 0) outline.reverse();
-        return expand3(options, path2.fromPoints({ closed: true }, outline));
+        return expand4(options, path2.fromPoints({ closed: true }, outline));
       });
       const allsides = newparts.reduce((sides, part) => sides.concat(geom2.toSides(part)), []);
       const newgeometry = geom2.create(allsides);
@@ -26100,7 +26100,7 @@ import * as THREE13 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.406",
+  version: "0.0.408",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -26901,6 +26901,7 @@ var tracesMaterialColors = {
 var import_extrusions = __toESM(require_extrusions(), 1);
 var import_primitives = __toESM(require_primitives(), 1);
 var import_transforms = __toESM(require_transforms(), 1);
+var import_expansions = __toESM(require_expansions(), 1);
 var arePointsClockwise = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
@@ -26911,13 +26912,17 @@ var arePointsClockwise = (points) => {
   const signedArea = area / 2;
   return signedArea <= 0;
 };
-var createBoardGeomWithOutline = (board, depth = 1.2) => {
+var createBoardGeomWithOutline = (board, depth = 1.2, options = {}) => {
+  const { xyOutset = 0 } = options;
   const { outline } = board;
   let outlineVec2 = outline.map((point2) => [point2.x, point2.y]);
   if (arePointsClockwise(outlineVec2)) {
     outlineVec2 = outlineVec2.reverse();
   }
-  const shape = (0, import_primitives.polygon)({ points: outlineVec2 });
+  let shape = (0, import_primitives.polygon)({ points: outlineVec2 });
+  if (xyOutset !== 0) {
+    shape = (0, import_expansions.expand)({ delta: xyOutset, corners: "edge" }, shape);
+  }
   let boardGeom = (0, import_extrusions.extrudeLinear)({ height: depth }, shape);
   boardGeom = (0, import_transforms.translate)([0, 0, -depth / 2], boardGeom);
   return boardGeom;
@@ -26992,6 +26997,7 @@ function extractRectBorderRadius(source) {
 // src/geoms/plated-hole.ts
 var platedHoleLipHeight = 0.05;
 var RECT_PAD_SEGMENTS = 64;
+var maybeClip = (geom, clipGeom) => clipGeom ? (0, import_booleans.intersect)(clipGeom, geom) : geom;
 var createRectPadGeom = ({
   width: width10,
   height: height10,
@@ -27012,84 +27018,71 @@ var createRectPadGeom = ({
   const offsetZ = center[2] - thickness / 2;
   return (0, import_transforms2.translate)([center[0], center[1], offsetZ], extruded);
 };
-var platedHole = (plated_hole, ctx) => {
+var platedHole = (plated_hole, ctx, options = {}) => {
+  const { clipGeom } = options;
   if (!plated_hole.shape) plated_hole.shape = "circle";
+  const throughDrillHeight = ctx.pcbThickness + 2 * platedHoleLipHeight + 4 * M;
   if (plated_hole.shape === "circle") {
-    return (0, import_colors2.colorize)(
-      colors.copper,
-      (0, import_booleans.subtract)(
-        (0, import_booleans.union)(
-          (0, import_primitives3.cylinder)({
-            center: [plated_hole.x, plated_hole.y, 0],
-            radius: plated_hole.hole_diameter / 2,
-            height: ctx.pcbThickness
-          }),
-          (0, import_primitives3.cylinder)({
-            center: [
-              plated_hole.x,
-              plated_hole.y,
-              ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M
-            ],
-            radius: plated_hole.outer_diameter / 2,
-            height: platedHoleLipHeight
-          }),
-          (0, import_primitives3.cylinder)({
-            center: [
-              plated_hole.x,
-              plated_hole.y,
-              -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M
-            ],
-            radius: plated_hole.outer_diameter / 2,
-            height: platedHoleLipHeight
-          })
-        ),
-        (0, import_primitives3.cylinder)({
-          center: [plated_hole.x, plated_hole.y, 0],
-          radius: plated_hole.hole_diameter / 2 - M,
-          height: 1.5
-        })
-      )
-    );
+    const outerDiameter = plated_hole.outer_diameter ?? Math.max(plated_hole.hole_diameter, 0);
+    const copperHeight = ctx.pcbThickness + 2 * (platedHoleLipHeight + M);
+    const copperBody = (0, import_primitives3.cylinder)({
+      center: [plated_hole.x, plated_hole.y, 0],
+      radius: outerDiameter / 2,
+      height: copperHeight
+    });
+    const copperSolid = maybeClip(copperBody, clipGeom);
+    const drill = (0, import_primitives3.cylinder)({
+      center: [plated_hole.x, plated_hole.y, 0],
+      radius: Math.max(plated_hole.hole_diameter / 2, 0.01),
+      height: throughDrillHeight
+    });
+    return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "circular_hole_with_rect_pad") {
     const padWidth = plated_hole.rect_pad_width || plated_hole.hole_diameter;
     const padHeight = plated_hole.rect_pad_height || plated_hole.hole_diameter;
     const rectBorderRadius = extractRectBorderRadius(plated_hole);
-    return (0, import_colors2.colorize)(
-      colors.copper,
-      (0, import_booleans.subtract)(
-        (0, import_booleans.union)(
-          // Top rectangular pad
-          createRectPadGeom({
-            width: padWidth,
-            height: padHeight,
-            thickness: platedHoleLipHeight,
-            center: [plated_hole.x, plated_hole.y, 1.2 / 2],
-            borderRadius: rectBorderRadius
-          }),
-          // Bottom rectangular pad
-          createRectPadGeom({
-            width: padWidth,
-            height: padHeight,
-            thickness: platedHoleLipHeight,
-            center: [plated_hole.x, plated_hole.y, -1.2 / 2],
-            borderRadius: rectBorderRadius
-          }),
-          // Plated barrel around hole
-          (0, import_primitives3.cylinder)({
-            center: [plated_hole.x, plated_hole.y, 0],
-            radius: plated_hole.hole_diameter / 2,
-            height: 1.2
-          })
-        ),
-        // Subtract actual hole through
+    const copperSolid = maybeClip(
+      (0, import_booleans.union)(
+        // Top rectangular pad
+        createRectPadGeom({
+          width: padWidth,
+          height: padHeight,
+          thickness: platedHoleLipHeight,
+          center: [
+            plated_hole.x,
+            plated_hole.y,
+            ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M
+          ],
+          borderRadius: rectBorderRadius
+        }),
+        // Bottom rectangular pad
+        createRectPadGeom({
+          width: padWidth,
+          height: padHeight,
+          thickness: platedHoleLipHeight,
+          center: [
+            plated_hole.x,
+            plated_hole.y,
+            -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M
+          ],
+          borderRadius: rectBorderRadius
+        }),
+        // Plated barrel around hole
         (0, import_primitives3.cylinder)({
           center: [plated_hole.x, plated_hole.y, 0],
-          radius: Math.max(plated_hole.hole_diameter / 2 - M, 0.01),
-          height: 1.5
+          radius: plated_hole.hole_diameter / 2,
+          height: ctx.pcbThickness
         })
-      )
+      ),
+      clipGeom
     );
+    const drill = (0, import_primitives3.cylinder)({
+      center: [plated_hole.x, plated_hole.y, 0],
+      radius: Math.max(plated_hole.hole_diameter / 2 - M, 0.01),
+      height: throughDrillHeight
+    });
+    return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "pill") {
     const shouldRotate = plated_hole.hole_height > plated_hole.hole_width;
@@ -27101,76 +27094,56 @@ var platedHole = (plated_hole, ctx) => {
     const outerRadius = outerPillHeight / 2;
     const rectLength = Math.abs(holeWidth - holeHeight);
     const outerRectLength = Math.abs(outerPillWidth - outerPillHeight);
-    const mainRectBarrel = (0, import_primitives3.cuboid)({
-      center: [plated_hole.x, plated_hole.y, 0],
-      size: shouldRotate ? [holeHeight, rectLength, ctx.pcbThickness] : [rectLength, holeHeight, ctx.pcbThickness]
-    });
-    const leftCapBarrel = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y - rectLength / 2, 0] : [plated_hole.x - rectLength / 2, plated_hole.y, 0],
-      radius: holeRadius,
-      height: ctx.pcbThickness
-    });
-    const rightCapBarrel = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y + rectLength / 2, 0] : [plated_hole.x + rectLength / 2, plated_hole.y, 0],
-      radius: holeRadius,
-      height: ctx.pcbThickness
-    });
-    const barrelUnion = (0, import_booleans.union)(mainRectBarrel, leftCapBarrel, rightCapBarrel);
-    const topLipZ = ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M;
-    const topLipRect = (0, import_primitives3.cuboid)({
-      center: [plated_hole.x, plated_hole.y, topLipZ],
-      size: shouldRotate ? [outerPillHeight, outerRectLength, platedHoleLipHeight] : [outerRectLength, outerPillHeight, platedHoleLipHeight]
-    });
-    const topLipLeftCap = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y - outerRectLength / 2, topLipZ] : [plated_hole.x - outerRectLength / 2, plated_hole.y, topLipZ],
-      radius: outerRadius,
-      height: platedHoleLipHeight
-    });
-    const topLipRightCap = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y + outerRectLength / 2, topLipZ] : [plated_hole.x + outerRectLength / 2, plated_hole.y, topLipZ],
-      radius: outerRadius,
-      height: platedHoleLipHeight
-    });
-    const topLipUnion = (0, import_booleans.union)(topLipRect, topLipLeftCap, topLipRightCap);
-    const bottomLipZ = -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M;
-    const bottomLipRect = (0, import_primitives3.cuboid)({
-      center: [plated_hole.x, plated_hole.y, bottomLipZ],
-      size: shouldRotate ? [outerPillHeight, outerRectLength, platedHoleLipHeight] : [outerRectLength, outerPillHeight, platedHoleLipHeight]
-    });
-    const bottomLipLeftCap = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y - outerRectLength / 2, bottomLipZ] : [plated_hole.x - outerRectLength / 2, plated_hole.y, bottomLipZ],
-      radius: outerRadius,
-      height: platedHoleLipHeight
-    });
-    const bottomLipRightCap = (0, import_primitives3.cylinder)({
-      center: shouldRotate ? [plated_hole.x, plated_hole.y + outerRectLength / 2, bottomLipZ] : [plated_hole.x + outerRectLength / 2, plated_hole.y, bottomLipZ],
-      radius: outerRadius,
-      height: platedHoleLipHeight
-    });
-    const bottomLipUnion = (0, import_booleans.union)(
-      bottomLipRect,
-      bottomLipLeftCap,
-      bottomLipRightCap
+    const copperHeight = ctx.pcbThickness + 2 * (platedHoleLipHeight + M);
+    const createPillSection = (width10, height10, thickness) => {
+      const radius = height10 / 2;
+      const length2 = Math.abs(width10 - height10);
+      if (length2 <= 1e-6) {
+        return (0, import_primitives3.cylinder)({
+          center: [plated_hole.x, plated_hole.y, 0],
+          radius,
+          height: thickness
+        });
+      }
+      const rect = (0, import_primitives3.cuboid)({
+        center: [plated_hole.x, plated_hole.y, 0],
+        size: shouldRotate ? [height10, length2, thickness] : [length2, height10, thickness]
+      });
+      const leftCap = (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [plated_hole.x, plated_hole.y - length2 / 2, 0] : [plated_hole.x - length2 / 2, plated_hole.y, 0],
+        radius,
+        height: thickness
+      });
+      const rightCap = (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [plated_hole.x, plated_hole.y + length2 / 2, 0] : [plated_hole.x + length2 / 2, plated_hole.y, 0],
+        radius,
+        height: thickness
+      });
+      return (0, import_booleans.union)(rect, leftCap, rightCap);
+    };
+    const outerBarrel = createPillSection(
+      outerPillWidth,
+      outerPillHeight,
+      copperHeight
     );
     const drillRect = (0, import_primitives3.cuboid)({
       center: [plated_hole.x, plated_hole.y, 0],
-      size: shouldRotate ? [holeHeight - 2 * M, rectLength, ctx.pcbThickness + 2 * M] : [rectLength, holeHeight - 2 * M, ctx.pcbThickness + 2 * M]
+      size: shouldRotate ? [holeHeight - 2 * M, rectLength, throughDrillHeight] : [rectLength, holeHeight - 2 * M, throughDrillHeight]
     });
     const drillLeftCap = (0, import_primitives3.cylinder)({
       center: shouldRotate ? [plated_hole.x, plated_hole.y - rectLength / 2, 0] : [plated_hole.x - rectLength / 2, plated_hole.y, 0],
       radius: holeRadius - M,
-      height: ctx.pcbThickness + 2 * M
+      height: throughDrillHeight
     });
     const drillRightCap = (0, import_primitives3.cylinder)({
       center: shouldRotate ? [plated_hole.x, plated_hole.y + rectLength / 2, 0] : [plated_hole.x + rectLength / 2, plated_hole.y, 0],
       radius: holeRadius - M,
-      height: ctx.pcbThickness + 2 * M
+      height: throughDrillHeight
     });
     const drillUnion = (0, import_booleans.union)(drillRect, drillLeftCap, drillRightCap);
-    return (0, import_colors2.colorize)(
-      colors.copper,
-      (0, import_booleans.subtract)((0, import_booleans.union)(barrelUnion, topLipUnion, bottomLipUnion), drillUnion)
-    );
+    const copperSolid = maybeClip(outerBarrel, clipGeom);
+    const drill = drillUnion;
+    return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "pill_hole_with_rect_pad") {
     const shouldRotate = plated_hole.hole_height > plated_hole.hole_width;
@@ -27183,52 +27156,62 @@ var platedHole = (plated_hole, ctx) => {
     const rectBorderRadius = extractRectBorderRadius(plated_hole);
     const mainRect = (0, import_primitives3.cuboid)({
       center: [plated_hole.x, plated_hole.y, 0],
-      size: shouldRotate ? [holeHeight, rectLength, 1.2] : [rectLength, holeHeight, 1.2]
+      size: shouldRotate ? [holeHeight, rectLength, ctx.pcbThickness] : [rectLength, holeHeight, ctx.pcbThickness]
     });
     const leftCap = (0, import_primitives3.cylinder)({
       center: shouldRotate ? [plated_hole.x, plated_hole.y - rectLength / 2, 0] : [plated_hole.x - rectLength / 2, plated_hole.y, 0],
       radius: holeRadius,
-      height: 1.2
+      height: ctx.pcbThickness
     });
     const rightCap = (0, import_primitives3.cylinder)({
       center: shouldRotate ? [plated_hole.x, plated_hole.y + rectLength / 2, 0] : [plated_hole.x + rectLength / 2, plated_hole.y, 0],
       radius: holeRadius,
-      height: 1.2
+      height: ctx.pcbThickness
     });
     const topPad = createRectPadGeom({
       width: padWidth,
       height: padHeight,
       thickness: platedHoleLipHeight,
-      center: [plated_hole.x, plated_hole.y, 1.2 / 2],
+      center: [
+        plated_hole.x,
+        plated_hole.y,
+        ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M
+      ],
       borderRadius: rectBorderRadius
     });
     const bottomPad = createRectPadGeom({
       width: padWidth,
       height: padHeight,
       thickness: platedHoleLipHeight,
-      center: [plated_hole.x, plated_hole.y, -1.2 / 2],
+      center: [
+        plated_hole.x,
+        plated_hole.y,
+        -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M
+      ],
       borderRadius: rectBorderRadius
     });
     const holeCut = (0, import_booleans.union)(
       (0, import_primitives3.cuboid)({
         center: [plated_hole.x, plated_hole.y, 0],
-        size: shouldRotate ? [holeHeight - platedHoleLipHeight, rectLength, 1.5] : [rectLength, holeHeight - platedHoleLipHeight, 1.5]
+        size: shouldRotate ? [holeHeight - platedHoleLipHeight, rectLength, throughDrillHeight] : [rectLength, holeHeight - platedHoleLipHeight, throughDrillHeight]
       }),
       (0, import_primitives3.cylinder)({
         center: shouldRotate ? [plated_hole.x, plated_hole.y - rectLength / 2, 0] : [plated_hole.x - rectLength / 2, plated_hole.y, 0],
         radius: holeRadius - platedHoleLipHeight,
-        height: 1.5
+        height: throughDrillHeight
       }),
       (0, import_primitives3.cylinder)({
         center: shouldRotate ? [plated_hole.x, plated_hole.y + rectLength / 2, 0] : [plated_hole.x + rectLength / 2, plated_hole.y, 0],
         radius: holeRadius - platedHoleLipHeight,
-        height: 1.5
+        height: throughDrillHeight
       })
     );
-    return (0, import_colors2.colorize)(
-      colors.copper,
-      (0, import_booleans.subtract)((0, import_booleans.union)(mainRect, leftCap, rightCap, topPad, bottomPad), holeCut)
+    const copperSolid = maybeClip(
+      (0, import_booleans.union)(mainRect, leftCap, rightCap, topPad, bottomPad),
+      clipGeom
     );
+    const drill = holeCut;
+    return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   } else {
     throw new Error(`Unsupported plated hole shape: ${plated_hole.shape}`);
   }
@@ -27236,7 +27219,7 @@ var platedHole = (plated_hole, ctx) => {
 
 // src/BoardGeomBuilder.ts
 var import_extrusions4 = __toESM(require_extrusions(), 1);
-var import_expansions2 = __toESM(require_expansions(), 1);
+var import_expansions3 = __toESM(require_expansions(), 1);
 
 // src/geoms/create-geoms-for-silkscreen-text.ts
 var import_text = __toESM(require_text(), 1);
@@ -27541,7 +27524,7 @@ function createSilkscreenTextGeoms(silkscreenText) {
 
 // src/geoms/create-geoms-for-silkscreen-path.ts
 var import_primitives4 = __toESM(require_primitives(), 1);
-var import_expansions = __toESM(require_expansions(), 1);
+var import_expansions2 = __toESM(require_expansions(), 1);
 var import_extrusions3 = __toESM(require_extrusions(), 1);
 var import_transforms3 = __toESM(require_transforms(), 1);
 var import_colors3 = __toESM(require_colors(), 1);
@@ -27550,7 +27533,7 @@ function createSilkscreenPathGeom(sp, ctx) {
   const routePoints = sp.route.map((p) => [p.x, p.y]);
   const pathLine = (0, import_primitives4.line)(routePoints);
   const strokeWidth = sp.stroke_width || 0.1;
-  const expandedPath = (0, import_expansions.expand)(
+  const expandedPath = (0, import_expansions2.expand)(
     { delta: strokeWidth / 2, corners: "round" },
     pathLine
   );
@@ -27652,6 +27635,8 @@ function createGeom2FromBRep(brep, arcSegments = 16) {
 
 // src/BoardGeomBuilder.ts
 var PAD_ROUNDED_SEGMENTS = 64;
+var BOARD_CLIP_Z_MARGIN = 1;
+var BOARD_CLIP_XY_OUTSET = 0.05;
 var createCenteredRectPadGeom = (width10, height10, thickness, rectBorderRadius) => {
   const clampedRadius = clampRectBorderRadius(width10, height10, rectBorderRadius);
   if (clampedRadius <= 0) {
@@ -27702,6 +27687,7 @@ var BoardGeomBuilder = class {
   silkscreenTextGeoms = [];
   silkscreenPathGeoms = [];
   copperPourGeoms = [];
+  boardClipGeom = null;
   state = "initializing";
   currentIndex = 0;
   ctx;
@@ -27737,10 +27723,11 @@ var BoardGeomBuilder = class {
     this.pcb_copper_pours = circuitJson.filter(
       (e) => e.type === "pcb_copper_pour"
     );
-    this.ctx = { pcbThickness: 1.2 };
+    this.ctx = { pcbThickness: this.board.thickness ?? 1.2 };
     this.initializeBoard();
   }
   initializeBoard() {
+    const clipDepth = this.ctx.pcbThickness + 2 * BOARD_CLIP_Z_MARGIN;
     if (this.board.outline && this.board.outline.length > 0) {
       this.boardGeom = createBoardGeomWithOutline(
         {
@@ -27748,11 +27735,26 @@ var BoardGeomBuilder = class {
         },
         this.ctx.pcbThickness
       );
+      this.boardClipGeom = createBoardGeomWithOutline(
+        {
+          outline: this.board.outline
+        },
+        clipDepth,
+        { xyOutset: BOARD_CLIP_XY_OUTSET }
+      );
     } else {
       this.boardGeom = (0, import_primitives6.cuboid)({
         size: [this.board.width, this.board.height, this.ctx.pcbThickness],
         center: [this.board.center.x, this.board.center.y, 0]
       });
+      this.boardClipGeom = (0, import_primitives6.cuboid)({
+        size: [
+          this.board.width + 2 * BOARD_CLIP_XY_OUTSET,
+          this.board.height + 2 * BOARD_CLIP_XY_OUTSET,
+          clipDepth
+        ],
+        center: [this.board.center.x, this.board.center.y, 0]
+      });
     }
     this.state = "processing_pads";
     this.currentIndex = 0;
@@ -27929,6 +27931,9 @@ var BoardGeomBuilder = class {
       pourGeom = (0, import_transforms4.translate)([0, 0, zPos], pourGeom);
     }
     if (pourGeom) {
+      if (this.boardClipGeom) {
+        pourGeom = (0, import_booleans3.intersect)(this.boardClipGeom, pourGeom);
+      }
       const coloredPourGeom = (0, import_colors4.colorize)(colors.copper, pourGeom);
       this.copperPourGeoms.push(coloredPourGeom);
     }
@@ -27949,7 +27954,9 @@ var BoardGeomBuilder = class {
       this.padGeoms = this.padGeoms.map(
         (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, cyGeom))
       );
-      const platedHoleGeom = platedHole(ph, this.ctx);
+      const platedHoleGeom = platedHole(ph, this.ctx, {
+        clipGeom: this.boardClipGeom
+      });
       this.platedHoleGeoms.push(platedHoleGeom);
     } else if (ph.shape === "pill" || ph.shape === "pill_hole_with_rect_pad") {
       const shouldRotate = ph.hole_height > ph.hole_width;
@@ -27979,7 +27986,9 @@ var BoardGeomBuilder = class {
       this.padGeoms = this.padGeoms.map(
         (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, pillHole))
       );
-      const platedHoleGeom = platedHole(ph, this.ctx);
+      const platedHoleGeom = platedHole(ph, this.ctx, {
+        clipGeom: this.boardClipGeom
+      });
       this.platedHoleGeoms.push(platedHoleGeom);
     }
   }
@@ -28011,8 +28020,12 @@ var BoardGeomBuilder = class {
         rectBorderRadius
       );
       const positionedPadGeom = (0, import_transforms4.translate)([pad2.x, pad2.y, zPos], basePadGeom);
-      const padGeom = (0, import_colors4.colorize)(colors.copper, positionedPadGeom);
-      this.padGeoms.push(padGeom);
+      let finalPadGeom = positionedPadGeom;
+      if (this.boardClipGeom) {
+        finalPadGeom = (0, import_booleans3.intersect)(this.boardClipGeom, finalPadGeom);
+      }
+      finalPadGeom = (0, import_colors4.colorize)(colors.copper, finalPadGeom);
+      this.padGeoms.push(finalPadGeom);
     } else if (pad2.shape === "rotated_rect") {
       let basePadGeom = createCenteredRectPadGeom(
         pad2.width,
@@ -28023,17 +28036,22 @@ var BoardGeomBuilder = class {
       const rotationRadians = pad2.ccw_rotation * Math.PI / 180;
       basePadGeom = (0, import_transforms4.rotateZ)(rotationRadians, basePadGeom);
       const positionedPadGeom = (0, import_transforms4.translate)([pad2.x, pad2.y, zPos], basePadGeom);
-      const padGeom = (0, import_colors4.colorize)(colors.copper, positionedPadGeom);
-      this.padGeoms.push(padGeom);
+      let finalPadGeom = positionedPadGeom;
+      if (this.boardClipGeom) {
+        finalPadGeom = (0, import_booleans3.intersect)(this.boardClipGeom, finalPadGeom);
+      }
+      finalPadGeom = (0, import_colors4.colorize)(colors.copper, finalPadGeom);
+      this.padGeoms.push(finalPadGeom);
     } else if (pad2.shape === "circle") {
-      const padGeom = (0, import_colors4.colorize)(
-        colors.copper,
-        (0, import_primitives6.cylinder)({
-          center: [pad2.x, pad2.y, zPos],
-          radius: pad2.radius,
-          height: M
-        })
-      );
+      let padGeom = (0, import_primitives6.cylinder)({
+        center: [pad2.x, pad2.y, zPos],
+        radius: pad2.radius,
+        height: M
+      });
+      if (this.boardClipGeom) {
+        padGeom = (0, import_booleans3.intersect)(this.boardClipGeom, padGeom);
+      }
+      padGeom = (0, import_colors4.colorize)(colors.copper, padGeom);
       this.padGeoms.push(padGeom);
     }
   }
@@ -28048,7 +28066,7 @@ var BoardGeomBuilder = class {
         const layerSign = currentLayer === "bottom" ? -1 : 1;
         const zPos = layerSign * this.ctx.pcbThickness / 2 + layerSign * M;
         const linePath = (0, import_primitives6.line)(currentSegmentPoints);
-        const expandedPath = (0, import_expansions2.expand)(
+        const expandedPath = (0, import_expansions3.expand)(
           { delta: currentWidth / 2, corners: "round" },
           linePath
         );
@@ -28080,6 +28098,9 @@ var BoardGeomBuilder = class {
           traceGeom = (0, import_booleans3.subtract)(traceGeom, cuttingCylinder);
         }
         const tracesMaterialColor = tracesMaterialColors[this.board.material] ?? colors.fr4GreenSolderWithMask;
+        if (this.boardClipGeom) {
+          traceGeom = (0, import_booleans3.intersect)(this.boardClipGeom, traceGeom);
+        }
         traceGeom = (0, import_colors4.colorize)(tracesMaterialColor, traceGeom);
         this.traceGeoms.push(traceGeom);
       }
@@ -28153,7 +28174,7 @@ var BoardGeomBuilder = class {
         Math.max(0.01, fontSize * 0.1),
         fontSize * 0.05
       );
-      const expandedPath = (0, import_expansions2.expand)(
+      const expandedPath = (0, import_expansions3.expand)(
         { delta: expansionDelta, corners: "round" },
         textPath
       );
@@ -28930,6 +28951,20 @@ function createPadManifoldOp({
       thickness: padBaseThickness,
       borderRadius: rectBorderRadius
     });
+  } else if (pad2.shape === "rotated_rect") {
+    const rectBorderRadius = extractRectBorderRadius(pad2);
+    let padOp = createRoundedRectPrism({
+      Manifold,
+      width: pad2.width,
+      height: pad2.height,
+      thickness: padBaseThickness,
+      borderRadius: rectBorderRadius
+    });
+    const rotation2 = pad2.ccw_rotation ?? 0;
+    if (rotation2) {
+      padOp = padOp.rotate([0, 0, rotation2]);
+    }
+    return padOp;
   } else if (pad2.shape === "circle" && pad2.radius) {
     return Manifold.cylinder(padBaseThickness, pad2.radius, -1, 32, true);
   }
@@ -28938,10 +28973,22 @@ function createPadManifoldOp({
 
 // src/utils/manifold/process-plated-holes.ts
 var COPPER_COLOR = new THREE19.Color(...colors.copper);
-function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
+var PLATED_HOLE_LIP_HEIGHT = 0.05;
+function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const platedHoleBoardDrills = [];
   const pcbPlatedHoles = su8(circuitJson).pcb_plated_hole.list();
   const platedHoleCopperGeoms = [];
+  const createPillOp = (width10, height10, depth) => {
+    const pillOp = createRoundedRectPrism({
+      Manifold,
+      width: width10,
+      height: height10,
+      thickness: depth,
+      borderRadius: Math.min(width10, height10) / 2
+    });
+    manifoldInstancesForCleanup.push(pillOp);
+    return pillOp;
+  };
   pcbPlatedHoles.forEach((ph, index) => {
     if (ph.shape === "circle") {
       const translatedDrill = createPlatedHoleDrill({
@@ -28978,69 +29025,31 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
       manifoldInstancesForCleanup.push(finalPlatedPartOp);
       const translatedPlatedPart = finalPlatedPartOp.translate([ph.x, ph.y, 0]);
       manifoldInstancesForCleanup.push(translatedPlatedPart);
-      const threeGeom = manifoldMeshToThreeGeometry(
-        translatedPlatedPart.getMesh()
-      );
+      let finalCopperOp = translatedPlatedPart;
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([
+          translatedPlatedPart,
+          boardClipVolume
+        ]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalCopperOp = clipped;
+      }
+      const threeGeom = manifoldMeshToThreeGeometry(finalCopperOp.getMesh());
       platedHoleCopperGeoms.push({
         key: `ph-${ph.pcb_plated_hole_id || index}`,
         geometry: threeGeom,
         color: COPPER_COLOR
       });
     } else if (ph.shape === "pill") {
-      const holeWidthRaw = ph.hole_width;
-      const holeHeightRaw = ph.hole_height;
-      const shouldRotate = holeHeightRaw > holeWidthRaw;
-      const holeW = shouldRotate ? holeHeightRaw : holeWidthRaw;
-      const holeH = shouldRotate ? holeWidthRaw : holeHeightRaw;
+      const holeW = ph.hole_width;
+      const holeH = ph.hole_height;
       const defaultPadExtension = 0.4;
-      const outerW = shouldRotate ? ph.outer_height ?? holeH + defaultPadExtension / 2 : ph.outer_width ?? holeW + defaultPadExtension / 2;
-      const outerH = shouldRotate ? ph.outer_width ?? holeW + defaultPadExtension / 2 : ph.outer_height ?? holeH + defaultPadExtension / 2;
-      const createPill = (width10, height10, depth) => {
-        const radius = height10 / 2;
-        const rectLength = width10 - height10;
-        let pillOp;
-        if (rectLength < 1e-9) {
-          pillOp = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          );
-        } else {
-          const rect = Manifold.cube(
-            [Math.max(0, rectLength), height10, depth],
-            true
-          );
-          const cap1 = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          ).translate([-rectLength / 2, 0, 0]);
-          const cap2 = Manifold.cylinder(
-            depth,
-            radius,
-            radius,
-            SMOOTH_CIRCLE_SEGMENTS,
-            true
-          ).translate([rectLength / 2, 0, 0]);
-          pillOp = Manifold.union([rect, cap1, cap2]);
-          manifoldInstancesForCleanup.push(rect, cap1, cap2);
-        }
-        manifoldInstancesForCleanup.push(pillOp);
-        return pillOp;
-      };
+      const outerW = ph.outer_width ?? holeW + defaultPadExtension;
+      const outerH = ph.outer_height ?? holeH + defaultPadExtension;
       const drillW = holeW + 2 * MANIFOLD_Z_OFFSET;
       const drillH = holeH + 2 * MANIFOLD_Z_OFFSET;
       const drillDepth = pcbThickness * 1.2;
-      let boardPillDrillOp = createPill(drillW, drillH, drillDepth);
-      if (shouldRotate) {
-        const rotatedOp = boardPillDrillOp.rotate([0, 0, 90]);
-        manifoldInstancesForCleanup.push(rotatedOp);
-        boardPillDrillOp = rotatedOp;
-      }
+      let boardPillDrillOp = createPillOp(drillW, drillH, drillDepth);
       if (ph.ccw_rotation) {
         const rotatedOp = boardPillDrillOp.rotate([0, 0, ph.ccw_rotation]);
         manifoldInstancesForCleanup.push(rotatedOp);
@@ -29054,12 +29063,12 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
       manifoldInstancesForCleanup.push(translatedBoardPillDrill);
       platedHoleBoardDrills.push(translatedBoardPillDrill);
       const copperPartThickness = pcbThickness + 2 * MANIFOLD_Z_OFFSET;
-      const outerCopperOpUnrotated = createPill(
+      const outerCopperOpUnrotated = createPillOp(
         outerW,
         outerH,
         copperPartThickness
       );
-      const innerDrillOpUnrotated = createPill(
+      const innerDrillOpUnrotated = createPillOp(
         holeW,
         holeH,
         copperPartThickness * 1.05
@@ -29069,11 +29078,6 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
         innerDrillOpUnrotated
       );
       manifoldInstancesForCleanup.push(finalPlatedPartOp);
-      if (shouldRotate) {
-        const rotatedOp = finalPlatedPartOp.rotate([0, 0, 90]);
-        manifoldInstancesForCleanup.push(rotatedOp);
-        finalPlatedPartOp = rotatedOp;
-      }
       if (ph.ccw_rotation) {
         const rotatedOp = finalPlatedPartOp.rotate([0, 0, ph.ccw_rotation]);
         manifoldInstancesForCleanup.push(rotatedOp);
@@ -29089,6 +29093,80 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
         geometry: threeGeom,
         color: COPPER_COLOR
       });
+    } else if (ph.shape === "pill_hole_with_rect_pad") {
+      const holeW = ph.hole_width;
+      const holeH = ph.hole_height;
+      const padWidth = ph.rect_pad_width;
+      const padHeight = ph.rect_pad_height;
+      const rectBorderRadius = extractRectBorderRadius(ph);
+      const padThickness = DEFAULT_SMT_PAD_THICKNESS;
+      const drillW = holeW + 2 * MANIFOLD_Z_OFFSET;
+      const drillH = holeH + 2 * MANIFOLD_Z_OFFSET;
+      const drillDepth = pcbThickness * 1.2;
+      let boardPillDrillOp = createPillOp(drillW, drillH, drillDepth);
+      const translatedBoardPillDrill = boardPillDrillOp.translate([
+        ph.x,
+        ph.y,
+        0
+      ]);
+      manifoldInstancesForCleanup.push(translatedBoardPillDrill);
+      platedHoleBoardDrills.push(translatedBoardPillDrill);
+      let copperBarrelOp = createPillOp(
+        holeW,
+        holeH,
+        pcbThickness + 2 * MANIFOLD_Z_OFFSET
+      );
+      let topPadOp = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: padThickness,
+        borderRadius: rectBorderRadius
+      });
+      manifoldInstancesForCleanup.push(topPadOp);
+      let bottomPadOp = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: padThickness,
+        borderRadius: rectBorderRadius
+      });
+      manifoldInstancesForCleanup.push(bottomPadOp);
+      const topPadZ = pcbThickness / 2 + padThickness / 2 + MANIFOLD_Z_OFFSET;
+      const bottomPadZ = -pcbThickness / 2 - padThickness / 2 - MANIFOLD_Z_OFFSET;
+      topPadOp = topPadOp.translate([0, 0, topPadZ]);
+      manifoldInstancesForCleanup.push(topPadOp);
+      bottomPadOp = bottomPadOp.translate([0, 0, bottomPadZ]);
+      manifoldInstancesForCleanup.push(bottomPadOp);
+      const copperUnionBeforeCut = Manifold.union([
+        copperBarrelOp,
+        topPadOp,
+        bottomPadOp
+      ]);
+      manifoldInstancesForCleanup.push(copperUnionBeforeCut);
+      const holeCutWidth = Math.max(holeW - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01);
+      const holeCutHeight = Math.max(holeH - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01);
+      const holeCutDepth = pcbThickness + 2 * padThickness + 4 * MANIFOLD_Z_OFFSET;
+      let holeCutOp = createPillOp(holeCutWidth, holeCutHeight, holeCutDepth);
+      const finalPlatedPartOp = copperUnionBeforeCut.subtract(holeCutOp);
+      manifoldInstancesForCleanup.push(finalPlatedPartOp);
+      const translatedPlatedPart = finalPlatedPartOp.translate([ph.x, ph.y, 0]);
+      manifoldInstancesForCleanup.push(translatedPlatedPart);
+      let finalCopperOp = translatedPlatedPart;
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([
+          translatedPlatedPart,
+          boardClipVolume
+        ]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalCopperOp = clipped;
+      }
+      const threeGeom = manifoldMeshToThreeGeometry(finalCopperOp.getMesh());
+      platedHoleCopperGeoms.push({
+        key: `ph-${ph.pcb_plated_hole_id || index}`,
+        geometry: threeGeom,
+        color: COPPER_COLOR
+      });
     } else if (ph.shape === "circular_hole_with_rect_pad") {
       const translatedDrill = createCircleHoleDrill({
         Manifold,
@@ -29156,7 +29234,16 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
       manifoldInstancesForCleanup.push(copperUnion);
       const translatedCopper = copperUnion.translate([ph.x, ph.y, 0]);
       manifoldInstancesForCleanup.push(translatedCopper);
-      const threeGeom = manifoldMeshToThreeGeometry(translatedCopper.getMesh());
+      let finalCopperOp = translatedCopper;
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([
+          translatedCopper,
+          boardClipVolume
+        ]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalCopperOp = clipped;
+      }
+      const threeGeom = manifoldMeshToThreeGeometry(finalCopperOp.getMesh());
       platedHoleCopperGeoms.push({
         key: `ph-${ph.pcb_plated_hole_id || index}`,
         geometry: threeGeom,
@@ -29203,7 +29290,7 @@ function createViaCopper({
 
 // src/utils/manifold/process-vias.ts
 var COPPER_COLOR2 = new THREE20.Color(...colors.copper);
-function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
+function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const viaBoardDrills = [];
   const pcbVias = su9(circuitJson).pcb_via.list();
   const viaCopperGeoms = [];
@@ -29233,9 +29320,16 @@ function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldIns
         segments: SMOOTH_CIRCLE_SEGMENTS
       });
       manifoldInstancesForCleanup.push(translatedViaCopper);
-      const threeGeom = manifoldMeshToThreeGeometry(
-        translatedViaCopper.getMesh()
-      );
+      let finalCopperOp = translatedViaCopper;
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([
+          translatedViaCopper,
+          boardClipVolume
+        ]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalCopperOp = clipped;
+      }
+      const threeGeom = manifoldMeshToThreeGeometry(finalCopperOp.getMesh());
       viaCopperGeoms.push({
         key: `via-${via.pcb_via_id || index}`,
         geometry: threeGeom,
@@ -29250,7 +29344,7 @@ function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldIns
 import { su as su10 } from "@tscircuit/circuit-json-util";
 import * as THREE21 from "three";
 var COPPER_COLOR3 = new THREE21.Color(...colors.copper);
-function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion) {
+function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion, boardClipVolume) {
   const smtPadGeoms = [];
   const smtPads = su10(circuitJson).pcb_smtpad.list();
   smtPads.forEach((pad2, index) => {
@@ -29270,6 +29364,11 @@ function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifold
         finalPadOp = translatedPad.subtract(holeUnion);
         manifoldInstancesForCleanup.push(finalPadOp);
       }
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([finalPadOp, boardClipVolume]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalPadOp = clipped;
+      }
       const threeGeom = manifoldMeshToThreeGeometry(finalPadOp.getMesh());
       smtPadGeoms.push({
         key: `pad-${pad2.pcb_smtpad_id || index}`,
@@ -29296,6 +29395,7 @@ var arePointsClockwise3 = (points) => {
 };
 function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, manifoldInstancesForCleanup) {
   let boardOp;
+  let outlineCrossSection = null;
   if (boardData.outline && boardData.outline.length >= 3) {
     let outlineVec2 = boardData.outline.map((p) => [
       p.x,
@@ -29306,6 +29406,7 @@ function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, ma
     }
     const crossSection = CrossSection.ofPolygons([outlineVec2]);
     manifoldInstancesForCleanup.push(crossSection);
+    outlineCrossSection = crossSection;
     boardOp = Manifold.extrude(
       crossSection,
       pcbThickness,
@@ -29334,7 +29435,7 @@ function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, ma
     boardOp = boardOp.translate([boardData.center.x, boardData.center.y, 0]);
     manifoldInstancesForCleanup.push(boardOp);
   }
-  return boardOp;
+  return { boardOp, outlineCrossSection };
 }
 
 // src/utils/manifold/process-copper-pours.ts
@@ -29405,7 +29506,7 @@ function ringToPoints2(ring2, arcSegments) {
   }
   return allPoints;
 }
-function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion) {
+function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion, boardClipVolume) {
   const copperPourGeoms = [];
   const copperPours = circuitJson.filter(
     (e) => e.type === "pcb_copper_pour"
@@ -29492,6 +29593,11 @@ function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbT
         manifoldInstancesForCleanup.push(withHoles);
         pourOp = withHoles;
       }
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([pourOp, boardClipVolume]);
+        manifoldInstancesForCleanup.push(clipped);
+        pourOp = clipped;
+      }
       const threeGeom = manifoldMeshToThreeGeometry(pourOp.getMesh());
       copperPourGeoms.push({
         key: `coppour-${pour.pcb_copper_pour_id}`,
@@ -29644,13 +29750,51 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
     try {
       const currentPcbThickness = boardData.thickness || 1.6;
       setPcbThickness(currentPcbThickness);
-      let currentBoardOp = createManifoldBoard(
+      const { boardOp: initialBoardOp, outlineCrossSection } = createManifoldBoard(
         Manifold,
         CrossSection,
         boardData,
         currentPcbThickness,
         manifoldInstancesForCleanup.current
       );
+      let currentBoardOp = initialBoardOp;
+      const BOARD_CLIP_Z_MARGIN2 = 1;
+      const clipThickness = currentPcbThickness + 2 * BOARD_CLIP_Z_MARGIN2;
+      let boardClipVolume = null;
+      const BOARD_CLIP_XY_OUTSET2 = 0.01;
+      if (outlineCrossSection) {
+        let clipCrossSection = outlineCrossSection;
+        if (BOARD_CLIP_XY_OUTSET2 > 0) {
+          const inflatedCrossSection = outlineCrossSection.offset(BOARD_CLIP_XY_OUTSET2);
+          manifoldInstancesForCleanup.current.push(inflatedCrossSection);
+          clipCrossSection = inflatedCrossSection;
+        }
+        const clipOp = Manifold.extrude(
+          clipCrossSection,
+          clipThickness,
+          void 0,
+          void 0,
+          void 0,
+          true
+        );
+        manifoldInstancesForCleanup.current.push(clipOp);
+        boardClipVolume = clipOp;
+      } else {
+        const clipWidth = (boardData.width || 0) + 2 * BOARD_CLIP_XY_OUTSET2;
+        const clipHeight = (boardData.height || 0) + 2 * BOARD_CLIP_XY_OUTSET2;
+        const clipCube = Manifold.cube(
+          [clipWidth, clipHeight, clipThickness],
+          true
+        );
+        manifoldInstancesForCleanup.current.push(clipCube);
+        const translatedClipCube = clipCube.translate([
+          boardData.center.x,
+          boardData.center.y,
+          0
+        ]);
+        manifoldInstancesForCleanup.current.push(translatedClipCube);
+        boardClipVolume = translatedClipCube;
+      }
       const allBoardDrills = [];
       let holeUnion = null;
       const { nonPlatedHoleBoardDrills } = processNonPlatedHolesForManifold(
@@ -29664,7 +29808,8 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         Manifold,
         circuitJson,
         currentPcbThickness,
-        manifoldInstancesForCleanup.current
+        manifoldInstancesForCleanup.current,
+        boardClipVolume
       );
       allBoardDrills.push(...platedHoleBoardDrills);
       currentGeoms.platedHoles = platedHoleCopperGeoms;
@@ -29672,7 +29817,8 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         Manifold,
         circuitJson,
         currentPcbThickness,
-        manifoldInstancesForCleanup.current
+        manifoldInstancesForCleanup.current,
+        boardClipVolume
       );
       allBoardDrills.push(...viaBoardDrills);
       currentGeoms.vias = viaCopperGeoms;
@@ -29717,7 +29863,8 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         circuitJson,
         currentPcbThickness,
         manifoldInstancesForCleanup.current,
-        holeUnion
+        holeUnion,
+        boardClipVolume
       );
       currentGeoms.smtPads = smtPadGeoms;
       const { copperPourGeoms } = processCopperPoursForManifold(
@@ -29726,7 +29873,8 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
         circuitJson,
         currentPcbThickness,
         manifoldInstancesForCleanup.current,
-        holeUnion
+        holeUnion,
+        boardClipVolume
       );
       currentGeoms.copperPours = copperPourGeoms;
       setGeoms(currentGeoms);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.407",
+  "version": "0.0.409",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",