@tscircuit/3d-viewer 0.0.524 → 0.0.526

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()
     };
@@ -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.523",
+  version: "0.0.525",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -28513,7 +28798,7 @@ var package_default = {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
     "circuit-json": "^0.0.372",
-    "circuit-to-canvas": "^0.0.81",
+    "circuit-to-canvas": "^0.0.83",
     "react-hot-toast": "^2.6.0",
     three: "^0.165.0",
     "three-stdlib": "^2.36.0",
@@ -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 THREE28 from "three";
+import * as THREE27 from "three";
 
 // node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
 var getBoundsFromPoints = (points) => {
@@ -31948,227 +32233,11 @@ function createCopperTextTextureForLayer({
   return texture;
 }
 
-// src/textures/create-copper-pour-texture-for-layer.ts
-import * as THREE23 from "three";
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer2 } from "circuit-to-canvas";
-
-// src/geoms/brep-converter.ts
-var import_primitives7 = __toESM(require_primitives(), 1);
-var import_booleans5 = __toESM(require_booleans(), 1);
-function segmentToPoints(p1, p2, bulge, arcSegments) {
-  if (!bulge || Math.abs(bulge) < 1e-9) {
-    return [];
-  }
-  const theta = 4 * Math.atan(bulge);
-  const dx = p2[0] - p1[0];
-  const dy = p2[1] - p1[1];
-  const dist = Math.sqrt(dx * dx + dy * dy);
-  if (dist < 1e-9) return [];
-  const radius = Math.abs(dist / (2 * Math.sin(theta / 2)));
-  const m = Math.sqrt(Math.max(0, radius * radius - dist / 2 * (dist / 2)));
-  const midPoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
-  const ux = dx / dist;
-  const uy = dy / dist;
-  const nx = -uy;
-  const ny = ux;
-  const centerX = midPoint[0] + nx * m * Math.sign(bulge);
-  const centerY = midPoint[1] + ny * m * Math.sign(bulge);
-  const startAngle = Math.atan2(p1[1] - centerY, p1[0] - centerX);
-  const points = [];
-  const numSteps = Math.max(
-    2,
-    Math.ceil(arcSegments * Math.abs(theta) / (Math.PI * 2) * 4)
-  );
-  const angleStep = theta / numSteps;
-  for (let i = 1; i < numSteps; i++) {
-    const angle = startAngle + angleStep * i;
-    points.push([
-      centerX + radius * Math.cos(angle),
-      centerY + radius * Math.sin(angle)
-    ]);
-  }
-  return points;
-}
-function ringToPoints(ring, arcSegments) {
-  const allPoints = [];
-  const vertices = ring.vertices;
-  for (let i = 0; i < vertices.length; i++) {
-    const p1 = vertices[i];
-    const p2 = vertices[(i + 1) % vertices.length];
-    allPoints.push([p1.x, p1.y]);
-    if (p1.bulge) {
-      const arcPoints = segmentToPoints(
-        [p1.x, p1.y],
-        [p2.x, p2.y],
-        p1.bulge,
-        arcSegments
-      );
-      allPoints.push(...arcPoints);
-    }
-  }
-  return allPoints;
-}
-
-// src/textures/create-copper-pour-texture-for-layer.ts
-function drawPolygon({
-  ctx,
-  points,
-  canvasXFromPcb,
-  canvasYFromPcb
-}) {
-  if (points.length < 3) return;
-  ctx.beginPath();
-  points.forEach((point, index2) => {
-    const canvasX = canvasXFromPcb(point[0]);
-    const canvasY = canvasYFromPcb(point[1]);
-    if (index2 === 0) {
-      ctx.moveTo(canvasX, canvasY);
-    } else {
-      ctx.lineTo(canvasX, canvasY);
-    }
-  });
-  ctx.closePath();
-  ctx.fill();
-}
-function drawBrepShape({
-  ctx,
-  pour,
-  canvasXFromPcb,
-  canvasYFromPcb
-}) {
-  const brepShape = pour.brep_shape;
-  if (!brepShape || !brepShape.outer_ring) return;
-  const outerRingPoints = ringToPoints(brepShape.outer_ring, 32);
-  if (outerRingPoints.length >= 3) {
-    drawPolygon({
-      ctx,
-      points: outerRingPoints,
-      canvasXFromPcb,
-      canvasYFromPcb
-    });
-  }
-  if (brepShape.inner_rings && brepShape.inner_rings.length > 0) {
-    ctx.globalCompositeOperation = "destination-out";
-    for (const innerRing of brepShape.inner_rings) {
-      const innerRingPoints = ringToPoints(innerRing, 32);
-      if (innerRingPoints.length >= 3) {
-        drawPolygon({
-          ctx,
-          points: innerRingPoints,
-          canvasXFromPcb,
-          canvasYFromPcb
-        });
-      }
-    }
-    ctx.globalCompositeOperation = "source-over";
-  }
-}
-function createCopperPourTextureForLayer({
-  layer,
-  circuitJson,
-  boardData,
-  traceTextureResolution = TRACE_TEXTURE_RESOLUTION
-}) {
-  const copperPours = circuitJson.filter(
-    (e) => e.type === "pcb_copper_pour"
-  );
-  const pcbRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const poursOnLayer = copperPours.filter((p) => p.layer === layer);
-  if (poursOnLayer.length === 0) return null;
-  const boardOutlineBounds = calculateOutlineBounds(boardData);
-  const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(
-    boardOutlineBounds.width * traceTextureResolution
-  );
-  const canvasHeight = Math.floor(
-    boardOutlineBounds.height * traceTextureResolution
-  );
-  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);
-  }
-  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
-  const rectAndPolygonPours = poursOnLayer.filter(
-    (pour) => pour.shape === "rect" || pour.shape === "polygon"
-  );
-  const brepPours = poursOnLayer.filter((pour) => pour.shape === "brep");
-  if (rectAndPolygonPours.length > 0) {
-    const drawer = new CircuitToCanvasDrawer2(ctx);
-    drawer.setCameraBounds({
-      minX: boardOutlineBounds.minX,
-      maxX: boardOutlineBounds.maxX,
-      minY: boardOutlineBounds.minY,
-      maxY: boardOutlineBounds.maxY
-    });
-    const coveredPours = rectAndPolygonPours.filter(
-      (p) => p.covered_with_solder_mask !== false
-    );
-    const uncoveredPours = rectAndPolygonPours.filter(
-      (p) => p.covered_with_solder_mask === false
-    );
-    const coveredColor = `rgb(${colors.fr4TracesWithMaskGreen.map((c) => c * 255).join(",")})`;
-    const uncoveredColor = `rgb(${colors.copper.map((c) => c * 255).join(",")})`;
-    if (coveredPours.length > 0) {
-      drawer.configure({
-        colorOverrides: {
-          copper: {
-            top: coveredColor,
-            bottom: coveredColor,
-            inner1: coveredColor,
-            inner2: coveredColor,
-            inner3: coveredColor,
-            inner4: coveredColor,
-            inner5: coveredColor,
-            inner6: coveredColor
-          }
-        }
-      });
-      drawer.drawElements(coveredPours, { layers: [pcbRenderLayer] });
-    }
-    if (uncoveredPours.length > 0) {
-      drawer.configure({
-        colorOverrides: {
-          copper: {
-            top: uncoveredColor,
-            bottom: uncoveredColor,
-            inner1: uncoveredColor,
-            inner2: uncoveredColor,
-            inner3: uncoveredColor,
-            inner4: uncoveredColor,
-            inner5: uncoveredColor,
-            inner6: uncoveredColor
-          }
-        }
-      });
-      drawer.drawElements(uncoveredPours, { layers: [pcbRenderLayer] });
-    }
-  }
-  for (const pour of brepPours) {
-    const covered = pour.covered_with_solder_mask !== false;
-    const colorArr = covered ? colors.fr4TracesWithMaskGreen : colors.copper;
-    const copperColor = `rgb(${colorArr[0] * 255}, ${colorArr[1] * 255}, ${colorArr[2] * 255})`;
-    ctx.fillStyle = copperColor;
-    drawBrepShape({ ctx, pour, canvasXFromPcb, canvasYFromPcb });
-  }
-  const texture = new THREE23.CanvasTexture(canvas);
-  texture.generateMipmaps = true;
-  texture.minFilter = THREE23.LinearMipmapLinearFilter;
-  texture.magFilter = THREE23.LinearFilter;
-  texture.anisotropy = 16;
-  texture.needsUpdate = true;
-  return texture;
-}
-
 // src/textures/create-fabrication-note-texture-for-layer.ts
-import * as THREE24 from "three";
+import * as THREE23 from "three";
 
 // src/textures/fabrication-note/fabrication-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer3 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer2 } from "circuit-to-canvas";
 
 // src/utils/units.ts
 var MM_PER_INCH = 25.4;
@@ -32266,7 +32335,7 @@ var drawFabricationNoteLayer = ({
 }) => {
   const renderLayer = `${layer}_fabrication_note`;
   const normalizedElements = elements.map(normalizeFabricationElement);
-  const drawer = new CircuitToCanvasDrawer3(ctx);
+  const drawer = new CircuitToCanvasDrawer2(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32392,20 +32461,20 @@ function createFabricationNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE24.CanvasTexture(canvas);
+  const texture = new THREE23.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE24.LinearMipmapLinearFilter;
-  texture.magFilter = THREE24.LinearFilter;
+  texture.minFilter = THREE23.LinearMipmapLinearFilter;
+  texture.magFilter = THREE23.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-pcb-note-texture-for-layer.ts
-import * as THREE25 from "three";
+import * as THREE24 from "three";
 
 // src/textures/pcb-note/pcb-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer3 } from "circuit-to-canvas";
 var TRANSPARENT2 = "rgba(0,0,0,0)";
 var setDrawerBounds3 = (drawer, bounds) => {
   drawer.setCameraBounds({
@@ -32484,7 +32553,7 @@ var drawPcbNoteLayer = ({
   elements
 }) => {
   const normalizedElements = elements.map(normalizePcbNoteElement);
-  const drawer = new CircuitToCanvasDrawer4(ctx);
+  const drawer = new CircuitToCanvasDrawer3(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32553,20 +32622,20 @@ function createPcbNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE25.CanvasTexture(canvas);
+  const texture = new THREE24.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE25.LinearMipmapLinearFilter;
-  texture.magFilter = THREE25.LinearFilter;
+  texture.minFilter = THREE24.LinearMipmapLinearFilter;
+  texture.magFilter = THREE24.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-silkscreen-texture-for-layer.ts
-import * as THREE26 from "three";
+import * as THREE25 from "three";
 
 // src/textures/silkscreen/silkscreen-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
 var FABRICATION_NOTE_COLOR2 = "rgb(255,243,204)";
 var TRANSPARENT3 = "rgba(0,0,0,0)";
 var setDrawerBounds4 = (drawer, bounds) => {
@@ -32585,7 +32654,7 @@ var drawSilkscreenLayer = ({
   silkscreenColor
 }) => {
   const renderLayer = layer === "top" ? "top_silkscreen" : "bottom_silkscreen";
-  const drawer = new CircuitToCanvasDrawer5(ctx);
+  const drawer = new CircuitToCanvasDrawer4(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32672,20 +32741,20 @@ function createSilkscreenTextureForLayer({
     elements,
     silkscreenColor
   });
-  const texture = new THREE26.CanvasTexture(canvas);
+  const texture = new THREE25.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE26.LinearMipmapLinearFilter;
-  texture.magFilter = THREE26.LinearFilter;
+  texture.minFilter = THREE25.LinearMipmapLinearFilter;
+  texture.magFilter = THREE25.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-soldermask-texture-for-layer.ts
-import * as THREE27 from "three";
+import * as THREE26 from "three";
 
 // src/textures/soldermask/soldermask-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } 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(
@@ -32721,7 +32790,7 @@ var drawSoldermaskLayer = ({
 }) => {
   const palette = getSoldermaskPalette(boardMaterial);
   const copperRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const drawer = new CircuitToCanvasDrawer6(ctx);
+  const drawer = new CircuitToCanvasDrawer5(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32765,7 +32834,7 @@ var drawSoldermaskLayer = ({
   if (uncoveredPours.length > 0) {
     ctx.save();
     ctx.globalCompositeOperation = "destination-out";
-    const cutoutDrawer = new CircuitToCanvasDrawer6(ctx);
+    const cutoutDrawer = new CircuitToCanvasDrawer5(ctx);
     cutoutDrawer.configure({
       colorOverrides: {
         copper: {
@@ -32814,10 +32883,10 @@ function createSoldermaskTextureForLayer({
     elements,
     boardMaterial: boardData.material
   });
-  const texture = new THREE27.CanvasTexture(canvas);
+  const texture = new THREE26.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE27.LinearMipmapLinearFilter;
-  texture.magFilter = THREE27.LinearFilter;
+  texture.minFilter = THREE26.LinearMipmapLinearFilter;
+  texture.magFilter = THREE26.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
@@ -32855,10 +32924,10 @@ var createCombinedTexture = ({
     const image = texture.image;
     ctx.drawImage(image, 0, 0, canvasWidth, canvasHeight);
   });
-  const combinedTexture = new THREE28.CanvasTexture(canvas);
+  const combinedTexture = new THREE27.CanvasTexture(canvas);
   combinedTexture.generateMipmaps = false;
-  combinedTexture.minFilter = THREE28.LinearFilter;
-  combinedTexture.magFilter = THREE28.LinearFilter;
+  combinedTexture.minFilter = THREE27.LinearFilter;
+  combinedTexture.magFilter = THREE27.LinearFilter;
   combinedTexture.premultiplyAlpha = true;
   combinedTexture.anisotropy = 16;
   combinedTexture.needsUpdate = true;
@@ -32899,12 +32968,6 @@ function createCombinedBoardTextures({
       copperColor,
       traceTextureResolution
     }) : null;
-    const copperPourTexture = showCopper ? createCopperPourTextureForLayer({
-      layer,
-      circuitJson,
-      boardData,
-      traceTextureResolution
-    }) : null;
     const padTexture = showCopper ? createPadTextureForLayer({
       layer,
       circuitJson,
@@ -32939,7 +33002,6 @@ function createCombinedBoardTextures({
     }) : null;
     return createCombinedTexture({
       textures: [
-        copperPourTexture,
         traceTexture,
         padTexture,
         soldermaskTexture,
@@ -32960,6 +33022,14 @@ function createCombinedBoardTextures({
   };
 }
 
+// src/textures/create-copper-pour-texture-for-layer.ts
+import * as THREE28 from "three";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
+
+// src/geoms/brep-converter.ts
+var import_primitives7 = __toESM(require_primitives(), 1);
+var import_booleans5 = __toESM(require_booleans(), 1);
+
 // src/textures/create-three-texture-meshes.ts
 import * as THREE29 from "three";
 function createTexturePlane(config, boardData) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.524",
+  "version": "0.0.526",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",
@@ -30,7 +30,7 @@
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
     "circuit-json": "^0.0.372",
-    "circuit-to-canvas": "^0.0.81",
+    "circuit-to-canvas": "^0.0.83",
     "react-hot-toast": "^2.6.0",
     "three": "^0.165.0",
     "three-stdlib": "^2.36.0",
@@ -60,7 +60,7 @@
     "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",