@tscircuit/3d-viewer 0.0.390 → 0.0.391

package/dist/index.js

@@ -1129,13 +1129,13 @@ var require_squaredLength = __commonJS({
 var require_subtract = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/subtract.js"(exports, module) {
     "use strict";
-    var subtract3 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       out[2] = a[2] - b[2];
       return out;
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -1676,7 +1676,7 @@ var require_scale2 = __commonJS({
 var require_subtract2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/subtract.js"(exports, module) {
     "use strict";
-    var subtract3 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       out[2] = a[2] - b[2];
@@ -1695,7 +1695,7 @@ var require_subtract2 = __commonJS({
       out[15] = a[15] - b[15];
       return out;
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -2205,12 +2205,12 @@ var require_squaredLength2 = __commonJS({
 var require_subtract3 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/subtract.js"(exports, module) {
     "use strict";
-    var subtract3 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       return out;
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -2671,14 +2671,14 @@ var require_point_line_distance = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/point-line-distance.js"(exports, module) {
     "use strict";
     var cross = require_cross();
-    var subtract3 = require_subtract();
+    var subtract4 = require_subtract();
     var squaredLength = require_squaredLength();
     var distanceSquared = (p, a, b) => {
       const ab = [];
       const ap = [];
       const cr = [];
-      subtract3(ab, b, a);
-      subtract3(ap, p, a);
+      subtract4(ab, b, a);
+      subtract4(ap, p, a);
       const area = squaredLength(cross(cr, ap, ab));
       const s = squaredLength(ab);
       if (s === 0) {
@@ -2697,11 +2697,11 @@ var require_get_plane_normal = __commonJS({
     "use strict";
     var cross = require_cross();
     var normalize = require_normalize();
-    var subtract3 = require_subtract();
+    var subtract4 = require_subtract();
     var planeNormal = (out, point1, point2, point32) => {
       const tmp = [0, 0, 0];
-      subtract3(out, point1, point2);
-      subtract3(tmp, point2, point32);
+      subtract4(out, point1, point2);
+      subtract4(tmp, point2, point32);
       cross(out, out, tmp);
       return normalize(out, out);
     };
@@ -2915,7 +2915,7 @@ var require_Face = __commonJS({
     var length2 = require_length();
     var normalize = require_normalize();
     var scale2 = require_scale();
-    var subtract3 = require_subtract();
+    var subtract4 = require_subtract();
     var HalfEdge = require_HalfEdge();
     var VISIBLE = 0;
     var NON_CONVEX = 1;
@@ -2949,14 +2949,14 @@ var require_Face = __commonJS({
         const e0 = this.edge;
         const e1 = e0.next;
         let e2 = e1.next;
-        const v2 = subtract3([], e1.head().point, e0.head().point);
+        const v2 = subtract4([], e1.head().point, e0.head().point);
         const t = [];
         const v1 = [];
         this.nVertices = 2;
         this.normal = [0, 0, 0];
         while (e2 !== e0) {
           copy(v1, v2);
-          subtract3(v2, e2.head().point, e0.head().point);
+          subtract4(v2, e2.head().point, e0.head().point);
           add(this.normal, this.normal, cross(t, v1, v2));
           e2 = e2.next;
           this.nVertices += 1;
@@ -2980,7 +2980,7 @@ var require_Face = __commonJS({
           } while (edge !== this.edge);
           const p1 = maxEdge.tail().point;
           const p2 = maxEdge.head().point;
-          const maxVector = subtract3([], p2, p1);
+          const maxVector = subtract4([], p2, p1);
           const maxLength = Math.sqrt(maxSquaredLength);
           scale2(maxVector, maxVector, 1 / maxLength);
           const maxProjection = dot(this.normal, maxVector);
@@ -4102,11 +4102,11 @@ var require_invert2 = __commonJS({
     "use strict";
     var plane = require_plane();
     var create = require_create6();
-    var invert = (polygon2) => {
-      const vertices = polygon2.vertices.slice().reverse();
+    var invert = (polygon3) => {
+      const vertices = polygon3.vertices.slice().reverse();
       const inverted = create(vertices);
-      if (polygon2.plane) {
-        inverted.plane = plane.flip(plane.create(), polygon2.plane);
+      if (polygon3.plane) {
+        inverted.plane = plane.flip(plane.create(), polygon3.plane);
       }
       return inverted;
     };
@@ -4138,7 +4138,7 @@ var require_isConvex = __commonJS({
     "use strict";
     var plane = require_plane();
     var vec3 = require_vec3();
-    var isConvex = (polygon2) => areVerticesConvex(polygon2.vertices);
+    var isConvex = (polygon3) => areVerticesConvex(polygon3.vertices);
     var areVerticesConvex = (vertices) => {
       const numvertices = vertices.length;
       if (numvertices > 2) {
@@ -4174,11 +4174,11 @@ var require_plane2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/plane.js"(exports, module) {
     "use strict";
     var mplane = require_plane();
-    var plane = (polygon2) => {
-      if (!polygon2.plane) {
-        polygon2.plane = mplane.fromPoints(mplane.create(), ...polygon2.vertices);
+    var plane = (polygon3) => {
+      if (!polygon3.plane) {
+        polygon3.plane = mplane.fromPoints(mplane.create(), ...polygon3.vertices);
       }
-      return polygon2.plane;
+      return polygon3.plane;
     };
     module.exports = plane;
   }
@@ -4189,13 +4189,13 @@ var require_measureArea = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureArea.js"(exports, module) {
     "use strict";
     var plane = require_plane2();
-    var measureArea = (polygon2) => {
-      const n = polygon2.vertices.length;
+    var measureArea = (polygon3) => {
+      const n = polygon3.vertices.length;
       if (n < 3) {
         return 0;
       }
-      const vertices = polygon2.vertices;
-      const normal = plane(polygon2);
+      const vertices = polygon3.vertices;
+      const normal = plane(polygon3);
       const ax = Math.abs(normal[0]);
       const ay = Math.abs(normal[1]);
       const az = Math.abs(normal[2]);
@@ -4254,8 +4254,8 @@ var require_measureBoundingBox = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureBoundingBox.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureBoundingBox = (polygon2) => {
-      const vertices = polygon2.vertices;
+    var measureBoundingBox = (polygon3) => {
+      const vertices = polygon3.vertices;
       const numvertices = vertices.length;
       const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0]);
       const max = vec3.clone(min);
@@ -4333,10 +4333,10 @@ var require_measureBoundingSphere = __commonJS({
     "use strict";
     var vec4 = require_vec4();
     var cache = /* @__PURE__ */ new WeakMap();
-    var measureBoundingSphere = (polygon2) => {
-      const boundingSphere = cache.get(polygon2);
+    var measureBoundingSphere = (polygon3) => {
+      const boundingSphere = cache.get(polygon3);
       if (boundingSphere) return boundingSphere;
-      const vertices = polygon2.vertices;
+      const vertices = polygon3.vertices;
       const out = vec4.create();
       if (vertices.length === 0) {
         out[0] = 0;
@@ -4366,7 +4366,7 @@ var require_measureBoundingSphere = __commonJS({
       const y = out[1] - maxy[1];
       const z105 = out[2] - maxz[2];
       out[3] = Math.sqrt(x * x + y * y + z105 * z105);
-      cache.set(polygon2, out);
+      cache.set(polygon3, out);
       return out;
     };
     module.exports = measureBoundingSphere;
@@ -4378,9 +4378,9 @@ var require_measureSignedVolume = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureSignedVolume.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureSignedVolume = (polygon2) => {
+    var measureSignedVolume = (polygon3) => {
       let signedVolume = 0;
-      const vertices = polygon2.vertices;
+      const vertices = polygon3.vertices;
       const cross = vec3.create();
       for (let i = 0; i < vertices.length - 2; i++) {
         vec3.cross(cross, vertices[i + 1], vertices[i + 2]);
@@ -4397,7 +4397,7 @@ var require_measureSignedVolume = __commonJS({
 var require_toPoints2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/toPoints.js"(exports, module) {
     "use strict";
-    var toPoints = (polygon2) => polygon2.vertices;
+    var toPoints = (polygon3) => polygon3.vertices;
     module.exports = toPoints;
   }
 });
@@ -4407,9 +4407,9 @@ var require_toString6 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/toString.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var toString = (polygon2) => {
+    var toString = (polygon3) => {
       let result = "poly3: vertices: [";
-      polygon2.vertices.forEach((vertex) => {
+      polygon3.vertices.forEach((vertex) => {
         result += `${vec3.toString(vertex)}, `;
       });
       result += "]";
@@ -4426,8 +4426,8 @@ var require_transform6 = __commonJS({
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var create = require_create6();
-    var transform2 = (matrix, polygon2) => {
-      const vertices = polygon2.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
+    var transform2 = (matrix, polygon3) => {
+      const vertices = polygon3.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
       if (mat4.isMirroring(matrix)) {
         vertices.reverse();
       }
@@ -4543,8 +4543,8 @@ var require_fromPoints4 = __commonJS({
         throw new Error("the given points must be an array");
       }
       const polygons = listofpoints.map((points, index) => {
-        const polygon2 = poly3.create(points);
-        return polygon2;
+        const polygon3 = poly3.create(points);
+        return polygon3;
       });
       const result = create(polygons);
       return result;
@@ -4595,7 +4595,7 @@ var require_applyTransforms2 = __commonJS({
     var poly3 = require_poly3();
     var applyTransforms = (geometry) => {
       if (mat4.isIdentity(geometry.transforms)) return geometry;
-      geometry.polygons = geometry.polygons.map((polygon2) => poly3.transform(geometry.transforms, polygon2));
+      geometry.polygons = geometry.polygons.map((polygon3) => poly3.transform(geometry.transforms, polygon3));
       geometry.transforms = mat4.create();
       return geometry;
     };
@@ -4622,7 +4622,7 @@ var require_invert3 = __commonJS({
     var toPolygons = require_toPolygons();
     var invert = (geometry) => {
       const polygons = toPolygons(geometry);
-      const newpolygons = polygons.map((polygon2) => poly3.invert(polygon2));
+      const newpolygons = polygons.map((polygon3) => poly3.invert(polygon3));
       return create(newpolygons);
     };
     module.exports = invert;
@@ -4655,7 +4655,7 @@ var require_toPoints3 = __commonJS({
     var toPolygons = require_toPolygons();
     var toPoints = (geometry) => {
       const polygons = toPolygons(geometry);
-      const listofpoints = polygons.map((polygon2) => poly3.toPoints(polygon2));
+      const listofpoints = polygons.map((polygon3) => poly3.toPoints(polygon3));
       return listofpoints;
     };
     module.exports = toPoints;
@@ -4671,8 +4671,8 @@ var require_toString7 = __commonJS({
     var toString = (geometry) => {
       const polygons = toPolygons(geometry);
       let result = "geom3 (" + polygons.length + " polygons):\n";
-      polygons.forEach((polygon2) => {
-        result += "  " + poly3.toString(polygon2) + "\n";
+      polygons.forEach((polygon3) => {
+        result += "  " + poly3.toString(polygon3) + "\n";
       });
       return result;
     };
@@ -4689,7 +4689,7 @@ var require_toCompactBinary2 = __commonJS({
       const polygons = geometry.polygons;
       const transforms2 = geometry.transforms;
       const numberOfPolygons = polygons.length;
-      const numberOfVertices = polygons.reduce((count, polygon2) => count + polygon2.vertices.length, 0);
+      const numberOfVertices = polygons.reduce((count, polygon3) => count + polygon3.vertices.length, 0);
       let color = [-1, -1, -1, -1];
       if (geometry.color) color = geometry.color;
       const compacted = new Float32Array(1 + 16 + 4 + 1 + numberOfPolygons + numberOfVertices * 3);
@@ -4717,8 +4717,8 @@ var require_toCompactBinary2 = __commonJS({
       compacted[21] = numberOfVertices;
       let ci = 22;
       let vi = ci + numberOfPolygons;
-      polygons.forEach((polygon2) => {
-        const points = poly3.toPoints(polygon2);
+      polygons.forEach((polygon3) => {
+        const points = poly3.toPoints(polygon3);
         compacted[ci] = points.length;
         ci++;
         for (let i = 0; i < points.length; i++) {
@@ -6146,7 +6146,7 @@ var require_measureArea2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly2/measureArea.js"(exports, module) {
     "use strict";
     var area = require_area();
-    var measureArea = (polygon2) => area(polygon2.vertices);
+    var measureArea = (polygon3) => area(polygon3.vertices);
     module.exports = measureArea;
   }
 });
@@ -6170,8 +6170,8 @@ var require_flip2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly2/flip.js"(exports, module) {
     "use strict";
     var create = require_create10();
-    var flip = (polygon2) => {
-      const vertices = polygon2.vertices.slice().reverse();
+    var flip = (polygon3) => {
+      const vertices = polygon3.vertices.slice().reverse();
       return create(vertices);
     };
     module.exports = flip;
@@ -6184,22 +6184,22 @@ var require_arePointsInside = __commonJS({
     "use strict";
     var measureArea = require_measureArea2();
     var flip = require_flip2();
-    var arePointsInside = (points, polygon2) => {
+    var arePointsInside = (points, polygon3) => {
       if (points.length === 0) return 0;
-      const vertices = polygon2.vertices;
+      const vertices = polygon3.vertices;
       if (vertices.length < 3) return 0;
-      if (measureArea(polygon2) < 0) {
-        polygon2 = flip(polygon2);
+      if (measureArea(polygon3) < 0) {
+        polygon3 = flip(polygon3);
       }
       const sum = points.reduce((acc, point2) => acc + isPointInside(point2, vertices), 0);
       return sum === points.length ? 1 : 0;
     };
-    var isPointInside = (point2, polygon2) => {
-      const numverts = polygon2.length;
+    var isPointInside = (point2, polygon3) => {
+      const numverts = polygon3.length;
       const tx = point2[0];
       const ty = point2[1];
-      let vtx0 = polygon2[numverts - 1];
-      let vtx1 = polygon2[0];
+      let vtx0 = polygon3[numverts - 1];
+      let vtx1 = polygon3[0];
       let yflag0 = vtx0[1] > ty;
       let insideFlag = 0;
       let i = 0;
@@ -6218,7 +6218,7 @@ var require_arePointsInside = __commonJS({
         }
         yflag0 = yflag1;
         vtx0 = vtx1;
-        vtx1 = polygon2[++i];
+        vtx1 = polygon3[++i];
       }
       return insideFlag;
     };
@@ -6897,7 +6897,7 @@ var require_measureArea3 = __commonJS({
       let area = cache.get(geometry);
       if (area) return area;
       const polygons = geom3.toPolygons(geometry);
-      area = polygons.reduce((area2, polygon2) => area2 + poly3.measureArea(polygon2), 0);
+      area = polygons.reduce((area2, polygon3) => area2 + poly3.measureArea(polygon3), 0);
       cache.set(geometry, area);
       return area;
     };
@@ -7000,8 +7000,8 @@ var require_measureBoundingBox2 = __commonJS({
         vec3.copy(minpoint, points[0]);
       }
       let maxpoint = vec3.clone(minpoint);
-      polygons.forEach((polygon2) => {
-        poly3.toPoints(polygon2).forEach((point2) => {
+      polygons.forEach((polygon3) => {
+        poly3.toPoints(polygon3).forEach((point2) => {
           vec3.min(minpoint, minpoint, point2);
           vec3.max(maxpoint, maxpoint, point2);
         });
@@ -7108,7 +7108,7 @@ var require_measureVolume = __commonJS({
       let volume = cache.get(geometry);
       if (volume) return volume;
       const polygons = geom3.toPolygons(geometry);
-      volume = polygons.reduce((volume2, polygon2) => volume2 + poly3.measureSignedVolume(polygon2), 0);
+      volume = polygons.reduce((volume2, polygon3) => volume2 + poly3.measureSignedVolume(polygon3), 0);
       cache.set(geometry, volume);
       return volume;
     };
@@ -7213,15 +7213,15 @@ var require_measureBoundingSphere2 = __commonJS({
       const polygons = geom3.toPolygons(geometry);
       if (polygons.length > 0) {
         let numPoints = 0;
-        polygons.forEach((polygon2) => {
-          poly3.toPoints(polygon2).forEach((point2) => {
+        polygons.forEach((polygon3) => {
+          poly3.toPoints(polygon3).forEach((point2) => {
             vec3.add(centroid, centroid, point2);
             numPoints++;
           });
         });
         vec3.scale(centroid, centroid, 1 / numPoints);
-        polygons.forEach((polygon2) => {
-          poly3.toPoints(polygon2).forEach((point2) => {
+        polygons.forEach((polygon3) => {
+          poly3.toPoints(polygon3).forEach((point2) => {
             radius = Math.max(radius, vec3.squaredDistance(centroid, point2));
           });
         });
@@ -7309,8 +7309,8 @@ var require_measureCenterOfMass = __commonJS({
       if (polygons.length === 0) return centerOfMass;
       let totalVolume = 0;
       const vector = vec3.create();
-      polygons.forEach((polygon2) => {
-        const vertices = polygon2.vertices;
+      polygons.forEach((polygon3) => {
+        const vertices = polygon3.vertices;
         for (let i = 0; i < vertices.length - 2; i++) {
           vec3.cross(vector, vertices[i + 1], vertices[i + 2]);
           const volume = vec3.dot(vertices[0], vector) / 6;
@@ -7891,9 +7891,9 @@ var require_polyhedron = __commonJS({
         faces.forEach((face) => face.reverse());
       }
       const polygons = faces.map((face, findex) => {
-        const polygon2 = poly3.create(face.map((pindex) => points[pindex]));
-        if (colors2 && colors2[findex]) polygon2.color = colors2[findex];
-        return polygon2;
+        const polygon3 = poly3.create(face.map((pindex) => points[pindex]));
+        if (colors2 && colors2[findex]) polygon3.color = colors2[findex];
+        return polygon3;
       });
       return geom3.create(polygons);
     };
@@ -8046,7 +8046,7 @@ var require_polygon = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/polygon.js"(exports, module) {
     "use strict";
     var geom2 = require_geom2();
-    var polygon2 = (options) => {
+    var polygon3 = (options) => {
       const defaults = {
         points: [],
         paths: [],
@@ -8087,7 +8087,7 @@ var require_polygon = __commonJS({
       }
       return geometry;
     };
-    module.exports = polygon2;
+    module.exports = polygon3;
   }
 });
 
@@ -10343,12 +10343,12 @@ var require_fromFakePolygons = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var geom2 = require_geom2();
-    var fromFakePolygon = (epsilon, polygon2) => {
-      if (polygon2.vertices.length < 4) {
+    var fromFakePolygon = (epsilon, polygon3) => {
+      if (polygon3.vertices.length < 4) {
         return null;
       }
       const vert1Indices = [];
-      const points3D = polygon2.vertices.filter((vertex, i) => {
+      const points3D = polygon3.vertices.filter((vertex, i) => {
         if (vertex[2] > 0) {
           vert1Indices.push(i);
           return true;
@@ -10375,7 +10375,7 @@ var require_fromFakePolygons = __commonJS({
       return points2D;
     };
     var fromFakePolygons = (epsilon, polygons) => {
-      const sides = polygons.map((polygon2) => fromFakePolygon(epsilon, polygon2)).filter((polygon2) => polygon2 !== null);
+      const sides = polygons.map((polygon3) => fromFakePolygon(epsilon, polygon3)).filter((polygon3) => polygon3 !== null);
       return geom2.create(sides);
     };
     module.exports = fromFakePolygons;
@@ -10732,8 +10732,8 @@ var require_reTesselateCoplanarPolygons = __commonJS({
               prevpolygon.outpolygon.leftpoints.reverse();
               const points2d = prevpolygon.outpolygon.rightpoints.concat(prevpolygon.outpolygon.leftpoints);
               const vertices3d = points2d.map((point2d) => orthobasis.to3D(point2d));
-              const polygon2 = poly3.fromPointsAndPlane(vertices3d, plane);
-              if (polygon2.vertices.length) destpolygons.push(polygon2);
+              const polygon3 = poly3.fromPointsAndPlane(vertices3d, plane);
+              if (polygon3.vertices.length) destpolygons.push(polygon3);
             }
           }
         }
@@ -10777,7 +10777,7 @@ var require_retessellate = __commonJS({
       if (geometry.isRetesselated) {
         return geometry;
       }
-      const polygons = geom3.toPolygons(geometry).map((polygon2, index) => ({ vertices: polygon2.vertices, plane: poly3.plane(polygon2), index }));
+      const polygons = geom3.toPolygons(geometry).map((polygon3, index) => ({ vertices: polygon3.vertices, plane: poly3.plane(polygon3), index }));
       const classified = classifyPolygons(polygons);
       const destPolygons = [];
       classified.forEach((group) => {
@@ -10823,8 +10823,8 @@ var require_retessellate = __commonJS({
       clusters.forEach((cluster) => {
         if (cluster[0]) result[cluster[0].index] = cluster;
       });
-      nonCoplanar.forEach((polygon2) => {
-        result[polygon2.index] = polygon2;
+      nonCoplanar.forEach((polygon3) => {
+        result[polygon3.index] = polygon3;
       });
       return result;
     };
@@ -11016,15 +11016,15 @@ var require_splitPolygonByPlane = __commonJS({
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitLineSegmentByPlane = require_splitLineSegmentByPlane();
-    var splitPolygonByPlane = (splane, polygon2) => {
+    var splitPolygonByPlane = (splane, polygon3) => {
       const result = {
         type: null,
         front: null,
         back: null
       };
-      const vertices = polygon2.vertices;
+      const vertices = polygon3.vertices;
       const numvertices = vertices.length;
-      const pplane = poly3.plane(polygon2);
+      const pplane = poly3.plane(polygon3);
       if (plane.equals(pplane, splane)) {
         result.type = 0;
       } else {
@@ -11124,10 +11124,10 @@ var require_PolygonTreeNode = __commonJS({
     var splitPolygonByPlane = require_splitPolygonByPlane();
     var PolygonTreeNode = class _PolygonTreeNode {
       // constructor creates the root node
-      constructor(parent, polygon2) {
+      constructor(parent, polygon3) {
         this.parent = parent;
         this.children = [];
-        this.polygon = polygon2;
+        this.polygon = polygon3;
         this.removed = false;
       }
       // fill the tree with polygons. Should be called on the root node only; child nodes must
@@ -11137,8 +11137,8 @@ var require_PolygonTreeNode = __commonJS({
           throw new Error("Assertion failed");
         }
         const _this = this;
-        polygons.forEach((polygon2) => {
-          _this.addChild(polygon2);
+        polygons.forEach((polygon3) => {
+          _this.addChild(polygon3);
         });
       }
       // remove a node
@@ -11215,9 +11215,9 @@ var require_PolygonTreeNode = __commonJS({
       }
       // only to be called for nodes with no children
       _splitByPlane(splane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes) {
-        const polygon2 = this.polygon;
-        if (polygon2) {
-          const bound = poly3.measureBoundingSphere(polygon2);
+        const polygon3 = this.polygon;
+        if (polygon3) {
+          const bound = poly3.measureBoundingSphere(polygon3);
           const sphereradius = bound[3] + EPS;
           const spherecenter = bound;
           const d = vec3.dot(splane, spherecenter) - splane[3];
@@ -11226,7 +11226,7 @@ var require_PolygonTreeNode = __commonJS({
           } else if (d < -sphereradius) {
             backnodes.push(this);
           } else {
-            const splitresult = splitPolygonByPlane(splane, polygon2);
+            const splitresult = splitPolygonByPlane(splane, polygon3);
             switch (splitresult.type) {
               case 0:
                 coplanarfrontnodes.push(this);
@@ -11259,8 +11259,8 @@ var require_PolygonTreeNode = __commonJS({
       // this should be called whenever the polygon is split
       // a child should be created for every fragment of the split polygon
       // returns the newly created child
-      addChild(polygon2) {
-        const newchild = new _PolygonTreeNode(this, polygon2);
+      addChild(polygon3) {
+        const newchild = new _PolygonTreeNode(this, polygon3);
         this.children.push(newchild);
         return newchild;
       }
@@ -11510,14 +11510,14 @@ var require_scissionGeom3 = __commonJS({
       const pl = polygons.length;
       const indexesPerPoint = /* @__PURE__ */ new Map();
       const temp = vec3.create();
-      polygons.forEach((polygon2, index) => {
-        polygon2.vertices.forEach((point2) => {
+      polygons.forEach((polygon3, index) => {
+        polygon3.vertices.forEach((point2) => {
           insertMapping(indexesPerPoint, vec3.snap(temp, point2, eps), index);
         });
       });
-      const indexesPerPolygon = polygons.map((polygon2) => {
+      const indexesPerPolygon = polygons.map((polygon3) => {
         let indexes = [];
-        polygon2.vertices.forEach((point2) => {
+        polygon3.vertices.forEach((point2) => {
           indexes = indexes.concat(findMapping(indexesPerPoint, vec3.snap(temp, point2, eps)));
         });
         return { e: 1, d: sortNb(indexes) };
@@ -11612,7 +11612,7 @@ var require_subtractGeom3 = __commonJS({
     var flatten = require_flatten();
     var retessellate = require_retessellate();
     var subtractSub = require_subtractGeom3Sub();
-    var subtract3 = (...geometries2) => {
+    var subtract4 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       let newgeometry = geometries2.shift();
       geometries2.forEach((geometry) => {
@@ -11621,7 +11621,7 @@ var require_subtractGeom3 = __commonJS({
       newgeometry = retessellate(newgeometry);
       return newgeometry;
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -11635,14 +11635,14 @@ var require_subtractGeom2 = __commonJS({
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
     var subtractGeom3 = require_subtractGeom3();
-    var subtract3 = (...geometries2) => {
+    var subtract4 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       const newgeometries = geometries2.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = subtractGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
       return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3));
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -11656,7 +11656,7 @@ var require_subtract4 = __commonJS({
     var geom3 = require_geom3();
     var subtractGeom2 = require_subtractGeom2();
     var subtractGeom3 = require_subtractGeom3();
-    var subtract3 = (...geometries2) => {
+    var subtract4 = (...geometries2) => {
       geometries2 = flatten(geometries2);
       if (geometries2.length === 0) throw new Error("wrong number of arguments");
       if (!areAllShapesTheSameType(geometries2)) {
@@ -11667,7 +11667,7 @@ var require_subtract4 = __commonJS({
       if (geom3.isA(geometry)) return subtractGeom3(geometries2);
       return geometry;
     };
-    module.exports = subtract3;
+    module.exports = subtract4;
   }
 });
 
@@ -11963,19 +11963,19 @@ var require_extrudePolygon = __commonJS({
         polygon1 = poly3.invert(polygon1);
       }
       const newpolygons = [polygon1];
-      const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1);
+      const polygon22 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1);
       const numvertices = polygon1.vertices.length;
       for (let i = 0; i < numvertices; i++) {
         const nexti = i < numvertices - 1 ? i + 1 : 0;
         const sideFacePolygon = poly3.create([
           polygon1.vertices[i],
-          polygon2.vertices[i],
-          polygon2.vertices[nexti],
+          polygon22.vertices[i],
+          polygon22.vertices[nexti],
           polygon1.vertices[nexti]
         ]);
         newpolygons.push(sideFacePolygon);
       }
-      newpolygons.push(poly3.invert(polygon2));
+      newpolygons.push(poly3.invert(polygon22));
       return geom3.create(newpolygons);
     };
     module.exports = extrudePolygon;
@@ -12036,17 +12036,17 @@ var require_expandShell = __commonJS({
       const v1 = vec3.create();
       const v2 = vec3.create();
       const polygons = geom3.toPolygons(geometry);
-      polygons.forEach((polygon2, index) => {
-        const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon2), 2 * delta);
-        const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon2);
+      polygons.forEach((polygon3, index) => {
+        const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon3), 2 * delta);
+        const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon3);
         const extrudedface = extrudePolygon(extrudevector, translatedpolygon);
         result = unionGeom3Sub(result, extrudedface);
-        const vertices = polygon2.vertices;
+        const vertices = polygon3.vertices;
         for (let i = 0; i < vertices.length; i++) {
-          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon2));
+          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon3));
           const j = (i + 1) % vertices.length;
           const edge = [vertices[i], vertices[j]];
-          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon2));
+          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon3));
         }
       });
       edges2planes.forEach((item) => {
@@ -12100,8 +12100,8 @@ var require_expandShell = __commonJS({
               startfacevertices.push(p1);
               endfacevertices.push(p2);
               const points = [prevp2, p2, p1, prevp1];
-              const polygon2 = poly3.create(points);
-              polygons2.push(polygon2);
+              const polygon3 = poly3.create(points);
+              polygons2.push(polygon3);
             }
             prevp1 = p1;
             prevp2 = p2;
@@ -12303,7 +12303,7 @@ var require_offsetGeom2 = __commonJS({
       }
       const outlines = geom2.toOutlines(geometry);
       const newoutlines = outlines.map((outline) => {
-        const level = outlines.reduce((acc, polygon2) => acc + poly2.arePointsInside(outline, poly2.create(polygon2)), 0);
+        const level = outlines.reduce((acc, polygon3) => acc + poly2.arePointsInside(outline, poly2.create(polygon3)), 0);
         const outside = level % 2 === 0;
         options = {
           delta: outside ? delta : -delta,
@@ -12920,24 +12920,24 @@ var require_snapPolygons = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var isValidPoly3 = (epsilon, polygon2) => {
-      const area = Math.abs(poly3.measureArea(polygon2));
+    var isValidPoly3 = (epsilon, polygon3) => {
+      const area = Math.abs(poly3.measureArea(polygon3));
       return Number.isFinite(area) && area > epsilon;
     };
     var snapPolygons = (epsilon, polygons) => {
-      let newpolygons = polygons.map((polygon2) => {
-        const snapvertices = polygon2.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon));
+      let newpolygons = polygons.map((polygon3) => {
+        const snapvertices = polygon3.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon));
         const newvertices = [];
         for (let i = 0; i < snapvertices.length; i++) {
           const j = (i + 1) % snapvertices.length;
           if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i]);
         }
         const newpolygon = poly3.create(newvertices);
-        if (polygon2.color) newpolygon.color = polygon2.color;
+        if (polygon3.color) newpolygon.color = polygon3.color;
         return newpolygon;
       });
       const epsilonArea = epsilon * epsilon * Math.sqrt(3) / 4;
-      newpolygons = newpolygons.filter((polygon2) => isValidPoly3(epsilonArea, polygon2));
+      newpolygons = newpolygons.filter((polygon3) => isValidPoly3(epsilonArea, polygon3));
       return newpolygons;
     };
     module.exports = snapPolygons;
@@ -12951,8 +12951,8 @@ var require_mergePolygons = __commonJS({
     var aboutEqualNormals = require_aboutEqualNormals();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var createEdges = (polygon2) => {
-      const points = poly3.toPoints(polygon2);
+    var createEdges = (polygon3) => {
+      const points = poly3.toPoints(polygon3);
       const edges = [];
       for (let i = 0; i < points.length; i++) {
         const j = (i + 1) % points.length;
@@ -13001,7 +13001,7 @@ var require_mergePolygons = __commonJS({
       return vec3.dot(d0, normal);
     };
     var createPolygonAnd = (edge) => {
-      let polygon2;
+      let polygon3;
       const points = [];
       while (edge.next) {
         const next = edge.next;
@@ -13012,8 +13012,8 @@ var require_mergePolygons = __commonJS({
         edge.prev = null;
         edge = next;
       }
-      if (points.length > 0) polygon2 = poly3.create(points);
-      return polygon2;
+      if (points.length > 0) polygon3 = poly3.create(points);
+      return polygon3;
     };
     var mergeCoplanarPolygons = (sourcepolygons) => {
       if (sourcepolygons.length < 2) return sourcepolygons;
@@ -13021,8 +13021,8 @@ var require_mergePolygons = __commonJS({
       const polygons = sourcepolygons.slice();
       const edgeList = /* @__PURE__ */ new Map();
       while (polygons.length > 0) {
-        const polygon2 = polygons.shift();
-        const edges = createEdges(polygon2);
+        const polygon3 = polygons.shift();
+        const edges = createEdges(polygon3);
         for (let i = 0; i < edges.length; i++) {
           const current2 = edges[i];
           const opposite = findOppositeEdge(edgeList, current2);
@@ -13078,8 +13078,8 @@ var require_mergePolygons = __commonJS({
       }
       const destpolygons = [];
       edgeList.forEach((edge) => {
-        const polygon2 = createPolygonAnd(edge);
-        if (polygon2) destpolygons.push(polygon2);
+        const polygon3 = createPolygonAnd(edge);
+        if (polygon3) destpolygons.push(polygon3);
       });
       edgeList.clear();
       return destpolygons;
@@ -13092,13 +13092,13 @@ var require_mergePolygons = __commonJS({
     };
     var mergePolygons = (epsilon, polygons) => {
       const polygonsPerPlane = [];
-      polygons.forEach((polygon2) => {
-        const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon2)));
+      polygons.forEach((polygon3) => {
+        const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon3)));
         if (mapping) {
           const polygons2 = mapping[1];
-          polygons2.push(polygon2);
+          polygons2.push(polygon3);
         } else {
-          polygonsPerPlane.push([poly3.plane(polygon2), [polygon2]]);
+          polygonsPerPlane.push([poly3.plane(polygon3), [polygon3]]);
         }
       });
       let destpolygons = [];
@@ -13194,15 +13194,15 @@ var require_insertTjunctions = __commonJS({
     var insertTjunctions = (polygons) => {
       const sidemap = /* @__PURE__ */ new Map();
       for (let polygonindex = 0; polygonindex < polygons.length; polygonindex++) {
-        const polygon2 = polygons[polygonindex];
-        const numvertices = polygon2.vertices.length;
+        const polygon3 = polygons[polygonindex];
+        const numvertices = polygon3.vertices.length;
         if (numvertices >= 3) {
-          let vertex = polygon2.vertices[0];
+          let vertex = polygon3.vertices[0];
           let vertextag = getTag(vertex);
           for (let vertexindex = 0; vertexindex < numvertices; vertexindex++) {
             let nextvertexindex = vertexindex + 1;
             if (nextvertexindex === numvertices) nextvertexindex = 0;
-            const nextvertex = polygon2.vertices[nextvertexindex];
+            const nextvertex = polygon3.vertices[nextvertexindex];
             const nextvertextag = getTag(nextvertex);
             const sidetag = `${vertextag}/${nextvertextag}`;
             const reversesidetag = `${nextvertextag}/${vertextag}`;
@@ -13310,17 +13310,17 @@ var require_insertTjunctions = __commonJS({
                       const distancesquared = vec3.squaredDistance(closestpoint, endpos);
                       if (distancesquared < constants.EPS * constants.EPS) {
                         const polygonindex = matchingside.polygonindex;
-                        const polygon2 = newpolygons[polygonindex];
+                        const polygon3 = newpolygons[polygonindex];
                         const insertionvertextag = getTag(matchingside.vertex1);
                         let insertionvertextagindex = -1;
-                        for (let i = 0; i < polygon2.vertices.length; i++) {
-                          if (getTag(polygon2.vertices[i]) === insertionvertextag) {
+                        for (let i = 0; i < polygon3.vertices.length; i++) {
+                          if (getTag(polygon3.vertices[i]) === insertionvertextag) {
                             insertionvertextagindex = i;
                             break;
                           }
                         }
                         if (assert && insertionvertextagindex < 0) throw new Error("assert failed");
-                        const newvertices = polygon2.vertices.slice(0);
+                        const newvertices = polygon3.vertices.slice(0);
                         newvertices.splice(insertionvertextagindex, 0, endvertex);
                         const newpolygon = poly3.create(newvertices);
                         newpolygons[polygonindex] = newpolygon;
@@ -13360,35 +13360,35 @@ var require_triangulatePolygons = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var triangulatePolygon = (epsilon, polygon2, triangles) => {
-      const nv = polygon2.vertices.length;
+    var triangulatePolygon = (epsilon, polygon3, triangles) => {
+      const nv = polygon3.vertices.length;
       if (nv > 3) {
         if (nv > 4) {
           const midpoint = [0, 0, 0];
-          polygon2.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
+          polygon3.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
           vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon);
           for (let i = 0; i < nv; i++) {
-            const poly = poly3.create([midpoint, polygon2.vertices[i], polygon2.vertices[(i + 1) % nv]]);
-            if (polygon2.color) poly.color = polygon2.color;
+            const poly = poly3.create([midpoint, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
+            if (polygon3.color) poly.color = polygon3.color;
             triangles.push(poly);
           }
           return;
         }
-        const poly0 = poly3.create([polygon2.vertices[0], polygon2.vertices[1], polygon2.vertices[2]]);
-        const poly1 = poly3.create([polygon2.vertices[0], polygon2.vertices[2], polygon2.vertices[3]]);
-        if (polygon2.color) {
-          poly0.color = polygon2.color;
-          poly1.color = polygon2.color;
+        const poly0 = poly3.create([polygon3.vertices[0], polygon3.vertices[1], polygon3.vertices[2]]);
+        const poly1 = poly3.create([polygon3.vertices[0], polygon3.vertices[2], polygon3.vertices[3]]);
+        if (polygon3.color) {
+          poly0.color = polygon3.color;
+          poly1.color = polygon3.color;
         }
         triangles.push(poly0, poly1);
         return;
       }
-      triangles.push(polygon2);
+      triangles.push(polygon3);
     };
     var triangulatePolygons = (epsilon, polygons) => {
       const triangles = [];
-      polygons.forEach((polygon2) => {
-        triangulatePolygon(epsilon, polygon2, triangles);
+      polygons.forEach((polygon3) => {
+        triangulatePolygon(epsilon, polygon3, triangles);
       });
       return triangles;
     };
@@ -24160,8 +24160,8 @@ var SmdChipLead = (props) => {
   const { thickness, width: width10, padContactLength, bodyDistance, height: height10, rotation: rotation2 } = props;
   const N = 15;
   const points = Array.from({ length: N }).map((_, i) => i / (N - 1) * bodyDistance).map((x) => [x, calculateSCurve(x, props)]);
-  const polygon2 = getExpandedStroke(points, thickness);
-  return /* @__PURE__ */ jsx5(Colorize, { color: "#fff", children: /* @__PURE__ */ jsx5(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx5(Rotate, { rotation: ["90deg", 0, rotation2 ?? 0], children: /* @__PURE__ */ jsx5(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx5(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx5(Polygon, { points: polygon2.map((p) => [p.x, p.y]) }) }) }) }) }) });
+  const polygon3 = getExpandedStroke(points, thickness);
+  return /* @__PURE__ */ jsx5(Colorize, { color: "#fff", children: /* @__PURE__ */ jsx5(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx5(Rotate, { rotation: ["90deg", 0, rotation2 ?? 0], children: /* @__PURE__ */ jsx5(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx5(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx5(Polygon, { points: polygon3.map((p) => [p.x, p.y]) }) }) }) }) }) });
 };
 var Tssop = ({
   pinCount,
@@ -25218,7 +25218,7 @@ var PushButtonLeg = (props) => {
     [-verticalLength / 5, horizontalLength / 4],
     [0, 0]
   ];
-  const polygon2 = getExpandedStroke(points, thickness);
+  const polygon3 = getExpandedStroke(points, thickness);
   return /* @__PURE__ */ jsx5(Colorize, { color: "#f2f2f2", children: /* @__PURE__ */ jsx5(
     Translate,
     {
@@ -25227,7 +25227,7 @@ var PushButtonLeg = (props) => {
         y: position?.y || 0,
         z: position?.z || 0
       },
-      children: /* @__PURE__ */ jsx5(Rotate, { rotation: [0, 55, rotation2], children: /* @__PURE__ */ jsx5(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx5(Polygon, { points: polygon2.map((p) => [p.y, p.x]) }) }) })
+      children: /* @__PURE__ */ jsx5(Rotate, { rotation: [0, 55, rotation2], children: /* @__PURE__ */ jsx5(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx5(Polygon, { points: polygon3.map((p) => [p.y, p.x]) }) }) })
     }
   ) });
 };
@@ -25619,8 +25619,8 @@ function convertCSGToThreeGeom(csg) {
     const indices = [];
     const colors2 = [];
     let idx = 0;
-    for (const polygon2 of csg.polygons) {
-      for (const vertex of polygon2.vertices) {
+    for (const polygon3 of csg.polygons) {
+      for (const vertex of polygon3.vertices) {
         vertex.index = idx;
         vertices.push(vertex[0], vertex[1], vertex[2]);
         if (csg.color && csg.color.length >= 3) {
@@ -25630,10 +25630,10 @@ function convertCSGToThreeGeom(csg) {
         }
         idx++;
       }
-      const first = polygon2.vertices[0].index;
-      for (let i = 2; i < polygon2.vertices.length; i++) {
-        const second = polygon2.vertices[i - 1].index;
-        const third = polygon2.vertices[i].index;
+      const first = polygon3.vertices[0].index;
+      for (let i = 2; i < polygon3.vertices.length; i++) {
+        const second = polygon3.vertices[i - 1].index;
+        const third = polygon3.vertices[i].index;
         indices.push(first, second, third);
       }
     }
@@ -26033,7 +26033,7 @@ import * as THREE11 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.389",
+  version: "0.0.390",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -26883,9 +26883,9 @@ var createBoardGeomFromCircuitJson = (circuitJson, opts = {}) => {
 
 // src/BoardGeomBuilder.ts
 var import_transforms3 = __toESM(require_transforms(), 1);
-var import_primitives5 = __toESM(require_primitives(), 1);
+var import_primitives6 = __toESM(require_primitives(), 1);
 var import_colors4 = __toESM(require_colors(), 1);
-var import_booleans2 = __toESM(require_booleans(), 1);
+var import_booleans3 = __toESM(require_booleans(), 1);
 import { su as su3 } from "@tscircuit/circuit-json-util";
 
 // src/geoms/plated-hole.ts
@@ -27432,6 +27432,91 @@ function createSilkscreenPathGeom(sp, ctx) {
   return pathGeom;
 }
 
+// src/geoms/brep-converter.ts
+var import_primitives5 = __toESM(require_primitives(), 1);
+var import_booleans2 = __toESM(require_booleans(), 1);
+function segmentToPoints(p1, p2, bulge, arcSegments) {
+  if (!bulge || Math.abs(bulge) < 1e-9) {
+    return [];
+  }
+  const theta = 4 * Math.atan(bulge);
+  const dx = p2[0] - p1[0];
+  const dy = p2[1] - p1[1];
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  if (dist < 1e-9) return [];
+  const radius = Math.abs(dist / (2 * Math.sin(theta / 2)));
+  const m = Math.sqrt(Math.max(0, radius * radius - dist / 2 * (dist / 2)));
+  const midPoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
+  const ux = dx / dist;
+  const uy = dy / dist;
+  const nx = -uy;
+  const ny = ux;
+  const centerX = midPoint[0] + nx * m * Math.sign(bulge);
+  const centerY = midPoint[1] + ny * m * Math.sign(bulge);
+  const startAngle = Math.atan2(p1[1] - centerY, p1[0] - centerX);
+  const points = [];
+  const numSteps = Math.max(
+    2,
+    Math.ceil(arcSegments * Math.abs(theta) / (Math.PI * 2) * 4)
+  );
+  const angleStep = theta / numSteps;
+  for (let i = 1; i < numSteps; i++) {
+    const angle = startAngle + angleStep * i;
+    points.push([
+      centerX + radius * Math.cos(angle),
+      centerY + radius * Math.sin(angle)
+    ]);
+  }
+  return points;
+}
+function ringToPoints(ring2, arcSegments) {
+  const allPoints = [];
+  const vertices = ring2.vertices;
+  for (let i = 0; i < vertices.length; i++) {
+    const p1 = vertices[i];
+    const p2 = vertices[(i + 1) % vertices.length];
+    allPoints.push([p1.x, p1.y]);
+    if (p1.bulge) {
+      const arcPoints = segmentToPoints(
+        [p1.x, p1.y],
+        [p2.x, p2.y],
+        p1.bulge,
+        arcSegments
+      );
+      allPoints.push(...arcPoints);
+    }
+  }
+  return allPoints;
+}
+function arePointsClockwise2(points) {
+  let area = 0;
+  for (let i = 0; i < points.length; i++) {
+    const j = (i + 1) % points.length;
+    area += points[i][0] * points[j][1];
+    area -= points[j][0] * points[i][1];
+  }
+  return area / 2 <= 0;
+}
+function createGeom2FromBRep(brep, arcSegments = 16) {
+  let outerPoints = ringToPoints(brep.outer_ring, arcSegments);
+  if (arePointsClockwise2(outerPoints)) {
+    outerPoints.reverse();
+  }
+  const outerGeom = (0, import_primitives5.polygon)({ points: outerPoints });
+  if (!brep.inner_rings || brep.inner_rings.length === 0) {
+    return outerGeom;
+  }
+  const innerGeoms = brep.inner_rings.map((ring2) => {
+    let innerPoints = ringToPoints(ring2, arcSegments);
+    if (arePointsClockwise2(innerPoints)) {
+      innerPoints.reverse();
+    }
+    return (0, import_primitives5.polygon)({ points: innerPoints });
+  });
+  if (innerGeoms.length === 0) return outerGeom;
+  return (0, import_booleans2.subtract)(outerGeom, innerGeoms);
+}
+
 // src/BoardGeomBuilder.ts
 var buildStateOrder = [
   "initializing",
@@ -27517,7 +27602,7 @@ var BoardGeomBuilder = class {
         this.ctx.pcbThickness
       );
     } else {
-      this.boardGeom = (0, import_primitives5.cuboid)({
+      this.boardGeom = (0, import_primitives6.cuboid)({
         size: [this.board.width, this.board.height, this.ctx.pcbThickness],
         center: [this.board.center.x, this.board.center.y, 0]
       });
@@ -27623,7 +27708,7 @@ var BoardGeomBuilder = class {
     const cutoutHeight = this.ctx.pcbThickness * 1.5;
     switch (cutout.shape) {
       case "rect":
-        cutoutGeom = (0, import_primitives5.cuboid)({
+        cutoutGeom = (0, import_primitives6.cuboid)({
           center: [cutout.center.x, cutout.center.y, 0],
           size: [cutout.width, cutout.height, cutoutHeight]
         });
@@ -27633,7 +27718,7 @@ var BoardGeomBuilder = class {
         }
         break;
       case "circle":
-        cutoutGeom = (0, import_primitives5.cylinder)({
+        cutoutGeom = (0, import_primitives6.cylinder)({
           center: [cutout.center.x, cutout.center.y, 0],
           radius: cutout.radius,
           height: cutoutHeight
@@ -27650,13 +27735,13 @@ var BoardGeomBuilder = class {
         if (arePointsClockwise(pointsVec2)) {
           pointsVec2 = pointsVec2.reverse();
         }
-        const polygon2d = (0, import_primitives5.polygon)({ points: pointsVec2 });
+        const polygon2d = (0, import_primitives6.polygon)({ points: pointsVec2 });
         cutoutGeom = (0, import_extrusions3.extrudeLinear)({ height: cutoutHeight }, polygon2d);
         cutoutGeom = (0, import_transforms3.translate)([0, 0, -cutoutHeight / 2], cutoutGeom);
         break;
     }
     if (cutoutGeom) {
-      this.boardGeom = (0, import_booleans2.subtract)(this.boardGeom, cutoutGeom);
+      this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, cutoutGeom);
     }
   }
   processCopperPour(pour) {
@@ -27664,7 +27749,7 @@ var BoardGeomBuilder = class {
     const zPos = layerSign * this.ctx.pcbThickness / 2 + layerSign * M;
     let pourGeom = null;
     if (pour.shape === "rect") {
-      let baseGeom = (0, import_primitives5.cuboid)({
+      let baseGeom = (0, import_primitives6.cuboid)({
         center: [0, 0, 0],
         // Create at origin for rotation
         size: [pour.width, pour.height, M]
@@ -27674,6 +27759,13 @@ var BoardGeomBuilder = class {
         baseGeom = (0, import_transforms3.rotateZ)(rotationRadians, baseGeom);
       }
       pourGeom = (0, import_transforms3.translate)([pour.center.x, pour.center.y, zPos], baseGeom);
+    } else if (pour.shape === "brep") {
+      const brepShape = pour.brep_shape;
+      if (brepShape && brepShape.outer_ring) {
+        const pourGeom2 = createGeom2FromBRep(brepShape);
+        pourGeom = (0, import_extrusions3.extrudeLinear)({ height: M }, pourGeom2);
+        pourGeom = (0, import_transforms3.translate)([0, 0, zPos], pourGeom);
+      }
     } else if (pour.shape === "polygon") {
       let pointsVec2 = pour.points.map((p) => [p.x, p.y]);
       if (pointsVec2.length < 3) {
@@ -27685,7 +27777,7 @@ var BoardGeomBuilder = class {
       if (arePointsClockwise(pointsVec2)) {
         pointsVec2 = pointsVec2.reverse();
       }
-      const polygon2d = (0, import_primitives5.polygon)({ points: pointsVec2 });
+      const polygon2d = (0, import_primitives6.polygon)({ points: pointsVec2 });
       pourGeom = (0, import_extrusions3.extrudeLinear)({ height: M }, polygon2d);
       pourGeom = (0, import_transforms3.translate)([0, 0, zPos], pourGeom);
     }
@@ -27697,7 +27789,7 @@ var BoardGeomBuilder = class {
   processPlatedHole(ph, opts = {}) {
     if (!this.boardGeom) return;
     if (ph.shape === "circle" || ph.shape === "circular_hole_with_rect_pad") {
-      const cyGeom = (0, import_primitives5.cylinder)({
+      const cyGeom = (0, import_primitives6.cylinder)({
         center: [ph.x, ph.y, 0],
         radius: ph.hole_diameter / 2 + M,
         // Add margin for subtraction
@@ -27705,10 +27797,10 @@ var BoardGeomBuilder = class {
         // Ensure it cuts through
       });
       if (!opts.dontCutBoard) {
-        this.boardGeom = (0, import_booleans2.subtract)(this.boardGeom, cyGeom);
+        this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, cyGeom);
       }
       this.padGeoms = this.padGeoms.map(
-        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans2.subtract)(pg, cyGeom))
+        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, cyGeom))
       );
       const platedHoleGeom = platedHole(ph, this.ctx);
       this.platedHoleGeoms.push(platedHoleGeom);
@@ -27718,27 +27810,27 @@ var BoardGeomBuilder = class {
       const holeHeight = shouldRotate ? ph.hole_width : ph.hole_height;
       const holeRadius = holeHeight / 2;
       const rectLength = Math.abs(holeWidth - holeHeight);
-      const pillHole = (0, import_booleans2.union)(
-        (0, import_primitives5.cuboid)({
+      const pillHole = (0, import_booleans3.union)(
+        (0, import_primitives6.cuboid)({
           center: [ph.x, ph.y, 0],
           size: shouldRotate ? [holeHeight, rectLength, this.ctx.pcbThickness * 1.5] : [rectLength, holeHeight, this.ctx.pcbThickness * 1.5]
         }),
-        (0, import_primitives5.cylinder)({
+        (0, import_primitives6.cylinder)({
           center: shouldRotate ? [ph.x, ph.y - rectLength / 2, 0] : [ph.x - rectLength / 2, ph.y, 0],
           radius: holeRadius,
           height: this.ctx.pcbThickness * 1.5
         }),
-        (0, import_primitives5.cylinder)({
+        (0, import_primitives6.cylinder)({
           center: shouldRotate ? [ph.x, ph.y + rectLength / 2, 0] : [ph.x + rectLength / 2, ph.y, 0],
           radius: holeRadius,
           height: this.ctx.pcbThickness * 1.5
         })
       );
       if (!opts.dontCutBoard) {
-        this.boardGeom = (0, import_booleans2.subtract)(this.boardGeom, pillHole);
+        this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, pillHole);
       }
       this.padGeoms = this.padGeoms.map(
-        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans2.subtract)(pg, pillHole))
+        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, pillHole))
       );
       const platedHoleGeom = platedHole(ph, this.ctx);
       this.platedHoleGeoms.push(platedHoleGeom);
@@ -27747,16 +27839,16 @@ var BoardGeomBuilder = class {
   processHole(hole) {
     if (!this.boardGeom) return;
     if (hole.hole_shape === "round" || hole.hole_shape === "circle") {
-      const cyGeom = (0, import_primitives5.cylinder)({
+      const cyGeom = (0, import_primitives6.cylinder)({
         center: [hole.x, hole.y, 0],
         radius: hole.hole_diameter / 2 + M,
         // Add margin for subtraction
         height: this.ctx.pcbThickness * 1.5
         // Ensure it cuts through
       });
-      this.boardGeom = (0, import_booleans2.subtract)(this.boardGeom, cyGeom);
+      this.boardGeom = (0, import_booleans3.subtract)(this.boardGeom, cyGeom);
       this.padGeoms = this.padGeoms.map(
-        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans2.subtract)(pg, cyGeom))
+        (pg) => (0, import_colors4.colorize)(colors.copper, (0, import_booleans3.subtract)(pg, cyGeom))
       );
     }
   }
@@ -27766,14 +27858,14 @@ var BoardGeomBuilder = class {
     if (pad2.shape === "rect") {
       const padGeom = (0, import_colors4.colorize)(
         colors.copper,
-        (0, import_primitives5.cuboid)({
+        (0, import_primitives6.cuboid)({
           center: [pad2.x, pad2.y, zPos],
           size: [pad2.width, pad2.height, M]
         })
       );
       this.padGeoms.push(padGeom);
     } else if (pad2.shape === "rotated_rect") {
-      let basePadGeom = (0, import_primitives5.cuboid)({
+      let basePadGeom = (0, import_primitives6.cuboid)({
         // Create at origin for rotation, then translate
         center: [0, 0, 0],
         size: [pad2.width, pad2.height, M]
@@ -27786,7 +27878,7 @@ var BoardGeomBuilder = class {
     } else if (pad2.shape === "circle") {
       const padGeom = (0, import_colors4.colorize)(
         colors.copper,
-        (0, import_primitives5.cylinder)({
+        (0, import_primitives6.cylinder)({
           center: [pad2.x, pad2.y, zPos],
           radius: pad2.radius,
           height: M
@@ -27805,7 +27897,7 @@ var BoardGeomBuilder = class {
       if (currentSegmentPoints.length >= 2 && currentLayer) {
         const layerSign = currentLayer === "bottom" ? -1 : 1;
         const zPos = layerSign * this.ctx.pcbThickness / 2 + layerSign * M;
-        const linePath = (0, import_primitives5.line)(currentSegmentPoints);
+        const linePath = (0, import_primitives6.line)(currentSegmentPoints);
         const expandedPath = (0, import_expansions2.expand)(
           { delta: currentWidth / 2, corners: "round" },
           linePath
@@ -27821,21 +27913,21 @@ var BoardGeomBuilder = class {
           startPointCoords[1]
         );
         if (startHole) {
-          const cuttingCylinder = (0, import_primitives5.cylinder)({
+          const cuttingCylinder = (0, import_primitives6.cylinder)({
             center: [startPointCoords[0], startPointCoords[1], zPos + M / 2],
             radius: startHole.diameter / 2 + M,
             height: M
           });
-          traceGeom = (0, import_booleans2.subtract)(traceGeom, cuttingCylinder);
+          traceGeom = (0, import_booleans3.subtract)(traceGeom, cuttingCylinder);
         }
         const endHole = this.getHoleToCut(endPointCoords[0], endPointCoords[1]);
         if (endHole) {
-          const cuttingCylinder = (0, import_primitives5.cylinder)({
+          const cuttingCylinder = (0, import_primitives6.cylinder)({
             center: [endPointCoords[0], endPointCoords[1], zPos + M / 2],
             radius: endHole.diameter / 2 + M,
             height: M
           });
-          traceGeom = (0, import_booleans2.subtract)(traceGeom, cuttingCylinder);
+          traceGeom = (0, import_booleans3.subtract)(traceGeom, cuttingCylinder);
         }
         const tracesMaterialColor = tracesMaterialColors[this.board.material] ?? colors.fr4GreenSolderWithMask;
         traceGeom = (0, import_colors4.colorize)(tracesMaterialColor, traceGeom);
@@ -27905,7 +27997,7 @@ var BoardGeomBuilder = class {
         point2[0] + xOffset + st.anchor_position.x,
         point2[1] + yOffset + st.anchor_position.y
       ]);
-      const textPath = (0, import_primitives5.line)(alignedOutline);
+      const textPath = (0, import_primitives6.line)(alignedOutline);
       const fontSize = st.font_size || 0.25;
       const expansionDelta = Math.min(
         Math.max(0.01, fontSize * 0.1),
@@ -28986,7 +29078,7 @@ function processSmtPadsForManifold(Manifold, circuitJson, pcbThickness, manifold
 }
 
 // src/utils/manifold/create-manifold-board.ts
-var arePointsClockwise2 = (points) => {
+var arePointsClockwise3 = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
@@ -29005,7 +29097,7 @@ function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, ma
       p.x,
       p.y
     ]);
-    if (arePointsClockwise2(outlineVec2)) {
+    if (arePointsClockwise3(outlineVec2)) {
       outlineVec2 = outlineVec2.reverse();
     }
     const crossSection = CrossSection.ofPolygons([outlineVec2]);
@@ -29044,7 +29136,7 @@ function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, ma
 // src/utils/manifold/process-copper-pours.ts
 import * as THREE20 from "three";
 var COPPER_COLOR4 = new THREE20.Color(...colors.copper);
-var arePointsClockwise3 = (points) => {
+var arePointsClockwise4 = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
@@ -29056,6 +29148,59 @@ var arePointsClockwise3 = (points) => {
   const signedArea = area / 2;
   return signedArea <= 0;
 };
+function segmentToPoints2(p1, p2, bulge, arcSegments) {
+  if (!bulge || Math.abs(bulge) < 1e-9) {
+    return [];
+  }
+  const theta = 4 * Math.atan(bulge);
+  const dx = p2[0] - p1[0];
+  const dy = p2[1] - p1[1];
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  if (dist < 1e-9) return [];
+  const radius = Math.abs(dist / (2 * Math.sin(theta / 2)));
+  const m = Math.sqrt(Math.max(0, radius * radius - dist / 2 * (dist / 2)));
+  const midPoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
+  const ux = dx / dist;
+  const uy = dy / dist;
+  const nx = -uy;
+  const ny = ux;
+  const centerX = midPoint[0] + nx * m * Math.sign(bulge);
+  const centerY = midPoint[1] + ny * m * Math.sign(bulge);
+  const startAngle = Math.atan2(p1[1] - centerY, p1[0] - centerX);
+  const points = [];
+  const numSteps = Math.max(
+    2,
+    Math.ceil(arcSegments * Math.abs(theta) / (Math.PI * 2) * 4)
+  );
+  const angleStep = theta / numSteps;
+  for (let i = 1; i < numSteps; i++) {
+    const angle = startAngle + angleStep * i;
+    points.push([
+      centerX + radius * Math.cos(angle),
+      centerY + radius * Math.sin(angle)
+    ]);
+  }
+  return points;
+}
+function ringToPoints2(ring2, arcSegments) {
+  const allPoints = [];
+  const vertices = ring2.vertices;
+  for (let i = 0; i < vertices.length; i++) {
+    const p1 = vertices[i];
+    const p2 = vertices[(i + 1) % vertices.length];
+    allPoints.push([p1.x, p1.y]);
+    if (p1.bulge) {
+      const arcPoints = segmentToPoints2(
+        [p1.x, p1.y],
+        [p2.x, p2.y],
+        p1.bulge,
+        arcSegments
+      );
+      allPoints.push(...arcPoints);
+    }
+  }
+  return allPoints;
+}
 function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup, holeUnion) {
   const copperPourGeoms = [];
   const copperPours = circuitJson.filter(
@@ -29082,7 +29227,7 @@ function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbT
         p.x,
         p.y
       ]);
-      if (arePointsClockwise3(pointsVec2)) {
+      if (arePointsClockwise4(pointsVec2)) {
         pointsVec2 = pointsVec2.reverse();
       }
       const crossSection = CrossSection.ofPolygons([pointsVec2]);
@@ -29100,6 +29245,42 @@ function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbT
         // center extrusion
       ).translate([0, 0, zPos]);
       manifoldInstancesForCleanup.push(pourOp);
+    } else if (pour.shape === "brep") {
+      const brepShape = pour.brep_shape;
+      if (!brepShape || !brepShape.outer_ring) continue;
+      let outerRingPoints = ringToPoints2(
+        brepShape.outer_ring,
+        SMOOTH_CIRCLE_SEGMENTS
+      );
+      if (arePointsClockwise4(outerRingPoints)) {
+        outerRingPoints = outerRingPoints.reverse();
+      }
+      const polygons = [outerRingPoints];
+      if (brepShape.inner_rings) {
+        const innerRingsPoints = brepShape.inner_rings.map((ring2) => {
+          let points = ringToPoints2(ring2, SMOOTH_CIRCLE_SEGMENTS);
+          if (!arePointsClockwise4(points)) {
+            points = points.reverse();
+          }
+          return points;
+        });
+        polygons.push(...innerRingsPoints);
+      }
+      const crossSection = CrossSection.ofPolygons(polygons);
+      manifoldInstancesForCleanup.push(crossSection);
+      pourOp = Manifold.extrude(
+        crossSection,
+        pourThickness,
+        0,
+        // nDivisions
+        0,
+        // twistDegrees
+        [1, 1],
+        // scaleTop
+        true
+        // center extrusion
+      ).translate([0, 0, zPos]);
+      manifoldInstancesForCleanup.push(pourOp);
     }
     if (pourOp) {
       if (holeUnion) {
@@ -29120,7 +29301,7 @@ function processCopperPoursForManifold(Manifold, CrossSection, circuitJson, pcbT
 
 // src/utils/manifold/process-cutouts.ts
 import { su as su11 } from "@tscircuit/circuit-json-util";
-var arePointsClockwise4 = (points) => {
+var arePointsClockwise5 = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
@@ -29185,7 +29366,7 @@ function processCutoutsForManifold(Manifold, CrossSection, circuitJson, pcbThick
           p.x,
           p.y
         ]);
-        if (arePointsClockwise4(pointsVec2)) {
+        if (arePointsClockwise5(pointsVec2)) {
           pointsVec2 = pointsVec2.reverse();
         }
         const crossSection = CrossSection.ofPolygons([pointsVec2]);
@@ -30118,17 +30299,17 @@ function createGeometryFromPolygons(polygons) {
   const geometry = new BufferGeometry3();
   const vertices = [];
   const normals = [];
-  for (const polygon2 of polygons) {
-    for (let i = 1; i < polygon2.vertices.length - 1; i++) {
+  for (const polygon3 of polygons) {
+    for (let i = 1; i < polygon3.vertices.length - 1; i++) {
       vertices.push(
-        ...polygon2.vertices[0],
-        ...polygon2.vertices[i],
-        ...polygon2.vertices[i + 1]
+        ...polygon3.vertices[0],
+        ...polygon3.vertices[i],
+        ...polygon3.vertices[i + 1]
         // Third vertex
       );
-      const v1 = new THREE24.Vector3(...polygon2.vertices[0]);
-      const v2 = new THREE24.Vector3(...polygon2.vertices[i]);
-      const v3 = new THREE24.Vector3(...polygon2.vertices[i + 1]);
+      const v1 = new THREE24.Vector3(...polygon3.vertices[0]);
+      const v2 = new THREE24.Vector3(...polygon3.vertices[i]);
+      const v3 = new THREE24.Vector3(...polygon3.vertices[i + 1]);
       const normal = new THREE24.Vector3().crossVectors(
         new THREE24.Vector3().subVectors(v2, v1),
         new THREE24.Vector3().subVectors(v3, v1)