@tscircuit/3d-viewer 0.0.524 → 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()
     };
@@ -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.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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.524",
+  "version": "0.0.525",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",
@@ -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",