@tscircuit/3d-viewer 0.0.523 → 0.0.525

package/dist/index.js

@@ -4399,6 +4399,52 @@ var require_isA3 = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js
+var require_isConvex2 = __commonJS({
+  "node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js"(exports, module) {
+    "use strict";
+    var { EPS } = require_constants();
+    var vec3 = require_vec3();
+    var geom3 = require_isA3();
+    var toPolygons = require_toPolygons();
+    var poly3 = require_poly3();
+    var isConvex = (geometry) => {
+      if (!geom3(geometry)) {
+        throw new Error("isConvex requires a geom3 geometry");
+      }
+      const polygons = toPolygons(geometry);
+      if (polygons.length === 0) {
+        return true;
+      }
+      const vertices = [];
+      const found = /* @__PURE__ */ new Set();
+      for (let i = 0; i < polygons.length; i++) {
+        const verts = polygons[i].vertices;
+        for (let j = 0; j < verts.length; j++) {
+          const v = verts[j];
+          const key = `${v[0]},${v[1]},${v[2]}`;
+          if (!found.has(key)) {
+            found.add(key);
+            vertices.push(v);
+          }
+        }
+      }
+      for (let i = 0; i < polygons.length; i++) {
+        const plane = poly3.plane(polygons[i]);
+        for (let j = 0; j < vertices.length; j++) {
+          const v = vertices[j];
+          const distance4 = vec3.dot(plane, v) - plane[3];
+          if (distance4 > EPS) {
+            return false;
+          }
+        }
+      }
+      return true;
+    };
+    module.exports = isConvex;
+  }
+});
+
 // node_modules/@jscad/modeling/src/geometries/geom3/toPoints.js
 var require_toPoints3 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/geom3/toPoints.js"(exports, module) {
@@ -4556,6 +4602,7 @@ var require_geom3 = __commonJS({
       fromCompactBinary: require_fromCompactBinary2(),
       invert: require_invert3(),
       isA: require_isA3(),
+      isConvex: require_isConvex2(),
       toPoints: require_toPoints3(),
       toPolygons: require_toPolygons(),
       toString: require_toString7(),
@@ -4752,7 +4799,7 @@ var require_appendArc = __commonJS({
         } else if (sweepFlag && deltatheta < 0) {
           deltatheta += TAU;
         }
-        let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1;
+        let numsteps = Math.floor(segments * (Math.abs(deltatheta) / TAU));
         if (numsteps < 1) numsteps = 1;
         for (let step = 1; step < numsteps; step++) {
           const theta = theta1 + step / numsteps * deltatheta;
@@ -7221,7 +7268,7 @@ var require_arc = __commonJS({
         vec2.add(point, point, centerv);
         pointArray.push(point);
       } else {
-        const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1;
+        const numsteps = Math.floor(segments * (Math.abs(rotation) / TAU));
         let edgestepsize = numsteps * 0.5 / rotation;
         if (edgestepsize > 0.25) edgestepsize = 0.25;
         const totalsteps = makeTangent ? numsteps + 2 : numsteps;
@@ -11254,6 +11301,205 @@ var require_intersect2 = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js
+var require_hullPoints3 = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js"(exports, module) {
+    "use strict";
+    var poly3 = require_poly3();
+    var quickhull = require_quickhull();
+    var hullPoints3 = (uniquePoints) => {
+      const faces = quickhull(uniquePoints, { skipTriangulation: true });
+      const polygons = faces.map((face) => {
+        const vertices = face.map((index2) => uniquePoints[index2]);
+        return poly3.create(vertices);
+      });
+      return polygons;
+    };
+    module.exports = hullPoints3;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js
+var require_unionGeom3Sub = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js"(exports, module) {
+    "use strict";
+    var geom3 = require_geom3();
+    var mayOverlap = require_mayOverlap();
+    var { Tree } = require_trees();
+    var unionSub = (geometry1, geometry2) => {
+      if (!mayOverlap(geometry1, geometry2)) {
+        return unionForNonIntersecting(geometry1, geometry2);
+      }
+      const a = new Tree(geom3.toPolygons(geometry1));
+      const b = new Tree(geom3.toPolygons(geometry2));
+      a.clipTo(b, false);
+      b.clipTo(a);
+      b.invert();
+      b.clipTo(a);
+      b.invert();
+      const newpolygons = a.allPolygons().concat(b.allPolygons());
+      const result = geom3.create(newpolygons);
+      return result;
+    };
+    var unionForNonIntersecting = (geometry1, geometry2) => {
+      let newpolygons = geom3.toPolygons(geometry1);
+      newpolygons = newpolygons.concat(geom3.toPolygons(geometry2));
+      return geom3.create(newpolygons);
+    };
+    module.exports = unionSub;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js
+var require_unionGeom3 = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js"(exports, module) {
+    "use strict";
+    var flatten = require_flatten();
+    var retessellate = require_retessellate();
+    var unionSub = require_unionGeom3Sub();
+    var union5 = (...geometries) => {
+      geometries = flatten(geometries);
+      let i;
+      for (i = 1; i < geometries.length; i += 2) {
+        geometries.push(unionSub(geometries[i - 1], geometries[i]));
+      }
+      let newgeometry = geometries[i - 1];
+      newgeometry = retessellate(newgeometry);
+      return newgeometry;
+    };
+    module.exports = union5;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/minkowski/minkowskiSum.js
+var require_minkowskiSum = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/minkowski/minkowskiSum.js"(exports, module) {
+    "use strict";
+    var flatten = require_flatten();
+    var geom3 = require_geom3();
+    var poly3 = require_poly3();
+    var hullPoints3 = require_hullPoints3();
+    var unionGeom3 = require_unionGeom3();
+    var minkowskiSum = (...geometries) => {
+      geometries = flatten(geometries);
+      if (geometries.length !== 2) {
+        throw new Error("minkowskiSum requires exactly two geometries");
+      }
+      const [geomA, geomB] = geometries;
+      if (!geom3.isA(geomA) || !geom3.isA(geomB)) {
+        throw new Error("minkowskiSum requires geom3 geometries");
+      }
+      const aConvex = geom3.isConvex(geomA);
+      const bConvex = geom3.isConvex(geomB);
+      if (aConvex && bConvex) {
+        return minkowskiSumConvex(geomA, geomB);
+      }
+      if (!aConvex && bConvex) {
+        return minkowskiSumNonConvexConvex(geomA, geomB);
+      }
+      if (aConvex && !bConvex) {
+        return minkowskiSumNonConvexConvex(geomB, geomA);
+      }
+      throw new Error("minkowskiSum of two non-convex geometries is not yet supported");
+    };
+    var minkowskiSumNonConvexConvex = (geomA, geomB) => {
+      const tetrahedra = decomposeIntoTetrahedra(geomA);
+      if (tetrahedra.length === 0) {
+        return geom3.create();
+      }
+      const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB));
+      if (parts.length === 1) {
+        return parts[0];
+      }
+      return unionGeom3(parts);
+    };
+    var decomposeIntoTetrahedra = (geometry) => {
+      const polygons = geom3.toPolygons(geometry);
+      if (polygons.length === 0) {
+        return [];
+      }
+      const tetrahedra = [];
+      for (let i = 0; i < polygons.length; i++) {
+        const polygon3 = polygons[i];
+        const vertices = polygon3.vertices;
+        let cx = 0, cy = 0, cz = 0;
+        for (let k = 0; k < vertices.length; k++) {
+          cx += vertices[k][0];
+          cy += vertices[k][1];
+          cz += vertices[k][2];
+        }
+        cx /= vertices.length;
+        cy /= vertices.length;
+        cz /= vertices.length;
+        const plane = poly3.plane(polygon3);
+        const nx = plane[0], ny = plane[1], nz = plane[2];
+        const offset4 = 0.1;
+        const apex = [
+          // Vertex used as apex in tetrahedron polygons below
+          cx - nx * offset4,
+          cy - ny * offset4,
+          cz - nz * offset4
+        ];
+        for (let j = 1; j < vertices.length - 1; j++) {
+          const v0 = vertices[0];
+          const v1 = vertices[j];
+          const v2 = vertices[j + 1];
+          const tetPolygons = createTetrahedronPolygons(apex, v0, v1, v2);
+          tetrahedra.push(geom3.create(tetPolygons));
+        }
+      }
+      return tetrahedra;
+    };
+    var createTetrahedronPolygons = (p0, p1, p2, p3) => {
+      return [
+        poly3.create([p0, p2, p1]),
+        // base seen from p3
+        poly3.create([p0, p1, p3]),
+        // face opposite p2
+        poly3.create([p1, p2, p3]),
+        // face opposite p0
+        poly3.create([p2, p0, p3])
+        // face opposite p1
+      ];
+    };
+    var minkowskiSumConvex = (geomA, geomB) => {
+      const pointsA = extractUniqueVertices(geomA);
+      const pointsB = extractUniqueVertices(geomB);
+      if (pointsA.length === 0 || pointsB.length === 0) {
+        return geom3.create();
+      }
+      const summedPoints = [];
+      for (let i = 0; i < pointsA.length; i++) {
+        const a = pointsA[i];
+        for (let j = 0; j < pointsB.length; j++) {
+          const b = pointsB[j];
+          summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]]);
+        }
+      }
+      const hullPolygons = hullPoints3(summedPoints);
+      return geom3.create(hullPolygons);
+    };
+    var extractUniqueVertices = (geometry) => {
+      const found = /* @__PURE__ */ new Set();
+      const unique = [];
+      const polygons = geom3.toPolygons(geometry);
+      for (let i = 0; i < polygons.length; i++) {
+        const vertices = polygons[i].vertices;
+        for (let j = 0; j < vertices.length; j++) {
+          const v = vertices[j];
+          const key = `${v[0]},${v[1]},${v[2]}`;
+          if (!found.has(key)) {
+            found.add(key);
+            unique.push(v);
+          }
+        }
+      }
+      return unique;
+    };
+    module.exports = minkowskiSum;
+  }
+});
+
 // node_modules/@jscad/modeling/src/operations/booleans/scissionGeom3.js
 var require_scissionGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/scissionGeom3.js"(exports, module) {
@@ -11442,58 +11688,6 @@ var require_subtract4 = __commonJS({
   }
 });
 
-// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js
-var require_unionGeom3Sub = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js"(exports, module) {
-    "use strict";
-    var geom3 = require_geom3();
-    var mayOverlap = require_mayOverlap();
-    var { Tree } = require_trees();
-    var unionSub = (geometry1, geometry2) => {
-      if (!mayOverlap(geometry1, geometry2)) {
-        return unionForNonIntersecting(geometry1, geometry2);
-      }
-      const a = new Tree(geom3.toPolygons(geometry1));
-      const b = new Tree(geom3.toPolygons(geometry2));
-      a.clipTo(b, false);
-      b.clipTo(a);
-      b.invert();
-      b.clipTo(a);
-      b.invert();
-      const newpolygons = a.allPolygons().concat(b.allPolygons());
-      const result = geom3.create(newpolygons);
-      return result;
-    };
-    var unionForNonIntersecting = (geometry1, geometry2) => {
-      let newpolygons = geom3.toPolygons(geometry1);
-      newpolygons = newpolygons.concat(geom3.toPolygons(geometry2));
-      return geom3.create(newpolygons);
-    };
-    module.exports = unionSub;
-  }
-});
-
-// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js
-var require_unionGeom3 = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js"(exports, module) {
-    "use strict";
-    var flatten = require_flatten();
-    var retessellate = require_retessellate();
-    var unionSub = require_unionGeom3Sub();
-    var union5 = (...geometries) => {
-      geometries = flatten(geometries);
-      let i;
-      for (i = 1; i < geometries.length; i += 2) {
-        geometries.push(unionSub(geometries[i - 1], geometries[i]));
-      }
-      let newgeometry = geometries[i - 1];
-      newgeometry = retessellate(newgeometry);
-      return newgeometry;
-    };
-    module.exports = union5;
-  }
-});
-
 // node_modules/@jscad/modeling/src/operations/booleans/unionGeom2.js
 var require_unionGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/unionGeom2.js"(exports, module) {
@@ -11546,6 +11740,7 @@ var require_booleans = __commonJS({
     "use strict";
     module.exports = {
       intersect: require_intersect2(),
+      minkowski: require_minkowskiSum(),
       scission: require_scission(),
       subtract: require_subtract4(),
       union: require_union()
@@ -12585,24 +12780,6 @@ var require_hullGeom2 = __commonJS({
   }
 });
 
-// node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js
-var require_hullPoints3 = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js"(exports, module) {
-    "use strict";
-    var poly3 = require_poly3();
-    var quickhull = require_quickhull();
-    var hullPoints3 = (uniquePoints) => {
-      const faces = quickhull(uniquePoints, { skipTriangulation: true });
-      const polygons = faces.map((face) => {
-        const vertices = face.map((index2) => uniquePoints[index2]);
-        return poly3.create(vertices);
-      });
-      return polygons;
-    };
-    module.exports = hullPoints3;
-  }
-});
-
 // node_modules/@jscad/modeling/src/operations/hulls/hullGeom3.js
 var require_hullGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/hullGeom3.js"(exports, module) {
@@ -12682,6 +12859,16 @@ var require_hulls = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/operations/minkowski/index.js
+var require_minkowski = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/minkowski/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      minkowskiSum: require_minkowskiSum()
+    };
+  }
+});
+
 // node_modules/@jscad/modeling/src/operations/modifiers/snapPolygons.js
 var require_snapPolygons = __commonJS({
   "node_modules/@jscad/modeling/src/operations/modifiers/snapPolygons.js"(exports, module) {
@@ -13523,6 +13710,7 @@ var require_src = __commonJS({
       expansions: require_expansions(),
       extrusions: require_extrusions(),
       hulls: require_hulls(),
+      minkowski: require_minkowski(),
       modifiers: require_modifiers(),
       transforms: require_transforms()
     };
@@ -14245,7 +14433,7 @@ var require_browser = __commonJS({
 
 // src/CadViewer.tsx
 import { useState as useState36, useCallback as useCallback21, useRef as useRef26, useEffect as useEffect44 } from "react";
-import * as THREE37 from "three";
+import * as THREE38 from "three";
 
 // src/CadViewerJscad.tsx
 import { su as su11 } from "@tscircuit/circuit-json-util";
@@ -23943,6 +24131,7 @@ var A2512 = ({ color = "#333" }) => {
 var FemaleHeader = ({
   x,
   y,
+  z: z18 = 0,
   pitch = 2.54,
   legsLength = 3,
   innerDiameter = 0.945,
@@ -23960,7 +24149,7 @@ var FemaleHeader = ({
         {
           color: "#000",
           size: [bodyLength10, bodyWidth, bodyHeight],
-          center: [x, y, flipZ(bodyHeight / 2)]
+          center: [x, y, flipZ(z18 + bodyHeight / 2)]
         }
       ),
       innerDiameter ? /* @__PURE__ */ jsx2(
@@ -23968,14 +24157,14 @@ var FemaleHeader = ({
         {
           height: bodyHeight + 0.1,
           radius: innerDiameter / 2,
-          center: [x, y, flipZ(bodyHeight / 2)],
+          center: [x, y, flipZ(z18 + bodyHeight / 2)],
           color: "#222"
         }
       ) : /* @__PURE__ */ jsx2(
         Cuboid,
         {
           size: [gapWidth, gapWidth, bodyHeight],
-          center: [x, y, flipZ(bodyHeight / 2)]
+          center: [x, y, flipZ(z18 + bodyHeight / 2)]
         }
       )
     ] }) }),
@@ -23986,7 +24175,7 @@ var FemaleHeader = ({
           {
             color: "silver",
             size: [pinThickness, pinThickness, legsLength * 0.9],
-            center: [x, y, flipZ(-legsLength / 2 * 0.9)]
+            center: [x, y, flipZ(z18 + -legsLength / 2 * 0.9)]
           }
         ),
         /* @__PURE__ */ jsx2(
@@ -23994,7 +24183,7 @@ var FemaleHeader = ({
           {
             color: "silver",
             size: [pinThickness / 1.8, pinThickness / 1.8, legsLength],
-            center: [x, y, flipZ(-legsLength / 2)]
+            center: [x, y, flipZ(z18 + -legsLength / 2)]
           }
         )
       ] }),
@@ -24003,7 +24192,7 @@ var FemaleHeader = ({
         {
           color: "silver",
           size: [gapWidth, gapWidth, gapWidth * 0.5],
-          center: [x, y, flipZ(gapWidth / 2 * 0.5)]
+          center: [x, y, flipZ(z18 + gapWidth / 2 * 0.5)]
         }
       )
     ] })
@@ -26531,7 +26720,7 @@ var StampBoard = ({
     for (let i = 0; i < leadsRight; i++) {
       const y = yOffset + i * leadsPitch;
       pads.push({
-        x: -halfBoardWidth + leadLength / 2,
+        x: halfBoardWidth - leadLength / 2,
         y: -y,
         // Flip y
         pl: leadLength,
@@ -26539,8 +26728,8 @@ var StampBoard = ({
       });
       if (innerHoles) {
         holes.push(
-          { x: -halfBoardWidth, y: -y },
-          { x: -halfBoardWidth + innerHoleEdgeDistance, y: -y }
+          { x: halfBoardWidth, y: -y },
+          { x: halfBoardWidth - innerHoleEdgeDistance, y: -y }
         );
       }
     }
@@ -26550,7 +26739,7 @@ var StampBoard = ({
     for (let i = 0; i < leadsLeft; i++) {
       const y = yOffset + i * leadsPitch;
       pads.push({
-        x: halfBoardWidth - leadLength / 2,
+        x: -halfBoardWidth + leadLength / 2,
         y: -y,
         // Flip y
         pl: leadLength,
@@ -26558,8 +26747,8 @@ var StampBoard = ({
       });
       if (innerHoles) {
         holes.push(
-          { x: halfBoardWidth, y: -y },
-          { x: halfBoardWidth - innerHoleEdgeDistance, y: -y }
+          { x: -halfBoardWidth, y: -y },
+          { x: -halfBoardWidth + innerHoleEdgeDistance, y: -y }
         );
       }
     }
@@ -26571,14 +26760,14 @@ var StampBoard = ({
       pads.push({
         x: -x,
         // Flip x
-        y: -bodyLength10 / 2 + leadLength / 2,
+        y: bodyLength10 / 2 - leadLength / 2,
         pl: leadWidth,
         pw: leadLength
       });
       if (innerHoles) {
         holes.push(
-          { x: -x, y: -bodyLength10 / 2 },
-          { x: -x, y: -bodyLength10 / 2 + innerHoleEdgeDistance }
+          { x: -x, y: bodyLength10 / 2 },
+          { x: -x, y: bodyLength10 / 2 - innerHoleEdgeDistance }
         );
       }
     }
@@ -26590,14 +26779,14 @@ var StampBoard = ({
       pads.push({
         x: -x,
         // Flip x
-        y: bodyLength10 / 2 - leadLength / 2,
+        y: -bodyLength10 / 2 + leadLength / 2,
         pl: leadWidth,
         pw: leadLength
       });
       if (innerHoles) {
         holes.push(
-          { x: -x, y: bodyLength10 / 2 },
-          { x: -x, y: bodyLength10 / 2 - innerHoleEdgeDistance }
+          { x: -x, y: -bodyLength10 / 2 },
+          { x: -x, y: -bodyLength10 / 2 + innerHoleEdgeDistance }
         );
       }
     }
@@ -26652,6 +26841,66 @@ var StampBoard = ({
     ] }) : rectPads })
   ] });
 };
+var Screen = ({
+  width: width10 = 30,
+  height: height10 = 22,
+  thickness = 1,
+  bezelInset = 2,
+  bezelDepth = 1,
+  screenColor = "#001414",
+  bezelColor = "#0f1116",
+  screenWidth,
+  screenHeight,
+  offset: offset4
+}) => {
+  const w = width10;
+  const h2 = height10;
+  const stackHeight = Math.max(thickness, 0.4);
+  const clampedBezelDepth = Math.max(Math.min(bezelDepth, stackHeight), 0.2);
+  const backBlockHeight = Math.max(stackHeight - clampedBezelDepth, 0);
+  const inset = Math.max(bezelInset, 0);
+  const innerWidth = Math.max(screenWidth ?? w - inset * 2, 2);
+  const innerHeight = Math.max(screenHeight ?? h2 - inset * 2, 2);
+  const screenThickness = Math.min(
+    Math.max(clampedBezelDepth * 0.6, 0.2),
+    clampedBezelDepth
+  );
+  const offsetX = offset4?.x ?? 0;
+  const offsetY = offset4?.y ?? 0;
+  const offsetZ = offset4?.z ?? 0;
+  return /* @__PURE__ */ jsxs(Translate, { offset: { x: offsetX, y: offsetY, z: offsetZ }, children: [
+    backBlockHeight > 0 && /* @__PURE__ */ jsx2(Colorize, { color: bezelColor, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [w, h2, backBlockHeight],
+        offset: [0, 0, backBlockHeight / 2]
+      }
+    ) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: bezelColor, children: /* @__PURE__ */ jsxs(Subtract, { children: [
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [w, h2, clampedBezelDepth],
+          offset: [0, 0, backBlockHeight + clampedBezelDepth / 2]
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        Cuboid,
+        {
+          size: [innerWidth, innerHeight, clampedBezelDepth + 0.02],
+          offset: [0, 0, backBlockHeight + clampedBezelDepth / 2]
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx2(Colorize, { color: screenColor, children: /* @__PURE__ */ jsx2(
+      Cuboid,
+      {
+        size: [innerWidth, innerHeight, screenThickness],
+        offset: [0, 0, backBlockHeight + screenThickness / 2]
+      }
+    ) })
+  ] });
+};
 var MountedPcbModule = ({
   numPins = 5,
   rows = 1,
@@ -26665,8 +26914,15 @@ var MountedPcbModule = ({
   holes = [],
   holeInset = 1,
   pinRowHoleEdgeToEdgeDist = 2,
-  nopin
+  female,
+  nopin,
+  screen,
+  screenWidth,
+  screenHeight,
+  screenCenterOffsetX,
+  screenCenterOffsetY
 }) => {
+  const showScreen = screen ?? false;
   const boardCenterZ = boardThickness / 2;
   const numPinsPerRow = Math.ceil(numPins / rows);
   let calculatedWidth;
@@ -26743,7 +26999,8 @@ var MountedPcbModule = ({
   const pinBodyHeight = 2;
   const longSidePinLength = 6;
   const shortSidePinLength = 3;
-  const boardOffsetZ = nopin ? 0 : pinBodyHeight;
+  const boardOffsetZ = nopin || female ? 0 : pinBodyHeight;
+  const boardTopZ = boardOffsetZ + boardThickness;
   const boardBody = /* @__PURE__ */ jsx2(Colorize, { color: "#008080", children: /* @__PURE__ */ jsxs(Subtract, { children: [
     /* @__PURE__ */ jsx2(
       Cuboid,
@@ -26802,10 +27059,32 @@ var MountedPcbModule = ({
     },
     `pin-3d-${index2}`
   ));
+  const femaleHeaderRow = pins.map((pin, index2) => /* @__PURE__ */ jsx2(
+    FemaleHeader,
+    {
+      x: pin.x,
+      y: pin.y,
+      flipZ: (z18) => -z18
+    },
+    `female-pin-3d-${index2}`
+  ));
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     boardBody,
     platedHoles,
-    !nopin && headerPins
+    !female && !nopin && headerPins,
+    female && femaleHeaderRow,
+    showScreen && /* @__PURE__ */ jsx2(
+      Screen,
+      {
+        width: screenWidth ?? finalWidth * 0.8,
+        height: screenHeight ?? finalHeight * 0.6,
+        offset: {
+          x: screenCenterOffsetX ?? 0,
+          y: screenCenterOffsetY ?? 0,
+          z: boardTopZ
+        }
+      }
+    )
   ] });
 };
 var Footprinter3d = ({ footprint }) => {
@@ -27086,7 +27365,13 @@ var Footprinter3d = ({ footprint }) => {
           holes,
           holeInset,
           pinRowHoleEdgeToEdgeDist,
-          nopin: fpJson.nopin
+          nopin: fpJson.nopin,
+          female: fpJson.female,
+          screen: fpJson.screen,
+          screenWidth: fpJson.screenwidth,
+          screenHeight: fpJson.screenheight,
+          screenCenterOffsetX: fpJson.screencenteroffsetx,
+          screenCenterOffsetY: fpJson.screencenteroffsety
         }
       );
     }
@@ -28483,7 +28768,7 @@ import * as THREE16 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.522",
+  version: "0.0.524",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -28543,7 +28828,7 @@ var package_default = {
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
     debug: "^4.4.0",
-    "jscad-electronics": "^0.0.118",
+    "jscad-electronics": "^0.0.123",
     "jscad-planner": "^0.0.13",
     jsdom: "^26.0.0",
     "manifold-3d": "^3.2.1",
@@ -31452,7 +31737,7 @@ import { su as su8 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect23, useMemo as useMemo19 } from "react";
 
 // src/textures/create-combined-board-textures.ts
-import * as THREE27 from "three";
+import * as THREE28 from "three";
 
 // node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
 var getBoundsFromPoints = (points) => {
@@ -32401,12 +32686,11 @@ function createFabricationNoteTextureForLayer({
   return texture;
 }
 
-// src/textures/create-silkscreen-texture-for-layer.ts
+// src/textures/create-pcb-note-texture-for-layer.ts
 import * as THREE25 from "three";
 
-// src/textures/silkscreen/silkscreen-drawing.ts
+// src/textures/pcb-note/pcb-note-drawing.ts
 import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
-var FABRICATION_NOTE_COLOR2 = "rgb(255,243,204)";
 var TRANSPARENT2 = "rgba(0,0,0,0)";
 var setDrawerBounds3 = (drawer, bounds) => {
   drawer.setCameraBounds({
@@ -32416,14 +32700,75 @@ var setDrawerBounds3 = (drawer, bounds) => {
     maxY: bounds.maxY
   });
 };
-var drawSilkscreenLayer = ({
+var normalizePcbNoteElement = (element) => {
+  if (element.type === "pcb_note_line") {
+    return {
+      ...element,
+      x1: coerceDimensionToMm(element.x1, 0),
+      y1: coerceDimensionToMm(element.y1, 0),
+      x2: coerceDimensionToMm(element.x2, 0),
+      y2: coerceDimensionToMm(element.y2, 0),
+      stroke_width: coerceDimensionToMm(element.stroke_width, 0.1)
+    };
+  }
+  if (element.type === "pcb_note_rect") {
+    return {
+      ...element,
+      center: {
+        x: coerceDimensionToMm(element.center.x, 0),
+        y: coerceDimensionToMm(element.center.y, 0)
+      },
+      width: coerceDimensionToMm(element.width, 0),
+      height: coerceDimensionToMm(element.height, 0),
+      stroke_width: coerceDimensionToMm(element.stroke_width, 0.1),
+      corner_radius: coerceDimensionToMm(element.corner_radius, 0)
+    };
+  }
+  if (element.type === "pcb_note_text") {
+    return {
+      ...element,
+      anchor_position: {
+        x: coerceDimensionToMm(element.anchor_position.x, 0),
+        y: coerceDimensionToMm(element.anchor_position.y, 0)
+      },
+      font_size: coerceDimensionToMm(element.font_size, 1)
+    };
+  }
+  if (element.type === "pcb_note_path") {
+    return {
+      ...element,
+      route: element.route.map((point) => ({
+        ...point,
+        x: coerceDimensionToMm(point.x, 0),
+        y: coerceDimensionToMm(point.y, 0)
+      })),
+      stroke_width: coerceDimensionToMm(element.stroke_width, 0.1)
+    };
+  }
+  if (element.type === "pcb_note_dimension") {
+    return {
+      ...element,
+      from: {
+        x: coerceDimensionToMm(element.from.x, 0),
+        y: coerceDimensionToMm(element.from.y, 0)
+      },
+      to: {
+        x: coerceDimensionToMm(element.to.x, 0),
+        y: coerceDimensionToMm(element.to.y, 0)
+      },
+      font_size: coerceDimensionToMm(element.font_size, 1),
+      arrow_size: coerceDimensionToMm(element.arrow_size, 1),
+      offset_distance: coerceDimensionToMm(element.offset_distance, 0)
+    };
+  }
+  return element;
+};
+var drawPcbNoteLayer = ({
   ctx,
-  layer,
   bounds,
-  elements,
-  silkscreenColor
+  elements
 }) => {
-  const renderLayer = layer === "top" ? "top_silkscreen" : "bottom_silkscreen";
+  const normalizedElements = elements.map(normalizePcbNoteElement);
   const drawer = new CircuitToCanvasDrawer4(ctx);
   drawer.configure({
     colorOverrides: {
@@ -32437,29 +32782,130 @@ var drawSilkscreenLayer = ({
         inner5: TRANSPARENT2,
         inner6: TRANSPARENT2
       },
-      copperPour: {
-        top: TRANSPARENT2,
-        bottom: TRANSPARENT2
-      },
+      copperPour: { top: TRANSPARENT2, bottom: TRANSPARENT2 },
       drill: TRANSPARENT2,
       boardOutline: TRANSPARENT2,
       substrate: TRANSPARENT2,
       keepout: TRANSPARENT2,
-      courtyard: {
+      courtyard: { top: TRANSPARENT2, bottom: TRANSPARENT2 },
+      soldermask: { top: TRANSPARENT2, bottom: TRANSPARENT2 },
+      soldermaskWithCopperUnderneath: {
         top: TRANSPARENT2,
         bottom: TRANSPARENT2
       },
-      soldermask: {
+      soldermaskOverCopper: {
         top: TRANSPARENT2,
         bottom: TRANSPARENT2
       },
+      silkscreen: { top: TRANSPARENT2, bottom: TRANSPARENT2 },
+      fabricationNote: TRANSPARENT2
+    }
+  });
+  setDrawerBounds3(drawer, bounds);
+  drawer.drawElements(normalizedElements);
+};
+
+// src/textures/create-pcb-note-texture-for-layer.ts
+var isPcbNoteElement = (element, layer) => {
+  if (!("layer" in element) || element.layer !== layer) return false;
+  return element.type.startsWith("pcb_note_");
+};
+function createPcbNoteTextureForLayer({
+  layer,
+  circuitJson,
+  boardData,
+  traceTextureResolution = TRACE_TEXTURE_RESOLUTION
+}) {
+  const elements = circuitJson.filter(
+    (element) => isPcbNoteElement(element, layer)
+  );
+  if (elements.length === 0) return null;
+  const bounds = getSoldermaskRenderBounds(circuitJson, boardData);
+  const canvasWidth = Math.floor(bounds.width * traceTextureResolution);
+  const canvasHeight = Math.floor(bounds.height * traceTextureResolution);
+  if (canvasWidth <= 0 || canvasHeight <= 0) return null;
+  const canvas = document.createElement("canvas");
+  canvas.width = canvasWidth;
+  canvas.height = canvasHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return null;
+  if (layer === "bottom") {
+    ctx.translate(0, canvasHeight);
+    ctx.scale(1, -1);
+  }
+  drawPcbNoteLayer({
+    ctx,
+    bounds,
+    elements
+  });
+  const texture = new THREE25.CanvasTexture(canvas);
+  texture.generateMipmaps = true;
+  texture.minFilter = THREE25.LinearMipmapLinearFilter;
+  texture.magFilter = THREE25.LinearFilter;
+  texture.anisotropy = 16;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+// src/textures/create-silkscreen-texture-for-layer.ts
+import * as THREE26 from "three";
+
+// src/textures/silkscreen/silkscreen-drawing.ts
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
+var FABRICATION_NOTE_COLOR2 = "rgb(255,243,204)";
+var TRANSPARENT3 = "rgba(0,0,0,0)";
+var setDrawerBounds4 = (drawer, bounds) => {
+  drawer.setCameraBounds({
+    minX: bounds.minX,
+    maxX: bounds.maxX,
+    minY: bounds.minY,
+    maxY: bounds.maxY
+  });
+};
+var drawSilkscreenLayer = ({
+  ctx,
+  layer,
+  bounds,
+  elements,
+  silkscreenColor
+}) => {
+  const renderLayer = layer === "top" ? "top_silkscreen" : "bottom_silkscreen";
+  const drawer = new CircuitToCanvasDrawer5(ctx);
+  drawer.configure({
+    colorOverrides: {
+      copper: {
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3,
+        inner1: TRANSPARENT3,
+        inner2: TRANSPARENT3,
+        inner3: TRANSPARENT3,
+        inner4: TRANSPARENT3,
+        inner5: TRANSPARENT3,
+        inner6: TRANSPARENT3
+      },
+      copperPour: {
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3
+      },
+      drill: TRANSPARENT3,
+      boardOutline: TRANSPARENT3,
+      substrate: TRANSPARENT3,
+      keepout: TRANSPARENT3,
+      courtyard: {
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3
+      },
+      soldermask: {
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3
+      },
       soldermaskWithCopperUnderneath: {
-        top: TRANSPARENT2,
-        bottom: TRANSPARENT2
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3
       },
       soldermaskOverCopper: {
-        top: TRANSPARENT2,
-        bottom: TRANSPARENT2
+        top: TRANSPARENT3,
+        bottom: TRANSPARENT3
       },
       silkscreen: {
         top: silkscreenColor,
@@ -32468,7 +32914,7 @@ var drawSilkscreenLayer = ({
       fabricationNote: FABRICATION_NOTE_COLOR2
     }
   });
-  setDrawerBounds3(drawer, bounds);
+  setDrawerBounds4(drawer, bounds);
   drawer.drawElements(elements, {
     layers: [renderLayer]
   });
@@ -32478,7 +32924,7 @@ var drawSilkscreenLayer = ({
 var isSilkscreenElement = (element, layer) => {
   if (!("layer" in element) || element.layer !== layer) return false;
   const elementType = element.type;
-  return elementType.startsWith("pcb_silkscreen_") || elementType === "pcb_note_line";
+  return elementType.startsWith("pcb_silkscreen_");
 };
 function createSilkscreenTextureForLayer({
   layer,
@@ -32511,20 +32957,20 @@ function createSilkscreenTextureForLayer({
     elements,
     silkscreenColor
   });
-  const texture = new THREE25.CanvasTexture(canvas);
+  const texture = new THREE26.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE25.LinearMipmapLinearFilter;
-  texture.magFilter = THREE25.LinearFilter;
+  texture.minFilter = THREE26.LinearMipmapLinearFilter;
+  texture.magFilter = THREE26.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-soldermask-texture-for-layer.ts
-import * as THREE26 from "three";
+import * as THREE27 from "three";
 
 // src/textures/soldermask/soldermask-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
 var toRgb = (colorArr) => {
   const [r = 0, g = 0, b = 0] = colorArr;
   return `rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(
@@ -32543,7 +32989,7 @@ var getSoldermaskPalette = (material) => {
     transparent: "rgba(0,0,0,0)"
   };
 };
-var setDrawerBounds4 = (drawer, bounds) => {
+var setDrawerBounds5 = (drawer, bounds) => {
   drawer.setCameraBounds({
     minX: bounds.minX,
     maxX: bounds.maxX,
@@ -32560,7 +33006,7 @@ var drawSoldermaskLayer = ({
 }) => {
   const palette = getSoldermaskPalette(boardMaterial);
   const copperRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const drawer = new CircuitToCanvasDrawer5(ctx);
+  const drawer = new CircuitToCanvasDrawer6(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32591,7 +33037,7 @@ var drawSoldermaskLayer = ({
       }
     }
   });
-  setDrawerBounds4(drawer, bounds);
+  setDrawerBounds5(drawer, bounds);
   drawer.drawElements(elements, {
     layers: [copperRenderLayer],
     drawSoldermask: true,
@@ -32604,7 +33050,7 @@ var drawSoldermaskLayer = ({
   if (uncoveredPours.length > 0) {
     ctx.save();
     ctx.globalCompositeOperation = "destination-out";
-    const cutoutDrawer = new CircuitToCanvasDrawer5(ctx);
+    const cutoutDrawer = new CircuitToCanvasDrawer6(ctx);
     cutoutDrawer.configure({
       colorOverrides: {
         copper: {
@@ -32619,7 +33065,7 @@ var drawSoldermaskLayer = ({
         }
       }
     });
-    setDrawerBounds4(cutoutDrawer, bounds);
+    setDrawerBounds5(cutoutDrawer, bounds);
     cutoutDrawer.drawElements(uncoveredPours, { layers: [copperRenderLayer] });
     ctx.restore();
   }
@@ -32653,10 +33099,10 @@ function createSoldermaskTextureForLayer({
     elements,
     boardMaterial: boardData.material
   });
-  const texture = new THREE26.CanvasTexture(canvas);
+  const texture = new THREE27.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE26.LinearMipmapLinearFilter;
-  texture.magFilter = THREE26.LinearFilter;
+  texture.minFilter = THREE27.LinearMipmapLinearFilter;
+  texture.magFilter = THREE27.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
@@ -32694,10 +33140,10 @@ var createCombinedTexture = ({
     const image = texture.image;
     ctx.drawImage(image, 0, 0, canvasWidth, canvasHeight);
   });
-  const combinedTexture = new THREE27.CanvasTexture(canvas);
+  const combinedTexture = new THREE28.CanvasTexture(canvas);
   combinedTexture.generateMipmaps = false;
-  combinedTexture.minFilter = THREE27.LinearFilter;
-  combinedTexture.magFilter = THREE27.LinearFilter;
+  combinedTexture.minFilter = THREE28.LinearFilter;
+  combinedTexture.magFilter = THREE28.LinearFilter;
   combinedTexture.premultiplyAlpha = true;
   combinedTexture.anisotropy = 16;
   combinedTexture.needsUpdate = true;
@@ -32764,6 +33210,12 @@ function createCombinedBoardTextures({
       boardData,
       traceTextureResolution
     }) : null;
+    const pcbNoteTexture = showSilkscreen ? createPcbNoteTextureForLayer({
+      layer,
+      circuitJson,
+      boardData,
+      traceTextureResolution
+    }) : null;
     const panelOutlineTexture = showBoardBody ? createPanelOutlineTextureForLayer({
       layer,
       circuitJson,
@@ -32779,6 +33231,7 @@ function createCombinedBoardTextures({
         copperTextTexture,
         silkscreenTexture,
         fabricationNoteTexture,
+        pcbNoteTexture,
         panelOutlineTexture
       ],
       boardData,
@@ -32793,7 +33246,7 @@ function createCombinedBoardTextures({
 }
 
 // src/textures/create-three-texture-meshes.ts
-import * as THREE28 from "three";
+import * as THREE29 from "three";
 function createTexturePlane(config, boardData) {
   const {
     texture,
@@ -32805,15 +33258,15 @@ function createTexturePlane(config, boardData) {
   } = config;
   if (!texture) return null;
   const boardOutlineBounds = calculateOutlineBounds(boardData);
-  const planeGeom = new THREE28.PlaneGeometry(
+  const planeGeom = new THREE29.PlaneGeometry(
     boardOutlineBounds.width,
     boardOutlineBounds.height
   );
-  const material = new THREE28.MeshBasicMaterial({
+  const material = new THREE29.MeshBasicMaterial({
     map: texture,
     transparent: true,
     alphaTest: 0.08,
-    side: THREE28.DoubleSide,
+    side: THREE29.DoubleSide,
     depthWrite: true,
     polygonOffset: usePolygonOffset,
     polygonOffsetFactor: usePolygonOffset ? -4 : 0,
@@ -32821,7 +33274,7 @@ function createTexturePlane(config, boardData) {
     polygonOffsetUnits: usePolygonOffset ? -4 : 0,
     opacity: isFaux ? FAUX_BOARD_OPACITY : 1
   });
-  const mesh = new THREE28.Mesh(planeGeom, material);
+  const mesh = new THREE29.Mesh(planeGeom, material);
   mesh.position.set(
     boardOutlineBounds.centerX,
     boardOutlineBounds.centerY,
@@ -32866,7 +33319,7 @@ function createTextureMeshes(textures, boardData, pcbThickness, isFaux = false)
 }
 
 // src/three-components/JscadBoardTextures.tsx
-import * as THREE29 from "three";
+import * as THREE30 from "three";
 
 // src/utils/layer-texture-resolution.ts
 var DEFAULT_MAX_TEXTURE_PIXELS = 4e6;
@@ -32962,7 +33415,7 @@ function JscadBoardTextures({
       const typedMaterial = material;
       for (const prop of textureProps) {
         const texture = typedMaterial[prop];
-        if (texture && texture instanceof THREE29.Texture) {
+        if (texture && texture instanceof THREE30.Texture) {
           texture.dispose();
           typedMaterial[prop] = null;
         }
@@ -32972,22 +33425,22 @@ function JscadBoardTextures({
     const createTexturePlane2 = (texture, zOffset, isBottomLayer, name, usePolygonOffset = false, depthWrite = true, renderOrder = 1) => {
       if (!texture) return null;
       const boardOutlineBounds = calculateOutlineBounds(boardData);
-      const planeGeom = new THREE29.PlaneGeometry(
+      const planeGeom = new THREE30.PlaneGeometry(
         boardOutlineBounds.width,
         boardOutlineBounds.height
       );
-      const material = new THREE29.MeshBasicMaterial({
+      const material = new THREE30.MeshBasicMaterial({
         map: texture,
         transparent: true,
         alphaTest: 0.08,
-        side: THREE29.DoubleSide,
+        side: THREE30.DoubleSide,
         depthWrite,
         polygonOffset: usePolygonOffset,
         polygonOffsetFactor: usePolygonOffset ? -4 : 0,
         polygonOffsetUnits: usePolygonOffset ? -4 : 0,
         opacity: isFaux ? FAUX_BOARD_OPACITY : 1
       });
-      const mesh = new THREE29.Mesh(planeGeom, material);
+      const mesh = new THREE30.Mesh(planeGeom, material);
       mesh.position.set(
         boardOutlineBounds.centerX,
         boardOutlineBounds.centerY,
@@ -33032,7 +33485,7 @@ function JscadBoardTextures({
         mesh.geometry.dispose();
         if (Array.isArray(mesh.material)) {
           mesh.material.forEach((material) => disposeTextureMaterial(material));
-        } else if (mesh.material instanceof THREE29.Material) {
+        } else if (mesh.material instanceof THREE30.Material) {
           disposeTextureMaterial(mesh.material);
         }
       });
@@ -33265,12 +33718,12 @@ var CadViewerJscad = forwardRef3(
 // src/CadViewerManifold.tsx
 import { su as su17 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect25, useMemo as useMemo22, useState as useState16 } from "react";
-import * as THREE36 from "three";
+import * as THREE37 from "three";
 
 // src/hooks/useManifoldBoardBuilder.ts
 import { su as su16 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect24, useMemo as useMemo21, useRef as useRef9, useState as useState15 } from "react";
-import * as THREE33 from "three";
+import * as THREE34 from "three";
 
 // src/utils/manifold/create-manifold-board.ts
 var arePointsClockwise2 = (points) => {
@@ -33612,17 +34065,17 @@ function processNonPlatedHolesForManifold(Manifold, CrossSection, circuitJson, p
 
 // src/utils/manifold/process-plated-holes.ts
 import { su as su14 } from "@tscircuit/circuit-json-util";
-import * as THREE31 from "three";
+import * as THREE32 from "three";
 
 // src/utils/manifold-mesh-to-three-geometry.ts
-import * as THREE30 from "three";
+import * as THREE31 from "three";
 function manifoldMeshToThreeGeometry(manifoldMesh) {
-  const geometry = new THREE30.BufferGeometry();
+  const geometry = new THREE31.BufferGeometry();
   geometry.setAttribute(
     "position",
-    new THREE30.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
+    new THREE31.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
   );
-  geometry.setIndex(new THREE30.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
+  geometry.setIndex(new THREE31.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
   if (manifoldMesh.runIndex && manifoldMesh.runIndex.length > 1 && manifoldMesh.runOriginalID) {
     for (let i = 0; i < manifoldMesh.runIndex.length - 1; i++) {
       const start = manifoldMesh.runIndex[i];
@@ -33656,7 +34109,7 @@ var createEllipsePoints = (width10, height10, segments) => {
   }
   return points;
 };
-var COPPER_COLOR = new THREE31.Color(...colors.copper);
+var COPPER_COLOR = new THREE32.Color(...colors.copper);
 var PLATED_HOLE_LIP_HEIGHT = 0.05;
 var PLATED_HOLE_PAD_THICKNESS = 3e-3;
 var PLATED_HOLE_SURFACE_CLEARANCE = 5e-4;
@@ -34398,7 +34851,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
 
 // src/utils/manifold/process-vias.ts
 import { su as su15 } from "@tscircuit/circuit-json-util";
-import * as THREE32 from "three";
+import * as THREE33 from "three";
 
 // src/utils/via-geoms.ts
 function createViaCopper2({
@@ -34451,7 +34904,7 @@ function createViaCopper2({
 }
 
 // src/utils/manifold/process-vias.ts
-var COPPER_COLOR2 = new THREE32.Color(...colors.copper);
+var COPPER_COLOR2 = new THREE33.Color(...colors.copper);
 function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const viaBoardDrills = [];
   const pcbVias = su15(circuitJson).pcb_via.list();
@@ -34671,7 +35124,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
             {
               key: "plated-holes-union",
               geometry: cutPlatedGeom,
-              color: new THREE33.Color(
+              color: new THREE34.Color(
                 colors.copper[0],
                 colors.copper[1],
                 colors.copper[2]
@@ -34701,7 +35154,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
         const matColorArray = boardMaterialColors[boardData.material] ?? colors.fr4Tan;
         currentGeoms.board = {
           geometry: finalBoardGeom,
-          color: new THREE33.Color(
+          color: new THREE34.Color(
             matColorArray[0],
             matColorArray[1],
             matColorArray[2]
@@ -34746,11 +35199,11 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
 };
 
 // src/utils/manifold/create-three-geometry-meshes.ts
-import * as THREE35 from "three";
+import * as THREE36 from "three";
 
 // src/utils/create-board-material.ts
-import * as THREE34 from "three";
-var DEFAULT_SIDE = THREE34.DoubleSide;
+import * as THREE35 from "three";
+var DEFAULT_SIDE = THREE35.DoubleSide;
 var createBoardMaterial = ({
   material,
   color,
@@ -34758,7 +35211,7 @@ var createBoardMaterial = ({
   isFaux = false
 }) => {
   if (material === "fr4") {
-    return new THREE34.MeshPhysicalMaterial({
+    return new THREE35.MeshPhysicalMaterial({
       color,
       side,
       metalness: 0,
@@ -34775,7 +35228,7 @@ var createBoardMaterial = ({
       polygonOffsetUnits: 1
     });
   }
-  return new THREE34.MeshStandardMaterial({
+  return new THREE35.MeshStandardMaterial({
     color,
     side,
     flatShading: true,
@@ -34794,12 +35247,12 @@ function createGeometryMeshes(geoms) {
   const meshes = [];
   if (!geoms) return meshes;
   if (geoms.board && geoms.board.geometry) {
-    const mesh = new THREE35.Mesh(
+    const mesh = new THREE36.Mesh(
       geoms.board.geometry,
       createBoardMaterial({
         material: geoms.board.material,
         color: geoms.board.color,
-        side: THREE35.DoubleSide,
+        side: THREE36.DoubleSide,
         isFaux: geoms.board.isFaux
       })
     );
@@ -34809,11 +35262,11 @@ function createGeometryMeshes(geoms) {
   const createMeshesFromArray = (geomArray) => {
     if (geomArray) {
       geomArray.forEach((comp) => {
-        const mesh = new THREE35.Mesh(
+        const mesh = new THREE36.Mesh(
           comp.geometry,
-          new THREE35.MeshStandardMaterial({
+          new THREE36.MeshStandardMaterial({
             color: comp.color,
-            side: THREE35.DoubleSide,
+            side: THREE36.DoubleSide,
             flatShading: true
             // Consistent with board
           })
@@ -34857,7 +35310,7 @@ var BoardMeshes = ({
       const typedMaterial = material;
       for (const prop of textureProps) {
         const texture = typedMaterial[prop];
-        if (texture && texture instanceof THREE36.Texture) {
+        if (texture && texture instanceof THREE37.Texture) {
           texture.dispose();
           typedMaterial[prop] = null;
         }
@@ -41746,7 +42199,7 @@ var KeyboardShortcutsDialog = ({
 
 // src/CadViewer.tsx
 import { jsx as jsx38, jsxs as jsxs11 } from "react/jsx-runtime";
-var DEFAULT_TARGET = new THREE37.Vector3(0, 0, 0);
+var DEFAULT_TARGET = new THREE38.Vector3(0, 0, 0);
 var INITIAL_CAMERA_POSITION = [5, -5, 5];
 var CadViewerInner = (props) => {
   const [engine, setEngine] = useState36("manifold");
@@ -42013,11 +42466,11 @@ var CadViewer = (props) => {
 // src/convert-circuit-json-to-3d-svg.ts
 var import_debug = __toESM(require_browser(), 1);
 import { su as su18 } from "@tscircuit/circuit-json-util";
-import * as THREE41 from "three";
+import * as THREE42 from "three";
 import { SVGRenderer } from "three/examples/jsm/renderers/SVGRenderer.js";
 
 // src/utils/create-geometry-from-polygons.ts
-import * as THREE38 from "three";
+import * as THREE39 from "three";
 import { BufferGeometry as BufferGeometry4, Float32BufferAttribute as Float32BufferAttribute3 } from "three";
 function createGeometryFromPolygons(polygons) {
   const geometry = new BufferGeometry4();
@@ -42031,12 +42484,12 @@ function createGeometryFromPolygons(polygons) {
         ...polygon3.vertices[i + 1]
         // Third vertex
       );
-      const v1 = new THREE38.Vector3(...polygon3.vertices[0]);
-      const v2 = new THREE38.Vector3(...polygon3.vertices[i]);
-      const v3 = new THREE38.Vector3(...polygon3.vertices[i + 1]);
-      const normal = new THREE38.Vector3().crossVectors(
-        new THREE38.Vector3().subVectors(v2, v1),
-        new THREE38.Vector3().subVectors(v3, v1)
+      const v1 = new THREE39.Vector3(...polygon3.vertices[0]);
+      const v2 = new THREE39.Vector3(...polygon3.vertices[i]);
+      const v3 = new THREE39.Vector3(...polygon3.vertices[i + 1]);
+      const normal = new THREE39.Vector3().crossVectors(
+        new THREE39.Vector3().subVectors(v2, v1),
+        new THREE39.Vector3().subVectors(v3, v1)
       ).normalize();
       normals.push(
         normal.x,
@@ -42060,10 +42513,10 @@ function createGeometryFromPolygons(polygons) {
 var import_modeling2 = __toESM(require_src(), 1);
 var import_jscad_planner2 = __toESM(require_dist(), 1);
 var jscadModeling2 = __toESM(require_src(), 1);
-import * as THREE40 from "three";
+import * as THREE41 from "three";
 
 // src/utils/load-model.ts
-import * as THREE39 from "three";
+import * as THREE40 from "three";
 import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { OBJLoader as OBJLoader2 } from "three/examples/jsm/loaders/OBJLoader.js";
 import { STLLoader as STLLoader2 } from "three/examples/jsm/loaders/STLLoader.js";
@@ -42071,12 +42524,12 @@ async function load3DModel(url) {
   if (url.endsWith(".stl")) {
     const loader = new STLLoader2();
     const geometry = await loader.loadAsync(url);
-    const material = new THREE39.MeshStandardMaterial({
+    const material = new THREE40.MeshStandardMaterial({
       color: 8947848,
       metalness: 0.5,
       roughness: 0.5
     });
-    return new THREE39.Mesh(geometry, material);
+    return new THREE40.Mesh(geometry, material);
   }
   if (url.endsWith(".obj")) {
     const loader = new OBJLoader2();
@@ -42109,9 +42562,9 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         model.rotation.set(
-          THREE40.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE41.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(model);
@@ -42125,13 +42578,13 @@ async function renderComponent(component, scene) {
     );
     if (jscadObject && (jscadObject.polygons || jscadObject.sides)) {
       const threeGeom = convertCSGToThreeGeom(jscadObject);
-      const material2 = new THREE40.MeshStandardMaterial({
+      const material2 = new THREE41.MeshStandardMaterial({
         color: 8947848,
         metalness: 0.5,
         roughness: 0.5,
-        side: THREE40.DoubleSide
+        side: THREE41.DoubleSide
       });
-      const mesh2 = new THREE40.Mesh(threeGeom, material2);
+      const mesh2 = new THREE41.Mesh(threeGeom, material2);
       if (component.position) {
         mesh2.position.set(
           component.position.x ?? 0,
@@ -42141,9 +42594,9 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         mesh2.rotation.set(
-          THREE40.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE41.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(mesh2);
@@ -42160,17 +42613,17 @@ async function renderComponent(component, scene) {
       if (!geom || !geom.polygons && !geom.sides) {
         continue;
       }
-      const color = new THREE40.Color(geomInfo.color);
+      const color = new THREE41.Color(geomInfo.color);
       color.convertLinearToSRGB();
       const geomWithColor = { ...geom, color: [color.r, color.g, color.b] };
       const threeGeom = convertCSGToThreeGeom(geomWithColor);
-      const material2 = new THREE40.MeshStandardMaterial({
+      const material2 = new THREE41.MeshStandardMaterial({
         vertexColors: true,
         metalness: 0.2,
         roughness: 0.8,
-        side: THREE40.DoubleSide
+        side: THREE41.DoubleSide
       });
-      const mesh2 = new THREE40.Mesh(threeGeom, material2);
+      const mesh2 = new THREE41.Mesh(threeGeom, material2);
       if (component.position) {
         mesh2.position.set(
           component.position.x ?? 0,
@@ -42180,22 +42633,22 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         mesh2.rotation.set(
-          THREE40.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE40.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE41.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE41.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(mesh2);
     }
     return;
   }
-  const geometry = new THREE40.BoxGeometry(0.5, 0.5, 0.5);
-  const material = new THREE40.MeshStandardMaterial({
+  const geometry = new THREE41.BoxGeometry(0.5, 0.5, 0.5);
+  const material = new THREE41.MeshStandardMaterial({
     color: 16711680,
     transparent: true,
     opacity: 0.25
   });
-  const mesh = new THREE40.Mesh(geometry, material);
+  const mesh = new THREE41.Mesh(geometry, material);
   if (component.position) {
     mesh.position.set(
       component.position.x ?? 0,
@@ -42216,11 +42669,11 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
     padding = 20,
     zoom = 1.5
   } = options;
-  const scene = new THREE41.Scene();
+  const scene = new THREE42.Scene();
   const renderer = new SVGRenderer();
   renderer.setSize(width10, height10);
-  renderer.setClearColor(new THREE41.Color(backgroundColor), 1);
-  const camera = new THREE41.OrthographicCamera();
+  renderer.setClearColor(new THREE42.Color(backgroundColor), 1);
+  const camera = new THREE42.OrthographicCamera();
   const aspect = width10 / height10;
   const frustumSize = 100;
   const halfFrustumSize = frustumSize / 2 / zoom;
@@ -42234,11 +42687,11 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
   camera.position.set(position.x, position.y, position.z);
   camera.up.set(0, 1, 0);
   const lookAt = options.camera?.lookAt ?? { x: 0, y: 0, z: 0 };
-  camera.lookAt(new THREE41.Vector3(lookAt.x, lookAt.y, lookAt.z));
+  camera.lookAt(new THREE42.Vector3(lookAt.x, lookAt.y, lookAt.z));
   camera.updateProjectionMatrix();
-  const ambientLight = new THREE41.AmbientLight(16777215, Math.PI / 2);
+  const ambientLight = new THREE42.AmbientLight(16777215, Math.PI / 2);
   scene.add(ambientLight);
-  const pointLight = new THREE41.PointLight(16777215, Math.PI / 4);
+  const pointLight = new THREE42.PointLight(16777215, Math.PI / 4);
   pointLight.position.set(-10, -10, 10);
   scene.add(pointLight);
   const components = su18(circuitJson).cad_component.list();
@@ -42249,7 +42702,7 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
   const boardGeom = createBoardGeomFromCircuitJson(circuitJson);
   if (boardGeom) {
     const solderMaskColor = colors.fr4SolderMaskGreen;
-    const baseColor = new THREE41.Color(
+    const baseColor = new THREE42.Color(
       solderMaskColor[0],
       solderMaskColor[1],
       solderMaskColor[2]
@@ -42261,28 +42714,28 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
       const material = createBoardMaterial({
         material: boardData?.material,
         color: baseColor,
-        side: THREE41.DoubleSide
+        side: THREE42.DoubleSide
       });
-      const mesh = new THREE41.Mesh(geometry, material);
+      const mesh = new THREE42.Mesh(geometry, material);
       scene.add(mesh);
     }
   }
-  const gridColor = new THREE41.Color(8947848);
-  const gridHelper = new THREE41.GridHelper(100, 100, gridColor, gridColor);
+  const gridColor = new THREE42.Color(8947848);
+  const gridHelper = new THREE42.GridHelper(100, 100, gridColor, gridColor);
   gridHelper.rotation.x = Math.PI / 2;
   const materials = Array.isArray(gridHelper.material) ? gridHelper.material : [gridHelper.material];
   for (const mat of materials) {
     mat.transparent = true;
     mat.opacity = 0.3;
-    if (mat instanceof THREE41.LineBasicMaterial) {
+    if (mat instanceof THREE42.LineBasicMaterial) {
       mat.color = gridColor;
       mat.vertexColors = false;
     }
   }
   scene.add(gridHelper);
-  const box = new THREE41.Box3().setFromObject(scene);
-  const center = box.getCenter(new THREE41.Vector3());
-  const size4 = box.getSize(new THREE41.Vector3());
+  const box = new THREE42.Box3().setFromObject(scene);
+  const center = box.getCenter(new THREE42.Vector3());
+  const size4 = box.getSize(new THREE42.Vector3());
   scene.position.sub(center);
   const maxDim = Math.max(size4.x, size4.y, size4.z);
   if (maxDim > 0) {