circuit-json-to-step 0.0.21 → 0.0.23

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   AdvancedFace as AdvancedFace3,
   Circle as Circle2,
   ClosedShell as ClosedShell2,
-  ManifoldSolidBrep as ManifoldSolidBrep3,
+  ManifoldSolidBrep as ManifoldSolidBrep4,
   ColourRgb,
   FillAreaStyleColour,
   FillAreaStyle,
@@ -41,192 +41,204 @@ import {
 } from "stepts";
 
 // lib/mesh-generation.ts
+import "stepts";
+
+// lib/scene-box-to-step.ts
+import { ClosedShell, ManifoldSolidBrep } from "stepts";
+
+// lib/scene-geometry.ts
+function rotatePoint3(point, rotation) {
+  if (!rotation) return point;
+  let { x, y, z } = point;
+  if (rotation.x) {
+    const cos = Math.cos(rotation.x);
+    const sin = Math.sin(rotation.x);
+    const nextY = y * cos - z * sin;
+    const nextZ = y * sin + z * cos;
+    y = nextY;
+    z = nextZ;
+  }
+  if (rotation.y) {
+    const cos = Math.cos(rotation.y);
+    const sin = Math.sin(rotation.y);
+    const nextX = x * cos + z * sin;
+    const nextZ = -x * sin + z * cos;
+    x = nextX;
+    z = nextZ;
+  }
+  if (rotation.z) {
+    const cos = Math.cos(rotation.z);
+    const sin = Math.sin(rotation.z);
+    const nextX = x * cos - y * sin;
+    const nextY = x * sin + y * cos;
+    x = nextX;
+    y = nextY;
+  }
+  return { x, y, z };
+}
+
+// lib/step-brep-utils.ts
 import {
   AdvancedFace,
   Axis2Placement3D,
   CartesianPoint,
-  ClosedShell,
   Direction,
   EdgeCurve,
   EdgeLoop,
   FaceOuterBound,
   Line,
-  ManifoldSolidBrep,
   OrientedEdge,
   Plane,
   Vector,
   VertexPoint
 } from "stepts";
-function createBoxTriangles(box) {
-  const { center, size } = box;
-  const halfX = size.x / 2;
-  const halfY = size.y / 2;
-  const halfZ = size.z / 2;
-  const corners = [
-    { x: -halfX, y: -halfY, z: -halfZ },
-    { x: halfX, y: -halfY, z: -halfZ },
-    { x: halfX, y: halfY, z: -halfZ },
-    { x: -halfX, y: halfY, z: -halfZ },
-    { x: -halfX, y: -halfY, z: halfZ },
-    { x: halfX, y: -halfY, z: halfZ },
-    { x: halfX, y: halfY, z: halfZ },
-    { x: -halfX, y: halfY, z: halfZ }
-  ].map((p) => ({ x: p.x + center.x, y: p.y + center.y, z: p.z + center.z }));
-  const triangles = [
-    // Bottom face (z = -halfZ)
-    {
-      vertices: [corners[0], corners[1], corners[2]],
-      normal: { x: 0, y: 0, z: -1 }
-    },
-    {
-      vertices: [corners[0], corners[2], corners[3]],
-      normal: { x: 0, y: 0, z: -1 }
-    },
-    // Top face (z = halfZ)
-    {
-      vertices: [corners[4], corners[6], corners[5]],
-      normal: { x: 0, y: 0, z: 1 }
-    },
-    {
-      vertices: [corners[4], corners[7], corners[6]],
-      normal: { x: 0, y: 0, z: 1 }
-    },
-    // Front face (y = -halfY)
-    {
-      vertices: [corners[0], corners[5], corners[1]],
-      normal: { x: 0, y: -1, z: 0 }
-    },
-    {
-      vertices: [corners[0], corners[4], corners[5]],
-      normal: { x: 0, y: -1, z: 0 }
-    },
-    // Back face (y = halfY)
-    {
-      vertices: [corners[2], corners[6], corners[7]],
-      normal: { x: 0, y: 1, z: 0 }
-    },
-    {
-      vertices: [corners[2], corners[7], corners[3]],
-      normal: { x: 0, y: 1, z: 0 }
-    },
-    // Left face (x = -halfX)
-    {
-      vertices: [corners[0], corners[3], corners[7]],
-      normal: { x: -1, y: 0, z: 0 }
-    },
-    {
-      vertices: [corners[0], corners[7], corners[4]],
-      normal: { x: -1, y: 0, z: 0 }
-    },
-    // Right face (x = halfX)
-    {
-      vertices: [corners[1], corners[6], corners[2]],
-      normal: { x: 1, y: 0, z: 0 }
+function createVertex(repo, point) {
+  return repo.add(
+    new VertexPoint(
+      "",
+      repo.add(new CartesianPoint("", point.x, point.y, point.z))
+    )
+  );
+}
+function createEdge(repo, vStart, vEnd) {
+  const pStart = vStart.resolve(repo).pnt.resolve(repo);
+  const pEnd = vEnd.resolve(repo).pnt.resolve(repo);
+  const dx = pEnd.x - pStart.x;
+  const dy = pEnd.y - pStart.y;
+  const dz = pEnd.z - pStart.z;
+  const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (length < 1e-10) {
+    const dir2 = repo.add(new Direction("", 1, 0, 0));
+    const vec2 = repo.add(new Vector("", dir2, 1e-10));
+    const line2 = repo.add(new Line("", vStart.resolve(repo).pnt, vec2));
+    return repo.add(new EdgeCurve("", vStart, vEnd, line2, true));
+  }
+  const dir = repo.add(new Direction("", dx / length, dy / length, dz / length));
+  const vec = repo.add(new Vector("", dir, length));
+  const line = repo.add(new Line("", vStart.resolve(repo).pnt, vec));
+  return repo.add(new EdgeCurve("", vStart, vEnd, line, true));
+}
+function createFaceFromVertices(repo, vertices) {
+  const edges = vertices.map(
+    (vertex, index) => createEdge(repo, vertex, vertices[(index + 1) % vertices.length])
+  );
+  const edgeLoop = repo.add(
+    new EdgeLoop(
+      "",
+      edges.map((edge) => repo.add(new OrientedEdge("", edge, true)))
+    )
+  );
+  const p1 = vertices[0].resolve(repo).pnt.resolve(repo);
+  const p2 = vertices[1].resolve(repo).pnt.resolve(repo);
+  const p3 = vertices[2].resolve(repo).pnt.resolve(repo);
+  const ux = p2.x - p1.x;
+  const uy = p2.y - p1.y;
+  const uz = p2.z - p1.z;
+  const vx = p3.x - p1.x;
+  const vy = p3.y - p1.y;
+  const vz = p3.z - p1.z;
+  const nx = uy * vz - uz * vy;
+  const ny = uz * vx - ux * vz;
+  const nz = ux * vy - uy * vx;
+  const normalLength = Math.sqrt(nx * nx + ny * ny + nz * nz);
+  const normal = normalLength < 1e-10 ? repo.add(new Direction("", 0, 0, 1)) : repo.add(
+    new Direction(
+      "",
+      nx / normalLength,
+      ny / normalLength,
+      nz / normalLength
+    )
+  );
+  const refLength = Math.sqrt(ux * ux + uy * uy + uz * uz);
+  const refDir = refLength < 1e-10 ? repo.add(new Direction("", 1, 0, 0)) : repo.add(
+    new Direction("", ux / refLength, uy / refLength, uz / refLength)
+  );
+  const placement = repo.add(
+    new Axis2Placement3D("", vertices[0].resolve(repo).pnt, normal, refDir)
+  );
+  const plane = repo.add(new Plane("", placement));
+  return repo.add(
+    new AdvancedFace(
+      "",
+      [repo.add(new FaceOuterBound("", edgeLoop, true))],
+      plane,
+      true
+    )
+  );
+}
+
+// lib/scene-box-to-step.ts
+function createSceneBoxSolid(repo, box) {
+  if (box.mesh?.triangles?.length) {
+    return createSceneMeshSolid(repo, box);
+  }
+  const localBounds = box.mesh?.boundingBox ? {
+    min: box.mesh.boundingBox.min,
+    max: box.mesh.boundingBox.max
+  } : {
+    min: {
+      x: -box.size.x / 2,
+      y: -box.size.y / 2,
+      z: -box.size.z / 2
     },
-    {
-      vertices: [corners[1], corners[5], corners[6]],
-      normal: { x: 1, y: 0, z: 0 }
+    max: {
+      x: box.size.x / 2,
+      y: box.size.y / 2,
+      z: box.size.z / 2
     }
-  ];
-  return triangles;
-}
-function createStepFacesFromTriangles(repo, triangles) {
-  const faces = [];
-  for (const triangle of triangles) {
-    const v1 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[0].x,
-            triangle.vertices[0].y,
-            triangle.vertices[0].z
-          )
-        )
-      )
-    );
-    const v2 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[1].x,
-            triangle.vertices[1].y,
-            triangle.vertices[1].z
-          )
-        )
-      )
-    );
-    const v3 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[2].x,
-            triangle.vertices[2].y,
-            triangle.vertices[2].z
-          )
-        )
-      )
-    );
-    const p1 = v1.resolve(repo).pnt.resolve(repo);
-    const p2 = v2.resolve(repo).pnt.resolve(repo);
-    const createEdge = (vStart, vEnd) => {
-      const pStart = vStart.resolve(repo).pnt.resolve(repo);
-      const pEnd = vEnd.resolve(repo).pnt.resolve(repo);
-      const dir = repo.add(
-        new Direction(
-          "",
-          pEnd.x - pStart.x,
-          pEnd.y - pStart.y,
-          pEnd.z - pStart.z
-        )
-      );
-      const vec = repo.add(new Vector("", dir, 1));
-      const line = repo.add(new Line("", vStart.resolve(repo).pnt, vec));
-      return repo.add(new EdgeCurve("", vStart, vEnd, line, true));
+  };
+  const corners = [
+    { x: localBounds.min.x, y: localBounds.min.y, z: localBounds.min.z },
+    { x: localBounds.max.x, y: localBounds.min.y, z: localBounds.min.z },
+    { x: localBounds.max.x, y: localBounds.max.y, z: localBounds.min.z },
+    { x: localBounds.min.x, y: localBounds.max.y, z: localBounds.min.z },
+    { x: localBounds.min.x, y: localBounds.min.y, z: localBounds.max.z },
+    { x: localBounds.max.x, y: localBounds.min.y, z: localBounds.max.z },
+    { x: localBounds.max.x, y: localBounds.max.y, z: localBounds.max.z },
+    { x: localBounds.min.x, y: localBounds.max.y, z: localBounds.max.z }
+  ].map((corner) => {
+    const rotated = rotatePoint3(corner, box.rotation);
+    return {
+      x: rotated.x + box.center.x,
+      y: rotated.y + box.center.y,
+      z: rotated.z + box.center.z
     };
-    const edge1 = createEdge(v1, v2);
-    const edge2 = createEdge(v2, v3);
-    const edge3 = createEdge(v3, v1);
-    const edgeLoop = repo.add(
-      new EdgeLoop("", [
-        repo.add(new OrientedEdge("", edge1, true)),
-        repo.add(new OrientedEdge("", edge2, true)),
-        repo.add(new OrientedEdge("", edge3, true))
-      ])
-    );
-    const normalDir = repo.add(
-      new Direction(
-        "",
-        triangle.normal.x,
-        triangle.normal.y,
-        triangle.normal.z
-      )
-    );
-    const refX = p2.x - p1.x;
-    const refY = p2.y - p1.y;
-    const refZ = p2.z - p1.z;
-    const refDir = repo.add(new Direction("", refX, refY, refZ));
-    const placement = repo.add(
-      new Axis2Placement3D("", v1.resolve(repo).pnt, normalDir, refDir)
-    );
-    const plane = repo.add(new Plane("", placement));
-    const face = repo.add(
-      new AdvancedFace(
-        "",
-        [repo.add(new FaceOuterBound("", edgeLoop, true))],
-        plane,
-        true
-      )
-    );
-    faces.push(face);
-  }
-  return faces;
+  });
+  const stepCorners = corners.map((corner) => ({
+    x: corner.x,
+    y: corner.z,
+    z: corner.y
+  }));
+  const vertices = stepCorners.map((corner) => createVertex(repo, corner));
+  const faces = [
+    [vertices[0], vertices[1], vertices[2], vertices[3]],
+    [vertices[4], vertices[7], vertices[6], vertices[5]],
+    [vertices[0], vertices[4], vertices[5], vertices[1]],
+    [vertices[1], vertices[5], vertices[6], vertices[2]],
+    [vertices[2], vertices[6], vertices[7], vertices[3]],
+    [vertices[3], vertices[7], vertices[4], vertices[0]]
+  ].map((faceVertices) => createFaceFromVertices(repo, faceVertices));
+  const shell = repo.add(new ClosedShell("", faces));
+  return repo.add(new ManifoldSolidBrep("Component", shell));
+}
+function createSceneMeshSolid(repo, box) {
+  const faces = box.mesh.triangles.map((triangle) => {
+    const vertices = triangle.vertices.map((vertex) => {
+      const rotated = rotatePoint3(vertex, box.rotation);
+      const translated = {
+        x: rotated.x + box.center.x,
+        y: rotated.z + box.center.z,
+        z: rotated.y + box.center.y
+      };
+      return createVertex(repo, translated);
+    });
+    return createFaceFromVertices(repo, vertices);
+  });
+  const shell = repo.add(new ClosedShell("", faces));
+  return repo.add(new ManifoldSolidBrep("Component", shell));
 }
+
+// lib/mesh-generation.ts
 async function generateComponentMeshes(options) {
   const {
     repo,
@@ -239,25 +251,25 @@ async function generateComponentMeshes(options) {
   } = options;
   const solids = [];
   try {
-    const filteredCircuitJson = circuitJson.filter((e) => {
-      if (e.type === "pcb_board") return false;
-      if (e.type === "cad_component" && e.cad_component_id && excludeCadComponentIds?.has(e.cad_component_id)) {
+    const filteredCircuitJson = circuitJson.filter((element) => {
+      if (element.type === "pcb_board") return false;
+      if (element.type === "cad_component" && element.cad_component_id && excludeCadComponentIds?.has(element.cad_component_id)) {
         return false;
       }
-      if (e.type === "pcb_component" && e.pcb_component_id && excludePcbComponentIds?.has(e.pcb_component_id)) {
+      if (element.type === "pcb_component" && element.pcb_component_id && excludePcbComponentIds?.has(element.pcb_component_id)) {
         return false;
       }
-      if (e.type === "cad_component" && e.model_step_url) {
+      if (element.type === "cad_component" && element.model_step_url) {
         return false;
       }
-      if (e.type === "cad_component" && e.pcb_component_id && pcbComponentIdsWithStepUrl?.has(e.pcb_component_id)) {
+      if (element.type === "cad_component" && element.pcb_component_id && pcbComponentIdsWithStepUrl?.has(element.pcb_component_id)) {
         return false;
       }
       return true;
-    }).map((e) => {
-      if (!includeExternalMeshes && e.type === "cad_component") {
+    }).map((element) => {
+      if (!includeExternalMeshes && element.type === "cad_component") {
         return {
-          ...e,
+          ...element,
           model_3mf_url: void 0,
           model_obj_url: void 0,
           model_stl_url: void 0,
@@ -265,7 +277,7 @@ async function generateComponentMeshes(options) {
           model_gltf_url: void 0
         };
       }
-      return e;
+      return element;
     });
     const gltfModule = "circuit-json-to-gltf";
     const { convertCircuitJsonTo3D } = await import(
@@ -276,43 +288,8 @@ async function generateComponentMeshes(options) {
       boardThickness,
       renderBoardTextures: false
     });
-    const allTriangles = [];
     for (const box of scene3d.boxes) {
-      if (box.mesh && "triangles" in box.mesh) {
-        allTriangles.push(...box.mesh.triangles);
-      } else {
-        const boxTriangles = createBoxTriangles(box);
-        allTriangles.push(...boxTriangles);
-      }
-    }
-    if (allTriangles.length > 0) {
-      const transformedTriangles = allTriangles.map((tri) => ({
-        vertices: tri.vertices.map((v) => ({
-          x: v.x,
-          y: v.z,
-          // GLTF Z becomes STEP Y
-          z: v.y
-          // GLTF Y becomes STEP Z
-        })),
-        normal: {
-          x: tri.normal.x,
-          y: tri.normal.z,
-          // GLTF Z becomes STEP Y
-          z: tri.normal.y
-          // GLTF Y becomes STEP Z
-        }
-      }));
-      const componentFaces = createStepFacesFromTriangles(
-        repo,
-        transformedTriangles
-      );
-      const componentShell = repo.add(
-        new ClosedShell("", componentFaces)
-      );
-      const componentSolid = repo.add(
-        new ManifoldSolidBrep("Components", componentShell)
-      );
-      solids.push(componentSolid);
+      solids.push(createSceneBoxSolid(repo, box));
     }
   } catch (error) {
     console.warn("Failed to generate component mesh:", error);
@@ -324,7 +301,7 @@ async function generateComponentMeshes(options) {
 import {
   CartesianPoint as CartesianPoint2,
   Direction as Direction2,
-  ManifoldSolidBrep as ManifoldSolidBrep2,
+  ManifoldSolidBrep as ManifoldSolidBrep3,
   Ref,
   Unknown,
   parseRepository
@@ -498,7 +475,7 @@ function mergeSingleStepModel(targetRepo, stepText, transform, placement) {
   }
   const solids = [];
   for (const [oldId, entity] of entries) {
-    if (entity instanceof ManifoldSolidBrep2) {
+    if (entity instanceof ManifoldSolidBrep3) {
       const mappedId = idMapping.get(oldId);
       if (mappedId !== void 0) {
         solids.push(new Ref(eid(mappedId)));
@@ -548,16 +525,16 @@ function adjustTransformForPlacement(entries, transform, placement) {
   transform.translation.x = targetX - center.x;
   transform.translation.y = targetY - center.y;
   if (isThroughHoleComponent) {
-    transform.translation.z = boardThickness;
+    transform.translation.z = boardThickness / 2;
   }
   if (!isThroughHoleComponent && boardThickness > 0) {
     const halfThickness = boardThickness / 2;
-    const offsetZ = targetZ - halfThickness;
+    const offsetZ = targetZ;
     if (normalizedLayer === "bottom") {
       transform.translation.z = -maxZ + offsetZ;
       transform.rotation.x = normalizeDegrees(transform.rotation.x + 180);
     } else {
-      transform.translation.z = boardThickness - minZ + offsetZ;
+      transform.translation.z = halfThickness - minZ + offsetZ;
     }
   } else if (!isThroughHoleComponent) {
     transform.translation.z = targetZ - center.z;
@@ -722,7 +699,7 @@ function normalizeStepNumericExponents(stepText) {
 var package_default = {
   name: "circuit-json-to-step",
   main: "dist/index.js",
-  version: "0.0.20",
+  version: "0.0.22",
   type: "module",
   scripts: {
     "pull-reference": `git clone https://github.com/tscircuit/circuit-json.git && find circuit-json/tests -name '*.test.ts' -exec bash -c 'mv "$0" "\${0%.test.ts}.ts"' {} \\; && git clone https://github.com/tscircuit/stepts.git && find stepts/tests -name '*.test.ts' -exec bash -c 'mv "$0" "\${0%.test.ts}.ts"' {} \\;`,
@@ -752,10 +729,10 @@ var package_default = {
   },
   dependencies: {
     "circuit-json-to-connectivity-map": "^0.0.22",
-    "circuit-json-to-gltf": "^0.0.91",
+    "circuit-json-to-gltf": "^0.0.93",
     "circuit-to-svg": "^0.0.327",
     "schematic-symbols": "^0.0.202",
-    stepts: "^0.0.3"
+    stepts: "^0.0.4"
   }
 };
 
@@ -1049,7 +1026,7 @@ function createPillHoleLoop(repo, hole, z, xDir) {
   );
   return repo.add(new EdgeLoop2("", orientedEdges));
 }
-function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
+function createPillCylindricalFaces(repo, hole, zMin, zMax, xDir, zDir) {
   const geom = getPillGeometry(hole);
   const {
     centerX,
@@ -1073,7 +1050,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1088,7 +1066,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1103,7 +1082,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1118,7 +1098,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1135,7 +1116,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1150,7 +1132,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1165,7 +1148,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1180,14 +1164,15 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
   }
   return faces;
 }
-function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAngle, rotation, centerX0, centerY0, boardThickness, zDir, xDir) {
+function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAngle, rotation, centerX0, centerY0, zMin, zMax, zDir, xDir) {
   const bottomStartX = centerX + radius * Math.cos(startAngle);
   const bottomStartY = centerY + radius * Math.sin(startAngle);
   const bottomEndX = centerX + radius * Math.cos(endAngle);
@@ -1209,29 +1194,25 @@ function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAn
   const bottomStartVertex = repo.add(
     new VertexPoint2(
       "",
-      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, 0))
+      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, zMin))
     )
   );
   const bottomEndVertex = repo.add(
     new VertexPoint2(
       "",
-      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, 0))
+      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, zMin))
     )
   );
   const topStart = repo.add(
     new VertexPoint2(
       "",
-      repo.add(
-        new CartesianPoint3("", bottomStart.x, bottomStart.y, boardThickness)
-      )
+      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, zMax))
     )
   );
   const topEnd = repo.add(
     new VertexPoint2(
       "",
-      repo.add(
-        new CartesianPoint3("", bottomEnd.x, bottomEnd.y, boardThickness)
-      )
+      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, zMax))
     )
   );
   const centerRotated = rotatePoint(
@@ -1242,7 +1223,7 @@ function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAn
     rotation
   );
   const bottomCenter = repo.add(
-    new CartesianPoint3("", centerRotated.x, centerRotated.y, 0)
+    new CartesianPoint3("", centerRotated.x, centerRotated.y, zMin)
   );
   const bottomPlacement = repo.add(
     new Axis2Placement3D2(
@@ -1257,7 +1238,7 @@ function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAn
     new EdgeCurve2("", bottomStartVertex, bottomEndVertex, bottomCircle, false)
   );
   const topCenter = repo.add(
-    new CartesianPoint3("", centerRotated.x, centerRotated.y, boardThickness)
+    new CartesianPoint3("", centerRotated.x, centerRotated.y, zMax)
   );
   const topPlacement = repo.add(new Axis2Placement3D2("", topCenter, zDir, xDir));
   const topCircle = repo.add(new Circle("", topPlacement, radius));
@@ -1265,37 +1246,34 @@ function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAn
   const v1 = repo.add(
     new VertexPoint2(
       "",
-      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, 0))
+      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, zMin))
     )
   );
   const v2 = repo.add(
     new VertexPoint2(
       "",
-      repo.add(
-        new CartesianPoint3("", bottomStart.x, bottomStart.y, boardThickness)
-      )
+      repo.add(new CartesianPoint3("", bottomStart.x, bottomStart.y, zMax))
     )
   );
   const v3 = repo.add(
     new VertexPoint2(
       "",
-      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, 0))
+      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, zMin))
     )
   );
   const v4 = repo.add(
     new VertexPoint2(
       "",
-      repo.add(
-        new CartesianPoint3("", bottomEnd.x, bottomEnd.y, boardThickness)
-      )
+      repo.add(new CartesianPoint3("", bottomEnd.x, bottomEnd.y, zMax))
     )
   );
   const dir1 = repo.add(new Direction3("", 0, 0, 1));
-  const vec1 = repo.add(new Vector2("", dir1, boardThickness));
+  const height = zMax - zMin;
+  const vec1 = repo.add(new Vector2("", dir1, height));
   const line1 = repo.add(new Line2("", v1.resolve(repo).pnt, vec1));
   const edge1 = repo.add(new EdgeCurve2("", v1, v2, line1, true));
   const dir2 = repo.add(new Direction3("", 0, 0, 1));
-  const vec2 = repo.add(new Vector2("", dir2, boardThickness));
+  const vec2 = repo.add(new Vector2("", dir2, height));
   const line2 = repo.add(new Line2("", v3.resolve(repo).pnt, vec2));
   const edge2 = repo.add(new EdgeCurve2("", v3, v4, line2, true));
   const loop = repo.add(
@@ -1321,25 +1299,25 @@ function createCylindricalWall(repo, centerX, centerY, radius, startAngle, endAn
     )
   );
 }
-function createPlanarWall(repo, startX, startY, endX, endY, rotation, centerX0, centerY0, boardThickness, zDir) {
+function createPlanarWall(repo, startX, startY, endX, endY, rotation, centerX0, centerY0, zMin, zMax, zDir) {
   const start = rotatePoint(startX, startY, centerX0, centerY0, rotation);
   const end = rotatePoint(endX, endY, centerX0, centerY0, rotation);
   const v1 = repo.add(
-    new VertexPoint2("", repo.add(new CartesianPoint3("", start.x, start.y, 0)))
+    new VertexPoint2(
+      "",
+      repo.add(new CartesianPoint3("", start.x, start.y, zMin))
+    )
   );
   const v2 = repo.add(
-    new VertexPoint2("", repo.add(new CartesianPoint3("", end.x, end.y, 0)))
+    new VertexPoint2("", repo.add(new CartesianPoint3("", end.x, end.y, zMin)))
   );
   const v3 = repo.add(
-    new VertexPoint2(
-      "",
-      repo.add(new CartesianPoint3("", end.x, end.y, boardThickness))
-    )
+    new VertexPoint2("", repo.add(new CartesianPoint3("", end.x, end.y, zMax)))
   );
   const v4 = repo.add(
     new VertexPoint2(
       "",
-      repo.add(new CartesianPoint3("", start.x, start.y, boardThickness))
+      repo.add(new CartesianPoint3("", start.x, start.y, zMax))
     )
   );
   const dx = end.x - start.x;
@@ -1358,10 +1336,11 @@ function createPlanarWall(repo, startX, startY, endX, endY, rotation, centerX0,
   const topLine = repo.add(new Line2("", v4.resolve(repo).pnt, topVec));
   const topEdge = repo.add(new EdgeCurve2("", v4, v3, topLine, true));
   const vertDir = repo.add(new Direction3("", 0, 0, 1));
-  const vertVec1 = repo.add(new Vector2("", vertDir, boardThickness));
+  const height = zMax - zMin;
+  const vertVec1 = repo.add(new Vector2("", vertDir, height));
   const vertLine1 = repo.add(new Line2("", v2.resolve(repo).pnt, vertVec1));
   const vertEdge1 = repo.add(new EdgeCurve2("", v2, v3, vertLine1, true));
-  const vertVec2 = repo.add(new Vector2("", vertDir, boardThickness));
+  const vertVec2 = repo.add(new Vector2("", vertDir, height));
   const vertLine2 = repo.add(new Line2("", v1.resolve(repo).pnt, vertVec2));
   const vertEdge2 = repo.add(new EdgeCurve2("", v1, v4, vertLine2, true));
   const loop = repo.add(
@@ -1378,7 +1357,7 @@ function createPlanarWall(repo, startX, startY, endX, endY, rotation, centerX0,
   const refDir = repo.add(
     new Direction3("", dx / edgeLength, dy / edgeLength, 0)
   );
-  const planeOrigin = repo.add(new CartesianPoint3("", start.x, start.y, 0));
+  const planeOrigin = repo.add(new CartesianPoint3("", start.x, start.y, zMin));
   const placement = repo.add(
     new Axis2Placement3D2("", planeOrigin, normalDir, refDir)
   );
@@ -1406,6 +1385,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   const productName = options.productName ?? "PCB";
   const boardCenterX = pcbBoard?.center?.x ?? 0;
   const boardCenterY = pcbBoard?.center?.y ?? 0;
+  const halfBoardThickness = boardThickness / 2;
   if (!boardWidth || !boardHeight) {
     throw new Error(
       "Board dimensions not found. Either provide boardWidth and boardHeight in options, or include a pcb_board in the circuit JSON with width and height properties."
@@ -1495,7 +1475,9 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       (point) => repo.add(
         new VertexPoint3(
           "",
-          repo.add(new CartesianPoint4("", point.x, point.y, 0))
+          repo.add(
+            new CartesianPoint4("", point.x, point.y, -halfBoardThickness)
+          )
         )
       )
     );
@@ -1503,7 +1485,9 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       (point) => repo.add(
         new VertexPoint3(
           "",
-          repo.add(new CartesianPoint4("", point.x, point.y, boardThickness))
+          repo.add(
+            new CartesianPoint4("", point.x, point.y, halfBoardThickness)
+          )
         )
       )
     );
@@ -1511,14 +1495,30 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     const halfWidth = boardWidth / 2;
     const halfHeight = boardHeight / 2;
     const corners = [
-      [boardCenterX - halfWidth, boardCenterY - halfHeight, 0],
-      [boardCenterX + halfWidth, boardCenterY - halfHeight, 0],
-      [boardCenterX + halfWidth, boardCenterY + halfHeight, 0],
-      [boardCenterX - halfWidth, boardCenterY + halfHeight, 0],
-      [boardCenterX - halfWidth, boardCenterY - halfHeight, boardThickness],
-      [boardCenterX + halfWidth, boardCenterY - halfHeight, boardThickness],
-      [boardCenterX + halfWidth, boardCenterY + halfHeight, boardThickness],
-      [boardCenterX - halfWidth, boardCenterY + halfHeight, boardThickness]
+      [
+        boardCenterX - halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness
+      ],
+      [
+        boardCenterX - halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness
+      ],
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, halfBoardThickness],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, halfBoardThickness]
     ];
     const vertices = corners.map(
       ([x, y, z]) => repo.add(
@@ -1528,7 +1528,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
     topVertices = [vertices[4], vertices[5], vertices[6], vertices[7]];
   }
-  function createEdge(v1, v2) {
+  function createEdge2(v1, v2) {
     const p1 = v1.resolve(repo).pnt.resolve(repo);
     const p2 = v2.resolve(repo).pnt.resolve(repo);
     const dx = p2.x - p1.x;
@@ -1554,17 +1554,17 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   for (let i = 0; i < bottomVertices.length; i++) {
     const v1 = bottomVertices[i];
     const v2 = bottomVertices[(i + 1) % bottomVertices.length];
-    bottomEdges.push(createEdge(v1, v2));
+    bottomEdges.push(createEdge2(v1, v2));
   }
   for (let i = 0; i < topVertices.length; i++) {
     const v1 = topVertices[i];
     const v2 = topVertices[(i + 1) % topVertices.length];
-    topEdges.push(createEdge(v1, v2));
+    topEdges.push(createEdge2(v1, v2));
   }
   for (let i = 0; i < bottomVertices.length; i++) {
-    verticalEdges.push(createEdge(bottomVertices[i], topVertices[i]));
+    verticalEdges.push(createEdge2(bottomVertices[i], topVertices[i]));
   }
-  const origin = repo.add(new CartesianPoint4("", 0, 0, 0));
+  const origin = repo.add(new CartesianPoint4("", 0, 0, -halfBoardThickness));
   const xDir = repo.add(new Direction4("", 1, 0, 0));
   const zDir = repo.add(new Direction4("", 0, 0, 1));
   const bottomFrame = repo.add(
@@ -1589,11 +1589,15 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       const holeX = typeof hole.x === "number" ? hole.x : hole.x.value;
       const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
       const radius = hole.hole_diameter / 2;
-      const holeCenter = repo.add(new CartesianPoint4("", holeX, holeY, 0));
+      const holeCenter = repo.add(
+        new CartesianPoint4("", holeX, holeY, -halfBoardThickness)
+      );
       const holeVertex = repo.add(
         new VertexPoint3(
           "",
-          repo.add(new CartesianPoint4("", holeX + radius, holeY, 0))
+          repo.add(
+            new CartesianPoint4("", holeX + radius, holeY, -halfBoardThickness)
+          )
         )
       );
       const holePlacement = repo.add(
@@ -1613,7 +1617,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       );
       bottomHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
     } else if (holeShape === "rotated_pill" || holeShape === "pill") {
-      const pillLoop = createPillHoleLoop(repo, hole, 0, xDir);
+      const pillLoop = createPillHoleLoop(repo, hole, -halfBoardThickness, xDir);
       bottomHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)));
     }
   }
@@ -1628,7 +1632,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       true
     )
   );
-  const topOrigin = repo.add(new CartesianPoint4("", 0, 0, boardThickness));
+  const topOrigin = repo.add(new CartesianPoint4("", 0, 0, halfBoardThickness));
   const topFrame = repo.add(new Axis2Placement3D3("", topOrigin, zDir, xDir));
   const topPlane = repo.add(new Plane3("", topFrame));
   const topLoop = repo.add(
@@ -1645,13 +1649,13 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
       const radius = hole.hole_diameter / 2;
       const holeCenter = repo.add(
-        new CartesianPoint4("", holeX, holeY, boardThickness)
+        new CartesianPoint4("", holeX, holeY, halfBoardThickness)
       );
       const holeVertex = repo.add(
         new VertexPoint3(
           "",
           repo.add(
-            new CartesianPoint4("", holeX + radius, holeY, boardThickness)
+            new CartesianPoint4("", holeX + radius, holeY, halfBoardThickness)
           )
         )
       );
@@ -1667,7 +1671,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       );
       topHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)));
     } else if (holeShape === "rotated_pill" || holeShape === "pill") {
-      const pillLoop = createPillHoleLoop(repo, hole, boardThickness, xDir);
+      const pillLoop = createPillHoleLoop(repo, hole, halfBoardThickness, xDir);
       topHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)));
     }
   }
@@ -1689,7 +1693,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     const edgeDir = {
       x: bottomV2.x - bottomV1.x,
       y: bottomV2.y - bottomV1.y,
-      z: 0
+      z: -halfBoardThickness
     };
     const normalDir = repo.add(new Direction4("", edgeDir.y, -edgeDir.x, 0));
     const refDir = repo.add(new Direction4("", edgeDir.x, edgeDir.y, 0));
@@ -1722,11 +1726,15 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       const holeX = typeof hole.x === "number" ? hole.x : hole.x.value;
       const holeY = typeof hole.y === "number" ? hole.y : hole.y.value;
       const radius = hole.hole_diameter / 2;
-      const bottomHoleCenter = repo.add(new CartesianPoint4("", holeX, holeY, 0));
+      const bottomHoleCenter = repo.add(
+        new CartesianPoint4("", holeX, holeY, -halfBoardThickness)
+      );
       const bottomHoleVertex = repo.add(
         new VertexPoint3(
           "",
-          repo.add(new CartesianPoint4("", holeX + radius, holeY, 0))
+          repo.add(
+            new CartesianPoint4("", holeX + radius, holeY, -halfBoardThickness)
+          )
         )
       );
       const bottomHolePlacement = repo.add(
@@ -1750,13 +1758,13 @@ async function circuitJsonToStep(circuitJson, options = {}) {
         )
       );
       const topHoleCenter = repo.add(
-        new CartesianPoint4("", holeX, holeY, boardThickness)
+        new CartesianPoint4("", holeX, holeY, halfBoardThickness)
       );
       const topHoleVertex = repo.add(
         new VertexPoint3(
           "",
           repo.add(
-            new CartesianPoint4("", holeX + radius, holeY, boardThickness)
+            new CartesianPoint4("", holeX + radius, holeY, halfBoardThickness)
           )
         )
       );
@@ -1792,7 +1800,8 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       const pillFaces = createPillCylindricalFaces(
         repo,
         hole,
-        boardThickness,
+        -halfBoardThickness,
+        halfBoardThickness,
         xDir,
         zDir
       );
@@ -1801,7 +1810,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   }
   const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
   const shell = repo.add(new ClosedShell2("", allFaces));
-  const solid = repo.add(new ManifoldSolidBrep3(productName, shell));
+  const solid = repo.add(new ManifoldSolidBrep4(productName, shell));
   const allSolids = [solid];
   let handledComponentIds = /* @__PURE__ */ new Set();
   let handledPcbComponentIds = /* @__PURE__ */ new Set();