circuit-json-to-gltf 0.0.33 → 0.0.35

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __toESM
-} from "./chunk-JSBRDJBE.js";
+} from "./chunk-QGM4M3NI.js";
 
 // node_modules/@jscad/modeling/src/utils/flatten.js
 var require_flatten = __commonJS({
@@ -784,7 +784,7 @@ var require_rotateY = __commonJS({
 var require_rotateZ = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/rotateZ.js"(exports, module) {
     "use strict";
-    var rotateZ2 = (out, vector, origin, radians) => {
+    var rotateZ3 = (out, vector, origin, radians) => {
       const p = [];
       const r = [];
       p[0] = vector[0] - origin[0];
@@ -796,7 +796,7 @@ var require_rotateZ = __commonJS({
       out[2] = vector[2];
       return out;
     };
-    module.exports = rotateZ2;
+    module.exports = rotateZ3;
   }
 });
 
@@ -1338,7 +1338,7 @@ var require_rotateZ2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/rotateZ.js"(exports, module) {
     "use strict";
     var { sin, cos } = require_trigonometry();
-    var rotateZ2 = (out, matrix, radians) => {
+    var rotateZ3 = (out, matrix, radians) => {
       const s = sin(radians);
       const c = cos(radians);
       const a00 = matrix[0];
@@ -1369,7 +1369,7 @@ var require_rotateZ2 = __commonJS({
       out[7] = a13 * c - a03 * s;
       return out;
     };
-    module.exports = rotateZ2;
+    module.exports = rotateZ3;
   }
 });
 
@@ -1443,7 +1443,7 @@ var require_toString2 = __commonJS({
 var require_translate = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/translate.js"(exports, module) {
     "use strict";
-    var translate2 = (out, matrix, offsets) => {
+    var translate3 = (out, matrix, offsets) => {
       const x = offsets[0];
       const y = offsets[1];
       const z = offsets[2];
@@ -1496,7 +1496,7 @@ var require_translate = __commonJS({
       }
       return out;
     };
-    module.exports = translate2;
+    module.exports = translate3;
   }
 });
 
@@ -3833,11 +3833,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;
     };
@@ -3869,7 +3869,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) {
@@ -3905,11 +3905,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;
   }
@@ -3920,13 +3920,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]);
@@ -3985,8 +3985,8 @@ var require_measureBoundingBox = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureBoundingBox.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureBoundingBox2 = (polygon2) => {
-      const vertices = polygon2.vertices;
+    var measureBoundingBox2 = (polygon3) => {
+      const vertices = polygon3.vertices;
       const numvertices = vertices.length;
       const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0]);
       const max = vec3.clone(min);
@@ -4064,10 +4064,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;
@@ -4097,7 +4097,7 @@ var require_measureBoundingSphere = __commonJS({
       const y = out[1] - maxy[1];
       const z = out[2] - maxz[2];
       out[3] = Math.sqrt(x * x + y * y + z * z);
-      cache.set(polygon2, out);
+      cache.set(polygon3, out);
       return out;
     };
     module.exports = measureBoundingSphere;
@@ -4109,9 +4109,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]);
@@ -4128,7 +4128,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;
   }
 });
@@ -4138,9 +4138,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 += "]";
@@ -4157,8 +4157,8 @@ var require_transform6 = __commonJS({
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var create = require_create6();
-    var transform = (matrix, polygon2) => {
-      const vertices = polygon2.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
+    var transform = (matrix, polygon3) => {
+      const vertices = polygon3.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
       if (mat4.isMirroring(matrix)) {
         vertices.reverse();
       }
@@ -4274,8 +4274,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;
@@ -4326,7 +4326,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;
     };
@@ -4353,7 +4353,7 @@ var require_invert3 = __commonJS({
     var toPolygons2 = require_toPolygons();
     var invert = (geometry) => {
       const polygons = toPolygons2(geometry);
-      const newpolygons = polygons.map((polygon2) => poly3.invert(polygon2));
+      const newpolygons = polygons.map((polygon3) => poly3.invert(polygon3));
       return create(newpolygons);
     };
     module.exports = invert;
@@ -4386,7 +4386,7 @@ var require_toPoints3 = __commonJS({
     var toPolygons2 = require_toPolygons();
     var toPoints = (geometry) => {
       const polygons = toPolygons2(geometry);
-      const listofpoints = polygons.map((polygon2) => poly3.toPoints(polygon2));
+      const listofpoints = polygons.map((polygon3) => poly3.toPoints(polygon3));
       return listofpoints;
     };
     module.exports = toPoints;
@@ -4402,8 +4402,8 @@ var require_toString7 = __commonJS({
     var toString = (geometry) => {
       const polygons = toPolygons2(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;
     };
@@ -4420,7 +4420,7 @@ var require_toCompactBinary2 = __commonJS({
       const polygons = geometry.polygons;
       const transforms = 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);
@@ -4448,8 +4448,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++) {
@@ -5877,7 +5877,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;
   }
 });
@@ -5901,8 +5901,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;
@@ -5915,22 +5915,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, point) => acc + isPointInside(point, vertices), 0);
       return sum === points.length ? 1 : 0;
     };
-    var isPointInside = (point, polygon2) => {
-      const numverts = polygon2.length;
+    var isPointInside = (point, polygon3) => {
+      const numverts = polygon3.length;
       const tx = point[0];
       const ty = point[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;
@@ -5949,7 +5949,7 @@ var require_arePointsInside = __commonJS({
         }
         yflag0 = yflag1;
         vtx0 = vtx1;
-        vtx1 = polygon2[++i];
+        vtx1 = polygon3[++i];
       }
       return insideFlag;
     };
@@ -6628,7 +6628,7 @@ var require_measureArea3 = __commonJS({
       let area = cache.get(geometry);
       if (area) return area;
       const polygons = geom32.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;
     };
@@ -6731,8 +6731,8 @@ var require_measureBoundingBox2 = __commonJS({
         vec3.copy(minpoint, points[0]);
       }
       let maxpoint = vec3.clone(minpoint);
-      polygons.forEach((polygon2) => {
-        poly3.toPoints(polygon2).forEach((point) => {
+      polygons.forEach((polygon3) => {
+        poly3.toPoints(polygon3).forEach((point) => {
           vec3.min(minpoint, minpoint, point);
           vec3.max(maxpoint, maxpoint, point);
         });
@@ -6839,7 +6839,7 @@ var require_measureVolume = __commonJS({
       let volume = cache.get(geometry);
       if (volume) return volume;
       const polygons = geom32.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;
     };
@@ -6944,15 +6944,15 @@ var require_measureBoundingSphere2 = __commonJS({
       const polygons = geom32.toPolygons(geometry);
       if (polygons.length > 0) {
         let numPoints = 0;
-        polygons.forEach((polygon2) => {
-          poly3.toPoints(polygon2).forEach((point) => {
+        polygons.forEach((polygon3) => {
+          poly3.toPoints(polygon3).forEach((point) => {
             vec3.add(centroid, centroid, point);
             numPoints++;
           });
         });
         vec3.scale(centroid, centroid, 1 / numPoints);
-        polygons.forEach((polygon2) => {
-          poly3.toPoints(polygon2).forEach((point) => {
+        polygons.forEach((polygon3) => {
+          poly3.toPoints(polygon3).forEach((point) => {
             radius = Math.max(radius, vec3.squaredDistance(centroid, point));
           });
         });
@@ -7040,8 +7040,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;
@@ -7622,9 +7622,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 (colors && colors[findex]) polygon2.color = colors[findex];
-        return polygon2;
+        const polygon3 = poly3.create(face.map((pindex) => points[pindex]));
+        if (colors && colors[findex]) polygon3.color = colors[findex];
+        return polygon3;
       });
       return geom32.create(polygons);
     };
@@ -7777,7 +7777,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: [],
@@ -7818,7 +7818,7 @@ var require_polygon = __commonJS({
       }
       return geometry;
     };
-    module.exports = polygon2;
+    module.exports = polygon3;
   }
 });
 
@@ -7829,7 +7829,7 @@ var require_rectangle = __commonJS({
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { isNumberArray } = require_commonChecks();
-    var rectangle2 = (options) => {
+    var rectangle3 = (options) => {
       const defaults = {
         center: [0, 0],
         size: [2, 2]
@@ -7849,7 +7849,7 @@ var require_rectangle = __commonJS({
       ];
       return geom2.fromPoints(points);
     };
-    module.exports = rectangle2;
+    module.exports = rectangle3;
   }
 });
 
@@ -8127,7 +8127,7 @@ var require_roundedRectangle = __commonJS({
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { isGTE, isNumberArray } = require_commonChecks();
-    var rectangle2 = require_rectangle();
+    var rectangle3 = require_rectangle();
     var roundedRectangle2 = (options) => {
       const defaults = {
         center: [0, 0],
@@ -8142,7 +8142,7 @@ var require_roundedRectangle = __commonJS({
       if (!isGTE(roundRadius, 0)) throw new Error("roundRadius must be positive");
       if (!isGTE(segments, 4)) throw new Error("segments must be four or more");
       if (size[0] === 0 || size[1] === 0) return geom2.create();
-      if (roundRadius === 0) return rectangle2({ center, size });
+      if (roundRadius === 0) return rectangle3({ center, size });
       size = size.map((v) => v / 2);
       if (roundRadius > size[0] - EPS || roundRadius > size[1] - EPS) throw new Error("roundRadius must be smaller than the radius of all dimensions");
       const cornersegments = Math.floor(segments / 4);
@@ -8198,7 +8198,7 @@ var require_sphere = __commonJS({
 var require_square = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/square.js"(exports, module) {
     "use strict";
-    var rectangle2 = require_rectangle();
+    var rectangle3 = require_rectangle();
     var { isGTE } = require_commonChecks();
     var square = (options) => {
       const defaults = {
@@ -8208,7 +8208,7 @@ var require_square = __commonJS({
       let { center, size } = Object.assign({}, defaults, options);
       if (!isGTE(size, 0)) throw new Error("size must be positive");
       size = [size, size];
-      return rectangle2({ center, size });
+      return rectangle3({ center, size });
     };
     module.exports = square;
   }
@@ -9458,12 +9458,12 @@ var require_rotate3 = __commonJS({
     };
     var rotateX2 = (angle, ...objects) => rotate([angle, 0, 0], objects);
     var rotateY = (angle, ...objects) => rotate([0, angle, 0], objects);
-    var rotateZ2 = (angle, ...objects) => rotate([0, 0, angle], objects);
+    var rotateZ3 = (angle, ...objects) => rotate([0, 0, angle], objects);
     module.exports = {
       rotate,
       rotateX: rotateX2,
       rotateY,
-      rotateZ: rotateZ2
+      rotateZ: rotateZ3
     };
   }
 });
@@ -9477,7 +9477,7 @@ var require_translate2 = __commonJS({
     var geom2 = require_geom2();
     var geom32 = require_geom3();
     var path2 = require_path2();
-    var translate2 = (offset, ...objects) => {
+    var translate3 = (offset, ...objects) => {
       if (!Array.isArray(offset)) throw new Error("offset must be an array");
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
@@ -9492,11 +9492,11 @@ var require_translate2 = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    var translateX = (offset, ...objects) => translate2([offset, 0, 0], objects);
-    var translateY = (offset, ...objects) => translate2([0, offset, 0], objects);
-    var translateZ = (offset, ...objects) => translate2([0, 0, offset], objects);
+    var translateX = (offset, ...objects) => translate3([offset, 0, 0], objects);
+    var translateY = (offset, ...objects) => translate3([0, offset, 0], objects);
+    var translateZ = (offset, ...objects) => translate3([0, 0, offset], objects);
     module.exports = {
-      translate: translate2,
+      translate: translate3,
       translateX,
       translateY,
       translateZ
@@ -9511,7 +9511,7 @@ var require_torus = __commonJS({
     var { TAU } = require_constants();
     var extrudeRotate = require_extrudeRotate();
     var { rotate } = require_rotate3();
-    var { translate: translate2 } = require_translate2();
+    var { translate: translate3 } = require_translate2();
     var circle = require_circle();
     var { isGT, isGTE } = require_commonChecks();
     var torus = (options) => {
@@ -9536,7 +9536,7 @@ var require_torus = __commonJS({
       if (innerRotation !== 0) {
         innerCircle = rotate([0, 0, innerRotation], innerCircle);
       }
-      innerCircle = translate2([outerRadius, 0], innerCircle);
+      innerCircle = translate3([outerRadius, 0], innerCircle);
       const extrudeOptions = {
         startAngle,
         angle: outerRotation,
@@ -10074,12 +10074,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;
@@ -10106,7 +10106,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;
@@ -10463,8 +10463,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);
             }
           }
         }
@@ -10508,7 +10508,7 @@ var require_retessellate = __commonJS({
       if (geometry.isRetesselated) {
         return geometry;
       }
-      const polygons = geom32.toPolygons(geometry).map((polygon2, index) => ({ vertices: polygon2.vertices, plane: poly3.plane(polygon2), index }));
+      const polygons = geom32.toPolygons(geometry).map((polygon3, index) => ({ vertices: polygon3.vertices, plane: poly3.plane(polygon3), index }));
       const classified = classifyPolygons(polygons);
       const destPolygons = [];
       classified.forEach((group) => {
@@ -10554,8 +10554,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;
     };
@@ -10747,15 +10747,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 {
@@ -10855,10 +10855,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
@@ -10868,8 +10868,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
@@ -10946,9 +10946,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];
@@ -10957,7 +10957,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);
@@ -10990,8 +10990,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;
       }
@@ -11241,14 +11241,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((point) => {
+      polygons.forEach((polygon3, index) => {
+        polygon3.vertices.forEach((point) => {
           insertMapping(indexesPerPoint, vec3.snap(temp, point, eps), index);
         });
       });
-      const indexesPerPolygon = polygons.map((polygon2) => {
+      const indexesPerPolygon = polygons.map((polygon3) => {
         let indexes = [];
-        polygon2.vertices.forEach((point) => {
+        polygon3.vertices.forEach((point) => {
           indexes = indexes.concat(findMapping(indexesPerPoint, vec3.snap(temp, point, eps)));
         });
         return { e: 1, d: sortNb(indexes) };
@@ -11694,19 +11694,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 geom32.create(newpolygons);
     };
     module.exports = extrudePolygon;
@@ -11767,17 +11767,17 @@ var require_expandShell = __commonJS({
       const v1 = vec3.create();
       const v2 = vec3.create();
       const polygons = geom32.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) => {
@@ -11831,8 +11831,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;
@@ -12034,7 +12034,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,
@@ -12182,7 +12182,7 @@ var require_extrudeLinear = __commonJS({
     var path2 = require_path2();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeLinearPath2 = require_extrudeLinearPath2();
-    var extrudeLinear2 = (options, ...objects) => {
+    var extrudeLinear3 = (options, ...objects) => {
       const defaults = {
         height: 1,
         twistAngle: 0,
@@ -12200,7 +12200,7 @@ var require_extrudeLinear = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = extrudeLinear2;
+    module.exports = extrudeLinear3;
   }
 });
 
@@ -12648,24 +12648,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;
@@ -12679,8 +12679,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;
@@ -12729,7 +12729,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;
@@ -12740,8 +12740,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;
@@ -12749,8 +12749,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 current = edges[i];
           const opposite = findOppositeEdge(edgeList, current);
@@ -12806,8 +12806,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;
@@ -12820,13 +12820,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 = [];
@@ -12922,15 +12922,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}`;
@@ -13038,17 +13038,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;
@@ -13088,35 +13088,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;
     };
@@ -13256,7 +13256,7 @@ var require_align = __commonJS({
     var flatten = require_flatten();
     var padArrayToLength = require_padArrayToLength();
     var measureAggregateBoundingBox = require_measureAggregateBoundingBox();
-    var { translate: translate2 } = require_translate2();
+    var { translate: translate3 } = require_translate2();
     var validateOptions = (options) => {
       if (!Array.isArray(options.modes) || options.modes.length > 3) throw new Error("align(): modes must be an array of length <= 3");
       options.modes = padArrayToLength(options.modes, "none", 3);
@@ -13293,7 +13293,7 @@ var require_align = __commonJS({
           translation[i] = relativeTo[i] - bounds[0][i];
         }
       }
-      return translate2(translation, geometry);
+      return translate3(translation, geometry);
     };
     var align = (options, ...geometries) => {
       const defaults = {
@@ -13330,7 +13330,7 @@ var require_center = __commonJS({
     var geom32 = require_geom3();
     var path2 = require_path2();
     var measureBoundingBox2 = require_measureBoundingBox2();
-    var { translate: translate2 } = require_translate2();
+    var { translate: translate3 } = require_translate2();
     var centerGeometry = (options, object) => {
       const defaults = {
         axes: [true, true, true],
@@ -13342,7 +13342,7 @@ var require_center = __commonJS({
       if (axes[0]) offset[0] = relativeTo[0] - (bounds[0][0] + (bounds[1][0] - bounds[0][0]) / 2);
       if (axes[1]) offset[1] = relativeTo[1] - (bounds[0][1] + (bounds[1][1] - bounds[0][1]) / 2);
       if (axes[2]) offset[2] = relativeTo[2] - (bounds[0][2] + (bounds[1][2] - bounds[0][2]) / 2);
-      return translate2(offset, object);
+      return translate3(offset, object);
     };
     var center = (options, ...objects) => {
       const defaults = {
@@ -14552,10 +14552,14 @@ async function renderBoardLayer(circuitJson, options) {
 }
 async function convertSvgToPng(svgString, resolution, backgroundColor) {
   if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return convertSvgToCanvasBrowser(svgString, resolution, backgroundColor);
+    const { svgToPngDataUrl } = await import("./svg-to-png-browser-VH734VGT.js");
+    return await svgToPngDataUrl(svgString, {
+      width: resolution,
+      background: backgroundColor
+    });
   } else {
     try {
-      const { svgToPngDataUrl } = await import("./svg-to-png-FCHG2ZUX.js");
+      const { svgToPngDataUrl } = await import("./svg-to-png-XFKMCXOE.js");
       return await svgToPngDataUrl(svgString, {
         width: resolution,
         background: backgroundColor
@@ -14645,18 +14649,20 @@ function scaleMesh(mesh, scale) {
 }
 
 // lib/utils/pcb-board-geometry.ts
-var import_extrusions = __toESM(require_extrusions(), 1);
-var import_primitives = __toESM(require_primitives(), 1);
-var import_transforms = __toESM(require_transforms(), 1);
+var import_extrusions2 = __toESM(require_extrusions(), 1);
+var import_primitives2 = __toESM(require_primitives(), 1);
+var import_transforms2 = __toESM(require_transforms(), 1);
 var import_booleans = __toESM(require_booleans(), 1);
 var geom3 = __toESM(require_geom3(), 1);
 var import_measureBoundingBox = __toESM(require_measureBoundingBox2(), 1);
+
+// lib/utils/pcb-board-cutouts.ts
+var import_extrusions = __toESM(require_extrusions(), 1);
+var import_primitives = __toESM(require_primitives(), 1);
+var import_transforms = __toESM(require_transforms(), 1);
 var DEFAULT_SEGMENTS = 64;
-var RADIUS_EPSILON = 1e-4;
-var toVec2 = (point, center) => [
-  point.x - center.x,
-  point.y - center.y
-];
+var toBoardSpaceVec2 = (point, center) => [point.x - center.x, -(point.y - center.y)];
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 var arePointsClockwise = (points) => {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
@@ -14667,6 +14673,119 @@ var arePointsClockwise = (points) => {
   const signedArea = area / 2;
   return signedArea <= 0;
 };
+var createCircularHole = (x, y, radius, thickness) => (0, import_primitives.cylinder)({
+  center: [x, y, 0],
+  height: thickness + 1,
+  radius,
+  segments: DEFAULT_SEGMENTS
+});
+var createCutoutGeoms = (boardCenter, thickness, cutouts = []) => {
+  const geoms = [];
+  for (const cutout of cutouts) {
+    if (!cutout) continue;
+    switch (cutout.shape) {
+      case "rect": {
+        const { center } = cutout;
+        if (!center || !isFiniteNumber(center.x) || !isFiniteNumber(center.y)) {
+          continue;
+        }
+        const width = typeof cutout.width === "number" && Number.isFinite(cutout.width) ? cutout.width : void 0;
+        const height = typeof cutout.height === "number" && Number.isFinite(cutout.height) ? cutout.height : void 0;
+        if (!width || !height) continue;
+        const relX = center.x - boardCenter.x;
+        const relY = -(center.y - boardCenter.y);
+        const rect2d = (0, import_primitives.rectangle)({ size: [width, height] });
+        let geom = (0, import_extrusions.extrudeLinear)({ height: thickness + 1 }, rect2d);
+        geom = (0, import_transforms.translate)([0, 0, -(thickness + 1) / 2], geom);
+        let rotationRad = 0;
+        const { rotation } = cutout;
+        if (typeof rotation === "number" && Number.isFinite(rotation)) {
+          rotationRad = rotation * Math.PI / 180;
+        } else if (rotation && typeof rotation === "object") {
+          const record = rotation;
+          const degreeCandidate = [
+            record.deg,
+            record.degs,
+            record.degree,
+            record.degrees,
+            record.ccw,
+            record.ccw_degrees,
+            record.ccw_degree
+          ].find(
+            (value) => typeof value === "number" && Number.isFinite(value)
+          );
+          if (degreeCandidate !== void 0) {
+            rotationRad = degreeCandidate * Math.PI / 180;
+          } else {
+            const radCandidate = [
+              record.rad,
+              record.rads,
+              record.radian,
+              record.radians,
+              record.ccw_radians
+            ].find(
+              (value) => typeof value === "number" && Number.isFinite(value)
+            );
+            if (radCandidate !== void 0) {
+              rotationRad = radCandidate;
+            }
+          }
+        }
+        if (rotationRad) {
+          geom = (0, import_transforms.rotateZ)(-rotationRad, geom);
+        }
+        geoms.push((0, import_transforms.translate)([relX, relY, 0], geom));
+        break;
+      }
+      case "circle": {
+        const { center } = cutout;
+        if (!center || !isFiniteNumber(center.x) || !isFiniteNumber(center.y)) {
+          continue;
+        }
+        const radius = (() => {
+          if (typeof cutout.radius === "number" && Number.isFinite(cutout.radius)) {
+            return cutout.radius;
+          }
+          if ("diameter" in cutout && typeof cutout.diameter === "number" && Number.isFinite(cutout.diameter)) {
+            return cutout.diameter / 2;
+          }
+          return void 0;
+        })();
+        if (!radius) continue;
+        const relX = center.x - boardCenter.x;
+        const relY = -(center.y - boardCenter.y);
+        geoms.push(createCircularHole(relX, relY, radius, thickness));
+        break;
+      }
+      case "polygon": {
+        const { points } = cutout;
+        if (!Array.isArray(points) || points.length < 3) continue;
+        let polygonPoints = points.filter(
+          (point) => point !== void 0 && isFiniteNumber(point.x) && isFiniteNumber(point.y)
+        ).map((point) => toBoardSpaceVec2(point, boardCenter));
+        if (polygonPoints.length < 3) continue;
+        if (arePointsClockwise(polygonPoints)) {
+          polygonPoints = polygonPoints.slice().reverse();
+        }
+        const polygon2d = (0, import_primitives.polygon)({ points: polygonPoints });
+        let geom = (0, import_extrusions.extrudeLinear)({ height: thickness + 1 }, polygon2d);
+        geom = (0, import_transforms.translate)([0, 0, -(thickness + 1) / 2], geom);
+        geoms.push(geom);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return geoms;
+};
+
+// lib/utils/pcb-board-geometry.ts
+var RADIUS_EPSILON = 1e-4;
+var toVec2 = (point, center) => [
+  point.x - center.x,
+  point.y - center.y
+];
 var getNumberProperty = (obj, key) => {
   const value = obj[key];
   return typeof value === "number" ? value : void 0;
@@ -14677,37 +14796,31 @@ var createBoardOutlineGeom = (board, center, thickness) => {
     if (arePointsClockwise(outlinePoints)) {
       outlinePoints = outlinePoints.slice().reverse();
     }
-    const shape2d = (0, import_primitives.polygon)({ points: outlinePoints });
-    let geom2 = (0, import_extrusions.extrudeLinear)({ height: thickness }, shape2d);
-    geom2 = (0, import_transforms.translate)([0, 0, -thickness / 2], geom2);
+    const shape2d = (0, import_primitives2.polygon)({ points: outlinePoints });
+    let geom2 = (0, import_extrusions2.extrudeLinear)({ height: thickness }, shape2d);
+    geom2 = (0, import_transforms2.translate)([0, 0, -thickness / 2], geom2);
     return geom2;
   }
-  const baseRect = (0, import_primitives.rectangle)({ size: [board.width, board.height] });
-  let geom = (0, import_extrusions.extrudeLinear)({ height: thickness }, baseRect);
-  geom = (0, import_transforms.translate)([0, 0, -thickness / 2], geom);
+  const baseRect = (0, import_primitives2.rectangle)({ size: [board.width, board.height] });
+  let geom = (0, import_extrusions2.extrudeLinear)({ height: thickness }, baseRect);
+  geom = (0, import_transforms2.translate)([0, 0, -thickness / 2], geom);
   return geom;
 };
-var createCircularHole = (x, y, radius, thickness) => (0, import_primitives.cylinder)({
-  center: [x, y, 0],
-  height: thickness + 1,
-  radius,
-  segments: DEFAULT_SEGMENTS
-});
 var createPillHole = (x, y, width, height, thickness, rotate) => {
   const minDimension = Math.min(width, height);
   const maxAllowedRadius = Math.max(0, minDimension / 2 - RADIUS_EPSILON);
   const roundRadius = maxAllowedRadius <= 0 ? 0 : Math.min(height / 2, maxAllowedRadius);
-  const hole2d = (0, import_primitives.roundedRectangle)({
+  const hole2d = (0, import_primitives2.roundedRectangle)({
     size: [width, height],
     roundRadius,
     segments: DEFAULT_SEGMENTS
   });
-  let hole3d = (0, import_extrusions.extrudeLinear)({ height: thickness + 1 }, hole2d);
-  hole3d = (0, import_transforms.translate)([0, 0, -(thickness + 1) / 2], hole3d);
+  let hole3d = (0, import_extrusions2.extrudeLinear)({ height: thickness + 1 }, hole2d);
+  hole3d = (0, import_transforms2.translate)([0, 0, -(thickness + 1) / 2], hole3d);
   if (rotate) {
-    hole3d = (0, import_transforms.rotateZ)(Math.PI / 2, hole3d);
+    hole3d = (0, import_transforms2.rotateZ)(Math.PI / 2, hole3d);
   }
-  return (0, import_transforms.translate)([x, y, 0], hole3d);
+  return (0, import_transforms2.translate)([x, y, 0], hole3d);
 };
 var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) => {
   const holeGeoms = [];
@@ -14743,17 +14856,17 @@ var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) =>
       const minDimension = Math.min(holeWidth, holeHeight);
       const maxAllowedRadius = Math.max(0, minDimension / 2 - RADIUS_EPSILON);
       const roundRadius = maxAllowedRadius <= 0 ? 0 : Math.min(holeHeight / 2, maxAllowedRadius);
-      const hole2d = (0, import_primitives.roundedRectangle)({
+      const hole2d = (0, import_primitives2.roundedRectangle)({
         size: [holeWidth, holeHeight],
         roundRadius,
         segments: DEFAULT_SEGMENTS
       });
-      let hole3d = (0, import_extrusions.extrudeLinear)({ height: thickness + 1 }, hole2d);
-      hole3d = (0, import_transforms.translate)([0, 0, -(thickness + 1) / 2], hole3d);
+      let hole3d = (0, import_extrusions2.extrudeLinear)({ height: thickness + 1 }, hole2d);
+      hole3d = (0, import_transforms2.translate)([0, 0, -(thickness + 1) / 2], hole3d);
       if (rotationRad !== 0) {
-        hole3d = (0, import_transforms.rotateZ)(rotationRad, hole3d);
+        hole3d = (0, import_transforms2.rotateZ)(rotationRad, hole3d);
       }
-      hole3d = (0, import_transforms.translate)([relX, relY, 0], hole3d);
+      hole3d = (0, import_transforms2.translate)([relX, relY, 0], hole3d);
       holeGeoms.push(hole3d);
       continue;
     }
@@ -14835,14 +14948,16 @@ var createBoundingBox = (bbox) => {
   };
 };
 var createBoardMesh = (board, options) => {
-  const { thickness, holes = [], platedHoles = [] } = options;
+  const { thickness, holes = [], platedHoles = [], cutouts = [] } = options;
   const center = board.center ?? { x: 0, y: 0 };
   let boardGeom = createBoardOutlineGeom(board, center, thickness);
   const holeGeoms = createHoleGeoms(center, thickness, holes, platedHoles);
-  if (holeGeoms.length > 0) {
-    boardGeom = (0, import_booleans.subtract)(boardGeom, ...holeGeoms);
+  const cutoutGeoms = createCutoutGeoms(center, thickness, cutouts);
+  const subtractGeoms = [...holeGeoms, ...cutoutGeoms];
+  if (subtractGeoms.length > 0) {
+    boardGeom = (0, import_booleans.subtract)(boardGeom, ...subtractGeoms);
   }
-  boardGeom = (0, import_transforms.rotateX)(-Math.PI / 2, boardGeom);
+  boardGeom = (0, import_transforms2.rotateX)(-Math.PI / 2, boardGeom);
   const polygons = geom3.toPolygons(boardGeom);
   const triangles = geom3ToTriangles(boardGeom, polygons);
   const bboxValues = (0, import_measureBoundingBox.default)(boardGeom);
@@ -14881,10 +14996,16 @@ async function convertCircuitJsonTo3D(circuitJson, options = {}) {
   if (pcbBoard) {
     const pcbHoles = db.pcb_hole?.list?.() ?? [];
     const pcbPlatedHoles = db.pcb_plated_hole?.list?.() ?? [];
+    const pcbCutouts = db.pcb_cutout?.list?.() ?? [];
+    const boardCutouts = pcbCutouts.filter((cutout) => {
+      const cutoutBoardId = cutout.pcb_board_id;
+      return !cutoutBoardId || cutoutBoardId === pcbBoard.pcb_board_id;
+    });
     const boardMesh = createBoardMesh(pcbBoard, {
       thickness: effectiveBoardThickness,
       holes: pcbHoles,
-      platedHoles: pcbPlatedHoles
+      platedHoles: pcbPlatedHoles,
+      cutouts: boardCutouts
     });
     const meshWidth = boardMesh.boundingBox.max.x - boardMesh.boundingBox.min.x;
     const meshHeight = boardMesh.boundingBox.max.z - boardMesh.boundingBox.min.z;
@@ -15627,6 +15748,38 @@ function transformMesh(mesh, translation, rotation, scale) {
   }
   return result;
 }
+function convertMeshToGLTFOrientation(mesh) {
+  const result = {
+    positions: [...mesh.positions],
+    normals: [...mesh.normals],
+    texcoords: [...mesh.texcoords],
+    indices: [...mesh.indices]
+  };
+  if (mesh.colors) {
+    result.colors = [...mesh.colors];
+  }
+  for (let i = 0; i < result.positions.length; i += 3) {
+    const x = result.positions[i];
+    if (typeof x === "number") {
+      result.positions[i] = -x;
+    }
+  }
+  for (let i = 0; i < result.normals.length; i += 3) {
+    const nx = result.normals[i];
+    if (typeof nx === "number") {
+      result.normals[i] = -nx;
+    }
+  }
+  for (let i = 0; i < result.indices.length; i += 3) {
+    const i1 = result.indices[i + 1];
+    const i2 = result.indices[i + 2];
+    if (typeof i1 === "number" && typeof i2 === "number") {
+      result.indices[i + 1] = i2;
+      result.indices[i + 2] = i1;
+    }
+  }
+  return result;
+}
 function getBounds(positions) {
   if (positions.length === 0) {
     return {
@@ -15714,6 +15867,7 @@ var GLTFBuilder = class {
       meshData = createBoxMesh(box.size);
     }
     meshData = transformMesh(meshData, box.center, box.rotation);
+    meshData = convertMeshToGLTFOrientation(meshData);
     let materialIndex = defaultMaterialIndex;
     if (box.color) {
       materialIndex = this.addMaterialFromColor(box.color, !box.mesh);
@@ -15767,10 +15921,8 @@ var GLTFBuilder = class {
     }
     const primitives = [];
     for (const { meshData, materialIndex } of meshDataArray) {
-      const transformedMeshData = transformMesh(
-        meshData,
-        box.center,
-        box.rotation
+      const transformedMeshData = convertMeshToGLTFOrientation(
+        transformMesh(meshData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedMeshData.positions,
@@ -15938,10 +16090,8 @@ var GLTFBuilder = class {
         vertexIndex += 3;
       }
       const meshData = { positions, normals, texcoords, indices };
-      const transformedMeshData = transformMesh(
-        meshData,
-        box.center,
-        box.rotation
+      const transformedMeshData = convertMeshToGLTFOrientation(
+        transformMesh(meshData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedMeshData.positions,
@@ -16060,10 +16210,8 @@ var GLTFBuilder = class {
     const meshIndex = this.meshes.length;
     const primitives = [];
     for (const [faceName, faceData] of Object.entries(faceMeshes)) {
-      const transformedFaceData = transformMesh(
-        faceData,
-        box.center,
-        box.rotation
+      const transformedFaceData = convertMeshToGLTFOrientation(
+        transformMesh(faceData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedFaceData.positions,