circuit-json-to-step 0.0.22 → 0.0.24

package/dist/index.js

@@ -26,207 +26,283 @@ import {
   AdvancedFace as AdvancedFace3,
   Circle as Circle2,
   ClosedShell as ClosedShell2,
-  ManifoldSolidBrep as ManifoldSolidBrep3,
-  ColourRgb,
-  FillAreaStyleColour,
-  FillAreaStyle,
-  SurfaceStyleFillArea,
-  SurfaceSideStyle,
-  SurfaceStyleUsage,
-  PresentationStyleAssignment,
-  StyledItem,
+  ManifoldSolidBrep as ManifoldSolidBrep4,
   MechanicalDesignGeometricPresentationRepresentation,
   AdvancedBrepShapeRepresentation,
   ShapeDefinitionRepresentation
 } from "stepts";
 
 // lib/mesh-generation.ts
+import "stepts";
+
+// lib/scene-box-to-step.ts
+import { ClosedShell, ManifoldSolidBrep } from "stepts";
+
+// lib/step-style-utils.ts
+import {
+  ColourRgb,
+  FillAreaStyle,
+  FillAreaStyleColour,
+  PresentationStyleAssignment,
+  StyledItem,
+  SurfaceSideStyle,
+  SurfaceStyleFillArea,
+  SurfaceStyleUsage
+} from "stepts";
+function createStyleCache() {
+  return /* @__PURE__ */ new Map();
+}
+function createStyledItem(repo, options) {
+  const { itemRef, rgb, styleCache, name = "color" } = options;
+  const key = rgb.map((value) => value.toFixed(6)).join(",");
+  let presStyle = styleCache.get(key);
+  if (!presStyle) {
+    const color = repo.add(new ColourRgb("", rgb[0], rgb[1], rgb[2]));
+    const fillColor = repo.add(new FillAreaStyleColour("", color));
+    const fillStyle = repo.add(new FillAreaStyle("", [fillColor]));
+    const surfaceFill = repo.add(new SurfaceStyleFillArea(fillStyle));
+    const surfaceSide = repo.add(new SurfaceSideStyle("", [surfaceFill]));
+    const surfaceUsage = repo.add(new SurfaceStyleUsage(".BOTH.", surfaceSide));
+    presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
+    styleCache.set(key, presStyle);
+  }
+  return repo.add(new StyledItem(name, [presStyle], itemRef));
+}
+function createStyledItems(repo, options) {
+  const { itemRefs, rgb, styleCache, name } = options;
+  return itemRefs.map(
+    (itemRef) => createStyledItem(repo, { itemRef, rgb, styleCache, name })
+  );
+}
+
+// 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;
+  };
+  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 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 {
+    solid: repo.add(new ManifoldSolidBrep(box.label ?? "Component", shell)),
+    styledItems: [],
+    usesIntrinsicFaceStyles: false,
+    styleTargets: faces
+  };
 }
-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
-        )
+function createSceneMeshSolid(repo, box) {
+  const styleCache = createStyleCache();
+  const styledItems = [];
+  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);
+    });
+    const face = createFaceFromVertices(repo, vertices);
+    const faceColor = normalizeTriangleColor(triangle.color);
+    if (faceColor) {
+      styledItems.push(
+        createStyledItem(repo, {
+          itemRef: face,
+          rgb: faceColor,
+          styleCache
+        })
       );
-      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 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;
+    }
+    return face;
+  });
+  const shell = repo.add(new ClosedShell("", faces));
+  return {
+    solid: repo.add(new ManifoldSolidBrep(box.label ?? "Component", shell)),
+    styledItems,
+    usesIntrinsicFaceStyles: faces.length > 0 && styledItems.length === faces.length,
+    styleTargets: []
+  };
+}
+function normalizeTriangleColor(color) {
+  if (!Array.isArray(color) || color.length < 3) return null;
+  const scale = color.some((value) => value > 1) ? 255 : 1;
+  return [
+    clampColorChannel(color[0] / scale),
+    clampColorChannel(color[1] / scale),
+    clampColorChannel(color[2] / scale)
+  ];
+}
+function clampColorChannel(value) {
+  return Math.max(0, Math.min(1, value));
 }
+
+// lib/mesh-generation.ts
 async function generateComponentMeshes(options) {
   const {
     repo,
@@ -239,25 +315,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 +341,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 +352,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 +365,7 @@ async function generateComponentMeshes(options) {
 import {
   CartesianPoint as CartesianPoint2,
   Direction as Direction2,
-  ManifoldSolidBrep as ManifoldSolidBrep2,
+  ManifoldSolidBrep as ManifoldSolidBrep3,
   Ref,
   Unknown,
   parseRepository
@@ -343,17 +384,6 @@ var EXCLUDED_ENTITY_TYPES = /* @__PURE__ */ new Set([
   "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",
@@ -498,7 +528,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 +578,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 +752,7 @@ function normalizeStepNumericExponents(stepText) {
 var package_default = {
   name: "circuit-json-to-step",
   main: "dist/index.js",
-  version: "0.0.21",
+  version: "0.0.23",
   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"' {} \\;`,
@@ -740,7 +770,7 @@ var package_default = {
     "@resvg/resvg-wasm": "^2.6.2",
     "@tscircuit/circuit-json-util": "^0.0.75",
     "@types/bun": "latest",
-    "circuit-json": "^0.0.286",
+    "circuit-json": "^0.0.406",
     "looks-same": "^10.0.1",
     "occt-import-js": "^0.0.23",
     poppygl: "^0.0.17",
@@ -752,7 +782,7 @@ 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.4"
@@ -1049,7 +1079,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 +1103,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1088,7 +1119,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1103,7 +1135,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1118,7 +1151,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1135,7 +1169,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1150,7 +1185,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir
       )
     );
@@ -1165,7 +1201,8 @@ function createPillCylindricalFaces(repo, hole, boardThickness, xDir, zDir) {
         rotation,
         centerX,
         centerY,
-        boardThickness,
+        zMin,
+        zMax,
         zDir,
         xDir
       )
@@ -1180,14 +1217,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 +1247,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 +1276,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 +1291,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 +1299,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 +1352,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 +1389,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 +1410,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 +1438,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 +1528,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 +1538,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 +1548,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 +1581,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 +1607,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(
@@ -1584,16 +1637,20 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   );
   const bottomHoleLoops = [];
   for (const hole of holes) {
-    const holeShape = hole.hole_shape || hole.shape;
+    const holeShape = hole.hole_shape ?? hole.shape;
     if (holeShape === "circle") {
-      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 holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 2;
+      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,22 +1670,19 @@ 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)));
     }
   }
   const bottomFace = repo.add(
     new AdvancedFace3(
       "",
-      [
-        repo.add(new FaceOuterBound3("", bottomLoop, true)),
-        ...bottomHoleLoops
-      ],
+      [repo.add(new FaceOuterBound3("", bottomLoop, true)), ...bottomHoleLoops],
       bottomPlane,
       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(
@@ -1639,19 +1693,19 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   );
   const topHoleLoops = [];
   for (const hole of holes) {
-    const holeShape = hole.hole_shape || hole.shape;
+    const holeShape = hole.hole_shape ?? hole.shape;
     if (holeShape === "circle") {
-      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 holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 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 +1721,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 +1743,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));
@@ -1717,16 +1771,20 @@ async function circuitJsonToStep(circuitJson, options = {}) {
   }
   const holeCylindricalFaces = [];
   for (const hole of holes) {
-    const holeShape = hole.hole_shape || hole.shape;
+    const holeShape = hole.hole_shape ?? hole.shape;
     if (holeShape === "circle") {
-      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 holeX = typeof hole.x === "number" ? hole.x : hole.x ?? 0;
+      const holeY = typeof hole.y === "number" ? hole.y : hole.y ?? 0;
+      const radius = (hole.hole_diameter ?? 0) / 2;
+      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 +1808,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 +1850,8 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       const pillFaces = createPillCylindricalFaces(
         repo,
         hole,
-        boardThickness,
+        -halfBoardThickness,
+        halfBoardThickness,
         xDir,
         zDir
       );
@@ -1800,9 +1859,17 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     }
   }
   const allFaces = [bottomFace, topFace, ...sideFaces, ...holeCylindricalFaces];
+  const styleCache = createStyleCache();
+  const boardStyledItems = createStyledItems(repo, {
+    itemRefs: allFaces,
+    rgb: [0.2, 0.6, 0.2],
+    styleCache
+  });
   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];
+  const componentStyledItems = [];
+  const solidsWithIntrinsicFaceStyles = /* @__PURE__ */ new Set();
   let handledComponentIds = /* @__PURE__ */ new Set();
   let handledPcbComponentIds = /* @__PURE__ */ new Set();
   if (options.includeComponents && options.includeExternalMeshes) {
@@ -1815,6 +1882,9 @@ async function circuitJsonToStep(circuitJson, options = {}) {
     handledComponentIds = mergeResult.handledComponentIds;
     handledPcbComponentIds = mergeResult.handledPcbComponentIds;
     allSolids.push(...mergeResult.solids);
+    mergeResult.solids.forEach((solidRef) => {
+      solidsWithIntrinsicFaceStyles.add(String(solidRef.id));
+    });
   }
   if (options.includeComponents) {
     const pcbComponentIdsWithStepUrl = /* @__PURE__ */ new Set();
@@ -1854,21 +1924,39 @@ async function circuitJsonToStep(circuitJson, options = {}) {
         excludePcbComponentIds: handledPcbComponentIds,
         pcbComponentIdsWithStepUrl
       });
-      allSolids.push(...componentSolids);
+      for (const componentSolid of componentSolids) {
+        allSolids.push(componentSolid.solid);
+        componentStyledItems.push(...componentSolid.styledItems);
+        if (componentSolid.usesIntrinsicFaceStyles) {
+          solidsWithIntrinsicFaceStyles.add(String(componentSolid.solid.id));
+        } else if (componentSolid.styleTargets.length > 0) {
+          componentStyledItems.push(
+            ...createStyledItems(repo, {
+              itemRefs: componentSolid.styleTargets,
+              rgb: [0.75, 0.75, 0.75],
+              styleCache
+            })
+          );
+          solidsWithIntrinsicFaceStyles.add(String(componentSolid.solid.id));
+        }
+      }
     }
   }
-  const styledItems = [];
-  allSolids.forEach((solidRef, index) => {
+  const styledItems = [
+    ...boardStyledItems,
+    ...componentStyledItems
+  ];
+  allSolids.forEach((itemRef, 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));
-    const surfaceSide = repo.add(new SurfaceSideStyle("", [surfaceFill]));
-    const surfaceUsage = repo.add(new SurfaceStyleUsage(".BOTH.", surfaceSide));
-    const presStyle = repo.add(new PresentationStyleAssignment([surfaceUsage]));
-    const styledItem = repo.add(new StyledItem("", [presStyle], solidRef));
+    if (isBoard || solidsWithIntrinsicFaceStyles.has(String(itemRef.id))) {
+      return;
+    }
+    const styledItem = createStyledItem(repo, {
+      itemRef,
+      rgb: [0.75, 0.75, 0.75],
+      styleCache,
+      name: ""
+    });
     styledItems.push(styledItem);
   });
   repo.add(