@tscircuit/3d-viewer 0.0.411 → 0.0.413

package/dist/index.js

@@ -16636,8 +16636,8 @@ var pcb_fabrication_note_dimension = z93.object({
   pcb_group_id: z93.string().optional(),
   subcircuit_id: z93.string().optional(),
   layer: visible_layer,
-  from: point.or(z93.string()),
-  to: point.or(z93.string()),
+  from: point,
+  to: point,
   text: z93.string().optional(),
   offset: length.optional(),
   font: z93.literal("tscircuit2024").default("tscircuit2024"),
@@ -26576,7 +26576,7 @@ import * as THREE13 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.410",
+  version: "0.0.412",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -26623,8 +26623,8 @@ var package_default = {
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/circuit-json-util": "^0.0.72",
-    "@tscircuit/core": "^0.0.783",
-    "@tscircuit/props": "^0.0.360",
+    "@tscircuit/core": "^0.0.787",
+    "@tscircuit/props": "^0.0.364",
     "@tscircuit/checks": "^0.0.85",
     "@tscircuit/math-utils": "^0.0.27",
     "@tscircuit/capacity-autorouter": "^0.0.131",
@@ -26636,7 +26636,7 @@ var package_default = {
     "@vitejs/plugin-react": "^4.3.4",
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
-    "circuit-json": "0.0.278",
+    "circuit-json": "0.0.279",
     "circuit-to-svg": "^0.0.179",
     debug: "^4.4.0",
     "jscad-electronics": "^0.0.48",
@@ -27519,38 +27519,67 @@ var platedHole = (plated_hole, ctx, options = {}) => {
     return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "circular_hole_with_rect_pad") {
+    const holeOffsetX = plated_hole.hole_offset_x || 0;
+    const holeOffsetY = plated_hole.hole_offset_y || 0;
     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);
     const copperSolid = maybeClip(
       (0, import_booleans.union)(
-        // Top rectangular pad
+        // Top rectangular pad (thicker to ensure connection)
         createRectPadGeom({
           width: padWidth,
           height: padHeight,
-          thickness: platedHoleLipHeight,
+          thickness: platedHoleLipHeight + 0.1,
+          // Slightly thicker to ensure connection
           center: [
             plated_hole.x,
             plated_hole.y,
-            ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M
+            ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M - 0.05
+            // Adjusted for thickness
           ],
           borderRadius: rectBorderRadius
         }),
-        // Bottom rectangular pad
+        // Bottom rectangular pad (thicker to ensure connection)
         createRectPadGeom({
           width: padWidth,
           height: padHeight,
-          thickness: platedHoleLipHeight,
+          thickness: platedHoleLipHeight + 0.1,
+          // Slightly thicker to ensure connection
           center: [
             plated_hole.x,
             plated_hole.y,
-            -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M
+            -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M + 0.05
+            // Adjusted for thickness
           ],
           borderRadius: rectBorderRadius
         }),
-        // Plated barrel around hole
+        // Main copper fill between pads with rounded corners
+        (() => {
+          const height10 = ctx.pcbThickness - platedHoleLipHeight * 2 - M * 2 + 0.1;
+          const rect2d = (0, import_primitives3.roundedRectangle)({
+            size: [padWidth, padHeight],
+            roundRadius: rectBorderRadius || 0,
+            segments: RECT_PAD_SEGMENTS
+          });
+          const extruded = (0, import_extrusions2.extrudeLinear)({ height: height10 }, rect2d);
+          return (0, import_transforms2.translate)(
+            [
+              plated_hole.x,
+              plated_hole.y,
+              -height10 / 2
+              // Center vertically
+            ],
+            extruded
+          );
+        })(),
+        // Plated barrel around hole (ensured connection with pads)
         (0, import_primitives3.cylinder)({
-          center: [plated_hole.x, plated_hole.y, 0],
+          center: [
+            plated_hole.x + (holeOffsetX || 0),
+            plated_hole.y + (holeOffsetY || 0),
+            0
+          ],
           radius: plated_hole.hole_diameter / 2,
           height: ctx.pcbThickness
         })
@@ -27558,11 +27587,35 @@ var platedHole = (plated_hole, ctx, options = {}) => {
       clipGeom
     );
     const drill = (0, import_primitives3.cylinder)({
-      center: [plated_hole.x, plated_hole.y, 0],
+      center: [
+        plated_hole.x + (holeOffsetX || 0),
+        plated_hole.y + (holeOffsetY || 0),
+        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));
+    const barrel = (0, import_primitives3.cylinder)({
+      center: [
+        plated_hole.x + (holeOffsetX || 0),
+        plated_hole.y + (holeOffsetY || 0),
+        0
+      ],
+      radius: plated_hole.hole_diameter / 2,
+      height: ctx.pcbThickness
+    });
+    let finalCopper = (0, import_booleans.union)(
+      (0, import_booleans.subtract)(copperSolid, barrel),
+      // Subtract the barrel from the main shape
+      barrel
+      // Add the barrel back to ensure proper connection
+    );
+    if (options.clipGeom) {
+      finalCopper = (0, import_booleans.subtract)(finalCopper, drill);
+      finalCopper = (0, import_booleans.intersect)(finalCopper, options.clipGeom);
+      return (0, import_colors2.colorize)(colors.copper, finalCopper);
+    }
+    return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(finalCopper, drill));
   }
   if (plated_hole.shape === "pill") {
     const shouldRotate = plated_hole.hole_height > plated_hole.hole_width;
@@ -27626,6 +27679,8 @@ var platedHole = (plated_hole, ctx, options = {}) => {
     return (0, import_colors2.colorize)(colors.copper, (0, import_booleans.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "pill_hole_with_rect_pad") {
+    const holeOffsetX = plated_hole.hole_offset_x || 0;
+    const holeOffsetY = plated_hole.hole_offset_y || 0;
     const shouldRotate = plated_hole.hole_height > plated_hole.hole_width;
     const holeWidth = shouldRotate ? plated_hole.hole_height : plated_hole.hole_width;
     const holeHeight = shouldRotate ? plated_hole.hole_width : plated_hole.hole_height;
@@ -27634,64 +27689,140 @@ var platedHole = (plated_hole, ctx, options = {}) => {
     const padWidth = plated_hole.rect_pad_width || holeWidth + 0.2;
     const padHeight = plated_hole.rect_pad_height || holeHeight + 0.2;
     const rectBorderRadius = extractRectBorderRadius(plated_hole);
-    const mainRect = (0, import_primitives3.cuboid)({
-      center: [plated_hole.x, plated_hole.y, 0],
-      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: 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: ctx.pcbThickness
-    });
-    const topPad = createRectPadGeom({
-      width: padWidth,
-      height: padHeight,
-      thickness: platedHoleLipHeight,
-      center: [
-        plated_hole.x,
-        plated_hole.y,
-        ctx.pcbThickness / 2 + platedHoleLipHeight / 2 + M
-      ],
-      borderRadius: rectBorderRadius
-    });
-    const bottomPad = createRectPadGeom({
+    const barrelMargin = 0.03;
+    const barrel = (0, import_booleans.union)(
+      (0, import_primitives3.cuboid)({
+        center: [plated_hole.x + holeOffsetX, plated_hole.y + holeOffsetY, 0],
+        size: shouldRotate ? [
+          holeHeight + 2 * barrelMargin,
+          rectLength + 2 * barrelMargin,
+          ctx.pcbThickness + 0.2
+        ] : [
+          rectLength + 2 * barrelMargin,
+          holeHeight + 2 * barrelMargin,
+          ctx.pcbThickness + 0.2
+        ]
+      }),
+      (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY - rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX - rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius + barrelMargin,
+        height: ctx.pcbThickness + 0.2
+        // extend slightly above/below PCB
+      }),
+      (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY + rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX + rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius + barrelMargin,
+        height: ctx.pcbThickness + 0.2
+      })
+    );
+    const holeCut = (0, import_booleans.union)(
+      (0, import_primitives3.cuboid)({
+        center: [plated_hole.x + holeOffsetX, plated_hole.y + holeOffsetY, 0],
+        size: shouldRotate ? [holeHeight, rectLength, throughDrillHeight * 1.1] : [rectLength, holeHeight, throughDrillHeight * 1.1]
+      }),
+      (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY - rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX - rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius,
+        height: throughDrillHeight * 1.1
+      }),
+      (0, import_primitives3.cylinder)({
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY + rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX + rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius,
+        height: throughDrillHeight * 1.1
+      })
+    );
+    const mainFill = createRectPadGeom({
       width: padWidth,
       height: padHeight,
-      thickness: platedHoleLipHeight,
-      center: [
-        plated_hole.x,
-        plated_hole.y,
-        -ctx.pcbThickness / 2 - platedHoleLipHeight / 2 - M
-      ],
+      thickness: ctx.pcbThickness - 2 * platedHoleLipHeight - M * 2 + 0.1,
+      center: [plated_hole.x, plated_hole.y, 0],
       borderRadius: rectBorderRadius
     });
-    const holeCut = (0, import_booleans.union)(
+    const createPadWithHole = (zOffset) => {
+      const pad2 = createRectPadGeom({
+        width: padWidth,
+        height: padHeight,
+        thickness: platedHoleLipHeight + 0.1,
+        center: [plated_hole.x, plated_hole.y, zOffset],
+        borderRadius: rectBorderRadius
+      });
+      return (0, import_booleans.subtract)(pad2, holeCut);
+    };
+    const topPad = createPadWithHole(
+      ctx.pcbThickness / 2 - platedHoleLipHeight / 2 + 0.05
+    );
+    const bottomPad = createPadWithHole(
+      -ctx.pcbThickness / 2 + platedHoleLipHeight / 2 - 0.05
+    );
+    const filledArea = (0, import_booleans.subtract)(mainFill, holeCut);
+    const barrelHoleCut = (0, import_booleans.union)(
       (0, import_primitives3.cuboid)({
-        center: [plated_hole.x, plated_hole.y, 0],
-        size: shouldRotate ? [holeHeight - platedHoleLipHeight, rectLength, throughDrillHeight] : [rectLength, holeHeight - platedHoleLipHeight, throughDrillHeight]
+        center: [plated_hole.x + holeOffsetX, plated_hole.y + holeOffsetY, 0],
+        size: shouldRotate ? [holeHeight - 2 * M, rectLength - 2 * M, throughDrillHeight * 1.1] : [rectLength - 2 * M, holeHeight - 2 * M, throughDrillHeight * 1.1]
       }),
       (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: throughDrillHeight
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY - rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX - rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius - M,
+        height: throughDrillHeight * 1.1
       }),
       (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: throughDrillHeight
+        center: shouldRotate ? [
+          plated_hole.x + holeOffsetX,
+          plated_hole.y + holeOffsetY + rectLength / 2,
+          0
+        ] : [
+          plated_hole.x + holeOffsetX + rectLength / 2,
+          plated_hole.y + holeOffsetY,
+          0
+        ],
+        radius: holeRadius - M,
+        height: throughDrillHeight * 1.1
       })
     );
-    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));
+    const barrelWithHole = (0, import_booleans.subtract)(barrel, barrelHoleCut);
+    const finalCopper = (0, import_booleans.union)(filledArea, barrelWithHole, topPad, bottomPad);
+    let result = maybeClip(finalCopper, clipGeom);
+    return (0, import_colors2.colorize)(colors.copper, result);
   } else {
     throw new Error(`Unsupported plated hole shape: ${plated_hole.shape}`);
   }
@@ -28421,13 +28552,24 @@ var BoardGeomBuilder = class {
   processPlatedHole(ph, opts = {}) {
     if (!this.boardGeom) return;
     if (ph.shape === "circle" || ph.shape === "circular_hole_with_rect_pad") {
-      const cyGeom = (0, import_primitives6.cylinder)({
-        center: [ph.x, ph.y, 0],
-        radius: ph.hole_diameter / 2 + M,
-        // Add margin for subtraction
-        height: this.ctx.pcbThickness * 1.5
-        // Ensure it cuts through
-      });
+      let cyGeom = null;
+      if (ph.shape === "circular_hole_with_rect_pad") {
+        cyGeom = (0, import_primitives6.cylinder)({
+          center: [ph.x + ph.hole_offset_x, ph.y + ph.hole_offset_y, 0],
+          radius: ph.hole_diameter / 2 + M,
+          // Add margin for subtraction
+          height: this.ctx.pcbThickness * 1.5
+          // Ensure it cuts through
+        });
+      } else {
+        cyGeom = (0, import_primitives6.cylinder)({
+          center: [ph.x, ph.y, 0],
+          radius: ph.hole_diameter / 2 + M,
+          // Add margin for subtraction
+          height: this.ctx.pcbThickness * 1.5
+          // Ensure it cuts through
+        });
+      }
       if (!opts.dontCutBoard) {
         this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, cyGeom);
       }
@@ -28444,22 +28586,58 @@ var BoardGeomBuilder = class {
       const holeHeight = shouldRotate ? ph.hole_width : ph.hole_height;
       const holeRadius = holeHeight / 2;
       const rectLength = Math.abs(holeWidth - holeHeight);
-      const pillHole = (0, import_booleans3.union)(
-        (0, import_primitives6.cuboid)({
-          center: [ph.x, ph.y, 0],
-          size: shouldRotate ? [holeHeight, rectLength, this.ctx.pcbThickness * 1.5] : [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
-        }),
-        (0, import_primitives6.cylinder)({
-          center: shouldRotate ? [ph.x, ph.y - rectLength / 2, 0] : [ph.x - rectLength / 2, ph.y, 0],
-          radius: holeRadius,
-          height: this.ctx.pcbThickness * 1.5
-        }),
-        (0, import_primitives6.cylinder)({
-          center: shouldRotate ? [ph.x, ph.y + rectLength / 2, 0] : [ph.x + rectLength / 2, ph.y, 0],
-          radius: holeRadius,
-          height: this.ctx.pcbThickness * 1.5
-        })
-      );
+      let pillHole;
+      if (ph.shape === "pill_hole_with_rect_pad") {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [ph.x + ph.hole_offset_x, ph.y + ph.hole_offset_y, 0],
+            size: shouldRotate ? [holeHeight, rectLength, this.ctx.pcbThickness * 1.5] : [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: shouldRotate ? [
+              ph.x + ph.hole_offset_x,
+              ph.y + ph.hole_offset_y - rectLength / 2,
+              0
+            ] : [
+              ph.x + ph.hole_offset_x - rectLength / 2,
+              ph.y + ph.hole_offset_y,
+              0
+            ],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: shouldRotate ? [
+              ph.x + ph.hole_offset_x,
+              ph.y + ph.hole_offset_y + rectLength / 2,
+              0
+            ] : [
+              ph.x + ph.hole_offset_x + rectLength / 2,
+              ph.y + ph.hole_offset_y,
+              0
+            ],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      } else {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [ph.x, ph.y, 0],
+            size: shouldRotate ? [holeHeight, rectLength, this.ctx.pcbThickness * 1.5] : [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: shouldRotate ? [ph.x, ph.y - rectLength / 2, 0] : [ph.x - rectLength / 2, ph.y, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: shouldRotate ? [ph.x, ph.y + rectLength / 2, 0] : [ph.x + rectLength / 2, ph.y, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      }
       if (!opts.dontCutBoard) {
         this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, pillHole);
       }
@@ -28486,6 +28664,99 @@ var BoardGeomBuilder = class {
       this.padGeoms = this.padGeoms.map(
         (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, cyGeom))
       );
+    } else if (hole.hole_shape === "pill") {
+      const holeWidth = hole.hole_width;
+      const holeHeight = hole.hole_height;
+      const holeRadius = Math.min(holeWidth, holeHeight) / 2;
+      const rectLength = Math.abs(holeWidth - holeHeight);
+      let pillHole;
+      if (holeWidth > holeHeight) {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [hole.x, hole.y, 0],
+            size: [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [hole.x - rectLength / 2, hole.y, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [hole.x + rectLength / 2, hole.y, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      } else {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [hole.x, hole.y, 0],
+            size: [holeWidth, rectLength, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [hole.x, hole.y - rectLength / 2, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [hole.x, hole.y + rectLength / 2, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      }
+      this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, pillHole);
+      this.padGeoms = this.padGeoms.map(
+        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, pillHole))
+      );
+    } else if (hole.hole_shape === "rotated_pill") {
+      const holeWidth = hole.hole_width;
+      const holeHeight = hole.hole_height;
+      const holeRadius = Math.min(holeWidth, holeHeight) / 2;
+      const rectLength = Math.abs(holeWidth - holeHeight);
+      let pillHole;
+      if (holeWidth > holeHeight) {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [0, 0, 0],
+            size: [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [-rectLength / 2, 0, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [rectLength / 2, 0, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      } else {
+        pillHole = (0, import_booleans3.union)(
+          (0, import_primitives6.cuboid)({
+            center: [0, 0, 0],
+            size: [holeWidth, rectLength, this.ctx.pcbThickness * 1.5]
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [0, -rectLength / 2, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          }),
+          (0, import_primitives6.cylinder)({
+            center: [0, rectLength / 2, 0],
+            radius: holeRadius,
+            height: this.ctx.pcbThickness * 1.5
+          })
+        );
+      }
+      const rotationRadians = hole.ccw_rotation * Math.PI / 180;
+      pillHole = (0, import_transforms4.rotateZ)(rotationRadians, pillHole);
+      pillHole = (0, import_transforms4.translate)([hole.x, hole.y, 0], pillHole);
+      this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, pillHole);
+      this.padGeoms = this.padGeoms.map(
+        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, pillHole))
+      );
     }
   }
   processPad(pad2) {
@@ -29348,34 +29619,6 @@ function createPlatedHoleDrill({
   return drill.translate([x, y, 0]);
 }
 
-// src/utils/manifold/process-non-plated-holes.ts
-function isCircleHole(hole) {
-  return (hole.shape === "circle" || hole.hole_shape === "circle") && typeof hole.hole_diameter === "number";
-}
-function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
-  const nonPlatedHoleBoardDrills = [];
-  const pcbHoles = su7(circuitJson).pcb_hole.list();
-  pcbHoles.forEach((hole) => {
-    if (isCircleHole(hole)) {
-      const translatedDrill = createCircleHoleDrill({
-        Manifold,
-        x: hole.x,
-        y: hole.y,
-        diameter: hole.hole_diameter,
-        thickness: pcbThickness,
-        segments: SMOOTH_CIRCLE_SEGMENTS
-      });
-      manifoldInstancesForCleanup.push(translatedDrill);
-      nonPlatedHoleBoardDrills.push(translatedDrill);
-    }
-  });
-  return { nonPlatedHoleBoardDrills };
-}
-
-// src/utils/manifold/process-plated-holes.ts
-import { su as su8 } from "@tscircuit/circuit-json-util";
-import * as THREE19 from "three";
-
 // src/utils/pad-geoms.ts
 var RECT_PAD_SEGMENTS2 = 64;
 function createRoundedRectPrism({
@@ -29451,7 +29694,69 @@ function createPadManifoldOp({
   return null;
 }
 
+// src/utils/manifold/process-non-plated-holes.ts
+function isCircleHole(hole) {
+  return (hole.shape === "circle" || hole.hole_shape === "circle") && typeof hole.hole_diameter === "number";
+}
+function isPillHole(hole) {
+  return (hole.shape === "pill" || hole.hole_shape === "pill") && typeof hole.hole_width === "number" && typeof hole.hole_height === "number";
+}
+function isRotatedPillHole(hole) {
+  return (hole.shape === "rotated_pill" || hole.hole_shape === "rotated_pill") && typeof hole.hole_width === "number" && typeof hole.hole_height === "number" && typeof hole.ccw_rotation === "number";
+}
+function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
+  const nonPlatedHoleBoardDrills = [];
+  const pcbHoles = su7(circuitJson).pcb_hole.list();
+  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;
+  };
+  pcbHoles.forEach((hole) => {
+    if (isCircleHole(hole)) {
+      const translatedDrill = createCircleHoleDrill({
+        Manifold,
+        x: hole.x,
+        y: hole.y,
+        diameter: hole.hole_diameter,
+        thickness: pcbThickness,
+        segments: SMOOTH_CIRCLE_SEGMENTS
+      });
+      manifoldInstancesForCleanup.push(translatedDrill);
+      nonPlatedHoleBoardDrills.push(translatedDrill);
+    } else if (isPillHole(hole)) {
+      const holeW = hole.hole_width;
+      const holeH = hole.hole_height;
+      const drillDepth = pcbThickness * 1.2;
+      const pillDrillOp = createPillOp(holeW, holeH, drillDepth);
+      const translatedPillDrill = pillDrillOp.translate([hole.x, hole.y, 0]);
+      manifoldInstancesForCleanup.push(translatedPillDrill);
+      nonPlatedHoleBoardDrills.push(translatedPillDrill);
+    } else if (isRotatedPillHole(hole)) {
+      const holeW = hole.hole_width;
+      const holeH = hole.hole_height;
+      const drillDepth = pcbThickness * 1.2;
+      let pillDrillOp = createPillOp(holeW, holeH, drillDepth);
+      const rotatedOp = pillDrillOp.rotate([0, 0, hole.ccw_rotation]);
+      manifoldInstancesForCleanup.push(rotatedOp);
+      pillDrillOp = rotatedOp;
+      const translatedPillDrill = pillDrillOp.translate([hole.x, hole.y, 0]);
+      manifoldInstancesForCleanup.push(translatedPillDrill);
+      nonPlatedHoleBoardDrills.push(translatedPillDrill);
+    }
+  });
+  return { nonPlatedHoleBoardDrills };
+}
+
 // src/utils/manifold/process-plated-holes.ts
+import { su as su8 } from "@tscircuit/circuit-json-util";
+import * as THREE19 from "three";
 var COPPER_COLOR = new THREE19.Color(...colors.copper);
 var PLATED_HOLE_LIP_HEIGHT = 0.05;
 function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
@@ -29576,6 +29881,8 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
     } else if (ph.shape === "pill_hole_with_rect_pad") {
       const holeW = ph.hole_width;
       const holeH = ph.hole_height;
+      const holeOffsetX = ph.hole_offset_x || 0;
+      const holeOffsetY = ph.hole_offset_y || 0;
       const padWidth = ph.rect_pad_width;
       const padHeight = ph.rect_pad_height;
       const rectBorderRadius = extractRectBorderRadius(ph);
@@ -29583,7 +29890,9 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
       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);
+      let boardPillDrillOp = createPillOp(drillW, drillH, drillDepth).translate(
+        [holeOffsetX, holeOffsetY, 0]
+      );
       const translatedBoardPillDrill = boardPillDrillOp.translate([
         ph.x,
         ph.y,
@@ -29591,51 +29900,59 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
       ]);
       manifoldInstancesForCleanup.push(translatedBoardPillDrill);
       platedHoleBoardDrills.push(translatedBoardPillDrill);
-      let copperBarrelOp = createPillOp(
-        holeW,
-        holeH,
-        pcbThickness + 2 * MANIFOLD_Z_OFFSET
-      );
-      let topPadOp = createRoundedRectPrism({
+      const mainFill = createRoundedRectPrism({
         Manifold,
         width: padWidth,
         height: padHeight,
-        thickness: padThickness,
+        thickness: pcbThickness - 2 * padThickness + 0.1,
+        // Fill between pads
         borderRadius: rectBorderRadius
       });
-      manifoldInstancesForCleanup.push(topPadOp);
-      let bottomPadOp = createRoundedRectPrism({
+      manifoldInstancesForCleanup.push(mainFill);
+      const topPad = createRoundedRectPrism({
         Manifold,
         width: padWidth,
         height: padHeight,
-        thickness: padThickness,
+        thickness: padThickness + 0.1,
         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
+      }).translate([0, 0, pcbThickness / 2 - padThickness / 2 + 0.05]);
+      const bottomPad = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: padThickness + 0.1,
+        borderRadius: rectBorderRadius
+      }).translate([0, 0, -pcbThickness / 2 + padThickness / 2 - 0.05]);
+      manifoldInstancesForCleanup.push(topPad, bottomPad);
+      const barrelPill = createPillOp(
+        holeW,
+        holeH,
+        pcbThickness * 1.02
+        // Slightly taller than board
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      manifoldInstancesForCleanup.push(barrelPill);
+      const copperUnion = Manifold.union([
+        mainFill,
+        topPad,
+        bottomPad,
+        barrelPill
       ]);
-      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;
+      manifoldInstancesForCleanup.push(copperUnion);
+      const holeCutOp = createPillOp(
+        Math.max(holeW - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01),
+        Math.max(holeH - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01),
+        pcbThickness * 1.2
+        // Ensure it cuts through
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      manifoldInstancesForCleanup.push(holeCutOp);
+      const finalCopper = copperUnion.subtract(holeCutOp);
+      manifoldInstancesForCleanup.push(finalCopper);
+      const translatedCopper = finalCopper.translate([ph.x, ph.y, 0]);
+      manifoldInstancesForCleanup.push(translatedCopper);
+      let finalCopperOp = translatedCopper;
       if (boardClipVolume) {
         const clipped = Manifold.intersection([
-          translatedPlatedPart,
+          translatedCopper,
           boardClipVolume
         ]);
         manifoldInstancesForCleanup.push(clipped);
@@ -29648,71 +29965,77 @@ function processPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, mani
         color: COPPER_COLOR
       });
     } else if (ph.shape === "circular_hole_with_rect_pad") {
+      const holeOffsetX = ph.hole_offset_x || 0;
+      const holeOffsetY = ph.hole_offset_y || 0;
       const translatedDrill = createCircleHoleDrill({
         Manifold,
-        x: ph.x,
-        y: ph.y,
+        x: ph.x + holeOffsetX,
+        // Apply hole offset
+        y: ph.y + holeOffsetY,
+        // Apply hole offset
         diameter: ph.hole_diameter,
         thickness: pcbThickness,
         segments: SMOOTH_CIRCLE_SEGMENTS
       });
       manifoldInstancesForCleanup.push(translatedDrill);
       platedHoleBoardDrills.push(translatedDrill);
-      const copperPartThickness = pcbThickness + 2 * MANIFOLD_Z_OFFSET;
-      const holeRadius = ph.hole_diameter / 2;
-      const barrelCylinder = Manifold.cylinder(
-        copperPartThickness,
-        holeRadius,
-        holeRadius,
-        SMOOTH_CIRCLE_SEGMENTS,
-        true
-      );
-      manifoldInstancesForCleanup.push(barrelCylinder);
       const padWidth = ph.rect_pad_width ?? ph.hole_diameter;
       const padHeight = ph.rect_pad_height ?? ph.hole_diameter;
       const rectBorderRadius = extractRectBorderRadius(ph);
       const padThickness = DEFAULT_SMT_PAD_THICKNESS;
+      const holeRadius = ph.hole_diameter / 2;
+      const mainFill = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: pcbThickness - 2 * padThickness + 0.1,
+        // Fill between pads
+        borderRadius: rectBorderRadius
+      });
+      manifoldInstancesForCleanup.push(mainFill);
       const topPad = createRoundedRectPrism({
         Manifold,
         width: padWidth,
         height: padHeight,
-        thickness: padThickness,
+        thickness: padThickness + 0.1,
         borderRadius: rectBorderRadius
-      }).translate([
-        0,
-        0,
-        pcbThickness / 2 + padThickness / 2 + MANIFOLD_Z_OFFSET
-      ]);
+      }).translate([0, 0, pcbThickness / 2 - padThickness / 2 + 0.05]);
       const bottomPad = createRoundedRectPrism({
         Manifold,
         width: padWidth,
         height: padHeight,
-        thickness: padThickness,
+        thickness: padThickness + 0.1,
         borderRadius: rectBorderRadius
-      }).translate([
-        0,
-        0,
-        -pcbThickness / 2 - padThickness / 2 - MANIFOLD_Z_OFFSET
-      ]);
+      }).translate([0, 0, -pcbThickness / 2 + padThickness / 2 - 0.05]);
       manifoldInstancesForCleanup.push(topPad, bottomPad);
-      const copperUnionUncut = Manifold.union([
-        barrelCylinder,
+      const barrelCylinder = Manifold.cylinder(
+        pcbThickness * 1.02,
+        // Slightly taller than board
+        holeRadius,
+        holeRadius,
+        SMOOTH_CIRCLE_SEGMENTS,
+        true
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      manifoldInstancesForCleanup.push(barrelCylinder);
+      const copperUnion = Manifold.union([
+        mainFill,
         topPad,
-        bottomPad
+        bottomPad,
+        barrelCylinder
       ]);
-      manifoldInstancesForCleanup.push(copperUnionUncut);
-      const centerHoleRadius = Math.max(holeRadius - M, 0.01);
-      const centerHole = Manifold.cylinder(
-        copperPartThickness * 1.1,
-        centerHoleRadius,
-        centerHoleRadius,
+      manifoldInstancesForCleanup.push(copperUnion);
+      const holeDrill = Manifold.cylinder(
+        pcbThickness * 1.2,
+        // Ensure it cuts through
+        Math.max(holeRadius - M, 0.01),
+        Math.max(holeRadius - M, 0.01),
         SMOOTH_CIRCLE_SEGMENTS,
         true
-      );
-      manifoldInstancesForCleanup.push(centerHole);
-      const copperUnion = copperUnionUncut.subtract(centerHole);
-      manifoldInstancesForCleanup.push(copperUnion);
-      const translatedCopper = copperUnion.translate([ph.x, ph.y, 0]);
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      manifoldInstancesForCleanup.push(holeDrill);
+      const finalCopper = copperUnion.subtract(holeDrill);
+      manifoldInstancesForCleanup.push(finalCopper);
+      const translatedCopper = finalCopper.translate([ph.x, ph.y, 0]);
       manifoldInstancesForCleanup.push(translatedCopper);
       let finalCopperOp = translatedCopper;
       if (boardClipVolume) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.411",
+  "version": "0.0.413",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",
@@ -47,8 +47,8 @@
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/circuit-json-util": "^0.0.72",
-    "@tscircuit/core": "^0.0.783",
-    "@tscircuit/props": "^0.0.360",
+    "@tscircuit/core": "^0.0.787",
+    "@tscircuit/props": "^0.0.364",
     "@tscircuit/checks": "^0.0.85",
     "@tscircuit/math-utils": "^0.0.27",
     "@tscircuit/capacity-autorouter": "^0.0.131",
@@ -60,7 +60,7 @@
     "@vitejs/plugin-react": "^4.3.4",
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
-    "circuit-json": "0.0.278",
+    "circuit-json": "0.0.279",
     "circuit-to-svg": "^0.0.179",
     "debug": "^4.4.0",
     "jscad-electronics": "^0.0.48",