circuit-json-to-step 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,6 +1,6 @@
 // lib/index.ts
 import {
-  Repository,
+  Repository as Repository2,
   ApplicationContext,
   ApplicationProtocolDefinition,
   ProductContext,
@@ -9,9 +9,9 @@ import {
   ProductDefinitionFormation,
   ProductDefinition,
   ProductDefinitionShape,
-  Unknown,
-  CartesianPoint as CartesianPoint2,
-  Direction as Direction2,
+  Unknown as Unknown2,
+  CartesianPoint as CartesianPoint3,
+  Direction as Direction3,
   Axis2Placement3D as Axis2Placement3D2,
   Plane as Plane2,
   CylindricalSurface,
@@ -26,7 +26,7 @@ import {
   AdvancedFace as AdvancedFace2,
   Circle,
   ClosedShell as ClosedShell2,
-  ManifoldSolidBrep as ManifoldSolidBrep2,
+  ManifoldSolidBrep as ManifoldSolidBrep3,
   ColourRgb,
   FillAreaStyleColour,
   FillAreaStyle,
@@ -233,11 +233,25 @@ async function generateComponentMeshes(options) {
     repo,
     circuitJson,
     boardThickness,
-    includeExternalMeshes = false
+    includeExternalMeshes = false,
+    excludeCadComponentIds,
+    excludePcbComponentIds
   } = options;
   const solids = [];
   try {
-    const filteredCircuitJson = circuitJson.filter((e) => e.type !== "pcb_board").map((e) => {
+    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)) {
+        return false;
+      }
+      if (e.type === "pcb_component" && e.pcb_component_id && excludePcbComponentIds?.has(e.pcb_component_id)) {
+        return false;
+      }
+      if (e.type === "cad_component" && e.model_step_url) {
+        return false;
+      }
+      return true;
+    }).map((e) => {
       if (!includeExternalMeshes && e.type === "cad_component") {
         return {
           ...e,
@@ -298,9 +312,408 @@ async function generateComponentMeshes(options) {
   return solids;
 }
 
+// lib/step-model-merger.ts
+import {
+  CartesianPoint as CartesianPoint2,
+  Direction as Direction2,
+  ManifoldSolidBrep as ManifoldSolidBrep2,
+  Ref,
+  Unknown,
+  parseRepository
+} from "stepts";
+import { eid } from "stepts/lib/core/EntityId";
+
+// lib/step-model-merger/excluded-entity-types.ts
+var EXCLUDED_ENTITY_TYPES = /* @__PURE__ */ new Set([
+  "APPLICATION_CONTEXT",
+  "APPLICATION_PROTOCOL_DEFINITION",
+  "PRODUCT",
+  "PRODUCT_CONTEXT",
+  "PRODUCT_DEFINITION",
+  "PRODUCT_DEFINITION_FORMATION",
+  "PRODUCT_DEFINITION_CONTEXT",
+  "PRODUCT_DEFINITION_SHAPE",
+  "SHAPE_DEFINITION_REPRESENTATION",
+  "ADVANCED_BREP_SHAPE_REPRESENTATION",
+  "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
+  "PRESENTATION_STYLE_ASSIGNMENT",
+  "SURFACE_STYLE_USAGE",
+  "SURFACE_SIDE_STYLE",
+  "SURFACE_STYLE_FILL_AREA",
+  "FILL_AREA_STYLE",
+  "FILL_AREA_STYLE_COLOUR",
+  "COLOUR_RGB",
+  "STYLED_ITEM",
+  "CURVE_STYLE",
+  "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
+  "PRODUCT_RELATED_PRODUCT_CATEGORY",
+  "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
+  "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
+  "ITEM_DEFINED_TRANSFORMATION"
+]);
+
+// lib/step-model-merger/vector-utils.ts
+function asVector3(value) {
+  return {
+    x: value?.x ?? 0,
+    y: value?.y ?? 0,
+    z: value?.z ?? 0
+  };
+}
+function toRadians(rotation) {
+  const factor = Math.PI / 180;
+  return {
+    x: rotation.x * factor,
+    y: rotation.y * factor,
+    z: rotation.z * factor
+  };
+}
+function transformPoint(point, rotation, translation) {
+  const rotated = rotateVector(point, rotation);
+  return [
+    rotated[0] + translation.x,
+    rotated[1] + translation.y,
+    rotated[2] + translation.z
+  ];
+}
+function transformDirection(vector, rotation) {
+  return rotateVector(vector, rotation);
+}
+function rotateVector(vector, rotation) {
+  let [x, y, z] = vector;
+  if (rotation.x !== 0) {
+    const cosX = Math.cos(rotation.x);
+    const sinX = Math.sin(rotation.x);
+    const y1 = y * cosX - z * sinX;
+    const z1 = y * sinX + z * cosX;
+    y = y1;
+    z = z1;
+  }
+  if (rotation.y !== 0) {
+    const cosY = Math.cos(rotation.y);
+    const sinY = Math.sin(rotation.y);
+    const x1 = x * cosY + z * sinY;
+    const z1 = -x * sinY + z * cosY;
+    x = x1;
+    z = z1;
+  }
+  if (rotation.z !== 0) {
+    const cosZ = Math.cos(rotation.z);
+    const sinZ = Math.sin(rotation.z);
+    const x1 = x * cosZ - y * sinZ;
+    const y1 = x * sinZ + y * cosZ;
+    x = x1;
+    y = y1;
+  }
+  return [x, y, z];
+}
+
+// lib/step-model-merger/read-step-file.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+async function readStepFile(modelUrl) {
+  if (/^https?:\/\//i.test(modelUrl)) {
+    const globalFetch = globalThis.fetch;
+    if (!globalFetch) {
+      throw new Error("fetch is not available in this environment");
+    }
+    const res = await globalFetch(modelUrl);
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+    return await res.text();
+  }
+  if (modelUrl.startsWith("file://")) {
+    const filePath = fileURLToPath(modelUrl);
+    return await fs.readFile(filePath, "utf8");
+  }
+  const resolvedPath = path.isAbsolute(modelUrl) ? modelUrl : path.resolve(process.cwd(), modelUrl);
+  return await fs.readFile(resolvedPath, "utf8");
+}
+
+// lib/step-model-merger.ts
+async function mergeExternalStepModels(options) {
+  const { repo, circuitJson, boardThickness } = options;
+  const cadComponents = circuitJson.filter(
+    (item) => item?.type === "cad_component" && typeof item.model_step_url === "string"
+  );
+  const pcbComponentMap = /* @__PURE__ */ new Map();
+  for (const item of circuitJson) {
+    if (item?.type === "pcb_component" && item.pcb_component_id) {
+      pcbComponentMap.set(item.pcb_component_id, item);
+    }
+  }
+  const solids = [];
+  const handledComponentIds = /* @__PURE__ */ new Set();
+  const handledPcbComponentIds = /* @__PURE__ */ new Set();
+  for (const component of cadComponents) {
+    const componentId = component.cad_component_id ?? "";
+    const stepUrl = component.model_step_url;
+    try {
+      const stepText = await readStepFile(stepUrl);
+      if (!stepText.trim()) {
+        throw new Error("STEP file is empty");
+      }
+      const pcbComponent = component.pcb_component_id ? pcbComponentMap.get(component.pcb_component_id) : void 0;
+      const layer = pcbComponent?.layer?.toLowerCase();
+      const transform = {
+        translation: asVector3(component.position),
+        rotation: asVector3(component.rotation)
+      };
+      const componentSolids = mergeSingleStepModel(repo, stepText, transform, {
+        layer,
+        boardThickness
+      });
+      if (componentSolids.length > 0) {
+        if (componentId) {
+          handledComponentIds.add(componentId);
+        }
+        const pcbComponentId = component.pcb_component_id;
+        if (pcbComponentId) {
+          handledPcbComponentIds.add(pcbComponentId);
+        }
+      }
+      solids.push(...componentSolids);
+    } catch (error) {
+      console.warn(`Failed to merge STEP model from ${stepUrl}:`, error);
+    }
+  }
+  return { solids, handledComponentIds, handledPcbComponentIds };
+}
+function mergeSingleStepModel(targetRepo, stepText, transform, placement) {
+  const sourceRepo = parseRepository(stepText);
+  let entries = sourceRepo.entries().map(([id, entity]) => [Number(id), entity]).filter(([, entity]) => !EXCLUDED_ENTITY_TYPES.has(entity.type));
+  entries = pruneInvalidEntries(entries);
+  adjustTransformForPlacement(entries, transform, placement);
+  applyTransform(entries, transform);
+  const idMapping = allocateIds(targetRepo, entries);
+  remapReferences(entries, idMapping);
+  for (const [oldId, entity] of entries) {
+    const mappedId = idMapping.get(oldId);
+    if (mappedId === void 0) continue;
+    targetRepo.set(eid(mappedId), entity);
+  }
+  const solids = [];
+  for (const [oldId, entity] of entries) {
+    if (entity instanceof ManifoldSolidBrep2) {
+      const mappedId = idMapping.get(oldId);
+      if (mappedId !== void 0) {
+        solids.push(new Ref(eid(mappedId)));
+      }
+    }
+  }
+  return solids;
+}
+function adjustTransformForPlacement(entries, transform, placement) {
+  if (!placement) return;
+  const points = [];
+  for (const [, entity] of entries) {
+    if (entity instanceof CartesianPoint2) {
+      points.push([entity.x, entity.y, entity.z]);
+    }
+  }
+  if (!points.length) return;
+  const rotationRadians = toRadians(transform.rotation);
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (const point of points) {
+    const [x, y, z] = rotateVector(point, rotationRadians);
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (z < minZ) minZ = z;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    if (z > maxZ) maxZ = z;
+  }
+  if (!Number.isFinite(minX)) return;
+  const center = {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2,
+    z: (minZ + maxZ) / 2
+  };
+  const normalizedLayer = placement.layer?.toLowerCase() === "bottom" ? "bottom" : "top";
+  const boardThickness = placement.boardThickness ?? 0;
+  const halfThickness = boardThickness / 2;
+  const targetX = transform.translation.x;
+  const targetY = transform.translation.y;
+  const targetZ = transform.translation.z;
+  transform.translation.x = targetX - center.x;
+  transform.translation.y = targetY - center.y;
+  if (boardThickness > 0) {
+    const offsetZ = targetZ - halfThickness;
+    if (normalizedLayer === "bottom") {
+      transform.translation.z = -maxZ + offsetZ;
+      transform.rotation.x = normalizeDegrees(transform.rotation.x + 180);
+    } else {
+      transform.translation.z = boardThickness - minZ + offsetZ;
+    }
+  } else {
+    transform.translation.z = targetZ - center.z;
+  }
+}
+function normalizeDegrees(value) {
+  const wrapped = value % 360;
+  return wrapped < 0 ? wrapped + 360 : wrapped;
+}
+function pruneInvalidEntries(entries) {
+  let remaining = entries.slice();
+  let remainingIds = new Set(remaining.map(([id]) => id));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const toRemove = /* @__PURE__ */ new Set();
+    for (const [entityId, entity] of remaining) {
+      const refs = collectReferencedIds(entity);
+      for (const refId of refs) {
+        if (!remainingIds.has(refId)) {
+          toRemove.add(entityId);
+          break;
+        }
+      }
+    }
+    if (toRemove.size > 0) {
+      changed = true;
+      remaining = remaining.filter(([id]) => !toRemove.has(id));
+      remainingIds = new Set(remaining.map(([id]) => id));
+    }
+  }
+  return remaining;
+}
+function collectReferencedIds(entity) {
+  const result = /* @__PURE__ */ new Set();
+  collectReferencedIdsRecursive(entity, result, /* @__PURE__ */ new Set());
+  return result;
+}
+function collectReferencedIdsRecursive(value, result, seen) {
+  if (!value) return;
+  if (value instanceof Ref) {
+    result.add(Number(value.id));
+    return;
+  }
+  if (value instanceof Unknown) {
+    for (const arg of value.args) {
+      arg.replace(/#(\d+)/g, (_, num) => {
+        result.add(Number(num));
+        return _;
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectReferencedIdsRecursive(item, result, seen);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of Object.values(value)) {
+      collectReferencedIdsRecursive(entry, result, seen);
+    }
+  }
+}
+function applyTransform(entries, transform) {
+  const rotation = toRadians(transform.rotation);
+  for (const [, entity] of entries) {
+    if (entity instanceof CartesianPoint2) {
+      const [x, y, z] = transformPoint(
+        [entity.x, entity.y, entity.z],
+        rotation,
+        transform.translation
+      );
+      entity.x = x;
+      entity.y = y;
+      entity.z = z;
+    } else if (entity instanceof Direction2) {
+      const [dx, dy, dz] = transformDirection(
+        [entity.dx, entity.dy, entity.dz],
+        rotation
+      );
+      const length = Math.hypot(dx, dy, dz);
+      if (length > 0) {
+        entity.dx = dx / length;
+        entity.dy = dy / length;
+        entity.dz = dz / length;
+      }
+    }
+  }
+}
+function allocateIds(targetRepo, entries) {
+  let nextId = getNextEntityId(targetRepo);
+  const idMapping = /* @__PURE__ */ new Map();
+  for (const [oldId] of entries) {
+    idMapping.set(oldId, nextId);
+    nextId += 1;
+  }
+  return idMapping;
+}
+function getNextEntityId(repo) {
+  let maxId = 0;
+  for (const [id] of repo.entries()) {
+    const numericId = Number(id);
+    if (numericId > maxId) {
+      maxId = numericId;
+    }
+  }
+  return maxId + 1;
+}
+function remapReferences(entries, idMapping) {
+  for (const [, entity] of entries) {
+    remapValue(entity, idMapping, /* @__PURE__ */ new Set());
+  }
+}
+function remapValue(value, idMapping, seen) {
+  if (!value) return;
+  if (value instanceof Ref) {
+    const mapped = idMapping.get(Number(value.id));
+    if (mapped !== void 0) {
+      value.id = eid(mapped);
+    }
+    return;
+  }
+  if (value instanceof Unknown) {
+    value.args = value.args.map(
+      (arg) => arg.replace(/#(\d+)/g, (match, num) => {
+        const mapped = idMapping.get(Number(num));
+        return mapped !== void 0 ? `#${mapped}` : match;
+      })
+    );
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      remapValue(item, idMapping, seen);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) return;
+    seen.add(value);
+    for (const key of Object.keys(value)) {
+      remapValue(value[key], idMapping, seen);
+    }
+  }
+}
+
+// lib/step-text-utils.ts
+function normalizeStepNumericExponents(stepText) {
+  return stepText.replace(
+    /(-?(?:\d+\.\d*|\.\d+|\d+))e([+-]?\d+)/g,
+    (_match, mantissa, exponent) => `${mantissa}E${exponent}`
+  );
+}
+
 // lib/index.ts
 async function circuitJsonToStep(circuitJson, options = {}) {
-  const repo = new Repository();
+  const repo = new Repository2();
   const pcbBoard = circuitJson.find((item) => item.type === "pcb_board");
   const holes = circuitJson.filter(
     (item) => item.type === "pcb_hole" || item.type === "pcb_plated_hole"
@@ -348,22 +761,22 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     new ProductDefinitionShape("", "", productDef)
   );
   const lengthUnit = repo.add(
-    new Unknown("", [
+    new Unknown2("", [
       "( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) )"
     ])
   );
   const angleUnit = repo.add(
-    new Unknown("", [
+    new Unknown2("", [
       "( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) )"
     ])
   );
   const solidAngleUnit = repo.add(
-    new Unknown("", [
+    new Unknown2("", [
       "( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() )"
     ])
   );
   const uncertainty = repo.add(
-    new Unknown("UNCERTAINTY_MEASURE_WITH_UNIT", [
+    new Unknown2("UNCERTAINTY_MEASURE_WITH_UNIT", [
       `LENGTH_MEASURE(1.E-07)`,
       `${lengthUnit}`,
       `'distance_accuracy_value'`,
@@ -371,7 +784,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     ])
   );
   const geomContext = repo.add(
-    new Unknown("", [
+    new Unknown2("", [
       `( GEOMETRIC_REPRESENTATION_CONTEXT(3) GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((${uncertainty})) GLOBAL_UNIT_ASSIGNED_CONTEXT((${lengthUnit},${angleUnit},${solidAngleUnit})) REPRESENTATION_CONTEXT('${productName}','3D') )`
     ])
   );
@@ -383,7 +796,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       (point) => repo.add(
         new VertexPoint2(
           "",
-          repo.add(new CartesianPoint2("", point.x, point.y, 0))
+          repo.add(new CartesianPoint3("", point.x, point.y, 0))
         )
       )
     );
@@ -391,7 +804,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       (point) => repo.add(
         new VertexPoint2(
           "",
-          repo.add(new CartesianPoint2("", point.x, point.y, boardThickness))
+          repo.add(new CartesianPoint3("", point.x, point.y, boardThickness))
         )
       )
     );
@@ -410,7 +823,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     ];
     const vertices = corners.map(
       ([x, y, z]) => repo.add(
-        new VertexPoint2("", repo.add(new CartesianPoint2("", x, y, z)))
+        new VertexPoint2("", repo.add(new CartesianPoint3("", x, y, z)))
       )
     );
     bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
@@ -420,7 +833,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     const p1 = v1.resolve(repo).pnt.resolve(repo);
     const p2 = v2.resolve(repo).pnt.resolve(repo);
     const dir = repo.add(
-      new Direction2("", p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
+      new Direction3("", p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
     );
     const vec = repo.add(new Vector2("", dir, 1));
     const line = repo.add(new Line2("", v1.resolve(repo).pnt, vec));
@@ -442,14 +855,14 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   for (let i = 0; i < bottomVertices.length; i++) {
     verticalEdges.push(createEdge(bottomVertices[i], topVertices[i]));
   }
-  const origin = repo.add(new CartesianPoint2("", 0, 0, 0));
-  const xDir = repo.add(new Direction2("", 1, 0, 0));
-  const zDir = repo.add(new Direction2("", 0, 0, 1));
+  const origin = repo.add(new CartesianPoint3("", 0, 0, 0));
+  const xDir = repo.add(new Direction3("", 1, 0, 0));
+  const zDir = repo.add(new Direction3("", 0, 0, 1));
   const bottomFrame = repo.add(
     new Axis2Placement3D2(
       "",
       origin,
-      repo.add(new Direction2("", 0, 0, -1)),
+      repo.add(new Direction3("", 0, 0, -1)),
       xDir
     )
   );
@@ -467,18 +880,18 @@ 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 CartesianPoint2("", holeX, holeY, 0));
+      const holeCenter = repo.add(new CartesianPoint3("", holeX, holeY, 0));
       const holeVertex = repo.add(
         new VertexPoint2(
           "",
-          repo.add(new CartesianPoint2("", holeX + radius, holeY, 0))
+          repo.add(new CartesianPoint3("", holeX + radius, holeY, 0))
         )
       );
       const holePlacement = repo.add(
         new Axis2Placement3D2(
           "",
           holeCenter,
-          repo.add(new Direction2("", 0, 0, -1)),
+          repo.add(new Direction3("", 0, 0, -1)),
           xDir
         )
       );
@@ -503,7 +916,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       true
     )
   );
-  const topOrigin = repo.add(new CartesianPoint2("", 0, 0, boardThickness));
+  const topOrigin = repo.add(new CartesianPoint3("", 0, 0, boardThickness));
   const topFrame = repo.add(new Axis2Placement3D2("", topOrigin, zDir, xDir));
   const topPlane = repo.add(new Plane2("", topFrame));
   const topLoop = repo.add(
@@ -520,13 +933,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 CartesianPoint2("", holeX, holeY, boardThickness)
+        new CartesianPoint3("", holeX, holeY, boardThickness)
       );
       const holeVertex = repo.add(
         new VertexPoint2(
           "",
           repo.add(
-            new CartesianPoint2("", holeX + radius, holeY, boardThickness)
+            new CartesianPoint3("", holeX + radius, holeY, boardThickness)
           )
         )
       );
@@ -563,8 +976,8 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       y: bottomV2.y - bottomV1.y,
       z: 0
     };
-    const normalDir = repo.add(new Direction2("", edgeDir.y, -edgeDir.x, 0));
-    const refDir = repo.add(new Direction2("", edgeDir.x, edgeDir.y, 0));
+    const normalDir = repo.add(new Direction3("", edgeDir.y, -edgeDir.x, 0));
+    const refDir = repo.add(new Direction3("", edgeDir.x, edgeDir.y, 0));
     const sideFrame = repo.add(
       new Axis2Placement3D2("", bottomV1Pnt, normalDir, refDir)
     );
@@ -594,18 +1007,18 @@ 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 CartesianPoint2("", holeX, holeY, 0));
+      const bottomHoleCenter = repo.add(new CartesianPoint3("", holeX, holeY, 0));
       const bottomHoleVertex = repo.add(
         new VertexPoint2(
           "",
-          repo.add(new CartesianPoint2("", holeX + radius, holeY, 0))
+          repo.add(new CartesianPoint3("", holeX + radius, holeY, 0))
         )
       );
       const bottomHolePlacement = repo.add(
         new Axis2Placement3D2(
           "",
           bottomHoleCenter,
-          repo.add(new Direction2("", 0, 0, -1)),
+          repo.add(new Direction3("", 0, 0, -1)),
           xDir
         )
       );
@@ -622,13 +1035,13 @@ async function circuitJsonToStep(circuitJson, options = {}) {
         )
       );
       const topHoleCenter = repo.add(
-        new CartesianPoint2("", holeX, holeY, boardThickness)
+        new CartesianPoint3("", holeX, holeY, boardThickness)
       );
       const topHoleVertex = repo.add(
         new VertexPoint2(
           "",
           repo.add(
-            new CartesianPoint2("", holeX + radius, holeY, boardThickness)
+            new CartesianPoint3("", holeX + radius, holeY, boardThickness)
           )
         )
       );
@@ -664,20 +1077,36 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   }
   const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
   const shell = repo.add(new ClosedShell2("", allFaces));
-  const solid = repo.add(new ManifoldSolidBrep2(productName, shell));
+  const solid = repo.add(new ManifoldSolidBrep3(productName, shell));
   const allSolids = [solid];
+  let handledComponentIds = /* @__PURE__ */ new Set();
+  let handledPcbComponentIds = /* @__PURE__ */ new Set();
+  if (options.includeComponents && options.includeExternalMeshes) {
+    const mergeResult = await mergeExternalStepModels({
+      repo,
+      circuitJson,
+      boardThickness
+    });
+    handledComponentIds = mergeResult.handledComponentIds;
+    handledPcbComponentIds = mergeResult.handledPcbComponentIds;
+    allSolids.push(...mergeResult.solids);
+  }
   if (options.includeComponents) {
     const componentSolids = await generateComponentMeshes({
       repo,
       circuitJson,
       boardThickness,
-      includeExternalMeshes: options.includeExternalMeshes
+      includeExternalMeshes: options.includeExternalMeshes,
+      excludeCadComponentIds: handledComponentIds,
+      excludePcbComponentIds: handledPcbComponentIds
     });
     allSolids.push(...componentSolids);
   }
   const styledItems = [];
-  for (const solidRef of allSolids) {
-    const color = repo.add(new ColourRgb("", 0.2, 0.6, 0.2));
+  allSolids.forEach((solidRef, index) => {
+    const isBoard = index === 0;
+    const [r, g, b] = isBoard ? [0.2, 0.6, 0.2] : [0.75, 0.75, 0.75];
+    const color = repo.add(new ColourRgb("", r, g, b));
     const fillColor = repo.add(new FillAreaStyleColour("", color));
     const fillStyle = repo.add(new FillAreaStyle("", [fillColor]));
     const surfaceFill = repo.add(new SurfaceStyleFillArea(fillStyle));
@@ -686,7 +1115,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     const presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
     const styledItem = repo.add(new StyledItem("", [presStyle], solidRef));
     styledItems.push(styledItem);
-  }
+  });
   repo.add(
     new MechanicalDesignGeometricPresentationRepresentation(
       "",
@@ -698,7 +1127,8 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     new AdvancedBrepShapeRepresentation(productName, allSolids, geomContext)
   );
   repo.add(new ShapeDefinitionRepresentation(productDefShape, shapeRep));
-  return repo.toPartFile({ name: productName });
+  const stepText = repo.toPartFile({ name: productName });
+  return normalizeStepNumericExponents(stepText);
 }
 export {
   circuitJsonToStep