@tscircuit/3d-viewer 0.0.604 → 0.0.606

package/dist/index.js

@@ -215,8 +215,8 @@ var require_invert = __commonJS({
 var require_equals = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/equals.js"(exports, module) {
     "use strict";
-    var equals = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];
-    module.exports = equals;
+    var equals2 = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];
+    module.exports = equals2;
   }
 });
 
@@ -225,11 +225,11 @@ var require_constants = __commonJS({
   "node_modules/@jscad/modeling/src/maths/constants.js"(exports, module) {
     "use strict";
     var spatialResolution = 1e5;
-    var EPS = 1e-5;
+    var EPS3 = 1e-5;
     var NEPS = 1e-13;
     var TAU = Math.PI * 2;
     module.exports = {
-      EPS,
+      EPS: EPS3,
       NEPS,
       TAU,
       spatialResolution
@@ -280,13 +280,13 @@ var require_identity = __commonJS({
 var require_fromRotation = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/fromRotation.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var { sin, cos } = require_trigonometry();
     var identity = require_identity();
     var fromRotation = (out, rad, axis) => {
       let [x, y, z42] = axis;
       const lengthSquared = x * x + y * y + z42 * z42;
-      if (Math.abs(lengthSquared) < EPS) {
+      if (Math.abs(lengthSquared) < EPS3) {
         return identity(out);
       }
       const len = 1 / Math.sqrt(lengthSquared);
@@ -585,8 +585,8 @@ var require_divide = __commonJS({
 var require_equals2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/equals.js"(exports, module) {
     "use strict";
-    var equals = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-    module.exports = equals;
+    var equals2 = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+    module.exports = equals2;
   }
 });
 
@@ -1213,13 +1213,13 @@ var require_multiply2 = __commonJS({
 var require_rotate = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/rotate.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var { sin, cos } = require_trigonometry();
     var copy = require_copy();
     var rotate2 = (out, matrix, radians, axis) => {
       let [x, y, z42] = axis;
       const lengthSquared = x * x + y * y + z42 * z42;
-      if (Math.abs(lengthSquared) < EPS) {
+      if (Math.abs(lengthSquared) < EPS3) {
         return copy(out, matrix);
       }
       const len = 1 / Math.sqrt(lengthSquared);
@@ -1720,8 +1720,8 @@ var require_dot2 = __commonJS({
 var require_equals3 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/equals.js"(exports, module) {
     "use strict";
-    var equals = (a, b) => a[0] === b[0] && a[1] === b[1];
-    module.exports = equals;
+    var equals2 = (a, b) => a[0] === b[0] && a[1] === b[1];
+    module.exports = equals2;
   }
 });
 
@@ -2431,12 +2431,12 @@ var require_point_line_distance = __commonJS({
       const cr = [];
       subtract4(ab, b, a);
       subtract4(ap, p, a);
-      const area = squaredLength(cross(cr, ap, ab));
+      const area2 = squaredLength(cross(cr, ap, ab));
       const s = squaredLength(ab);
       if (s === 0) {
         throw Error("a and b are the same point");
       }
-      return area / s;
+      return area2 / s;
     };
     var pointLineDistance = (point, a, b) => Math.sqrt(distanceSquared(point, a, b));
     module.exports = pointLineDistance;
@@ -3540,8 +3540,8 @@ var require_copy4 = __commonJS({
 var require_equals4 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec4/equals.js"(exports, module) {
     "use strict";
-    var equals = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
-    module.exports = equals;
+    var equals2 = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+    module.exports = equals2;
   }
 });
 
@@ -3708,19 +3708,19 @@ var require_fromPoints3 = __commonJS({
 var require_fromPointsRandom = __commonJS({
   "node_modules/@jscad/modeling/src/maths/plane/fromPointsRandom.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec3 = require_vec3();
     var fromPointsRandom = (out, a, b, c) => {
       let ba = vec3.subtract(vec3.create(), b, a);
       let ca = vec3.subtract(vec3.create(), c, a);
-      if (vec3.length(ba) < EPS) {
+      if (vec3.length(ba) < EPS3) {
         ba = vec3.orthogonal(ba, ca);
       }
-      if (vec3.length(ca) < EPS) {
+      if (vec3.length(ca) < EPS3) {
         ca = vec3.orthogonal(ca, ba);
       }
       let normal = vec3.cross(vec3.create(), ba, ca);
-      if (vec3.length(normal) < EPS) {
+      if (vec3.length(normal) < EPS3) {
         ca = vec3.orthogonal(ca, ba);
         normal = vec3.cross(normal, ba, ca);
       }
@@ -3960,7 +3960,7 @@ var require_measureArea = __commonJS({
       } else if (ay > az) {
         coord = 2;
       }
-      let area = 0;
+      let area2 = 0;
       let h2 = 0;
       let i = 1;
       let j = 2;
@@ -3969,19 +3969,19 @@ var require_measureArea = __commonJS({
           for (i = 1; i < n; i++) {
             h2 = i - 1;
             j = (i + 1) % n;
-            area += vertices[i][1] * (vertices[j][2] - vertices[h2][2]);
+            area2 += vertices[i][1] * (vertices[j][2] - vertices[h2][2]);
           }
-          area += vertices[0][1] * (vertices[1][2] - vertices[n - 1][2]);
-          area /= 2 * normal[0];
+          area2 += vertices[0][1] * (vertices[1][2] - vertices[n - 1][2]);
+          area2 /= 2 * normal[0];
           break;
         case 2:
           for (i = 1; i < n; i++) {
             h2 = i - 1;
             j = (i + 1) % n;
-            area += vertices[i][2] * (vertices[j][0] - vertices[h2][0]);
+            area2 += vertices[i][2] * (vertices[j][0] - vertices[h2][0]);
           }
-          area += vertices[0][2] * (vertices[1][0] - vertices[n - 1][0]);
-          area /= 2 * normal[1];
+          area2 += vertices[0][2] * (vertices[1][0] - vertices[n - 1][0]);
+          area2 /= 2 * normal[1];
           break;
         case 3:
         // ignore Z coordinates
@@ -3989,13 +3989,13 @@ var require_measureArea = __commonJS({
           for (i = 1; i < n; i++) {
             h2 = i - 1;
             j = (i + 1) % n;
-            area += vertices[i][0] * (vertices[j][1] - vertices[h2][1]);
+            area2 += vertices[i][0] * (vertices[j][1] - vertices[h2][1]);
           }
-          area += vertices[0][0] * (vertices[1][1] - vertices[n - 1][1]);
-          area /= 2 * normal[2];
+          area2 += vertices[0][0] * (vertices[1][1] - vertices[n - 1][1]);
+          area2 /= 2 * normal[2];
           break;
       }
-      return area;
+      return area2;
     };
     module.exports = measureArea;
   }
@@ -4403,7 +4403,7 @@ var require_isA3 = __commonJS({
 var require_isConvex2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_isA3();
     var toPolygons = require_toPolygons();
@@ -4434,7 +4434,7 @@ var require_isConvex2 = __commonJS({
         for (let j = 0; j < vertices.length; j++) {
           const v = vertices[j];
           const distance6 = vec3.dot(plane, v) - plane[3];
-          if (distance6 > EPS) {
+          if (distance6 > EPS3) {
             return false;
           }
         }
@@ -4626,7 +4626,7 @@ var require_clone8 = __commonJS({
 var require_close = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/path2/close.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec2 = require_vec2();
     var clone = require_clone8();
     var close = (geometry) => {
@@ -4637,7 +4637,7 @@ var require_close = __commonJS({
         const points = cloned.points;
         const p0 = points[0];
         let pn = points[points.length - 1];
-        while (vec2.distance(p0, pn) < EPS * EPS) {
+        while (vec2.distance(p0, pn) < EPS3 * EPS3) {
           points.pop();
           if (points.length === 1) break;
           pn = points[points.length - 1];
@@ -4672,7 +4672,7 @@ var require_create8 = __commonJS({
 var require_fromPoints5 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/path2/fromPoints.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec2 = require_vec2();
     var close = require_close();
     var create = require_create8();
@@ -4684,7 +4684,7 @@ var require_fromPoints5 = __commonJS({
       if (created.points.length > 1) {
         const p0 = created.points[0];
         const pn = created.points[created.points.length - 1];
-        if (vec2.distance(p0, pn) < EPS * EPS) {
+        if (vec2.distance(p0, pn) < EPS3 * EPS3) {
           closed = true;
         }
       }
@@ -4825,13 +4825,13 @@ var require_concat = __commonJS({
     "use strict";
     var fromPoints = require_fromPoints5();
     var toPoints = require_toPoints4();
-    var { equals } = require_vec2();
+    var { equals: equals2 } = require_vec2();
     var concat = (...paths) => {
       let isClosed = false;
       let newpoints = [];
       paths.forEach((path, i) => {
         const tmp = toPoints(path).slice();
-        if (newpoints.length > 0 && tmp.length > 0 && equals(tmp[0], newpoints[newpoints.length - 1])) tmp.shift();
+        if (newpoints.length > 0 && tmp.length > 0 && equals2(tmp[0], newpoints[newpoints.length - 1])) tmp.shift();
         if (tmp.length > 0 && isClosed) {
           throw new Error(`Cannot concatenate to a closed path; check the ${i}th path`);
         }
@@ -4975,7 +4975,7 @@ var require_equals5 = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var toPoints = require_toPoints4();
-    var equals = (a, b) => {
+    var equals2 = (a, b) => {
       if (a.isClosed !== b.isClosed) {
         return false;
       }
@@ -5003,7 +5003,7 @@ var require_equals5 = __commonJS({
       } while (++offset4 < length83);
       return false;
     };
-    module.exports = equals;
+    module.exports = equals2;
   }
 });
 
@@ -5927,16 +5927,16 @@ var require_curves = __commonJS({
 var require_area = __commonJS({
   "node_modules/@jscad/modeling/src/maths/utils/area.js"(exports, module) {
     "use strict";
-    var area = (points) => {
-      let area2 = 0;
+    var area2 = (points) => {
+      let area3 = 0;
       for (let i = 0; i < points.length; i++) {
         const j = (i + 1) % points.length;
-        area2 += points[i][0] * points[j][1];
-        area2 -= points[j][0] * points[i][1];
+        area3 += points[i][0] * points[j][1];
+        area3 -= points[j][0] * points[i][1];
       }
-      return area2 / 2;
+      return area3 / 2;
     };
-    module.exports = area;
+    module.exports = area2;
   }
 });
 
@@ -5944,8 +5944,8 @@ var require_area = __commonJS({
 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 area2 = require_area();
+    var measureArea = (polygon2) => area2(polygon2.vertices);
     module.exports = measureArea;
   }
 });
@@ -6153,8 +6153,8 @@ var require_distanceToPoint = __commonJS({
 var require_equals6 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/line2/equals.js"(exports, module) {
     "use strict";
-    var equals = (line1, line2) => line1[0] === line2[0] && (line1[1] === line2[1] && line1[2] === line2[2]);
-    module.exports = equals;
+    var equals2 = (line1, line2) => line1[0] === line2[0] && (line1[1] === line2[1] && line1[2] === line2[2]);
+    module.exports = equals2;
   }
 });
 
@@ -6481,12 +6481,12 @@ var require_equals7 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/line3/equals.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var equals = (line1, line2) => {
+    var equals2 = (line1, line2) => {
       if (!vec3.equals(line1[1], line2[1])) return false;
       if (!vec3.equals(line1[0], line2[0])) return false;
       return true;
     };
-    module.exports = equals;
+    module.exports = equals2;
   }
 });
 
@@ -6511,12 +6511,12 @@ var require_fromPlanes = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var { solve2Linear } = require_utils();
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var fromPointAndDirection = require_fromPointAndDirection();
     var fromPlanes = (out, plane1, plane2) => {
       let direction = vec3.cross(vec3.create(), plane1, plane2);
       let length83 = vec3.length(direction);
-      if (length83 < EPS) {
+      if (length83 < EPS3) {
         throw new Error("parallel planes do not intersect");
       }
       length83 = 1 / length83;
@@ -6684,21 +6684,21 @@ var require_measureArea3 = __commonJS({
     var cache = /* @__PURE__ */ new WeakMap();
     var measureAreaOfPath2 = () => 0;
     var measureAreaOfGeom2 = (geometry) => {
-      let area = cache.get(geometry);
-      if (area) return area;
+      let area2 = cache.get(geometry);
+      if (area2) return area2;
       const sides2 = geom2.toSides(geometry);
-      area = sides2.reduce((area2, side) => area2 + (side[0][0] * side[1][1] - side[0][1] * side[1][0]), 0);
-      area *= 0.5;
-      cache.set(geometry, area);
-      return area;
+      area2 = sides2.reduce((area3, side) => area3 + (side[0][0] * side[1][1] - side[0][1] * side[1][0]), 0);
+      area2 *= 0.5;
+      cache.set(geometry, area2);
+      return area2;
     };
     var measureAreaOfGeom3 = (geometry) => {
-      let area = cache.get(geometry);
-      if (area) return area;
+      let area2 = cache.get(geometry);
+      if (area2) return area2;
       const polygons = geom3.toPolygons(geometry);
-      area = polygons.reduce((area2, polygon2) => area2 + poly3.measureArea(polygon2), 0);
-      cache.set(geometry, area);
-      return area;
+      area2 = polygons.reduce((area3, polygon2) => area3 + poly3.measureArea(polygon2), 0);
+      cache.set(geometry, area2);
+      return area2;
     };
     var measureArea = (...geometries) => {
       geometries = flatten(geometries);
@@ -6729,7 +6729,7 @@ var require_measureAggregateArea = __commonJS({
         return areas;
       }
       const result = 0;
-      return areas.reduce((result2, area) => result2 + area, result);
+      return areas.reduce((result2, area2) => result2 + area2, result);
     };
     module.exports = measureAggregateArea;
   }
@@ -6855,13 +6855,13 @@ var require_measureAggregateBoundingBox = __commonJS({
 var require_calculateEpsilonFromBounds = __commonJS({
   "node_modules/@jscad/modeling/src/measurements/calculateEpsilonFromBounds.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var calculateEpsilonFromBounds = (bounds, dimensions) => {
       let total = 0;
       for (let i = 0; i < dimensions; i++) {
         total += bounds[1][i] - bounds[0][i];
       }
-      return EPS * total / dimensions;
+      return EPS3 * total / dimensions;
     };
     module.exports = calculateEpsilonFromBounds;
   }
@@ -7079,7 +7079,7 @@ var require_measureCenterOfMass = __commonJS({
       let centerOfMass = cacheOfCenterOfMass.get(geometry);
       if (centerOfMass !== void 0) return centerOfMass;
       const sides2 = geom2.toSides(geometry);
-      let area = 0;
+      let area2 = 0;
       let x = 0;
       let y = 0;
       if (sides2.length > 0) {
@@ -7087,12 +7087,12 @@ var require_measureCenterOfMass = __commonJS({
           const p1 = sides2[i][0];
           const p2 = sides2[i][1];
           const a = p1[0] * p2[1] - p1[1] * p2[0];
-          area += a;
+          area2 += a;
           x += (p1[0] + p2[0]) * a;
           y += (p1[1] + p2[1]) * a;
         }
-        area /= 2;
-        const f = 1 / (area * 6);
+        area2 /= 2;
+        const f = 1 / (area2 * 6);
         x *= f;
         y *= f;
       }
@@ -7230,7 +7230,7 @@ var require_commonChecks = __commonJS({
 var require_arc = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/arc.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec2 = require_vec2();
     var path2 = require_path2();
     var { isGT, isGTE, isNumberArray } = require_commonChecks();
@@ -7258,7 +7258,7 @@ var require_arc = __commonJS({
       if (startAngle > endAngle) {
         rotation = endAngle + (TAU - startAngle);
       }
-      const minangle = Math.acos((radius * radius + radius * radius - EPS * EPS) / (2 * radius * radius));
+      const minangle = Math.acos((radius * radius + radius * radius - EPS3 * EPS3) / (2 * radius * radius));
       const centerv = vec2.clone(center);
       let point;
       const pointArray = [];
@@ -7296,7 +7296,7 @@ var require_arc = __commonJS({
 var require_ellipse = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/ellipse.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { sin, cos } = require_trigonometry();
@@ -7327,7 +7327,7 @@ var require_ellipse = __commonJS({
         rotation = endAngle + (TAU - startAngle);
       }
       const minradius = Math.min(radius[0], radius[1]);
-      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS * EPS) / (2 * minradius * minradius));
+      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS3 * EPS3) / (2 * minradius * minradius));
       if (rotation < minangle) throw new Error("startAngle and endAngle do not define a significant rotation");
       segments = Math.floor(segments * (rotation / TAU));
       const centerv = vec2.clone(center);
@@ -7439,7 +7439,7 @@ var require_cube = __commonJS({
 var require_cylinderElliptic = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/cylinderElliptic.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
     var poly3 = require_poly3();
@@ -7476,7 +7476,7 @@ var require_cylinderElliptic = __commonJS({
         rotation = endAngle + (TAU - startAngle);
       }
       const minradius = Math.min(startRadius[0], startRadius[1], endRadius[0], endRadius[1]);
-      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS * EPS) / (2 * minradius * minradius));
+      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS3 * EPS3) / (2 * minradius * minradius));
       if (rotation < minangle) throw new Error("startAngle and endAngle do not define a significant rotation");
       const slices = Math.floor(segments * (rotation / TAU));
       const start = vec3.fromValues(0, 0, -(height10 / 2));
@@ -7584,15 +7584,15 @@ var require_ellipsoid = __commonJS({
         segments: 32,
         axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
       };
-      const { center, radius, segments, axes } = Object.assign({}, defaults2, options);
+      const { center, radius, segments, axes: axes2 } = Object.assign({}, defaults2, options);
       if (!isNumberArray(center, 3)) throw new Error("center must be an array of X, Y and Z values");
       if (!isNumberArray(radius, 3)) throw new Error("radius must be an array of X, Y and Z values");
       if (!radius.every((n) => n >= 0)) throw new Error("radius values must be positive");
       if (!isGTE(segments, 4)) throw new Error("segments must be four or more");
       if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom3.create();
-      const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0]);
-      const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1]);
-      const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2]);
+      const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes2[0]), radius[0]);
+      const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes2[1]), radius[1]);
+      const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes2[2]), radius[2]);
       const qsegments = Math.round(segments / 4);
       let prevcylinderpoint;
       const polygons = [];
@@ -7925,7 +7925,7 @@ var require_rectangle = __commonJS({
 var require_roundedCuboid = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedCuboid.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec2 = require_vec2();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
@@ -7941,7 +7941,7 @@ var require_roundedCuboid = __commonJS({
       let layerradius = radius * cospitch;
       let layeroffset = size4[2] - (radius - radius * sinpitch);
       if (!positive) layeroffset = radius - radius * sinpitch - size4[2];
-      layerradius = layerradius > EPS ? layerradius : 0;
+      layerradius = layerradius > EPS3 ? layerradius : 0;
       const corner0 = vec3.add(vec3.create(), center, [size4[0] - radius, size4[1] - radius, layeroffset]);
       const corner1 = vec3.add(vec3.create(), center, [radius - size4[0], size4[1] - radius, layeroffset]);
       const corner2 = vec3.add(vec3.create(), center, [radius - size4[0], radius - size4[1], layeroffset]);
@@ -8036,7 +8036,7 @@ var require_roundedCuboid = __commonJS({
       if (size4[0] === 0 || size4[1] === 0 || size4[2] === 0) return geom3.create();
       if (roundRadius === 0) return cuboid5({ center, size: size4 });
       size4 = size4.map((v) => v / 2);
-      if (roundRadius > size4[0] - EPS || roundRadius > size4[1] - EPS || roundRadius > size4[2] - EPS) throw new Error("roundRadius must be smaller than the radius of all dimensions");
+      if (roundRadius > size4[0] - EPS3 || roundRadius > size4[1] - EPS3 || roundRadius > size4[2] - EPS3) throw new Error("roundRadius must be smaller than the radius of all dimensions");
       segments = Math.floor(segments / 4);
       let prevCornersPos = null;
       let prevCornersNeg = null;
@@ -8078,7 +8078,7 @@ var require_roundedCuboid = __commonJS({
 var require_roundedCylinder = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedCylinder.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
     var poly3 = require_poly3();
@@ -8106,7 +8106,7 @@ var require_roundedCylinder = __commonJS({
       const end = [0, 0, height10 / 2];
       const direction = vec3.subtract(vec3.create(), end, start);
       const length83 = vec3.length(direction);
-      if (2 * roundRadius > length83 - EPS) throw new Error("height must be larger than twice roundRadius");
+      if (2 * roundRadius > length83 - EPS3) throw new Error("height must be larger than twice roundRadius");
       let defaultnormal;
       if (Math.abs(direction[0]) > Math.abs(direction[1])) {
         defaultnormal = vec3.fromValues(0, 1, 0);
@@ -8191,7 +8191,7 @@ var require_roundedCylinder = __commonJS({
 var require_roundedRectangle = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedRectangle.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { isGTE, isNumberArray } = require_commonChecks();
@@ -8212,7 +8212,7 @@ var require_roundedRectangle = __commonJS({
       if (size4[0] === 0 || size4[1] === 0) return geom2.create();
       if (roundRadius === 0) return rectangle({ center, size: size4 });
       size4 = size4.map((v) => v / 2);
-      if (roundRadius > size4[0] - EPS || roundRadius > size4[1] - EPS) throw new Error("roundRadius must be smaller than the radius of all dimensions");
+      if (roundRadius > size4[0] - EPS3 || roundRadius > size4[1] - EPS3) throw new Error("roundRadius must be smaller than the radius of all dimensions");
       const cornersegments = Math.floor(segments / 4);
       const corner0 = vec2.add(vec2.create(), center, [size4[0] - roundRadius, size4[1] - roundRadius]);
       const corner1 = vec2.add(vec2.create(), center, [roundRadius - size4[0], size4[1] - roundRadius]);
@@ -8253,10 +8253,10 @@ var require_sphere = __commonJS({
         segments: 32,
         axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
       };
-      let { center, radius, segments, axes } = Object.assign({}, defaults2, options);
+      let { center, radius, segments, axes: axes2 } = Object.assign({}, defaults2, options);
       if (!isGTE(radius, 0)) throw new Error("radius must be positive");
       radius = [radius, radius, radius];
-      return ellipsoid({ center, radius, segments, axes });
+      return ellipsoid({ center, radius, segments, axes: axes2 });
     };
     module.exports = sphere;
   }
@@ -8458,7 +8458,7 @@ var require_equals8 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/slice/equals.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var equals = (a, b) => {
+    var equals2 = (a, b) => {
       const aedges = a.edges;
       const bedges = b.edges;
       if (aedges.length !== bedges.length) {
@@ -8471,7 +8471,7 @@ var require_equals8 = __commonJS({
       }, true);
       return isEqual;
     };
-    module.exports = equals;
+    module.exports = equals2;
   }
 });
 
@@ -8630,7 +8630,7 @@ var require_linkedList = __commonJS({
         this.steiner = false;
       }
     };
-    var insertNode = (i, x, y, last) => {
+    var insertNode2 = (i, x, y, last) => {
       const p = new Node2(i, x, y);
       if (!last) {
         p.prev = p;
@@ -8643,13 +8643,13 @@ var require_linkedList = __commonJS({
       }
       return p;
     };
-    var removeNode = (p) => {
+    var removeNode2 = (p) => {
       p.next.prev = p.prev;
       p.prev.next = p.next;
       if (p.prevZ) p.prevZ.nextZ = p.nextZ;
       if (p.nextZ) p.nextZ.prevZ = p.prevZ;
     };
-    module.exports = { Node: Node2, insertNode, removeNode, sortLinked };
+    module.exports = { Node: Node2, insertNode: insertNode2, removeNode: removeNode2, sortLinked };
   }
 });
 
@@ -8657,9 +8657,9 @@ var require_linkedList = __commonJS({
 var require_triangle = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/earcut/triangle.js"(exports, module) {
     "use strict";
-    var pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
-    var area = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-    module.exports = { area, pointInTriangle };
+    var pointInTriangle2 = (ax, ay, bx, by, cx, cy, px, py) => (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+    var area2 = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+    module.exports = { area: area2, pointInTriangle: pointInTriangle2 };
   }
 });
 
@@ -8667,34 +8667,34 @@ var require_triangle = __commonJS({
 var require_linkedPolygon = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/earcut/linkedPolygon.js"(exports, module) {
     "use strict";
-    var { Node: Node2, insertNode, removeNode } = require_linkedList();
-    var { area } = require_triangle();
+    var { Node: Node2, insertNode: insertNode2, removeNode: removeNode2 } = require_linkedList();
+    var { area: area2 } = require_triangle();
     var linkedPolygon = (data, start, end, dim, clockwise) => {
       let last;
-      if (clockwise === signedArea(data, start, end, dim) > 0) {
+      if (clockwise === signedArea2(data, start, end, dim) > 0) {
         for (let i = start; i < end; i += dim) {
-          last = insertNode(i, data[i], data[i + 1], last);
+          last = insertNode2(i, data[i], data[i + 1], last);
         }
       } else {
         for (let i = end - dim; i >= start; i -= dim) {
-          last = insertNode(i, data[i], data[i + 1], last);
+          last = insertNode2(i, data[i], data[i + 1], last);
         }
       }
-      if (last && equals(last, last.next)) {
-        removeNode(last);
+      if (last && equals2(last, last.next)) {
+        removeNode2(last);
         last = last.next;
       }
       return last;
     };
-    var filterPoints = (start, end) => {
+    var filterPoints2 = (start, end) => {
       if (!start) return start;
       if (!end) end = start;
       let p = start;
       let again;
       do {
         again = false;
-        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-          removeNode(p);
+        if (!p.steiner && (equals2(p, p.next) || area2(p.prev, p, p.next) === 0)) {
+          removeNode2(p);
           p = end = p.prev;
           if (p === p.next) break;
           again = true;
@@ -8704,33 +8704,33 @@ var require_linkedPolygon = __commonJS({
       } while (again || p !== end);
       return end;
     };
-    var cureLocalIntersections = (start, triangles, dim) => {
+    var cureLocalIntersections2 = (start, triangles, dim) => {
       let p = start;
       do {
         const a = p.prev;
         const b = p.next.next;
-        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        if (!equals2(a, b) && intersects2(a, p, p.next, b) && locallyInside2(a, b) && locallyInside2(b, a)) {
           triangles.push(a.i / dim);
           triangles.push(p.i / dim);
           triangles.push(b.i / dim);
-          removeNode(p);
-          removeNode(p.next);
+          removeNode2(p);
+          removeNode2(p.next);
           p = start = b;
         }
         p = p.next;
       } while (p !== start);
-      return filterPoints(p);
+      return filterPoints2(p);
     };
-    var intersectsPolygon = (a, b) => {
+    var intersectsPolygon2 = (a, b) => {
       let p = a;
       do {
-        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;
+        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects2(p, p.next, a, b)) return true;
         p = p.next;
       } while (p !== a);
       return false;
     };
-    var locallyInside = (a, b) => area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-    var middleInside = (a, b) => {
+    var locallyInside2 = (a, b) => area2(a.prev, a, a.next) < 0 ? area2(a, b, a.next) >= 0 && area2(a, a.prev, b) >= 0 : area2(a, b, a.prev) < 0 || area2(a, a.next, b) < 0;
+    var middleInside2 = (a, b) => {
       let p = a;
       let inside = false;
       const px = (a.x + b.x) / 2;
@@ -8743,7 +8743,7 @@ var require_linkedPolygon = __commonJS({
       } while (p !== a);
       return inside;
     };
-    var splitPolygon = (a, b) => {
+    var splitPolygon2 = (a, b) => {
       const a2 = new Node2(a.i, a.x, a.y);
       const b2 = new Node2(b.i, b.x, b.y);
       const an = a.next;
@@ -8758,24 +8758,24 @@ var require_linkedPolygon = __commonJS({
       b2.prev = bp;
       return b2;
     };
-    var isValidDiagonal = (a, b) => a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // doesn't intersect other edges
-    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
-    var intersects = (p1, q1, p2, q2) => {
-      const o1 = Math.sign(area(p1, q1, p2));
-      const o2 = Math.sign(area(p1, q1, q2));
-      const o3 = Math.sign(area(p2, q2, p1));
-      const o4 = Math.sign(area(p2, q2, q1));
+    var isValidDiagonal2 = (a, b) => a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon2(a, b) && // doesn't intersect other edges
+    (locallyInside2(a, b) && locallyInside2(b, a) && middleInside2(a, b) && // locally visible
+    (area2(a.prev, a, b.prev) || area2(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals2(a, b) && area2(a.prev, a, a.next) > 0 && area2(b.prev, b, b.next) > 0);
+    var intersects2 = (p1, q1, p2, q2) => {
+      const o1 = Math.sign(area2(p1, q1, p2));
+      const o2 = Math.sign(area2(p1, q1, q2));
+      const o3 = Math.sign(area2(p2, q2, p1));
+      const o4 = Math.sign(area2(p2, q2, q1));
       if (o1 !== o2 && o3 !== o4) return true;
-      if (o1 === 0 && onSegment2(p1, p2, q1)) return true;
-      if (o2 === 0 && onSegment2(p1, q2, q1)) return true;
-      if (o3 === 0 && onSegment2(p2, p1, q2)) return true;
-      if (o4 === 0 && onSegment2(p2, q1, q2)) return true;
+      if (o1 === 0 && onSegment3(p1, p2, q1)) return true;
+      if (o2 === 0 && onSegment3(p1, q2, q1)) return true;
+      if (o3 === 0 && onSegment3(p2, p1, q2)) return true;
+      if (o4 === 0 && onSegment3(p2, q1, q2)) return true;
       return false;
     };
-    var onSegment2 = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-    var signedArea = (data, start, end, dim) => {
+    var onSegment3 = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+    var signedArea2 = (data, start, end, dim) => {
       let sum = 0;
       for (let i = start, j = end - dim; i < end; i += dim) {
         sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
@@ -8783,8 +8783,8 @@ var require_linkedPolygon = __commonJS({
       }
       return sum;
     };
-    var equals = (p1, p2) => p1.x === p2.x && p1.y === p2.y;
-    module.exports = { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, locallyInside, splitPolygon };
+    var equals2 = (p1, p2) => p1.x === p2.x && p1.y === p2.y;
+    module.exports = { cureLocalIntersections: cureLocalIntersections2, filterPoints: filterPoints2, isValidDiagonal: isValidDiagonal2, linkedPolygon, locallyInside: locallyInside2, splitPolygon: splitPolygon2 };
   }
 });
 
@@ -8792,35 +8792,35 @@ var require_linkedPolygon = __commonJS({
 var require_eliminateHoles = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/earcut/eliminateHoles.js"(exports, module) {
     "use strict";
-    var { filterPoints, linkedPolygon, locallyInside, splitPolygon } = require_linkedPolygon();
-    var { area, pointInTriangle } = require_triangle();
-    var eliminateHoles = (data, holeIndices, outerNode, dim) => {
+    var { filterPoints: filterPoints2, linkedPolygon, locallyInside: locallyInside2, splitPolygon: splitPolygon2 } = require_linkedPolygon();
+    var { area: area2, pointInTriangle: pointInTriangle2 } = require_triangle();
+    var eliminateHoles2 = (data, holeIndices, outerNode, dim) => {
       const queue = [];
       for (let i = 0, len = holeIndices.length; i < len; i++) {
         const start = holeIndices[i] * dim;
         const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
         const list = linkedPolygon(data, start, end, dim, false);
         if (list === list.next) list.steiner = true;
-        queue.push(getLeftmost(list));
+        queue.push(getLeftmost2(list));
       }
       queue.sort((a, b) => a.x - b.x);
       for (let i = 0; i < queue.length; i++) {
-        outerNode = eliminateHole(queue[i], outerNode);
-        outerNode = filterPoints(outerNode, outerNode.next);
+        outerNode = eliminateHole2(queue[i], outerNode);
+        outerNode = filterPoints2(outerNode, outerNode.next);
       }
       return outerNode;
     };
-    var eliminateHole = (hole, outerNode) => {
-      const bridge = findHoleBridge(hole, outerNode);
+    var eliminateHole2 = (hole, outerNode) => {
+      const bridge = findHoleBridge2(hole, outerNode);
       if (!bridge) {
         return outerNode;
       }
-      const bridgeReverse = splitPolygon(bridge, hole);
-      const filteredBridge = filterPoints(bridge, bridge.next);
-      filterPoints(bridgeReverse, bridgeReverse.next);
+      const bridgeReverse = splitPolygon2(bridge, hole);
+      const filteredBridge = filterPoints2(bridge, bridge.next);
+      filterPoints2(bridgeReverse, bridgeReverse.next);
       return outerNode === bridge ? filteredBridge : outerNode;
     };
-    var findHoleBridge = (hole, outerNode) => {
+    var findHoleBridge2 = (hole, outerNode) => {
       let p = outerNode;
       const hx = hole.x;
       const hy = hole.y;
@@ -8848,9 +8848,9 @@ var require_eliminateHoles = __commonJS({
       let tanMin = Infinity;
       p = m;
       do {
-        if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle2(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
           const tan = Math.abs(hy - p.y) / (hx - p.x);
-          if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          if (locallyInside2(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector2(m, p)))) {
             m = p;
             tanMin = tan;
           }
@@ -8859,8 +8859,8 @@ var require_eliminateHoles = __commonJS({
       } while (p !== stop);
       return m;
     };
-    var sectorContainsSector = (m, p) => area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
-    var getLeftmost = (start) => {
+    var sectorContainsSector2 = (m, p) => area2(m.prev, m, p.prev) < 0 && area2(p.next, m, m.next) < 0;
+    var getLeftmost2 = (start) => {
       let p = start;
       let leftmost = start;
       do {
@@ -8869,7 +8869,7 @@ var require_eliminateHoles = __commonJS({
       } while (p !== start);
       return leftmost;
     };
-    module.exports = eliminateHoles;
+    module.exports = eliminateHoles2;
   }
 });
 
@@ -8877,10 +8877,10 @@ var require_eliminateHoles = __commonJS({
 var require_earcut = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/earcut/index.js"(exports, module) {
     "use strict";
-    var eliminateHoles = require_eliminateHoles();
-    var { removeNode, sortLinked } = require_linkedList();
-    var { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, splitPolygon } = require_linkedPolygon();
-    var { area, pointInTriangle } = require_triangle();
+    var eliminateHoles2 = require_eliminateHoles();
+    var { removeNode: removeNode2, sortLinked } = require_linkedList();
+    var { cureLocalIntersections: cureLocalIntersections2, filterPoints: filterPoints2, isValidDiagonal: isValidDiagonal2, linkedPolygon, splitPolygon: splitPolygon2 } = require_linkedPolygon();
+    var { area: area2, pointInTriangle: pointInTriangle2 } = require_triangle();
     var triangulate = (data, holeIndices, dim = 2) => {
       const hasHoles = holeIndices && holeIndices.length;
       const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
@@ -8888,7 +8888,7 @@ var require_earcut = __commonJS({
       const triangles = [];
       if (!outerNode || outerNode.next === outerNode.prev) return triangles;
       let minX, minY, maxX, maxY, invSize;
-      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (hasHoles) outerNode = eliminateHoles2(data, holeIndices, outerNode, dim);
       if (data.length > 80 * dim) {
         minX = maxX = data[0];
         minY = maxY = data[1];
@@ -8903,23 +8903,23 @@ var require_earcut = __commonJS({
         invSize = Math.max(maxX - minX, maxY - minY);
         invSize = invSize !== 0 ? 1 / invSize : 0;
       }
-      earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+      earcutLinked2(outerNode, triangles, dim, minX, minY, invSize);
       return triangles;
     };
-    var earcutLinked = (ear, triangles, dim, minX, minY, invSize, pass) => {
+    var earcutLinked2 = (ear, triangles, dim, minX, minY, invSize, pass) => {
       if (!ear) return;
-      if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+      if (!pass && invSize) indexCurve2(ear, minX, minY, invSize);
       let stop = ear;
       let prev;
       let next;
       while (ear.prev !== ear.next) {
         prev = ear.prev;
         next = ear.next;
-        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        if (invSize ? isEarHashed2(ear, minX, minY, invSize) : isEar2(ear)) {
           triangles.push(prev.i / dim);
           triangles.push(ear.i / dim);
           triangles.push(next.i / dim);
-          removeNode(ear);
+          removeNode2(ear);
           ear = next.next;
           stop = next.next;
           continue;
@@ -8927,71 +8927,71 @@ var require_earcut = __commonJS({
         ear = next;
         if (ear === stop) {
           if (!pass) {
-            earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+            earcutLinked2(filterPoints2(ear), triangles, dim, minX, minY, invSize, 1);
           } else if (pass === 1) {
-            ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
-            earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+            ear = cureLocalIntersections2(filterPoints2(ear), triangles, dim);
+            earcutLinked2(ear, triangles, dim, minX, minY, invSize, 2);
           } else if (pass === 2) {
-            splitEarcut(ear, triangles, dim, minX, minY, invSize);
+            splitEarcut2(ear, triangles, dim, minX, minY, invSize);
           }
           break;
         }
       }
     };
-    var isEar = (ear) => {
+    var isEar2 = (ear) => {
       const a = ear.prev;
       const b = ear;
       const c = ear.next;
-      if (area(a, b, c) >= 0) return false;
+      if (area2(a, b, c) >= 0) return false;
       let p = ear.next.next;
       while (p !== ear.prev) {
-        if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) {
+        if (pointInTriangle2(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area2(p.prev, p, p.next) >= 0) {
           return false;
         }
         p = p.next;
       }
       return true;
     };
-    var isEarHashed = (ear, minX, minY, invSize) => {
+    var isEarHashed2 = (ear, minX, minY, invSize) => {
       const a = ear.prev;
       const b = ear;
       const c = ear.next;
-      if (area(a, b, c) >= 0) return false;
+      if (area2(a, b, c) >= 0) return false;
       const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;
       const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;
       const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;
       const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
-      const minZ = zOrder(minTX, minTY, minX, minY, invSize);
-      const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+      const minZ = zOrder2(minTX, minTY, minX, minY, invSize);
+      const maxZ = zOrder2(maxTX, maxTY, minX, minY, invSize);
       let p = ear.prevZ;
       let n = ear.nextZ;
       while (p && p.z >= minZ && n && n.z <= maxZ) {
-        if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+        if (p !== ear.prev && p !== ear.next && pointInTriangle2(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area2(p.prev, p, p.next) >= 0) return false;
         p = p.prevZ;
-        if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+        if (n !== ear.prev && n !== ear.next && pointInTriangle2(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area2(n.prev, n, n.next) >= 0) return false;
         n = n.nextZ;
       }
       while (p && p.z >= minZ) {
-        if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+        if (p !== ear.prev && p !== ear.next && pointInTriangle2(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area2(p.prev, p, p.next) >= 0) return false;
         p = p.prevZ;
       }
       while (n && n.z <= maxZ) {
-        if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+        if (n !== ear.prev && n !== ear.next && pointInTriangle2(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area2(n.prev, n, n.next) >= 0) return false;
         n = n.nextZ;
       }
       return true;
     };
-    var splitEarcut = (start, triangles, dim, minX, minY, invSize) => {
+    var splitEarcut2 = (start, triangles, dim, minX, minY, invSize) => {
       let a = start;
       do {
         let b = a.next.next;
         while (b !== a.prev) {
-          if (a.i !== b.i && isValidDiagonal(a, b)) {
-            let c = splitPolygon(a, b);
-            a = filterPoints(a, a.next);
-            c = filterPoints(c, c.next);
-            earcutLinked(a, triangles, dim, minX, minY, invSize);
-            earcutLinked(c, triangles, dim, minX, minY, invSize);
+          if (a.i !== b.i && isValidDiagonal2(a, b)) {
+            let c = splitPolygon2(a, b);
+            a = filterPoints2(a, a.next);
+            c = filterPoints2(c, c.next);
+            earcutLinked2(a, triangles, dim, minX, minY, invSize);
+            earcutLinked2(c, triangles, dim, minX, minY, invSize);
             return;
           }
           b = b.next;
@@ -8999,10 +8999,10 @@ var require_earcut = __commonJS({
         a = a.next;
       } while (a !== start);
     };
-    var indexCurve = (start, minX, minY, invSize) => {
+    var indexCurve2 = (start, minX, minY, invSize) => {
       let p = start;
       do {
-        if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+        if (p.z === null) p.z = zOrder2(p.x, p.y, minX, minY, invSize);
         p.prevZ = p.prev;
         p.nextZ = p.next;
         p = p.next;
@@ -9011,7 +9011,7 @@ var require_earcut = __commonJS({
       p.prevZ = null;
       sortLinked(p, (p2) => p2.z);
     };
-    var zOrder = (x, y, minX, minY, invSize) => {
+    var zOrder2 = (x, y, minX, minY, invSize) => {
       x = 32767 * (x - minX) * invSize;
       y = 32767 * (y - minY) * invSize;
       x = (x | x << 8) & 16711935;
@@ -9032,7 +9032,7 @@ var require_earcut = __commonJS({
 var require_assignHoles = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/earcut/assignHoles.js"(exports, module) {
     "use strict";
-    var { area } = require_utils();
+    var { area: area2 } = require_utils();
     var { toOutlines } = require_geom2();
     var { arePointsInside } = require_poly2();
     var assignHoles = (geometry) => {
@@ -9040,7 +9040,7 @@ var require_assignHoles = __commonJS({
       const solids = [];
       const holes = [];
       outlines.forEach((outline, i) => {
-        const a = area(outline);
+        const a = area2(outline);
         if (a < 0) {
           holes.push(i);
         } else if (a > 0) {
@@ -9148,7 +9148,7 @@ var require_toPolygons2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/slice/toPolygons.js"(exports, module) {
     "use strict";
     var poly3 = require_poly3();
-    var earcut = require_earcut();
+    var earcut2 = require_earcut();
     var PolygonHierarchy = require_polygonHierarchy();
     var toPolygons = (slice) => {
       const hierarchy = new PolygonHierarchy(slice);
@@ -9163,7 +9163,7 @@ var require_toPolygons2 = __commonJS({
         const vertices = [solid, ...holes].flat();
         const data = vertices.flat();
         const getVertex = (i) => hierarchy.to3D(vertices[i]);
-        const indices = earcut(data, holesIndex);
+        const indices = earcut2(data, holesIndex);
         for (let i = 0; i < indices.length; i += 3) {
           const tri = indices.slice(i, i + 3).map(getVertex);
           polygons.push(poly3.fromPointsAndPlane(tri, hierarchy.plane));
@@ -9276,7 +9276,7 @@ var require_repair = __commonJS({
 var require_extrudeWalls = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/extrudeWalls.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var slice = require_slice();
@@ -9316,7 +9316,7 @@ var require_extrudeWalls = __commonJS({
       });
       return newEdges;
     };
-    var EPSAREA = EPS * EPS / 2 * Math.sin(Math.PI / 3);
+    var EPSAREA = EPS3 * EPS3 / 2 * Math.sin(Math.PI / 3);
     var extrudeWalls = (slice0, slice1) => {
       let edges0 = slice.toEdges(slice0);
       let edges1 = slice.toEdges(slice1);
@@ -10299,7 +10299,7 @@ var require_OrthoNormalBasis = __commonJS({
 var require_reTesselateCoplanarPolygons = __commonJS({
   "node_modules/@jscad/modeling/src/operations/modifiers/reTesselateCoplanarPolygons.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var line2 = require_line2();
     var vec2 = require_vec2();
     var OrthoNormalBasis = require_OrthoNormalBasis();
@@ -10317,7 +10317,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
       const topy2polygonindexes = /* @__PURE__ */ new Map();
       const ycoordinatetopolygonindexes = /* @__PURE__ */ new Map();
       const ycoordinatebins = /* @__PURE__ */ new Map();
-      const ycoordinateBinningFactor = 10 / EPS;
+      const ycoordinateBinningFactor = 10 / EPS3;
       for (let polygonindex = 0; polygonindex < numpolygons; polygonindex++) {
         const poly3d = sourcepolygons[polygonindex];
         let vertices2d = [];
@@ -10497,7 +10497,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
             const prevoutpolygon = newoutpolygonrow[newoutpolygonrow.length - 1];
             const d1 = vec2.distance(outpolygon.topleft, prevoutpolygon.topright);
             const d2 = vec2.distance(outpolygon.bottomleft, prevoutpolygon.bottomright);
-            if (d1 < EPS && d2 < EPS) {
+            if (d1 < EPS3 && d2 < EPS3) {
               outpolygon.topleft = prevoutpolygon.topleft;
               outpolygon.leftline = prevoutpolygon.leftline;
               outpolygon.bottomleft = prevoutpolygon.bottomleft;
@@ -10514,8 +10514,8 @@ var require_reTesselateCoplanarPolygons = __commonJS({
             for (let ii = 0; ii < prevoutpolygonrow.length; ii++) {
               if (!matchedindexes.has(ii)) {
                 const prevpolygon = prevoutpolygonrow[ii];
-                if (vec2.distance(prevpolygon.bottomleft, thispolygon.topleft) < EPS) {
-                  if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS) {
+                if (vec2.distance(prevpolygon.bottomleft, thispolygon.topleft) < EPS3) {
+                  if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS3) {
                     matchedindexes.add(ii);
                     const v1 = line2.direction(thispolygon.leftline);
                     const v2 = line2.direction(prevpolygon.leftline);
@@ -10523,8 +10523,8 @@ var require_reTesselateCoplanarPolygons = __commonJS({
                     const v3 = line2.direction(thispolygon.rightline);
                     const v4 = line2.direction(prevpolygon.rightline);
                     const d2 = v3[0] - v4[0];
-                    const leftlinecontinues = Math.abs(d1) < EPS;
-                    const rightlinecontinues = Math.abs(d2) < EPS;
+                    const leftlinecontinues = Math.abs(d1) < EPS3;
+                    const rightlinecontinues = Math.abs(d2) < EPS3;
                     const leftlineisconvex = leftlinecontinues || d1 >= 0;
                     const rightlineisconvex = rightlinecontinues || d2 >= 0;
                     if (leftlineisconvex && rightlineisconvex) {
@@ -10543,7 +10543,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
             if (!prevcontinuedindexes.has(ii)) {
               const prevpolygon = prevoutpolygonrow[ii];
               prevpolygon.outpolygon.rightpoints.push(prevpolygon.bottomright);
-              if (vec2.distance(prevpolygon.bottomright, prevpolygon.bottomleft) > EPS) {
+              if (vec2.distance(prevpolygon.bottomright, prevpolygon.bottomleft) > EPS3) {
                 prevpolygon.outpolygon.leftpoints.push(prevpolygon.bottomleft);
               }
               prevpolygon.outpolygon.leftpoints.reverse();
@@ -10562,7 +10562,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
               rightpoints: []
             };
             thispolygon.outpolygon.leftpoints.push(thispolygon.topleft);
-            if (vec2.distance(thispolygon.topleft, thispolygon.topright) > EPS) {
+            if (vec2.distance(thispolygon.topleft, thispolygon.topright) > EPS3) {
               thispolygon.outpolygon.rightpoints.push(thispolygon.topright);
             }
           } else {
@@ -10663,7 +10663,7 @@ var require_retessellate = __commonJS({
 var require_mayOverlap = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/mayOverlap.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var measureBoundingBox = require_measureBoundingBox2();
     var mayOverlap = (geometry1, geometry2) => {
       if (geometry1.polygons.length === 0 || geometry2.polygons.length === 0) {
@@ -10675,12 +10675,12 @@ var require_mayOverlap = __commonJS({
       const bounds2 = measureBoundingBox(geometry2);
       const min2 = bounds2[0];
       const max2 = bounds2[1];
-      if (min2[0] - max1[0] > EPS) return false;
-      if (min1[0] - max2[0] > EPS) return false;
-      if (min2[1] - max1[1] > EPS) return false;
-      if (min1[1] - max2[1] > EPS) return false;
-      if (min2[2] - max1[2] > EPS) return false;
-      if (min1[2] - max2[2] > EPS) return false;
+      if (min2[0] - max1[0] > EPS3) return false;
+      if (min1[0] - max2[0] > EPS3) return false;
+      if (min2[1] - max1[1] > EPS3) return false;
+      if (min1[1] - max2[1] > EPS3) return false;
+      if (min2[2] - max1[2] > EPS3) return false;
+      if (min1[2] - max2[2] > EPS3) return false;
       return true;
     };
     module.exports = mayOverlap;
@@ -10830,12 +10830,12 @@ var require_splitLineSegmentByPlane = __commonJS({
 var require_splitPolygonByPlane = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/trees/splitPolygonByPlane.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var plane = require_plane();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitLineSegmentByPlane = require_splitLineSegmentByPlane();
-    var EPS_SQUARED = EPS * EPS;
+    var EPS_SQUARED = EPS3 * EPS3;
     var removeConsecutiveDuplicates = (vertices) => {
       const result = [];
       let prevvertex = vertices[vertices.length - 1];
@@ -10863,12 +10863,12 @@ var require_splitPolygonByPlane = __commonJS({
         let hasfront = false;
         let hasback = false;
         const vertexIsBack = [];
-        const MINEPS = -EPS;
+        const MINEPS = -EPS3;
         for (let i = 0; i < numvertices; i++) {
           const t = vec3.dot(splane, vertices[i]) - splane[3];
           const isback = t < MINEPS;
           vertexIsBack.push(isback);
-          if (t > EPS) hasfront = true;
+          if (t > EPS3) hasfront = true;
           if (t < MINEPS) hasback = true;
         }
         if (!hasfront && !hasback) {
@@ -10933,7 +10933,7 @@ var require_splitPolygonByPlane = __commonJS({
 var require_PolygonTreeNode = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/trees/PolygonTreeNode.js"(exports, module) {
     "use strict";
-    var { EPS } = require_constants();
+    var { EPS: EPS3 } = require_constants();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitPolygonByPlane = require_splitPolygonByPlane();
@@ -11036,7 +11036,7 @@ var require_PolygonTreeNode = __commonJS({
         const polygon2 = this.polygon;
         if (polygon2) {
           const bound = poly3.measureBoundingSphere(polygon2);
-          const sphereradius = bound[3] + EPS;
+          const sphereradius = bound[3] + EPS3;
           const spherecenter = bound;
           const d = vec3.dot(splane, spherecenter) - splane[3];
           if (d > sphereradius) {
@@ -11752,11 +11752,11 @@ var require_booleans = __commonJS({
 var require_offsetFromPoints = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/offsetFromPoints.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var intersect3 = require_intersect();
     var line2 = require_line2();
     var vec2 = require_vec2();
-    var area = require_area();
+    var area2 = require_area();
     var offsetFromPoints = (options, points) => {
       const defaults2 = {
         delta: 1,
@@ -11765,8 +11765,8 @@ var require_offsetFromPoints = __commonJS({
         segments: 16
       };
       let { delta, corners, closed, segments } = Object.assign({}, defaults2, options);
-      if (Math.abs(delta) < EPS) return points;
-      let rotation = options.closed ? area(points) : 1;
+      if (Math.abs(delta) < EPS3) return points;
+      let rotation = options.closed ? area2(points) : 1;
       if (rotation === 0) rotation = 1;
       const orientation2 = rotation > 0 && delta >= 0 || rotation < 0 && delta < 0;
       delta = Math.abs(delta);
@@ -11923,7 +11923,7 @@ var require_extrudePolygon = __commonJS({
     var vec3 = require_vec3();
     var geom3 = require_geom3();
     var poly3 = require_poly3();
-    var extrudePolygon = (offsetvector, polygon1) => {
+    var extrudePolygon2 = (offsetvector, polygon1) => {
       const direction = vec3.dot(poly3.plane(polygon1), offsetvector);
       if (direction > 0) {
         polygon1 = poly3.invert(polygon1);
@@ -11944,7 +11944,7 @@ var require_extrudePolygon = __commonJS({
       newpolygons.push(poly3.invert(polygon2));
       return geom3.create(newpolygons);
     };
-    module.exports = extrudePolygon;
+    module.exports = extrudePolygon2;
   }
 });
 
@@ -11952,7 +11952,7 @@ var require_extrudePolygon = __commonJS({
 var require_expandShell = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/expandShell.js"(exports, module) {
     "use strict";
-    var { EPS, TAU } = require_constants();
+    var { EPS: EPS3, TAU } = require_constants();
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var fnNumberSort = require_fnNumberSort();
@@ -11961,7 +11961,7 @@ var require_expandShell = __commonJS({
     var sphere = require_sphere();
     var retessellate = require_retessellate();
     var unionGeom3Sub = require_unionGeom3Sub();
-    var extrudePolygon = require_extrudePolygon();
+    var extrudePolygon2 = require_extrudePolygon();
     var mapPlaneToVertex = (map, vertex, plane) => {
       const key = vertex.toString();
       if (!map.has(key)) {
@@ -12005,7 +12005,7 @@ var require_expandShell = __commonJS({
       polygons.forEach((polygon2, index2) => {
         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);
-        const extrudedface = extrudePolygon(extrudevector, translatedpolygon);
+        const extrudedface = extrudePolygon2(extrudevector, translatedpolygon);
         result = unionGeom3Sub(result, extrudedface);
         const vertices = polygon2.vertices;
         for (let i = 0; i < vertices.length; i++) {
@@ -12057,7 +12057,7 @@ var require_expandShell = __commonJS({
           const p2 = vec3.add(vec3.create(), endpoint, v1);
           let skip = false;
           if (i >= 0) {
-            if (vec3.distance(p1, prevp1) < EPS) {
+            if (vec3.distance(p1, prevp1) < EPS3) {
               skip = true;
             }
           }
@@ -12147,14 +12147,14 @@ var require_expandGeom3 = __commonJS({
 var require_expandPath2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/expandPath2.js"(exports, module) {
     "use strict";
-    var area = require_area();
+    var area2 = require_area();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var path2 = require_path2();
     var offsetFromPoints = require_offsetFromPoints();
     var createGeometryFromClosedOffsets = (paths) => {
       let { external, internal } = paths;
-      if (area(external) < 0) {
+      if (area2(external) < 0) {
         external = external.reverse();
       } else {
         internal = internal.reverse();
@@ -12467,7 +12467,7 @@ var require_extrudeRectangularPath2 = __commonJS({
 var require_extrudeRectangularGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/extrudeRectangularGeom2.js"(exports, module) {
     "use strict";
-    var { area } = require_utils();
+    var { area: area2 } = require_utils();
     var geom2 = require_geom2();
     var path2 = require_path2();
     var expand2 = require_expand();
@@ -12483,7 +12483,7 @@ var require_extrudeRectangularGeom2 = __commonJS({
       const outlines = geom2.toOutlines(geometry);
       if (outlines.length === 0) throw new Error("the given geometry cannot be empty");
       const newparts = outlines.map((outline) => {
-        if (area(outline) < 0) outline.reverse();
+        if (area2(outline) < 0) outline.reverse();
         return expand2(options, path2.fromPoints({ closed: true }, outline));
       });
       const allsides = newparts.reduce((sides2, part) => sides2.concat(geom2.toSides(part)), []);
@@ -12876,8 +12876,8 @@ var require_snapPolygons = __commonJS({
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var isValidPoly3 = (epsilon, polygon2) => {
-      const area = Math.abs(poly3.measureArea(polygon2));
-      return Number.isFinite(area) && area > epsilon;
+      const area2 = Math.abs(poly3.measureArea(polygon2));
+      return Number.isFinite(area2) && area2 > epsilon;
     };
     var snapPolygons = (epsilon, polygons) => {
       let newpolygons = polygons.map((polygon2) => {
@@ -13563,12 +13563,12 @@ var require_center = __commonJS({
         axes: [true, true, true],
         relativeTo: [0, 0, 0]
       };
-      const { axes, relativeTo } = Object.assign({}, defaults2, options);
+      const { axes: axes2, relativeTo } = Object.assign({}, defaults2, options);
       const bounds = measureBoundingBox(object);
       const offset4 = [0, 0, 0];
-      if (axes[0]) offset4[0] = relativeTo[0] - (bounds[0][0] + (bounds[1][0] - bounds[0][0]) / 2);
-      if (axes[1]) offset4[1] = relativeTo[1] - (bounds[0][1] + (bounds[1][1] - bounds[0][1]) / 2);
-      if (axes[2]) offset4[2] = relativeTo[2] - (bounds[0][2] + (bounds[1][2] - bounds[0][2]) / 2);
+      if (axes2[0]) offset4[0] = relativeTo[0] - (bounds[0][0] + (bounds[1][0] - bounds[0][0]) / 2);
+      if (axes2[1]) offset4[1] = relativeTo[1] - (bounds[0][1] + (bounds[1][1] - bounds[0][1]) / 2);
+      if (axes2[2]) offset4[2] = relativeTo[2] - (bounds[0][2] + (bounds[1][2] - bounds[0][2]) / 2);
       return translate6(offset4, object);
     };
     var center = (options, ...objects) => {
@@ -13577,11 +13577,11 @@ var require_center = __commonJS({
         relativeTo: [0, 0, 0]
         // TODO: Add additional 'methods' of centering: midpoint, centroid
       };
-      const { axes, relativeTo } = Object.assign({}, defaults2, options);
+      const { axes: axes2, relativeTo } = Object.assign({}, defaults2, options);
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
       if (relativeTo.length !== 3) throw new Error("relativeTo must be an array of length 3");
-      options = { axes, relativeTo };
+      options = { axes: axes2, relativeTo };
       const results = objects.map((object) => {
         if (path2.isA(object)) return centerGeometry(options, object);
         if (geom2.isA(object)) return centerGeometry(options, object);
@@ -14431,9 +14431,29 @@ var require_browser = __commonJS({
   }
 });
 
+// src/utils/resolve-fold-pcbs.ts
+function resolveFoldPcbs(circuitJson, foldPcbs) {
+  return foldPcbs ?? circuitJson.some(
+    (element) => element.type === "cad_component" && element.is_on_folded_board === true
+  );
+}
+
 // src/CadViewer.tsx
 import { useCallback as useCallback24, useEffect as useEffect49, useRef as useRef29, useState as useState39 } from "react";
-import * as THREE51 from "three";
+import * as THREE52 from "three";
+
+// src/hooks/use-convert-children-to-soup.ts
+import { Circuit } from "@tscircuit/core";
+import { useMemo } from "react";
+var useConvertChildrenToCircuitJson = (children) => {
+  return useMemo(() => {
+    if (!children) return [];
+    const circuit = new Circuit();
+    circuit.add(children);
+    circuit.render();
+    return circuit.getCircuitJson();
+  }, [children]);
+};
 
 // src/CadViewerJscad.tsx
 import { su as su12 } from "@tscircuit/circuit-json-util";
@@ -14457,7 +14477,7 @@ var getCadPcbContext = (cad, circuitJson) => {
 
 // src/AnyCadComponent.tsx
 import { su as su2 } from "@tscircuit/circuit-json-util";
-import { useCallback as useCallback3, useEffect as useEffect11, useMemo as useMemo8, useState as useState7 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect11, useMemo as useMemo9, useState as useState7 } from "react";
 
 // src/contexts/LayerVisibilityContext.tsx
 import {
@@ -14465,7 +14485,7 @@ import {
   useContext,
   useState,
   useCallback,
-  useMemo
+  useMemo as useMemo2
 } from "react";
 import { jsx } from "react/jsx-runtime";
 var ENCLOSURE_VISIBILITY_CYCLE = [
@@ -14512,7 +14532,7 @@ var LayerVisibilityProvider = ({ children }) => {
   const resetToDefaults = useCallback(() => {
     setVisibility(defaultVisibility);
   }, []);
-  const value = useMemo(
+  const value = useMemo2(
     () => ({
       visibility,
       setLayerVisibility,
@@ -14533,11 +14553,11 @@ var useLayerVisibility = () => {
 };
 
 // src/hooks/usePcbThickness.ts
-import { useMemo as useMemo2 } from "react";
+import { useMemo as useMemo3 } from "react";
 import { su } from "@tscircuit/circuit-json-util";
 var DEFAULT_PCB_THICKNESS = 1.2;
 function usePcbThickness(circuitJson) {
-  return useMemo2(() => {
+  return useMemo3(() => {
     if (!circuitJson) return DEFAULT_PCB_THICKNESS;
     try {
       const board = su(circuitJson).pcb_board.list()[0];
@@ -37428,7 +37448,7 @@ function getJscadModelForFootprint(footprint, jscad3) {
 
 // src/three-components/FootprinterModel.tsx
 var jscadModeling = __toESM(require_src(), 1);
-import { useMemo as useMemo4, useEffect as useEffect5 } from "react";
+import { useMemo as useMemo5, useEffect as useEffect5 } from "react";
 import * as THREE4 from "three";
 
 // src/ContainerWithTooltip.tsx
@@ -37440,7 +37460,7 @@ import {
   useContext as useContext3,
   useState as useState3,
   useCallback as useCallback2,
-  useMemo as useMemo3,
+  useMemo as useMemo4,
   useEffect as useEffect3,
   useRef as useRef2
 } from "react";
@@ -37457,8 +37477,8 @@ var useHover = () => {
 var HoverProvider = ({ children }) => {
   const { camera, renderer } = useThree();
   const [hoverables, setHoverables] = useState3([]);
-  const raycaster = useMemo3(() => new THREE2.Raycaster(), []);
-  const mouse = useMemo3(() => new THREE2.Vector2(), []);
+  const raycaster = useMemo4(() => new THREE2.Raycaster(), []);
+  const mouse = useMemo4(() => new THREE2.Vector2(), []);
   const hoverablesRef = useRef2(hoverables);
   hoverablesRef.current = hoverables;
   const hoveredObjectRef = useRef2(null);
@@ -37510,9 +37530,9 @@ var HoverProvider = ({ children }) => {
         }
         return;
       }
-      const intersects = raycaster.intersectObjects(objectsToIntersect, true);
-      if (intersects.length > 0) {
-        const firstIntersect = intersects[0];
+      const intersects2 = raycaster.intersectObjects(objectsToIntersect, true);
+      if (intersects2.length > 0) {
+        const firstIntersect = intersects2[0];
         const newHovered = findHoverable(firstIntersect.object);
         if (newHovered) {
           const eventPayload = {
@@ -37551,7 +37571,7 @@ var HoverProvider = ({ children }) => {
       domElement.removeEventListener("mousemove", onMouseMove);
     };
   }, [renderer, onMouseMove]);
-  const contextValue = useMemo3(
+  const contextValue = useMemo4(
     () => ({
       addHoverable,
       removeHoverable
@@ -37610,7 +37630,7 @@ var FootprinterModel = ({
   isTranslucent = false
 }) => {
   const { rootObject } = useThree();
-  const group = useMemo4(() => {
+  const group = useMemo5(() => {
     if (!footprint) return null;
     const { geometries } = getJscadModelForFootprint(footprint, jscadModeling);
     const group2 = new THREE4.Group();
@@ -37720,7 +37740,7 @@ var getDefaultEnvironmentMap = (renderer) => {
 };
 
 // src/three-components/useCadModelTransformGraph.ts
-import { useEffect as useEffect6, useMemo as useMemo5 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo6 } from "react";
 import * as THREE7 from "three";
 
 // src/utils/cad-model-fit.ts
@@ -37788,10 +37808,10 @@ var useCadModelTransformGraph = ({
   scale: scale2
 }) => {
   const { rootObject } = useThree();
-  const boardTransformGroup = useMemo5(() => new THREE7.Group(), []);
-  const fitTransformGroup = useMemo5(() => new THREE7.Group(), []);
-  const modelTransformGroup = useMemo5(() => new THREE7.Group(), []);
-  const loaderTransformGroup = useMemo5(() => new THREE7.Group(), []);
+  const boardTransformGroup = useMemo6(() => new THREE7.Group(), []);
+  const fitTransformGroup = useMemo6(() => new THREE7.Group(), []);
+  const modelTransformGroup = useMemo6(() => new THREE7.Group(), []);
+  const loaderTransformGroup = useMemo6(() => new THREE7.Group(), []);
   useEffect6(() => {
     boardTransformGroup.add(fitTransformGroup);
     return () => {
@@ -38028,7 +38048,7 @@ function GltfModel({
 var import_jscad_planner = __toESM(require_dist(), 1);
 var import_modeling = __toESM(require_src(), 1);
 import * as THREE9 from "three";
-import { useMemo as useMemo6, useEffect as useEffect8 } from "react";
+import { useMemo as useMemo7, useEffect as useEffect8 } from "react";
 import { jsx as jsx7 } from "react/jsx-runtime";
 var JscadModel = ({
   jscadPlan,
@@ -38045,7 +38065,7 @@ var JscadModel = ({
   scale: scale2,
   isTranslucent = false
 }) => {
-  const { threeGeom, material } = useMemo6(() => {
+  const { threeGeom, material } = useMemo7(() => {
     const jscadObject = (0, import_jscad_planner.executeJscadOperations)(import_modeling.default, jscadPlan);
     if (!jscadObject || !jscadObject.polygons && !jscadObject.sides) {
       return { threeGeom: null, material: null };
@@ -38060,7 +38080,7 @@ var JscadModel = ({
     });
     return { threeGeom: threeGeom2, material: material2 };
   }, [jscadPlan, isTranslucent]);
-  const mesh = useMemo6(() => {
+  const mesh = useMemo7(() => {
     if (!threeGeom) return null;
     const createdMesh = new THREE9.Mesh(threeGeom, material);
     createdMesh.renderOrder = isTranslucent ? 2 : 1;
@@ -38203,7 +38223,7 @@ function useGlobalObjLoader(url) {
 }
 
 // src/three-components/MixedStlModel.tsx
-import { useMemo as useMemo7 } from "react";
+import { useMemo as useMemo8 } from "react";
 import * as THREE10 from "three";
 import { jsx as jsx8 } from "react/jsx-runtime";
 function MixedStlModel({
@@ -38222,7 +38242,7 @@ function MixedStlModel({
   isTranslucent = false
 }) {
   const obj = useGlobalObjLoader(url);
-  const model = useMemo7(() => {
+  const model = useMemo8(() => {
     if (obj && !(obj instanceof Error)) {
       obj.traverse((child) => {
         if (child instanceof THREE10.Mesh && child.material) {
@@ -38796,7 +38816,7 @@ function getAdjustedCadPosition(cadComponent, layer, pcbThickness) {
     return void 0;
   }
   let boardRelativeZ = cadComponent.position.z;
-  if (cadComponent.pcb_component_id && layer === "bottom" && cadComponent.position.z >= 0) {
+  if (!cadComponent.is_on_folded_board && cadComponent.pcb_component_id && layer === "bottom" && cadComponent.position.z >= 0) {
     boardRelativeZ = -(cadComponent.position.z + pcbThickness);
   }
   return [cadComponent.position.x, cadComponent.position.y, boardRelativeZ];
@@ -38954,12 +38974,12 @@ var AnyCadComponent = ({
     setIsHovered(false);
     setHoverPosition(null);
   }, []);
-  const componentName = useMemo8(() => {
+  const componentName = useMemo9(() => {
     return su2(circuitJson).source_component.getUsing({
       source_component_id: cad_component.source_component_id
     })?.name;
   }, [circuitJson, cad_component.source_component_id]);
-  const { pcbComponent, layer, isThroughHole } = useMemo8(
+  const { pcbComponent, layer, isThroughHole } = useMemo9(
     () => getCadPcbContext(cad_component, circuitJson),
     [cad_component, circuitJson]
   );
@@ -38982,7 +39002,7 @@ var AnyCadComponent = ({
     setFallbackModelIndex(0);
     setLastModelError(null);
   }, [cad_component.cad_component_id, url, gltfUrl, stepUrl]);
-  const isEnclosure = useMemo8(
+  const isEnclosure = useMemo9(
     () => isLegacyFdmEnclosure(cad_component, circuitJson),
     [cad_component, circuitJson]
   );
@@ -38991,7 +39011,7 @@ var AnyCadComponent = ({
   const renderedModelType = getRenderedCadModelType(sourceModelType);
   const gltfModelType = cad_component.model_glb_url ? "glb" : "gltf";
   const meshModelType = cad_component.model_wrl_url ? "wrl" : cad_component.model_stl_url ? "stl" : "obj";
-  const modelTransform = useMemo8(
+  const modelTransform = useMemo9(
     () => getCadModelTransform(cad_component, {
       layer,
       pcbThickness,
@@ -39001,7 +39021,7 @@ var AnyCadComponent = ({
   );
   const rotationOffset = tuple(...modelTransform.rotation);
   const adjustedPosition = modelTransform.position;
-  const fallbackModelComponents = useMemo8(() => {
+  const fallbackModelComponents = useMemo9(() => {
     const components = [];
     if (gltfUrl) {
       components.push(
@@ -39198,13 +39218,13 @@ var AnyCadComponent = ({
 };
 
 // src/CadViewerContainer.tsx
-import { forwardRef as forwardRef2, useEffect as useEffect20, useMemo as useMemo16, useState as useState11 } from "react";
+import { forwardRef as forwardRef2, useEffect as useEffect20, useMemo as useMemo17, useState as useState11 } from "react";
 import * as THREE23 from "three";
 
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.602",
+  version: "0.0.605",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/3d-viewer"
@@ -39242,7 +39262,7 @@ var package_default = {
   dependencies: {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
-    "circuit-json": "^0.0.497",
+    "circuit-json": "^0.0.500",
     "circuit-to-canvas": "^0.0.131",
     "react-hot-toast": "^2.6.0",
     three: "^0.165.0",
@@ -39257,6 +39277,7 @@ var package_default = {
     "@tscircuit/circuit-json-util": "*"
   },
   devDependencies: {
+    "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.5.tgz",
     "@biomejs/biome": "^2.1.4",
     "@chromatic-com/storybook": "^1.9.0",
     "@jscad/modeling": "^2.12.5",
@@ -39266,7 +39287,10 @@ var package_default = {
     "@storybook/blocks": "9.0.0-alpha.17",
     "@storybook/react-vite": "^9.1.5",
     "@tscircuit/alphabet": "^0.0.25",
+    "@tscircuit/circuit-json-util": "^0.0.116",
     "@tscircuit/copper-pour-solver": "^0.0.29",
+    "@tscircuit/core": "^0.0.1964",
+    "@tscircuit/props": "^0.0.666",
     "@tscircuit/solver-utils": "^0.0.4",
     "@types/jsdom": "^21.1.7",
     "@types/react": "19",
@@ -39275,7 +39299,6 @@ var package_default = {
     "@vitejs/plugin-react": "^4.3.4",
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
-    "circuit-json-to-gltf": "0.0.129",
     debug: "^4.4.0",
     "jscad-electronics": "^0.0.178",
     "jscad-planner": "^0.0.13",
@@ -39289,9 +39312,7 @@ var package_default = {
     typescript: "^5.7.3",
     vite: "^7.1.5",
     "vite-tsconfig-paths": "^4.3.2",
-    "@tscircuit/core": "^0.0.1955",
-    "@tscircuit/props": "^0.0.664",
-    "@tscircuit/circuit-json-util": "^0.0.116"
+    "circuit-json-to-gltf": "0.0.129"
   },
   patchedDependencies: {
     "@tscircuit/fanout-solver@0.0.78": "patches/@tscircuit%2Ffanout-solver@0.0.78.patch"
@@ -39299,7 +39320,7 @@ var package_default = {
 };
 
 // src/contexts/appearance-context.tsx
-import { createContext as createContext4, useContext as useContext4, useEffect as useEffect12, useMemo as useMemo9, useState as useState8 } from "react";
+import { createContext as createContext4, useContext as useContext4, useEffect as useEffect12, useMemo as useMemo10, useState as useState8 } from "react";
 import { jsx as jsx11 } from "react/jsx-runtime";
 var LIGHTING_STORAGE_KEY = "cadViewerLightingEnabled";
 var readStoredLightingEnabled = () => {
@@ -39323,7 +39344,7 @@ var AppearanceProvider = ({
       lightingEnabled ? "true" : "false"
     );
   }, [lightingEnabled]);
-  const value = useMemo9(
+  const value = useMemo10(
     () => ({
       darkBackgroundEnabled,
       setDarkBackgroundEnabled,
@@ -39349,7 +39370,7 @@ import {
   createContext as createContext5,
   useCallback as useCallback4,
   useContext as useContext5,
-  useMemo as useMemo10,
+  useMemo as useMemo11,
   useRef as useRef3,
   useState as useState9
 } from "react";
@@ -39404,7 +39425,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
   const [cameraRotation, setCameraRotation] = useState9(
     new THREE13.Euler(0, 0, 0)
   );
-  const baseDistance = useMemo10(() => {
+  const baseDistance = useMemo11(() => {
     const [x, y, z42] = initialCameraPosition ?? [5, -5, 5];
     const distance6 = Math.hypot(
       x - defaultTarget.x,
@@ -39512,7 +39533,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
     },
     []
   );
-  const cameraControllerContextValue = useMemo10(
+  const cameraControllerContextValue = useMemo11(
     () => ({
       controlsRef,
       mainCameraRef,
@@ -39747,7 +39768,7 @@ import {
   useCallback as useCallback7,
   forwardRef,
   useImperativeHandle,
-  useMemo as useMemo11
+  useMemo as useMemo12
 } from "react";
 import * as THREE16 from "three";
 
@@ -39795,7 +39816,7 @@ var Canvas = forwardRef(
       },
       []
     );
-    const scene = useMemo11(() => new THREE16.Scene(), []);
+    const scene = useMemo12(() => new THREE16.Scene(), []);
     if (sceneProps?.up) {
       scene.up.set(sceneProps.up.x, sceneProps.up.y, sceneProps.up.z);
     }
@@ -39851,16 +39872,23 @@ var Canvas = forwardRef(
       onCreatedRef.current?.({ camera, renderer });
       let animationFrameId;
       const clock = new THREE16.Clock();
+      let isVisible = true;
+      const visibilityObserver = new IntersectionObserver(([entry]) => {
+        isVisible = entry?.isIntersecting ?? false;
+        if (isVisible) handleResize();
+      });
+      visibilityObserver.observe(mountRef.current);
       const animate = () => {
+        animationFrameId = requestAnimationFrame(animate);
+        if (!isVisible) return;
         const time = clock.getElapsedTime();
         const delta = clock.getDelta();
         frameListeners.current.forEach((listener) => listener(time, delta));
         renderer.render(scene, camera);
-        animationFrameId = requestAnimationFrame(animate);
       };
       animate();
       const handleResize = () => {
-        if (mountRef.current) {
+        if (mountRef.current?.clientWidth && mountRef.current.clientHeight) {
           const newAspect = mountRef.current.clientWidth / mountRef.current.clientHeight;
           if (camera instanceof THREE16.PerspectiveCamera) {
             camera.aspect = newAspect;
@@ -39886,6 +39914,7 @@ var Canvas = forwardRef(
         };
         window.removeEventListener("resize", handleResize);
         cancelAnimationFrame(animationFrameId);
+        visibilityObserver.disconnect();
         if (mountRef.current && renderer.domElement) {
           mountRef.current.removeChild(renderer.domElement);
         }
@@ -39901,7 +39930,7 @@ var Canvas = forwardRef(
 );
 
 // src/react-three/Grid.tsx
-import { useEffect as useEffect15, useMemo as useMemo12 } from "react";
+import { useEffect as useEffect15, useMemo as useMemo13 } from "react";
 import * as THREE17 from "three";
 var vertexShader = `
   varying vec3 worldPosition;
@@ -39947,7 +39976,7 @@ var Grid = ({
 }) => {
   const { scene, camera } = useThree();
   const size4 = 1e3;
-  const gridMesh = useMemo12(() => {
+  const gridMesh = useMemo13(() => {
     const geometry = new THREE17.PlaneGeometry(size4, size4);
     geometry.rotateX(-Math.PI / 2);
     const material = new THREE17.ShaderMaterial({
@@ -39993,7 +40022,7 @@ var Grid = ({
 };
 
 // src/react-three/Lights.tsx
-import { useEffect as useEffect16, useMemo as useMemo13 } from "react";
+import { useEffect as useEffect16, useMemo as useMemo14 } from "react";
 import * as THREE18 from "three";
 var UNDERSIDE_LIGHT_FACTOR = 0.75;
 var Lights = ({
@@ -40003,7 +40032,7 @@ var Lights = ({
   shadowsEnabled = false
 }) => {
   const { scene } = useThree();
-  const lightRig = useMemo13(() => {
+  const lightRig = useMemo14(() => {
     const rig = new THREE18.Group();
     rig.name = "cad-viewer-light-rig";
     const centerX = boardCenter?.x ?? 0;
@@ -40118,7 +40147,7 @@ var Lights = ({
 };
 
 // src/react-three/OrbitControls.tsx
-import { useEffect as useEffect17, useMemo as useMemo14 } from "react";
+import { useEffect as useEffect17, useMemo as useMemo15 } from "react";
 import * as THREE19 from "three";
 import { OrbitControls as ThreeOrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
 var OrbitControls = ({
@@ -40134,7 +40163,7 @@ var OrbitControls = ({
   onControlsChange
 }) => {
   const { camera, renderer } = useThree();
-  const controls = useMemo14(() => {
+  const controls = useMemo15(() => {
     if (!camera || !renderer) return null;
     return new ThreeOrbitControls(camera, renderer.domElement);
   }, [camera, renderer]);
@@ -40383,7 +40412,14 @@ var OrientationCubeCanvas = () => {
     group.add(topText);
     group.add(bottomText);
     let animationFrameId = null;
+    let isVisible = true;
+    const visibilityObserver = new IntersectionObserver(([entry]) => {
+      isVisible = entry?.isIntersecting ?? false;
+    });
+    visibilityObserver.observe(canvas);
     const animate = () => {
+      animationFrameId = requestAnimationFrame(animate);
+      if (!isVisible) return;
       if (mainCameraRef.current) {
         const cameraPosition = computePointInFront(
           mainCameraRef.current.rotation ?? new THREE20.Euler(0, 0, 0),
@@ -40395,10 +40431,10 @@ var OrientationCubeCanvas = () => {
         }
       }
       renderer.render(scene, camera);
-      animationFrameId = requestAnimationFrame(animate);
     };
     animate();
     return () => {
+      visibilityObserver.disconnect();
       canvas.remove();
       if (animationFrameId !== null) {
         cancelAnimationFrame(animationFrameId);
@@ -40435,7 +40471,7 @@ var OrientationCubeCanvas = () => {
 };
 
 // src/three-components/reference-object.tsx
-import { useEffect as useEffect19, useMemo as useMemo15 } from "react";
+import { useEffect as useEffect19, useMemo as useMemo16 } from "react";
 
 // src/reference-objects/create-reference-object.ts
 import * as THREE21 from "three";
@@ -40821,7 +40857,7 @@ var ReferenceObject = ({
   boardCenter
 }) => {
   const { scene } = useThree();
-  const object = useMemo15(() => {
+  const object = useMemo16(() => {
     const nextObject = createReferenceObject(type);
     const position = getReferenceObjectPosition(
       type,
@@ -40887,17 +40923,17 @@ var CadViewerContainer = forwardRef2(
         onCameraControllerReady(controller);
       }
     }, [controller, onCameraControllerReady]);
-    const comparisonBounds = useMemo16(() => {
+    const comparisonBounds = useMemo17(() => {
       if (!referenceObject) return void 0;
       return getComparisonBounds(referenceObject, boardDimensions, boardCenter);
     }, [referenceObject, boardDimensions, boardCenter]);
-    const gridSectionSize = useMemo16(() => {
+    const gridSectionSize = useMemo17(() => {
       if (!boardDimensions) return 10;
       const width10 = boardDimensions.width ?? 0;
       const height10 = boardDimensions.height ?? 0;
       return Math.max(Math.max(width10, height10) * 1.5, 10);
     }, [boardDimensions]);
-    const orbitTarget = useMemo16(() => {
+    const orbitTarget = useMemo17(() => {
       if (comparisonBounds) {
         return [
           (comparisonBounds.minX + comparisonBounds.maxX) / 2,
@@ -41030,19 +41066,6 @@ var CadViewerContainer = forwardRef2(
   }
 );
 
-// src/hooks/use-convert-children-to-soup.ts
-import { Circuit } from "@tscircuit/core";
-import { useMemo as useMemo17 } from "react";
-var useConvertChildrenToCircuitJson = (children) => {
-  return useMemo17(() => {
-    if (!children) return [];
-    const circuit = new Circuit();
-    circuit.add(children);
-    circuit.render();
-    return circuit.getCircuitJson();
-  }, [children]);
-};
-
 // src/hooks/use-stls-from-geom.ts
 import { useState as useState12, useEffect as useEffect21 } from "react";
 import stlSerializer from "@jscad/stl-serializer";
@@ -41091,14 +41114,14 @@ var import_primitives = __toESM(require_primitives(), 1);
 var import_transforms = __toESM(require_transforms(), 1);
 var import_expansions = __toESM(require_expansions(), 1);
 var arePointsClockwise = (points) => {
-  let area = 0;
+  let area2 = 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];
+    area2 += points[i][0] * points[j][1];
+    area2 -= points[j][0] * points[i][1];
   }
-  const signedArea = area / 2;
-  return signedArea <= 0;
+  const signedArea2 = area2 / 2;
+  return signedArea2 <= 0;
 };
 var createBoardGeomWithOutline = (board, depth = 1.2, options = {}) => {
   const { xyOutset = 0 } = options;
@@ -41129,6 +41152,7 @@ var colors = {
   fr4SolderMaskGreen: [0.06, 0.31, 0.19],
   fr4TracesWithMaskGreen: [0.09, 0.38, 0.23],
   fr4TracesWithoutMaskTan: [0.6, 0.43, 0.28],
+  flexAmber: [0.8, 0.61, 0.2],
   fr1Tan: [0.8, 0.4, 0.2],
   fr1TracesWithMaskCopper: [0.9, 0.6, 0.2],
   fr1SolderMaskGreen: [0.02, 0.1, 0.04]
@@ -41139,11 +41163,13 @@ var TRACE_TEXTURE_RESOLUTION = 150;
 var FAUX_BOARD_OPACITY = 0.6;
 var boardMaterialColors = {
   fr1: colors.fr1Tan,
-  fr4: colors.fr4Tan
+  fr4: colors.fr4Tan,
+  flex: colors.flexAmber
 };
 var soldermaskColors = {
   fr1: colors.fr1SolderMaskGreen,
-  fr4: colors.fr4SolderMaskGreen
+  fr4: colors.fr4SolderMaskGreen,
+  flex: colors.flexAmber
 };
 
 // src/utils/soldermask-color.ts
@@ -44646,6 +44672,7 @@ var createDataTexture = (canvas) => {
 var createBoardReliefTextures = (texture, maskedCopperMask) => {
   const sourceCanvas = texture.image;
   if (!sourceCanvas?.width || !sourceCanvas.height) return null;
+  const { width: canvasWidth, height: canvasHeight } = sourceCanvas;
   const sourceCtx = sourceCanvas.getContext("2d");
   if (!sourceCtx) return null;
   const maskCanvas = maskedCopperMask?.image;
@@ -44653,48 +44680,37 @@ var createBoardReliefTextures = (texture, maskedCopperMask) => {
   const maskWidth = maskCanvas?.width ?? 0;
   const maskHeight = maskCanvas?.height ?? 0;
   const maskImageData = maskCtx && maskWidth && maskHeight ? maskCtx.getImageData(0, 0, maskWidth, maskHeight) : null;
-  const imageData = sourceCtx.getImageData(
-    0,
-    0,
-    sourceCanvas.width,
-    sourceCanvas.height
-  );
+  const imageData = sourceCtx.getImageData(0, 0, canvasWidth, canvasHeight);
   const data = imageData.data;
-  const heights = new Float32Array(sourceCanvas.width * sourceCanvas.height);
+  const heights = new Float32Array(canvasWidth * canvasHeight);
   const roughnessCanvas = document.createElement("canvas");
   const metalnessCanvas = document.createElement("canvas");
-  roughnessCanvas.width = metalnessCanvas.width = sourceCanvas.width;
-  roughnessCanvas.height = metalnessCanvas.height = sourceCanvas.height;
+  roughnessCanvas.width = metalnessCanvas.width = canvasWidth;
+  roughnessCanvas.height = metalnessCanvas.height = canvasHeight;
   const roughnessCtx = roughnessCanvas.getContext("2d");
   const metalnessCtx = metalnessCanvas.getContext("2d");
   if (!roughnessCtx || !metalnessCtx) return null;
   const roughnessImageData = roughnessCtx.createImageData(
-    sourceCanvas.width,
-    sourceCanvas.height
+    canvasWidth,
+    canvasHeight
   );
   const metalnessImageData = metalnessCtx.createImageData(
-    sourceCanvas.width,
-    sourceCanvas.height
+    canvasWidth,
+    canvasHeight
   );
   const roughnessData = roughnessImageData.data;
   const metalnessData = metalnessImageData.data;
   for (let i = 0; i < data.length; i += 4) {
     const pixelIndex = i / 4;
-    const x = pixelIndex % sourceCanvas.width;
-    const y = Math.floor(pixelIndex / sourceCanvas.width);
+    const x = pixelIndex % canvasWidth;
+    const y = Math.floor(pixelIndex / canvasWidth);
     const alpha = data[i + 3] ?? 0;
     if (alpha < 16) {
       heights[pixelIndex] = invertSurfaceHeight(PLAIN_SOLDERMASK_HEIGHT);
       continue;
     }
-    const maskX = maskImageData ? Math.min(
-      maskWidth - 1,
-      Math.floor(x / sourceCanvas.width * maskWidth)
-    ) : 0;
-    const maskY = maskImageData ? Math.min(
-      maskHeight - 1,
-      Math.floor(y / sourceCanvas.height * maskHeight)
-    ) : 0;
+    const maskX = maskImageData ? Math.min(maskWidth - 1, Math.floor(x / canvasWidth * maskWidth)) : 0;
+    const maskY = maskImageData ? Math.min(maskHeight - 1, Math.floor(y / canvasHeight * maskHeight)) : 0;
     const maskAlpha = maskImageData ? maskImageData.data[(maskY * maskWidth + maskX) * 4 + 3] ?? 0 : 0;
     const profile = getBoardSurfaceProfile(
       data[i] ?? 0,
@@ -44702,13 +44718,13 @@ var createBoardReliefTextures = (texture, maskedCopperMask) => {
       data[i + 2] ?? 0,
       maskAlpha >= 16
     );
-    const salt = sourceCanvas.width + sourceCanvas.height;
+    const salt = canvasWidth + canvasHeight;
     const fineGrain = profile.isExposedCopper ? createCopperDetail(x, y, salt) : profile.isMaskedCopper ? createMaskedTraceDetail(x, y, salt) : 0;
-    const height10 = clamp01(
+    const surfaceHeight = clamp01(
       invertSurfaceHeight(profile.height) + fineGrain * profile.microSurfaceWeight
     );
-    heights[pixelIndex] = height10;
-    const heightChannel = height10 * 255;
+    heights[pixelIndex] = surfaceHeight;
+    const heightChannel = surfaceHeight * 255;
     data[i] = data[i + 1] = data[i + 2] = heightChannel;
     data[i + 3] = 255;
     const roughness = profile.isExposedCopper ? clamp01(
@@ -44726,31 +44742,28 @@ var createBoardReliefTextures = (texture, maskedCopperMask) => {
   roughnessCtx.putImageData(roughnessImageData, 0, 0);
   metalnessCtx.putImageData(metalnessImageData, 0, 0);
   const bumpCanvas = document.createElement("canvas");
-  bumpCanvas.width = sourceCanvas.width;
-  bumpCanvas.height = sourceCanvas.height;
+  bumpCanvas.width = canvasWidth;
+  bumpCanvas.height = canvasHeight;
   const bumpCtx = bumpCanvas.getContext("2d");
   if (!bumpCtx) return null;
   bumpCtx.putImageData(imageData, 0, 0);
   const normalCanvas = document.createElement("canvas");
-  normalCanvas.width = sourceCanvas.width;
-  normalCanvas.height = sourceCanvas.height;
+  normalCanvas.width = canvasWidth;
+  normalCanvas.height = canvasHeight;
   const normalCtx = normalCanvas.getContext("2d");
   if (!normalCtx) return null;
-  const normalImageData = normalCtx.createImageData(
-    sourceCanvas.width,
-    sourceCanvas.height
-  );
+  const normalImageData = normalCtx.createImageData(canvasWidth, canvasHeight);
   const normalData = normalImageData.data;
-  const getHeight4 = (x, y) => heights[Math.max(0, Math.min(sourceCanvas.height - 1, y)) * sourceCanvas.width + Math.max(0, Math.min(sourceCanvas.width - 1, x))] ?? 0;
-  for (let y = 0; y < sourceCanvas.height; y++) {
-    for (let x = 0; x < sourceCanvas.width; x++) {
+  const getHeight4 = (x, y) => heights[Math.max(0, Math.min(canvasHeight - 1, y)) * canvasWidth + Math.max(0, Math.min(canvasWidth - 1, x))] ?? 0;
+  for (let y = 0; y < canvasHeight; y++) {
+    for (let x = 0; x < canvasWidth; x++) {
       const dx = (getHeight4(x + 1, y) - getHeight4(x - 1, y)) * 4;
       const dy = (getHeight4(x, y + 1) - getHeight4(x, y - 1)) * 4;
-      const normal = new THREE40.Vector3(-dx, -dy, 1).normalize();
-      const i = (y * sourceCanvas.width + x) * 4;
-      normalData[i] = (normal.x * 0.5 + 0.5) * 255;
-      normalData[i + 1] = (normal.y * 0.5 + 0.5) * 255;
-      normalData[i + 2] = (normal.z * 0.5 + 0.5) * 255;
+      const inverseLength = 1 / Math.sqrt(dx * dx + dy * dy + 1);
+      const i = (y * canvasWidth + x) * 4;
+      normalData[i] = (-dx * inverseLength * 0.5 + 0.5) * 255;
+      normalData[i + 1] = (-dy * inverseLength * 0.5 + 0.5) * 255;
+      normalData[i + 2] = (inverseLength * 0.5 + 0.5) * 255;
       normalData[i + 3] = 255;
     }
   }
@@ -45400,28 +45413,1149 @@ var CadViewerJscad = forwardRef3(
   }
 );
 
+// node_modules/earcut/src/earcut.js
+var steiners = /* @__PURE__ */ new Set();
+var filteredOut = false;
+function earcut(data, holeIndices, dim = 2) {
+  const hasHoles = holeIndices && holeIndices.length;
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  if (steiners.size) steiners.clear();
+  let outerNode = linkedList(data, 0, outerLen, dim, true);
+  const triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+  let minX = 0, minY = 0, invSize = 0;
+  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = data[0];
+    minY = data[1];
+    let maxX = minX;
+    let maxY = minY;
+    for (let i = dim; i < outerLen; i += dim) {
+      const x = data[i];
+      const y = data[i + 1];
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, minX, minY, invSize);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  let last = null;
+  if (clockwise === signedArea(data, start, end, dim) > 0) {
+    for (let i = start; i < end; i += dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  } else {
+    for (let i = end - dim; i >= start; i -= dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end = start) {
+  const full = end === start;
+  let p = start, again;
+  do {
+    again = false;
+    if (p !== p.next && (steiners.size === 0 || !steiners.has(p)) && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      if (full || p === end) end = p.prev;
+      filteredOut = true;
+      removeNode(p);
+      p = p.prev;
+      again = true;
+    } else if (full || p !== end) {
+      p = p.next;
+      again = !full;
+    }
+  } while (again || p !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, minX, minY, invSize) {
+  if (invSize) indexCurve(ear, minX, minY, invSize);
+  let stop = ear, cured = false;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (area(prev, ear, next) < 0 && (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear))) {
+      triangles.push(prev.i, ear.i, next.i);
+      removeNode(ear);
+      ear = next;
+      stop = next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      filteredOut = false;
+      ear = filterPoints(ear);
+      if (filteredOut) {
+        stop = ear;
+        continue;
+      }
+      if (!cured) {
+        ear = cureLocalIntersections(ear, triangles);
+        stop = ear;
+        cured = true;
+        continue;
+      }
+      splitEarcut(ear, triangles, minX, minY, invSize);
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  const a = ear.prev, b = ear, c = ear.next, ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y, x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  let p = c.next;
+  while (p !== a) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && !(ax === p.x && ay === p.y) && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    p = p.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  const a = ear.prev, b = ear, c = ear.next, ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y, x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy), minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  let p = ear.prevZ;
+  while (p && p.z >= minZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== c && !(ax === p.x && ay === p.y) && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    p = p.prevZ;
+  }
+  let n = ear.nextZ;
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== c && !(ax === n.x && ay === n.y) && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles) {
+  let p = start;
+  let cured = false;
+  do {
+    const a = p.prev, b = p.next.next;
+    if (intersects(a, p, p.next, b, false) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i, p.i, b.i);
+      removeNode(p);
+      removeNode(p.next);
+      p = start = b;
+      cured = true;
+    }
+    p = p.next;
+  } while (p !== start);
+  return cured ? filterPoints(p) : p;
+}
+function splitEarcut(start, triangles, minX, minY, invSize) {
+  let a = start;
+  do {
+    let b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        let c = splitPolygon(a, b);
+        a = filterPoints(a, a.next);
+        c = filterPoints(c, c.next);
+        earcutLinked(a, triangles, minX, minY, invSize);
+        earcutLinked(c, triangles, minX, minY, invSize);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+var indexActive = false;
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  const queue = [];
+  for (let i = 0, len = holeIndices.length; i < len; i++) {
+    const start = holeIndices[i] * dim;
+    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    const list = (
+      /** @type {Node} */
+      linkedList(data, start, end, dim, false)
+    );
+    if (list === list.next) steiners.add(list);
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareXYSlope);
+  buildBlockIndex(data.length / dim, holeIndices.length);
+  indexSegment(outerNode, outerNode);
+  indexActive = true;
+  for (let i = 0; i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  indexActive = false;
+  return filterPoints(outerNode);
+}
+function compareXYSlope(a, b) {
+  return a.x - b.x || a.y - b.y || (a.next.y - a.y) / (a.next.x - a.x) - (b.next.y - b.y) / (b.next.x - b.x);
+}
+function eliminateHole(hole, outerNode) {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  const bridgeReverse = splitPolygon(bridge, hole);
+  const bridge2 = bridgeReverse.next;
+  indexSegment(bridge, bridge2.next);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+var K = 16;
+var blockBBox = new Float64Array(0);
+var numBlocks = 0;
+var blockHead = [];
+var blockStop = [];
+function buildBlockIndex(maxNodes, numHoles) {
+  const maxBlocks = Math.ceil((maxNodes + 2 * numHoles) / K) + numHoles + 2;
+  if (blockBBox.length < maxBlocks * 4) blockBBox = new Float64Array(maxBlocks * 4);
+  numBlocks = 0;
+}
+function indexSegment(head, stop) {
+  let p = head;
+  do {
+    const b = numBlocks++;
+    blockHead[b] = p;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    let k = 0;
+    do {
+      const c = p.next;
+      p.z = b;
+      if (p.x < minX) minX = p.x;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.y > maxY) maxY = p.y;
+      if (c.x < minX) minX = c.x;
+      if (c.x > maxX) maxX = c.x;
+      if (c.y < minY) minY = c.y;
+      if (c.y > maxY) maxY = c.y;
+      p = c;
+    } while (++k < K && p !== stop);
+    blockStop[b] = p;
+    const g = b * 4;
+    blockBBox[g] = minX;
+    blockBBox[g + 1] = minY;
+    blockBBox[g + 2] = maxX;
+    blockBBox[g + 3] = maxY;
+  } while (p !== stop);
+}
+function growBlock(head, tail) {
+  const g = head.z * 4;
+  if (tail.x < blockBBox[g]) blockBBox[g] = tail.x;
+  if (tail.y < blockBBox[g + 1]) blockBBox[g + 1] = tail.y;
+  if (tail.x > blockBBox[g + 2]) blockBBox[g + 2] = tail.x;
+  if (tail.y > blockBBox[g + 3]) blockBBox[g + 3] = tail.y;
+}
+function liveBlockStop(b) {
+  let stop = blockStop[b];
+  while (stop.prev.next !== stop) stop = stop.next;
+  blockStop[b] = stop;
+  return stop;
+}
+function liveBlockHead(b) {
+  let head = blockHead[b];
+  while (head.prev.next !== head) head = head.next;
+  blockHead[b] = head;
+  return head;
+}
+function findHoleBridge(hole, outerNode) {
+  let p = outerNode;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m;
+  if (equals(hole, p)) return p;
+  for (let b = 0, g = 0; b < numBlocks; b++, g += 4) {
+    if (hy < blockBBox[g + 1] || hy > blockBBox[g + 3] || blockBBox[g] > hx || blockBBox[g + 2] <= qx) continue;
+    const stop = liveBlockStop(b);
+    p = liveBlockHead(b);
+    do {
+      if (p.prev.next === p) {
+        if (equals(hole, p.next)) return p.next;
+        else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+          const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+          if (x <= hx && x > qx) {
+            qx = x;
+            m = p.x < p.next.x ? p : p.next;
+            if (x === hx) return m;
+          }
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+  }
+  if (!m) return null;
+  const mx = m.x;
+  const my = m.y;
+  const tminY = Math.min(hy, my);
+  const tmaxY = Math.max(hy, my);
+  let tanMin = Infinity;
+  for (let b = 0, g = 0; b < numBlocks; b++, g += 4) {
+    if (blockBBox[g + 2] < mx || blockBBox[g] > hx || blockBBox[g + 3] < tminY || blockBBox[g + 1] > tmaxY) continue;
+    const stop = liveBlockStop(b);
+    p = liveBlockHead(b);
+    do {
+      if (p.prev.next === p && hx >= p.x && p.x >= mx && hx !== p.x && // skip dead nodes
+      pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        const tan = Math.abs(hy - p.y) / (hx - p.x);
+        if ((locallyInside(p, hole) || p.y === hy && p.next.y === hy && p.next.x > hx) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+  }
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+var sortArr = [];
+var sortBuf = [];
+var zArr = new Uint32Array(0);
+var zBuf = new Uint32Array(0);
+var counts = new Uint32Array(256);
+function indexCurve(start, minX, minY, invSize) {
+  let p = start;
+  let n = 0;
+  do {
+    p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    sortArr[n++] = p;
+    p = p.next;
+  } while (p !== start);
+  sortNodes(n);
+  let prev = null;
+  for (let i = 0; i < n; i++) {
+    const node = sortArr[i];
+    node.prevZ = prev;
+    if (prev) prev.nextZ = node;
+    prev = node;
+  }
+  prev.nextZ = null;
+}
+function sortNodes(n) {
+  if (n <= 32) {
+    for (let i = 1; i < n; i++) {
+      const node = sortArr[i], z42 = node.z;
+      let j = i - 1;
+      while (j >= 0 && sortArr[j].z > z42) {
+        sortArr[j + 1] = sortArr[j];
+        j--;
+      }
+      sortArr[j + 1] = node;
+    }
+    return;
+  }
+  if (zArr.length < n) {
+    zArr = new Uint32Array(n);
+    zBuf = new Uint32Array(n);
+    sortBuf = new Array(n);
+  }
+  for (let i = 0; i < n; i++) zArr[i] = sortArr[i].z;
+  radixPass(n, sortArr, zArr, sortBuf, zBuf, 0);
+  radixPass(n, sortBuf, zBuf, sortArr, zArr, 8);
+  radixPass(n, sortArr, zArr, sortBuf, zBuf, 16);
+  radixPass(n, sortBuf, zBuf, sortArr, zArr, 24);
+}
+function radixPass(n, src, srcZ, dst, dstZ, shift4) {
+  counts.fill(0);
+  for (let i = 0; i < n; i++) counts[srcZ[i] >>> shift4 & 255]++;
+  let sum = 0;
+  for (let b = 0; b < 256; b++) {
+    const c = counts[b];
+    counts[b] = sum;
+    sum += c;
+  }
+  for (let i = 0; i < n; i++) {
+    const z42 = srcZ[i];
+    const pos = counts[z42 >>> shift4 & 255]++;
+    dst[pos] = src[i];
+    dstZ[pos] = z42;
+  }
+}
+function zOrder(x, y, minX, minY, invSize) {
+  x = (x - minX) * invSize | 0;
+  y = (y - minY) * invSize | 0;
+  x = (x | x << 8) & 16711935;
+  x = (x | x << 4) & 252645135;
+  x = (x | x << 2) & 858993459;
+  x = (x | x << 1) & 1431655765;
+  y = (y | y << 8) & 16711935;
+  y = (y | y << 4) & 252645135;
+  y = (y | y << 2) & 858993459;
+  y = (y | y << 1) & 1431655765;
+  return x | y << 1;
+}
+function getLeftmost(start) {
+  let p = start, leftmost = start;
+  do {
+    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
+    p = p.next;
+  } while (p !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function isValidDiagonal(a, b) {
+  const zeroLength = equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0;
+  return a.next.i !== b.i && (zeroLength || locallyInside(a, b) && locallyInside(b, a) && // // locally visible
+  (area(a.prev, a, b.prev) !== 0 || area(a, b.prev, b) !== 0)) && // no opposite-facing sectors
+  !intersectsPolygon(a, b) && (zeroLength || middleInside(a, b));
+}
+function area(p, q, r) {
+  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2, includeBoundary = true) {
+  const o1 = area(p1, q1, p2);
+  const o2 = area(p1, q1, q2);
+  const o3 = area(p2, q2, p1);
+  const o4 = area(p2, q2, q1);
+  if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0)) return true;
+  if (!includeBoundary) return false;
+  if (o1 === 0 && onSegment2(p1, p2, q1)) return true;
+  if (o2 === 0 && onSegment2(p1, q2, q1)) return true;
+  if (o3 === 0 && onSegment2(p2, p1, q2)) return true;
+  if (o4 === 0 && onSegment2(p2, q1, q2)) return true;
+  return false;
+}
+function onSegment2(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function intersectsPolygon(a, b) {
+  const minX = Math.min(a.x, b.x);
+  const maxX = Math.max(a.x, b.x);
+  const minY = Math.min(a.y, b.y);
+  const maxY = Math.max(a.y, b.y);
+  let p = a;
+  do {
+    const n = p.next;
+    if (p.x > maxX && n.x > maxX || p.x < minX && n.x < minX || p.y > maxY && n.y > maxY || p.y < minY && n.y < minY) {
+      p = n;
+      continue;
+    }
+    if (p.i !== a.i && n.i !== a.i && p.i !== b.i && n.i !== b.i && intersects(p, n, a, b)) return true;
+    p = n;
+  } while (p !== a);
+  return false;
+}
+function locallyInside(a, b) {
+  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+function middleInside(a, b) {
+  let p = a;
+  let inside = false;
+  const px = (a.x + b.x) / 2;
+  const py = (a.y + b.y) / 2;
+  do {
+    const n = p.next;
+    if (p.y > py !== n.y > py && px < (n.x - p.x) * (py - p.y) / (n.y - p.y) + p.x)
+      inside = !inside;
+    p = n;
+  } while (p !== a);
+  return inside;
+}
+function splitPolygon(a, b) {
+  const a2 = createNode(a.i, a.x, a.y), b2 = createNode(b.i, b.x, b.y), an = a.next, bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function insertNode(i, x, y, last) {
+  const p = createNode(i, x, y);
+  if (!last) {
+    p.prev = p;
+    p.next = p;
+  } else {
+    p.next = last.next;
+    p.prev = last;
+    last.next.prev = p;
+    last.next = p;
+  }
+  return p;
+}
+function removeNode(p) {
+  p.next.prev = p.prev;
+  p.prev.next = p.next;
+  if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+  if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  if (indexActive) growBlock(p.prev, p.next);
+}
+function createNode(i, x, y) {
+  return (
+    /** @type {Node} */
+    /** @type {unknown} */
+    {
+      i,
+      // vertex index in coordinates array
+      x,
+      y,
+      // vertex coordinates
+      prev: null,
+      // previous and next vertex nodes in a polygon ring
+      next: null,
+      z: 0,
+      // z-order curve value; doubles as owning block in the hole-bridge index during eliminateHoles
+      prevZ: null,
+      // previous and next nodes in z-order
+      nextZ: null
+    }
+  );
+}
+function signedArea(data, start, end, dim) {
+  let sum = 0;
+  for (let i = start, j = end - dim; i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum;
+}
+
+// node_modules/@tscircuit/flex-utils/dist/index.js
+var EPS = 1e-7;
+function createPcbFold(records, thickness) {
+  if (!Number.isFinite(thickness) || thickness < 0)
+    throw new Error("Board thickness must be finite and nonnegative");
+  const bends = records.map((b) => {
+    const { start, end, bend_angle: degrees, bend_radius: radius } = b;
+    const values = [start?.x, start?.y, end?.x, end?.y, degrees, radius];
+    if (values.some((v) => !Number.isFinite(v)) || radius <= thickness / 2 || !["left", "right"].includes(b.bend_side)) {
+      throw new Error(
+        `Invalid PCB bend ${b.pcb_bend_id}: finite geometry and radius greater than half the board thickness are required`
+      );
+    }
+    const length83 = Math.hypot(end.x - start.x, end.y - start.y);
+    if (length83 < EPS || Math.abs(degrees) > 180)
+      throw new Error(
+        `Unsupported PCB bend ${b.pcb_bend_id}: distinct endpoints and angles within \xB1180 degrees are required`
+      );
+    const sign = b.bend_side === "right" ? 1 : -1;
+    const nx = sign * (end.y - start.y) / length83;
+    const ny = -sign * (end.x - start.x) / length83;
+    const angle = degrees * Math.PI / 180;
+    const width10 = radius * Math.abs(angle);
+    const center = start.x * nx + start.y * ny;
+    return {
+      id: b.pcb_bend_id,
+      nx,
+      ny,
+      start: center - width10 / 2,
+      end: center + width10 / 2,
+      angle,
+      radius,
+      axisMin: Math.min(
+        -ny * start.x + nx * start.y,
+        -ny * end.x + nx * end.y
+      ),
+      axisMax: Math.max(
+        -ny * start.x + nx * start.y,
+        -ny * end.x + nx * end.y
+      )
+    };
+  }).filter((b) => Math.abs(b.angle) > EPS);
+  const first = bends[0];
+  if (first && bends.some(
+    (b) => Math.abs(b.nx - first.nx) > EPS || Math.abs(b.ny - first.ny) > EPS
+  )) {
+    throw new Error(
+      "Folded PCB rendering currently requires parallel bends with the same moving direction"
+    );
+  }
+  bends.sort((a, b) => a.start - b.start);
+  for (let i = 1; i < bends.length; i++) {
+    if (bends[i].start < bends[i - 1].end - EPS)
+      throw new Error("Overlapping PCB bend zones are not supported");
+  }
+  const distalFirst = [...bends].reverse();
+  const transform = ({
+    p,
+    anchor,
+    direction
+  }) => {
+    let result = { ...p };
+    for (const b of distalFirst) {
+      const width10 = b.end - b.start;
+      const s = anchor.x * b.nx + anchor.y * b.ny - b.start;
+      const q = Math.max(0, Math.min(width10, s));
+      const theta = b.angle * q / width10;
+      const cos = Math.cos(theta), sin = Math.sin(theta);
+      const projected = result.x * b.nx + result.y * b.ny - (direction ? 0 : b.start);
+      const tangentX = result.x - (projected + (direction ? 0 : b.start)) * b.nx;
+      const tangentY = result.y - (projected + (direction ? 0 : b.start)) * b.ny;
+      const signedRadius = Math.sign(b.angle) * b.radius;
+      const tx = direction ? 0 : signedRadius * sin - q * cos;
+      const tz = direction ? 0 : signedRadius * (1 - cos) - q * sin;
+      const folded = projected * cos - result.z * sin + tx;
+      result = {
+        x: tangentX + (folded + (direction ? 0 : b.start)) * b.nx,
+        y: tangentY + (folded + (direction ? 0 : b.start)) * b.ny,
+        z: projected * sin + result.z * cos + tz
+      };
+    }
+    return result;
+  };
+  const inverse = ({
+    p,
+    anchor,
+    direction
+  }) => {
+    const origin = direction ? { x: 0, y: 0, z: 0 } : transform({
+      p: { x: 0, y: 0, z: 0 },
+      anchor,
+      direction: false
+    });
+    const d = { x: p.x - origin.x, y: p.y - origin.y, z: p.z - origin.z };
+    const axes2 = [
+      { x: 1, y: 0, z: 0 },
+      { x: 0, y: 1, z: 0 },
+      { x: 0, y: 0, z: 1 }
+    ].map((v) => transform({ p: v, anchor, direction: true }));
+    const dot = (v) => v.x * d.x + v.y * d.y + v.z * d.z;
+    return { x: dot(axes2[0]), y: dot(axes2[1]), z: dot(axes2[2]) };
+  };
+  return {
+    bends,
+    inversePoint: (p, anchor) => inverse({ p, anchor, direction: false }),
+    inverseDirection: (p, anchor) => inverse({ p, anchor, direction: true }),
+    point: (p, anchor = p) => transform({ p, anchor, direction: false }),
+    direction: (p, anchor) => transform({ p, anchor, direction: true }),
+    assertRigid(points, label) {
+      for (const b of bends) {
+        const ds = points.map((p) => p.x * b.nx + p.y * b.ny);
+        if (Math.max(...ds) > b.start + EPS && Math.min(...ds) < b.end - EPS)
+          throw new Error(`${label} intersects PCB bend zone ${b.id}`);
+      }
+    }
+  };
+}
+var EPS2 = 1e-7;
+function boundsOfTriangles(triangles) {
+  const points = triangles.flatMap((t) => t.vertices);
+  if (!points.length)
+    return { min: { x: 0, y: 0, z: 0 }, max: { x: 0, y: 0, z: 0 } };
+  const min2 = { x: Infinity, y: Infinity, z: Infinity };
+  const max2 = { x: -Infinity, y: -Infinity, z: -Infinity };
+  for (const p of points)
+    for (const key of ["x", "y", "z"]) {
+      min2[key] = Math.min(min2[key], p[key]);
+      max2[key] = Math.max(max2[key], p[key]);
+    }
+  return { min: min2, max: max2 };
+}
+function foldSurfaceMesh(mesh, fold) {
+  const planes = fold.bends.flatMap((b) => {
+    const steps = Math.ceil(Math.abs(b.angle) / (Math.PI / 36));
+    return Array.from({ length: steps + 1 }, (_, i) => ({
+      b,
+      d: b.start + (b.end - b.start) * i / steps
+    }));
+  });
+  const { min: min2, max: max2 } = mesh.boundingBox;
+  const split = ({
+    polygon: polygon2,
+    nx,
+    ny,
+    d
+  }) => {
+    const distances = polygon2.map(({ p }) => nx * p.x + ny * p.y - d);
+    if (Math.min(...distances) >= -EPS2 || Math.max(...distances) <= EPS2)
+      return [polygon2];
+    const halves = [[], []];
+    for (let side = 0; side < 2; side++) {
+      const sign = side === 0 ? 1 : -1;
+      for (let i = 0; i < polygon2.length; i++) {
+        const a = polygon2[i], next = (i + 1) % polygon2.length, b = polygon2[next];
+        const da = distances[i] * sign, db = distances[next] * sign;
+        if (da >= -EPS2) halves[side].push(a);
+        if (da > EPS2 && db < -EPS2 || da < -EPS2 && db > EPS2) {
+          const t = da / (da - db);
+          halves[side].push({
+            p: {
+              x: a.p.x + (b.p.x - a.p.x) * t,
+              y: a.p.y + (b.p.y - a.p.y) * t,
+              z: a.p.z + (b.p.z - a.p.z) * t
+            },
+            uv: {
+              u: a.uv.u + (b.uv.u - a.uv.u) * t,
+              v: a.uv.v + (b.uv.v - a.uv.v) * t
+            }
+          });
+        }
+      }
+    }
+    return halves.filter((p) => p.length >= 3);
+  };
+  const triangles = [];
+  for (const triangle of mesh.triangles) {
+    const face = triangle.pcbFace ?? (triangle.normal.z > 0.8 ? "top" : triangle.normal.z < -0.8 ? "bottom" : "side");
+    let polygons = [
+      triangle.vertices.map((p, index2) => ({
+        p,
+        uv: triangle.uvs?.[index2] ?? {
+          u: (p.x - min2.x) / (max2.x - min2.x),
+          v: 1 - (p.y - min2.y) / (max2.y - min2.y)
+        }
+      }))
+    ];
+    for (const { b, d } of planes)
+      polygons = polygons.flatMap(
+        (p) => split({ polygon: p, nx: b.nx, ny: b.ny, d })
+      );
+    for (const polygon2 of polygons) {
+      for (const b of fold.bends) {
+        const mid = polygon2.reduce((sum, { p }) => sum + p.x * b.nx + p.y * b.ny, 0) / polygon2.length;
+        if (mid > b.start + EPS2 && mid < b.end - EPS2 && polygon2.some(({ p }) => {
+          const along = -b.ny * p.x + b.nx * p.y;
+          return along < b.axisMin - EPS2 || along > b.axisMax + EPS2;
+        }))
+          throw new Error(
+            `PCB bend ${b.id} must span the full board cross-section through its bend zone`
+          );
+      }
+      for (let i = 1; i + 1 < polygon2.length; i++) {
+        const verts = [polygon2[0], polygon2[i], polygon2[i + 1]];
+        const vertices = verts.map(
+          ({ p }) => fold.point(p)
+        );
+        const [a, b, c] = vertices;
+        const u = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z }, v = { x: c.x - a.x, y: c.y - a.y, z: c.z - a.z };
+        const n = {
+          x: u.y * v.z - u.z * v.y,
+          y: u.z * v.x - u.x * v.z,
+          z: u.x * v.y - u.y * v.x
+        };
+        const l = Math.hypot(n.x, n.y, n.z);
+        if (l < 1e-12) continue;
+        triangles.push({
+          ...triangle,
+          vertices,
+          normal: { x: n.x / l, y: n.y / l, z: n.z / l },
+          pcbFace: face,
+          uvs: verts.map(({ uv }) => uv)
+        });
+      }
+    }
+  }
+  return { ...mesh, triangles, boundingBox: boundsOfTriangles(triangles) };
+}
+var axes = [
+  { x: 1, y: 0, z: 0 },
+  { x: 0, y: 1, z: 0 },
+  { x: 0, y: 0, z: 1 }
+];
+function rotateVector(v, degrees) {
+  const [x, y, z42] = [degrees.x, degrees.y, degrees.z].map(
+    (a2) => a2 * Math.PI / 180
+  );
+  const a = {
+    x: Math.cos(z42) * v.x - Math.sin(z42) * v.y,
+    y: Math.sin(z42) * v.x + Math.cos(z42) * v.y,
+    z: v.z
+  };
+  const b = {
+    x: Math.cos(y) * a.x + Math.sin(y) * a.z,
+    y: a.y,
+    z: -Math.sin(y) * a.x + Math.cos(y) * a.z
+  };
+  return {
+    x: b.x,
+    y: Math.cos(x) * b.y - Math.sin(x) * b.z,
+    z: Math.sin(x) * b.y + Math.cos(x) * b.z
+  };
+}
+function rotationFromAxes([a, b, c]) {
+  const y = Math.asin(Math.max(-1, Math.min(1, c.x)));
+  const regular = Math.abs(c.x) < 1 - 1e-12;
+  return {
+    x: (regular ? Math.atan2(-c.y, c.z) : Math.atan2(b.z, b.y)) * 180 / Math.PI,
+    y: y * 180 / Math.PI,
+    z: (regular ? Math.atan2(-b.x, a.x) : 0) * 180 / Math.PI
+  };
+}
+function transformCadComponent({ cadComponent, foldPcbs }, context) {
+  return transformCadComponentPlacement(
+    { cadComponentPlacement: cadComponent, foldPcbs },
+    context
+  );
+}
+function transformCadComponentPlacement({
+  cadComponentPlacement,
+  foldPcbs
+}, context) {
+  if (cadComponentPlacement.is_on_folded_board === true === foldPcbs)
+    return cadComponentPlacement;
+  const { fold, boardCenter, flatMount } = context;
+  const anchor = {
+    x: flatMount.x - boardCenter.x,
+    y: flatMount.y - boardCenter.y,
+    z: 0
+  };
+  fold.assertRigid([anchor], "CAD mount");
+  const point = {
+    x: cadComponentPlacement.position.x - boardCenter.x,
+    y: cadComponentPlacement.position.y - boardCenter.y,
+    z: cadComponentPlacement.position.z
+  };
+  const direction = foldPcbs ? fold.direction : fold.inverseDirection;
+  const transformed = foldPcbs ? fold.point(point, anchor) : fold.inversePoint(point, anchor);
+  const rotation = cadComponentPlacement.rotation ?? context.defaultRotation ?? { x: 0, y: 0, z: 0 };
+  const basis = axes.map((v) => direction(rotateVector(v, rotation), anchor));
+  return {
+    ...cadComponentPlacement,
+    position: {
+      x: transformed.x + boardCenter.x,
+      y: transformed.y + boardCenter.y,
+      z: transformed.z
+    },
+    rotation: rotationFromAxes(basis),
+    is_on_folded_board: foldPcbs
+  };
+}
+function getCadFoldContext(cadComponent, json) {
+  const pcb = json.find(
+    (e) => e.type === "pcb_component" && e.pcb_component_id === cadComponent.pcb_component_id
+  );
+  if (pcb?.type !== "pcb_component") {
+    if (cadComponent.is_on_folded_board)
+      throw new Error(
+        `Folded CAD ${cadComponent.cad_component_id} requires its flat pcb_component reference`
+      );
+    return void 0;
+  }
+  const boards = json.filter((e) => e.type === "pcb_board");
+  const explicit = pcb.positioned_relative_to_pcb_board_id;
+  const matching = explicit ? boards.filter((b) => b.pcb_board_id === explicit) : boards.filter(
+    (b) => b.subcircuit_id && b.subcircuit_id === pcb.subcircuit_id
+  );
+  const board = matching.length === 1 ? matching[0] : !explicit && !matching.length && boards.length === 1 ? boards[0] : void 0;
+  if (!board)
+    throw new Error(
+      `Cannot unambiguously resolve board for CAD ${cadComponent.cad_component_id}`
+    );
+  const bends = json.filter(
+    (e) => e.type === "pcb_bend" && e.pcb_board_id === board.pcb_board_id
+  );
+  return {
+    fold: createPcbFold(bends, board.thickness ?? 1.6),
+    boardCenter: board.center,
+    flatMount: pcb.center,
+    defaultRotation: {
+      x: (cadComponent.layer ?? pcb.layer) === "bottom" ? 180 : 0,
+      y: 0,
+      z: 0
+    }
+  };
+}
+function transformCircuitJsonCadComponents(json, options) {
+  const hasBends = json.some((element) => element.type === "pcb_bend");
+  return json.map((element) => {
+    if (element.type !== "cad_component") return element;
+    const cadComponent = element;
+    if (!hasBends && !cadComponent.is_on_folded_board) return element;
+    if (cadComponent.is_on_folded_board === true === options.foldPcbs)
+      return element;
+    const context = getCadFoldContext(cadComponent, json);
+    if (!context || !context.fold.bends.length && !cadComponent.is_on_folded_board)
+      return element;
+    return transformCadComponent(
+      { cadComponent, foldPcbs: options.foldPcbs },
+      context
+    );
+  });
+}
+function extrudePolygon({
+  outline,
+  bottom,
+  top
+}) {
+  if (outline.length < 3 || !Number.isFinite(bottom) || !Number.isFinite(top) || top <= bottom || outline.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y)))
+    throw new Error(
+      "A finite polygon and positive extrusion thickness are required"
+    );
+  let area2 = 0;
+  for (const [i, a] of outline.entries()) {
+    const b = outline[(i + 1) % outline.length];
+    area2 += a.x * b.y - b.x * a.y;
+  }
+  if (Math.abs(area2) < 1e-12) throw new Error("Degenerate polygon");
+  const polygon2 = area2 > 0 ? outline : [...outline].reverse();
+  const triangles = [];
+  const add = ({
+    a,
+    b,
+    c,
+    pcbFace
+  }) => {
+    const u = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z }, v = { x: c.x - a.x, y: c.y - a.y, z: c.z - a.z };
+    const n = {
+      x: u.y * v.z - u.z * v.y,
+      y: u.z * v.x - u.x * v.z,
+      z: u.x * v.y - u.y * v.x
+    };
+    const l = Math.hypot(n.x, n.y, n.z);
+    if (l > 1e-12)
+      triangles.push({
+        vertices: [a, b, c],
+        normal: { x: n.x / l, y: n.y / l, z: n.z / l },
+        pcbFace
+      });
+  };
+  const indices = earcut(polygon2.flatMap((p) => [p.x, p.y]));
+  for (let i = 0; i < indices.length; i += 3) {
+    const [a, b, c] = indices.slice(i, i + 3).map((j) => polygon2[j]);
+    add({
+      a: { ...a, z: top },
+      b: { ...b, z: top },
+      c: { ...c, z: top },
+      pcbFace: "top"
+    });
+    add({
+      a: { ...c, z: bottom },
+      b: { ...b, z: bottom },
+      c: { ...a, z: bottom },
+      pcbFace: "bottom"
+    });
+  }
+  for (let i = 0; i < polygon2.length; i++) {
+    const a = polygon2[i], b = polygon2[(i + 1) % polygon2.length];
+    add({
+      a: { ...a, z: bottom },
+      b: { ...b, z: bottom },
+      c: { ...b, z: top },
+      pcbFace: "side"
+    });
+    add({
+      a: { ...a, z: bottom },
+      b: { ...b, z: top },
+      c: { ...a, z: top },
+      pcbFace: "side"
+    });
+  }
+  return { triangles, boundingBox: boundsOfTriangles(triangles) };
+}
+function createStiffenerMesh({
+  stiffener,
+  boardThickness,
+  fold
+}) {
+  const adhesive = stiffener.adhesive_thickness ?? 0;
+  if (!Number.isFinite(adhesive) || adhesive < 0 || !Number.isFinite(stiffener.thickness) || stiffener.thickness <= 0 || !["top", "bottom"].includes(stiffener.layer))
+    throw new Error(`Invalid PCB stiffener ${stiffener.pcb_stiffener_id}`);
+  const outline = stiffener.shape === "polygon" ? stiffener.outline : (() => {
+    if (!(stiffener.width > 0 && stiffener.height > 0))
+      throw new Error("Invalid stiffener dimensions");
+    const a = (stiffener.rotation ?? 0) * Math.PI / 180;
+    return [
+      [-1, -1],
+      [1, -1],
+      [1, 1],
+      [-1, 1]
+    ].map(([x, y]) => ({
+      x: stiffener.center.x + x * stiffener.width / 2 * Math.cos(a) - y * stiffener.height / 2 * Math.sin(a),
+      y: stiffener.center.y + x * stiffener.width / 2 * Math.sin(a) + y * stiffener.height / 2 * Math.cos(a)
+    }));
+  })();
+  const near = boardThickness / 2 + adhesive, far = near + stiffener.thickness;
+  const mesh = extrudePolygon({
+    outline,
+    bottom: stiffener.layer === "top" ? near : -far,
+    top: stiffener.layer === "top" ? far : -near
+  });
+  if (!fold) return mesh;
+  fold.assertRigid(
+    mesh.triangles.flatMap((t) => t.vertices),
+    stiffener.pcb_stiffener_id
+  );
+  const anchor = {
+    x: outline.reduce((s, p) => s + p.x, 0) / outline.length,
+    y: outline.reduce((s, p) => s + p.y, 0) / outline.length,
+    z: 0
+  };
+  const triangles = mesh.triangles.map((t) => ({
+    ...t,
+    vertices: t.vertices.map((p) => fold.point(p, anchor)),
+    normal: fold.direction(t.normal, anchor)
+  }));
+  return { ...mesh, triangles, boundingBox: boundsOfTriangles(triangles) };
+}
+
+// src/utils/flex-meshes.ts
+import * as THREE44 from "three";
+function meshToSurface(mesh, center) {
+  mesh.updateMatrix();
+  const geometry = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry;
+  const position = geometry.getAttribute("position"), uv = geometry.getAttribute("uv");
+  const triangles = [];
+  for (let i = 0; i < position.count; i += 3) {
+    const vertices = [0, 1, 2].map((j) => {
+      const v = new THREE44.Vector3().fromBufferAttribute(position, i + j).applyMatrix4(mesh.matrix);
+      return { x: v.x - center.x, y: v.y - center.y, z: v.z };
+    });
+    const [a, b, c] = vertices;
+    const n = new THREE44.Vector3(b.x - a.x, b.y - a.y, b.z - a.z).cross(new THREE44.Vector3(c.x - a.x, c.y - a.y, c.z - a.z)).normalize();
+    triangles.push({
+      vertices,
+      normal: { x: n.x, y: n.y, z: n.z },
+      ...uv ? {
+        uvs: [0, 1, 2].map((j) => ({
+          u: uv.getX(i + j),
+          v: uv.getY(i + j)
+        }))
+      } : {}
+    });
+  }
+  if (geometry !== mesh.geometry) geometry.dispose();
+  return { triangles, boundingBox: boundsOfTriangles(triangles) };
+}
+function surfaceToGeometry(surface, center) {
+  const positions = [], normals = [], uvs = [];
+  for (const triangle of surface.triangles)
+    triangle.vertices.forEach((p, i) => {
+      positions.push(p.x + center.x, p.y + center.y, p.z);
+      normals.push(triangle.normal.x, triangle.normal.y, triangle.normal.z);
+      uvs.push(triangle.uvs?.[i]?.u ?? 0, triangle.uvs?.[i]?.v ?? 0);
+    });
+  const geometry = new THREE44.BufferGeometry();
+  geometry.setAttribute(
+    "position",
+    new THREE44.Float32BufferAttribute(positions, 3)
+  );
+  geometry.setAttribute("normal", new THREE44.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new THREE44.Float32BufferAttribute(uvs, 2));
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function replaceGeometry(mesh, surface, board) {
+  const output = mesh.clone();
+  output.geometry = surfaceToGeometry(surface, board.center);
+  output.position.set(0, 0, 0);
+  output.rotation.set(0, 0, 0);
+  output.scale.set(1, 1, 1);
+  output.updateMatrix();
+  return output;
+}
+function createFlexMeshes(geometryMeshes, textureMeshes, json, foldPcbs) {
+  const boards = json.filter((e) => e.type === "pcb_board");
+  const bends = json.filter((e) => e.type === "pcb_bend"), stiffeners = json.filter((e) => e.type === "pcb_stiffener");
+  if (!bends.length && !stiffeners.length)
+    return { geometryMeshes, textureMeshes };
+  const board = boards[0];
+  if (!board || boards.length !== 1 || json.some((e) => e.type === "pcb_panel") || [...bends, ...stiffeners].some((e) => e.pcb_board_id !== board.pcb_board_id))
+    throw new Error(
+      "Flex rendering requires one board, matching board references, and no panel"
+    );
+  const fold = foldPcbs ? createPcbFold(bends, board.thickness ?? 1.6) : void 0;
+  const body = geometryMeshes.find((m) => m.name === "board-geom");
+  const flatBody = body ? meshToSurface(body, board.center) : void 0;
+  const geometry = fold ? geometryMeshes.map(
+    (mesh) => replaceGeometry(
+      mesh,
+      foldSurfaceMesh(meshToSurface(mesh, board.center), fold),
+      board
+    )
+  ) : [...geometryMeshes];
+  const textures = fold && flatBody ? textureMeshes.map((mesh) => {
+    mesh.updateMatrix();
+    const inverse = mesh.matrix.clone().invert();
+    const bottom = mesh.name.startsWith("bottom");
+    const dimensions = mesh.geometry.parameters;
+    const triangles = flatBody.triangles.filter((t) => bottom ? t.normal.z < -0.9 : t.normal.z > 0.9).map((t) => {
+      const vertices = t.vertices.map((p) => ({
+        ...p,
+        z: mesh.position.z
+      }));
+      const uvs = vertices.map((p) => {
+        const local = new THREE44.Vector3(
+          p.x + board.center.x,
+          p.y + board.center.y,
+          p.z
+        ).applyMatrix4(inverse);
+        return {
+          u: local.x / dimensions.width + 0.5,
+          v: local.y / dimensions.height + 0.5
+        };
+      });
+      return { ...t, vertices, uvs };
+    });
+    const result = replaceGeometry(
+      mesh,
+      foldSurfaceMesh(
+        { triangles, boundingBox: boundsOfTriangles(triangles) },
+        fold
+      ),
+      board
+    );
+    mesh.geometry.dispose();
+    return result;
+  }) : textureMeshes;
+  for (const stiffener of stiffeners) {
+    const mesh = new THREE44.Mesh(
+      surfaceToGeometry(
+        createStiffenerMesh({
+          stiffener,
+          boardThickness: board.thickness ?? 1.6,
+          fold
+        }),
+        board.center
+      ),
+      new THREE44.MeshStandardMaterial({
+        color: stiffener.material === "fr4" ? "#879568" : stiffener.material === "polyimide" ? "#bd7f27" : "#b8bdc4",
+        side: THREE44.DoubleSide
+      })
+    );
+    mesh.name = "board-stiffener";
+    configureObjectShadows(mesh);
+    geometry.push(mesh);
+  }
+  const bounds = new THREE44.Box3();
+  for (const mesh of [...geometry, ...textures]) bounds.expandByObject(mesh);
+  return {
+    geometryMeshes: geometry,
+    textureMeshes: textures,
+    bounds: {
+      minX: bounds.min.x,
+      maxX: bounds.max.x,
+      minY: bounds.min.y,
+      maxY: bounds.max.y,
+      minZ: bounds.min.z,
+      maxZ: bounds.max.z
+    }
+  };
+}
+
 // src/CadViewerManifold.tsx
 import { su as su17 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect28, useMemo as useMemo24, useState as useState17 } from "react";
-import * as THREE50 from "three";
+import * as THREE51 from "three";
 
 // src/hooks/useManifoldBoardBuilder.ts
 import { su as su16 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect27, useMemo as useMemo23, useRef as useRef9, useState as useState16 } from "react";
-import * as THREE47 from "three";
+import * as THREE48 from "three";
 
 // src/utils/manifold/create-manifold-board.ts
 var arePointsClockwise2 = (points) => {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
     if (points[i] && points[j]) {
-      area += points[i][0] * points[j][1];
-      area -= points[j][0] * points[i][1];
+      area2 += points[i][0] * points[j][1];
+      area2 -= points[j][0] * points[i][1];
     }
   }
-  const signedArea = area / 2;
-  return signedArea <= 0;
+  const signedArea2 = area2 / 2;
+  return signedArea2 <= 0;
 };
 function createManifoldBoard(Manifold, CrossSection, boardData, pcbThickness, manifoldInstancesForCleanup) {
   let boardOp;
@@ -45515,16 +46649,16 @@ function createRoundedRectPrism({
 
 // src/utils/manifold/process-cutouts.ts
 var arePointsClockwise3 = (points) => {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
     if (points[i] && points[j]) {
-      area += points[i][0] * points[j][1];
-      area -= points[j][0] * points[i][1];
+      area2 += points[i][0] * points[j][1];
+      area2 -= points[j][0] * points[i][1];
     }
   }
-  const signedArea = area / 2;
-  return signedArea <= 0;
+  const signedArea2 = area2 / 2;
+  return signedArea2 <= 0;
 };
 function processCutoutsForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
   const cutoutOps = [];
@@ -45719,13 +46853,13 @@ function processNonPlatedHolesForManifold(Manifold, CrossSection, circuitJson, p
       holeOp = createRectOp(holeW, holeH, drillDepth);
     } else if (holeShape === "oval") {
       let points = createEllipsePoints2(holeW, holeH, SMOOTH_CIRCLE_SEGMENTS);
-      let area = 0;
+      let area2 = 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];
+        area2 += points[i][0] * points[j][1];
+        area2 -= points[j][0] * points[i][1];
       }
-      if (area <= 0) {
+      if (area2 <= 0) {
         points = points.reverse();
       }
       const crossSection = CrossSection.ofPolygons([points]);
@@ -45757,17 +46891,17 @@ function processNonPlatedHolesForManifold(Manifold, CrossSection, circuitJson, p
 
 // src/utils/manifold/process-plated-holes.ts
 import { su as su15 } from "@tscircuit/circuit-json-util";
-import * as THREE45 from "three";
+import * as THREE46 from "three";
 
 // src/utils/manifold-mesh-to-three-geometry.ts
-import * as THREE44 from "three";
+import * as THREE45 from "three";
 function manifoldMeshToThreeGeometry(manifoldMesh) {
-  const geometry = new THREE44.BufferGeometry();
+  const geometry = new THREE45.BufferGeometry();
   geometry.setAttribute(
     "position",
-    new THREE44.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
+    new THREE45.Float32BufferAttribute(manifoldMesh.vertProperties, 3)
   );
-  geometry.setIndex(new THREE44.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
+  geometry.setIndex(new THREE45.Uint32BufferAttribute(manifoldMesh.triVerts, 1));
   if (manifoldMesh.runIndex && manifoldMesh.runIndex.length > 1 && manifoldMesh.runOriginalID) {
     for (let i = 0; i < manifoldMesh.runIndex.length - 1; i++) {
       const start = manifoldMesh.runIndex[i];
@@ -45782,16 +46916,16 @@ function manifoldMeshToThreeGeometry(manifoldMesh) {
 
 // src/utils/manifold/process-plated-holes.ts
 var arePointsClockwise4 = (points) => {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const j = (i + 1) % points.length;
     if (points[i] && points[j]) {
-      area += points[i][0] * points[j][1];
-      area -= points[j][0] * points[i][1];
+      area2 += points[i][0] * points[j][1];
+      area2 -= points[j][0] * points[i][1];
     }
   }
-  const signedArea = area / 2;
-  return signedArea <= 0;
+  const signedArea2 = area2 / 2;
+  return signedArea2 <= 0;
 };
 var createEllipsePoints = (width10, height10, segments) => {
   const points = [];
@@ -45801,7 +46935,7 @@ var createEllipsePoints = (width10, height10, segments) => {
   }
   return points;
 };
-var COPPER_COLOR = new THREE45.Color(...colors.copper);
+var COPPER_COLOR = new THREE46.Color(...colors.copper);
 var PLATED_HOLE_LIP_HEIGHT = 0.05;
 var PLATED_HOLE_PAD_THICKNESS = 3e-3;
 var PLATED_HOLE_SURFACE_CLEARANCE = 5e-4;
@@ -46431,7 +47565,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
 }
 
 // src/utils/manifold/process-vias.ts
-import * as THREE46 from "three";
+import * as THREE47 from "three";
 
 // src/utils/via-geoms.ts
 function createViaCopper2({
@@ -46469,7 +47603,7 @@ function createViaCopper2({
 }
 
 // src/utils/manifold/process-vias.ts
-var COPPER_COLOR2 = new THREE46.Color(...colors.copper);
+var COPPER_COLOR2 = new THREE47.Color(...colors.copper);
 function processViasForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup, boardClipVolume) {
   const viaBoardDrills = [];
   const pcbVias = getPcbVias(circuitJson);
@@ -46690,7 +47824,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
             {
               key: "plated-holes-union",
               geometry: cutPlatedGeom,
-              color: new THREE47.Color(
+              color: new THREE48.Color(
                 colors.copper[0],
                 colors.copper[1],
                 colors.copper[2]
@@ -46760,11 +47894,11 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
 };
 
 // src/utils/manifold/create-three-geometry-meshes.ts
-import * as THREE49 from "three";
+import * as THREE50 from "three";
 
 // src/utils/create-board-material.ts
-import * as THREE48 from "three";
-var DEFAULT_SIDE = THREE48.DoubleSide;
+import * as THREE49 from "three";
+var DEFAULT_SIDE = THREE49.DoubleSide;
 var createBoardMaterial = ({
   material,
   color,
@@ -46772,7 +47906,7 @@ var createBoardMaterial = ({
   isFaux = false
 }) => {
   if (material === "fr4") {
-    return new THREE48.MeshPhysicalMaterial({
+    return new THREE49.MeshPhysicalMaterial({
       color,
       side,
       metalness: 0,
@@ -46790,7 +47924,7 @@ var createBoardMaterial = ({
       polygonOffsetUnits: 1
     });
   }
-  return new THREE48.MeshStandardMaterial({
+  return new THREE49.MeshStandardMaterial({
     color,
     side,
     flatShading: true,
@@ -46809,12 +47943,12 @@ function createGeometryMeshes(geoms) {
   const meshes = [];
   if (!geoms) return meshes;
   if (geoms.board?.geometry) {
-    const mesh = new THREE49.Mesh(
+    const mesh = new THREE50.Mesh(
       geoms.board.geometry,
       createBoardMaterial({
         material: geoms.board.material,
         color: geoms.board.color,
-        side: THREE49.DoubleSide,
+        side: THREE50.DoubleSide,
         isFaux: geoms.board.isFaux
       })
     );
@@ -46825,11 +47959,11 @@ function createGeometryMeshes(geoms) {
   const createMeshesFromArray = (geomArray) => {
     if (geomArray) {
       for (const comp of geomArray) {
-        const mesh = new THREE49.Mesh(
+        const mesh = new THREE50.Mesh(
           comp.geometry,
-          new THREE49.MeshStandardMaterial({
+          new THREE50.MeshStandardMaterial({
             color: comp.color,
-            side: THREE49.DoubleSide,
+            side: THREE50.DoubleSide,
             flatShading: true
             // Consistent with board
           })
@@ -46874,7 +48008,7 @@ var BoardMeshes = ({
       const typedMaterial = material;
       for (const prop of textureProps) {
         const texture = typedMaterial[prop];
-        if (texture && texture instanceof THREE50.Texture) {
+        if (texture && texture instanceof THREE51.Texture) {
           texture.dispose();
         }
       }
@@ -46885,7 +48019,7 @@ var BoardMeshes = ({
     if (!rootObject) return;
     for (const mesh of geometryMeshes) {
       let shouldShow = true;
-      if (mesh.name === "board-geom") {
+      if (mesh.name === "board-geom" || mesh.name === "board-stiffener") {
         shouldShow = visibility.boardBody;
       } else if (mesh.name.includes("plated_hole") || mesh.name.includes("via")) {
         shouldShow = visibility.topCopper || visibility.bottomCopper;
@@ -46922,6 +48056,7 @@ var BoardMeshes = ({
 var MANIFOLD_CDN_BASE_URL = "https://cdn.jsdelivr.net/npm/manifold-3d@3.2.1";
 var CadViewerManifold = ({
   circuitJson: circuitJsonProp,
+  foldPcbs,
   autoRotateDisabled,
   clickToInteractEnabled,
   onUserInteraction,
@@ -47009,14 +48144,40 @@ try {
     boardData,
     isFauxBoard
   } = useManifoldBoardBuilder(manifoldJSModule, circuitJson, visibility);
-  const geometryMeshes = useMemo24(() => createGeometryMeshes(geoms), [geoms]);
-  const textureMeshes = useMemo24(
-    () => createTextureMeshes(textures, boardData, pcbThickness, isFauxBoard),
-    [textures, boardData, pcbThickness, isFauxBoard]
-  );
+  const flex = useMemo24(() => {
+    try {
+      const resolvedFoldPcbs = resolveFoldPcbs(circuitJson, foldPcbs);
+      const posedJson = transformCircuitJsonCadComponents(circuitJson, {
+        foldPcbs: resolvedFoldPcbs
+      });
+      const meshes = createFlexMeshes(
+        createGeometryMeshes(geoms),
+        createTextureMeshes(textures, boardData, pcbThickness, isFauxBoard),
+        circuitJson,
+        resolvedFoldPcbs
+      );
+      return { ...meshes, posedJson, error: void 0 };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : String(error),
+        geometryMeshes: [],
+        textureMeshes: [],
+        posedJson: circuitJson,
+        bounds: void 0
+      };
+    }
+  }, [
+    geoms,
+    textures,
+    boardData,
+    pcbThickness,
+    isFauxBoard,
+    circuitJson,
+    foldPcbs
+  ]);
   const cadComponents = useMemo24(
-    () => su17(circuitJson).cad_component.list(),
-    [circuitJson]
+    () => su17(flex.posedJson).cad_component.list(),
+    [flex.posedJson]
   );
   const boardDimensions = useMemo24(() => {
     if (!boardData) return void 0;
@@ -47063,10 +48224,11 @@ try {
   if (!manifoldJSModule) {
     return /* @__PURE__ */ jsx19("div", { style: { padding: "1em" }, children: "Loading Manifold module..." });
   }
-  if (builderError) {
+  if (builderError || flex.error) {
     return /* @__PURE__ */ jsxs6(
       "div",
       {
+        role: "alert",
         style: {
           color: "red",
           padding: "1em",
@@ -47075,7 +48237,7 @@ try {
         },
         children: [
           "Error: ",
-          builderError
+          builderError ?? flex.error
         ]
       }
     );
@@ -47098,10 +48260,11 @@ try {
         /* @__PURE__ */ jsx19(
           BoardMeshes,
           {
-            geometryMeshes,
-            textureMeshes
+            geometryMeshes: flex.geometryMeshes,
+            textureMeshes: flex.textureMeshes
           }
         ),
+        flex.bounds && /* @__PURE__ */ jsx19(FitCameraToComparison, { bounds: flex.bounds }),
         cadComponents.map((cad_component) => /* @__PURE__ */ jsx19(
           ThreeErrorBoundary,
           {
@@ -47110,7 +48273,7 @@ try {
               AnyCadComponent,
               {
                 cad_component,
-                circuitJson,
+                circuitJson: flex.posedJson,
                 resolveStaticAsset
               }
             )
@@ -52820,6 +53983,27 @@ var MenuItemImpl = /* @__PURE__ */ React41.forwardRef(
     );
   }, "MenuItemImpl")
 );
+var MenuCheckboxItem = /* @__PURE__ */ React41.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name21(function MenuCheckboxItem2(props, forwardedRef) {
+    const { checked = false, onCheckedChange, ...checkboxItemProps } = props;
+    return /* @__PURE__ */ jsx30(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ jsx30(
+      MenuItem,
+      {
+        role: "menuitemcheckbox",
+        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
+        ...checkboxItemProps,
+        ref: forwardedRef,
+        "data-state": getCheckedState(checked),
+        onSelect: composeEventHandlers(
+          checkboxItemProps.onSelect,
+          () => onCheckedChange?.(isIndeterminate(checked) ? true : !checked),
+          { checkForDefaultPrevented: false }
+        )
+      }
+    ) });
+  }, "MenuCheckboxItem")
+);
 var RADIO_GROUP_NAME = "MenuRadioGroup";
 var [RadioGroupProvider, useRadioGroupContext] = createMenuContext(
   RADIO_GROUP_NAME,
@@ -53087,10 +54271,10 @@ function isPointInPolygon(point, polygon2) {
   return inside;
 }
 __name21(isPointInPolygon, "isPointInPolygon");
-function isPointerInGraceArea(event, area) {
-  if (!area) return false;
+function isPointerInGraceArea(event, area2) {
+  if (!area2) return false;
   const cursorPos = { x: event.clientX, y: event.clientY };
-  return isPointInPolygon(cursorPos, area);
+  return isPointInPolygon(cursorPos, area2);
 }
 __name21(isPointerInGraceArea, "isPointerInGraceArea");
 function whenMouse(handler) {
@@ -53102,6 +54286,7 @@ var Anchor2 = MenuAnchor;
 var Portal3 = MenuPortal;
 var Content2 = MenuContent;
 var Item2 = MenuItem;
+var CheckboxItem = MenuCheckboxItem;
 var Separator = MenuSeparator;
 var Sub = MenuSub;
 var SubTrigger = MenuSubTrigger;
@@ -53243,6 +54428,11 @@ var DropdownMenuItem = /* @__PURE__ */ React42.forwardRef(
     return /* @__PURE__ */ jsx31(Item2, { ...menuScope, ...itemProps, ref: forwardedRef });
   }, "DropdownMenuItem")
 );
+var DropdownMenuCheckboxItem = /* @__PURE__ */ React42.forwardRef(/* @__PURE__ */ __name22(function DropdownMenuCheckboxItem2(props, forwardedRef) {
+  const { __scopeDropdownMenu, ...checkboxItemProps } = props;
+  const menuScope = useMenuScope(__scopeDropdownMenu);
+  return /* @__PURE__ */ jsx31(CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });
+}, "DropdownMenuCheckboxItem"));
 var DropdownMenuSeparator = /* @__PURE__ */ React42.forwardRef(/* @__PURE__ */ __name22(function DropdownMenuSeparator2(props, forwardedRef) {
   const { __scopeDropdownMenu, ...separatorProps } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
@@ -53292,6 +54482,7 @@ var Trigger = DropdownMenuTrigger;
 var Portal22 = DropdownMenuPortal;
 var Content22 = DropdownMenuContent;
 var Item22 = DropdownMenuItem;
+var CheckboxItem2 = DropdownMenuCheckboxItem;
 var Separator2 = DropdownMenuSeparator;
 var Sub2 = DropdownMenuSub;
 var SubTrigger2 = DropdownMenuSubTrigger;
@@ -53860,6 +55051,9 @@ var ContextMenu = ({
   engine,
   cameraPreset,
   autoRotate,
+  foldPcbs = false,
+  onFoldPcbsToggle,
+  flexScene = false,
   referenceObject = null,
   onEngineSwitch,
   onCameraPresetSelect,
@@ -54078,6 +55272,23 @@ var ContextMenu = ({
                   }
                 ) })
               ] }),
+              onFoldPcbsToggle && /* @__PURE__ */ jsxs8(
+                CheckboxItem2,
+                {
+                  checked: foldPcbs,
+                  onCheckedChange: onFoldPcbsToggle,
+                  style: {
+                    ...itemStyles2,
+                    backgroundColor: hoveredItem === "fold" ? "#404040" : "transparent"
+                  },
+                  onMouseEnter: () => setHoveredItem("fold"),
+                  onMouseLeave: () => setHoveredItem(null),
+                  children: [
+                    /* @__PURE__ */ jsx34("span", { style: iconContainerStyles2, children: foldPcbs && /* @__PURE__ */ jsx34(CheckIcon, {}) }),
+                    /* @__PURE__ */ jsx34("span", { children: "Fold PCBs" })
+                  ]
+                }
+              ),
               /* @__PURE__ */ jsxs8(
                 Item22,
                 {
@@ -54117,7 +55328,7 @@ var ContextMenu = ({
                 }
               ),
               /* @__PURE__ */ jsx34(Separator2, { style: separatorStyles2 }),
-              /* @__PURE__ */ jsxs8(
+              !flexScene && /* @__PURE__ */ jsxs8(
                 Item22,
                 {
                   style: {
@@ -54134,11 +55345,17 @@ var ContextMenu = ({
                   onMouseLeave: () => setHoveredItem(null),
                   onTouchStart: () => setHoveredItem("engine"),
                   children: [
-                    /* @__PURE__ */ jsxs8("span", { style: { flex: 1, display: "flex", alignItems: "center" }, children: [
-                      "Switch to ",
-                      engine === "jscad" ? "Manifold" : "JSCAD",
-                      " Engine"
-                    ] }),
+                    /* @__PURE__ */ jsxs8(
+                      "span",
+                      {
+                        style: { flex: 1, display: "flex", alignItems: "center" },
+                        children: [
+                          "Switch to ",
+                          engine === "jscad" ? "Manifold" : "JSCAD",
+                          " Engine"
+                        ]
+                      }
+                    ),
                     /* @__PURE__ */ jsx34(
                       "div",
                       {
@@ -54807,7 +56024,7 @@ var useGlobalDownloadGltf = () => {
 
 // src/CadViewer.tsx
 import { jsx as jsx37, jsxs as jsxs11 } from "react/jsx-runtime";
-var DEFAULT_TARGET = new THREE51.Vector3(0, 0, 0);
+var DEFAULT_TARGET = new THREE52.Vector3(0, 0, 0);
 var INITIAL_CAMERA_POSITION = [5, -5, 5];
 var readStoredCameraType = () => {
   if (typeof window === "undefined") return void 0;
@@ -54815,6 +56032,18 @@ var readStoredCameraType = () => {
   return stored === "orthographic" || stored === "perspective" ? stored : void 0;
 };
 var CadViewerInner = (props) => {
+  const childrenCircuitJson = useConvertChildrenToCircuitJson(
+    props.circuitJson ? void 0 : props.children
+  );
+  const circuitJson = props.circuitJson ?? childrenCircuitJson;
+  const hasBends = circuitJson.some((element) => element.type === "pcb_bend");
+  const hasFlexGeometry = hasBends || circuitJson.some((element) => element.type === "pcb_stiffener");
+  const [foldPcbsOverride, setFoldPcbs] = useState39(
+    void 0
+  );
+  const foldPcbs = foldPcbsOverride ?? props.foldPcbs;
+  const resolvedFoldPcbs = resolveFoldPcbs(circuitJson, foldPcbs);
+  const resolvedProps = { ...props, circuitJson, children: void 0 };
   const [engine, setEngine] = useState39(() => {
     const stored = window.localStorage.getItem("cadViewerEngine");
     return stored === "jscad" || stored === "manifold" ? stored : "manifold";
@@ -54978,10 +56207,20 @@ var CadViewerInner = (props) => {
       },
       ...contextMenuEventHandlers,
       children: [
-        engine === "jscad" ? /* @__PURE__ */ jsx37(
+        hasFlexGeometry ? /* @__PURE__ */ jsx37(
+          CadViewerManifold_default,
+          {
+            ...resolvedProps,
+            foldPcbs,
+            autoRotateDisabled: props.autoRotateDisabled || !autoRotate,
+            onUserInteraction: handleUserInteraction,
+            onCameraControllerReady: handleCameraControllerReady,
+            referenceObject
+          }
+        ) : engine === "jscad" ? /* @__PURE__ */ jsx37(
           CadViewerJscad,
           {
-            ...props,
+            ...resolvedProps,
             autoRotateDisabled: props.autoRotateDisabled || !autoRotate,
             cameraType,
             onUserInteraction: handleUserInteraction,
@@ -54991,7 +56230,7 @@ var CadViewerInner = (props) => {
         ) : /* @__PURE__ */ jsx37(
           CadViewerManifold_default,
           {
-            ...props,
+            ...resolvedProps,
             autoRotateDisabled: props.autoRotateDisabled || !autoRotate,
             cameraType,
             onUserInteraction: handleUserInteraction,
@@ -55005,6 +56244,13 @@ var CadViewerInner = (props) => {
             menuRef,
             menuPos,
             engine,
+            flexScene: hasFlexGeometry,
+            foldPcbs: resolvedFoldPcbs,
+            onFoldPcbsToggle: hasBends ? () => {
+              setFoldPcbs(!resolvedFoldPcbs);
+              setCameraPreset("Custom");
+              closeMenu();
+            } : void 0,
             cameraPreset,
             autoRotate,
             referenceObject,
@@ -55066,14 +56312,14 @@ var CadViewer = (props) => {
 // src/convert-circuit-json-to-3d-svg.ts
 var import_debug = __toESM(require_browser(), 1);
 import { su as su18 } from "@tscircuit/circuit-json-util";
-import * as THREE55 from "three";
+import * as THREE56 from "three";
 import { SVGRenderer } from "three/examples/jsm/renderers/SVGRenderer.js";
 
 // src/utils/create-geometry-from-polygons.ts
-import * as THREE52 from "three";
-import { BufferGeometry as BufferGeometry5, Float32BufferAttribute as Float32BufferAttribute4 } from "three";
+import * as THREE53 from "three";
+import { BufferGeometry as BufferGeometry6, Float32BufferAttribute as Float32BufferAttribute5 } from "three";
 function createGeometryFromPolygons(polygons) {
-  const geometry = new BufferGeometry5();
+  const geometry = new BufferGeometry6();
   const vertices = [];
   const normals = [];
   for (const polygon2 of polygons) {
@@ -55084,12 +56330,12 @@ function createGeometryFromPolygons(polygons) {
         ...polygon2.vertices[i + 1]
         // Third vertex
       );
-      const v1 = new THREE52.Vector3(...polygon2.vertices[0]);
-      const v2 = new THREE52.Vector3(...polygon2.vertices[i]);
-      const v3 = new THREE52.Vector3(...polygon2.vertices[i + 1]);
-      const normal = new THREE52.Vector3().crossVectors(
-        new THREE52.Vector3().subVectors(v2, v1),
-        new THREE52.Vector3().subVectors(v3, v1)
+      const v1 = new THREE53.Vector3(...polygon2.vertices[0]);
+      const v2 = new THREE53.Vector3(...polygon2.vertices[i]);
+      const v3 = new THREE53.Vector3(...polygon2.vertices[i + 1]);
+      const normal = new THREE53.Vector3().crossVectors(
+        new THREE53.Vector3().subVectors(v2, v1),
+        new THREE53.Vector3().subVectors(v3, v1)
       ).normalize();
       normals.push(
         normal.x,
@@ -55104,8 +56350,8 @@ function createGeometryFromPolygons(polygons) {
       );
     }
   }
-  geometry.setAttribute("position", new Float32BufferAttribute4(vertices, 3));
-  geometry.setAttribute("normal", new Float32BufferAttribute4(normals, 3));
+  geometry.setAttribute("position", new Float32BufferAttribute5(vertices, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute5(normals, 3));
   return geometry;
 }
 
@@ -55113,10 +56359,10 @@ function createGeometryFromPolygons(polygons) {
 var import_modeling2 = __toESM(require_src(), 1);
 var import_jscad_planner2 = __toESM(require_dist(), 1);
 var jscadModeling2 = __toESM(require_src(), 1);
-import * as THREE54 from "three";
+import * as THREE55 from "three";
 
 // src/utils/load-model.ts
-import * as THREE53 from "three";
+import * as THREE54 from "three";
 import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { OBJLoader as OBJLoader2 } from "three/examples/jsm/loaders/OBJLoader.js";
 import { STLLoader as STLLoader2 } from "three/examples/jsm/loaders/STLLoader.js";
@@ -55124,12 +56370,12 @@ async function load3DModel(url) {
   if (url.endsWith(".stl")) {
     const loader = new STLLoader2();
     const geometry = await loader.loadAsync(url);
-    const material = new THREE53.MeshStandardMaterial({
+    const material = new THREE54.MeshStandardMaterial({
       color: 8947848,
       metalness: 0.5,
       roughness: 0.5
     });
-    return new THREE53.Mesh(geometry, material);
+    return new THREE54.Mesh(geometry, material);
   }
   if (url.endsWith(".obj")) {
     const loader = new OBJLoader2();
@@ -55162,9 +56408,9 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         model.rotation.set(
-          THREE54.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE55.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(model);
@@ -55178,13 +56424,13 @@ async function renderComponent(component, scene) {
     );
     if (jscadObject && (jscadObject.polygons || jscadObject.sides)) {
       const threeGeom = convertCSGToThreeGeom(jscadObject);
-      const material2 = new THREE54.MeshStandardMaterial({
+      const material2 = new THREE55.MeshStandardMaterial({
         color: 8947848,
         metalness: 0.5,
         roughness: 0.5,
-        side: THREE54.DoubleSide
+        side: THREE55.DoubleSide
       });
-      const mesh2 = new THREE54.Mesh(threeGeom, material2);
+      const mesh2 = new THREE55.Mesh(threeGeom, material2);
       if (component.position) {
         mesh2.position.set(
           component.position.x ?? 0,
@@ -55194,9 +56440,9 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         mesh2.rotation.set(
-          THREE54.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE55.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(mesh2);
@@ -55213,17 +56459,17 @@ async function renderComponent(component, scene) {
       if (!geom || !geom.polygons && !geom.sides) {
         continue;
       }
-      const color = new THREE54.Color(geomInfo.color);
+      const color = new THREE55.Color(geomInfo.color);
       color.convertLinearToSRGB();
       const geomWithColor = { ...geom, color: [color.r, color.g, color.b] };
       const threeGeom = convertCSGToThreeGeom(geomWithColor);
-      const material2 = new THREE54.MeshStandardMaterial({
+      const material2 = new THREE55.MeshStandardMaterial({
         vertexColors: true,
         metalness: 0.2,
         roughness: 0.8,
-        side: THREE54.DoubleSide
+        side: THREE55.DoubleSide
       });
-      const mesh2 = new THREE54.Mesh(threeGeom, material2);
+      const mesh2 = new THREE55.Mesh(threeGeom, material2);
       if (component.position) {
         mesh2.position.set(
           component.position.x ?? 0,
@@ -55233,22 +56479,22 @@ async function renderComponent(component, scene) {
       }
       if (component.rotation) {
         mesh2.rotation.set(
-          THREE54.MathUtils.degToRad(component.rotation.x ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.y ?? 0),
-          THREE54.MathUtils.degToRad(component.rotation.z ?? 0)
+          THREE55.MathUtils.degToRad(component.rotation.x ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.y ?? 0),
+          THREE55.MathUtils.degToRad(component.rotation.z ?? 0)
         );
       }
       scene.add(mesh2);
     }
     return;
   }
-  const geometry = new THREE54.BoxGeometry(0.5, 0.5, 0.5);
-  const material = new THREE54.MeshStandardMaterial({
+  const geometry = new THREE55.BoxGeometry(0.5, 0.5, 0.5);
+  const material = new THREE55.MeshStandardMaterial({
     color: 16711680,
     transparent: true,
     opacity: 0.25
   });
-  const mesh = new THREE54.Mesh(geometry, material);
+  const mesh = new THREE55.Mesh(geometry, material);
   if (component.position) {
     mesh.position.set(
       component.position.x ?? 0,
@@ -55269,11 +56515,11 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
     padding = 20,
     zoom = 1.5
   } = options;
-  const scene = new THREE55.Scene();
+  const scene = new THREE56.Scene();
   const renderer = new SVGRenderer();
   renderer.setSize(width10, height10);
-  renderer.setClearColor(new THREE55.Color(backgroundColor), 1);
-  const camera = new THREE55.OrthographicCamera();
+  renderer.setClearColor(new THREE56.Color(backgroundColor), 1);
+  const camera = new THREE56.OrthographicCamera();
   const aspect = width10 / height10;
   const frustumSize = 100;
   const halfFrustumSize = frustumSize / 2 / zoom;
@@ -55287,11 +56533,11 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
   camera.position.set(position.x, position.y, position.z);
   camera.up.set(0, 1, 0);
   const lookAt = options.camera?.lookAt ?? { x: 0, y: 0, z: 0 };
-  camera.lookAt(new THREE55.Vector3(lookAt.x, lookAt.y, lookAt.z));
+  camera.lookAt(new THREE56.Vector3(lookAt.x, lookAt.y, lookAt.z));
   camera.updateProjectionMatrix();
-  const ambientLight = new THREE55.AmbientLight(16777215, Math.PI / 2);
+  const ambientLight = new THREE56.AmbientLight(16777215, Math.PI / 2);
   scene.add(ambientLight);
-  const pointLight = new THREE55.PointLight(16777215, Math.PI / 4);
+  const pointLight = new THREE56.PointLight(16777215, Math.PI / 4);
   pointLight.position.set(-10, -10, 10);
   scene.add(pointLight);
   const components = su18(circuitJson).cad_component.list();
@@ -55316,28 +56562,28 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
       const material = createBoardMaterial({
         material: boardData?.material,
         color: edgeColor,
-        side: THREE55.DoubleSide
+        side: THREE56.DoubleSide
       });
-      const mesh = new THREE55.Mesh(geometry, material);
+      const mesh = new THREE56.Mesh(geometry, material);
       scene.add(mesh);
     }
   }
-  const gridColor = new THREE55.Color(8947848);
-  const gridHelper = new THREE55.GridHelper(100, 100, gridColor, gridColor);
+  const gridColor = new THREE56.Color(8947848);
+  const gridHelper = new THREE56.GridHelper(100, 100, gridColor, gridColor);
   gridHelper.rotation.x = Math.PI / 2;
   const materials = Array.isArray(gridHelper.material) ? gridHelper.material : [gridHelper.material];
   for (const mat of materials) {
     mat.transparent = true;
     mat.opacity = 0.3;
-    if (mat instanceof THREE55.LineBasicMaterial) {
+    if (mat instanceof THREE56.LineBasicMaterial) {
       mat.color = gridColor;
       mat.vertexColors = false;
     }
   }
   scene.add(gridHelper);
-  const box = new THREE55.Box3().setFromObject(scene);
-  const center = box.getCenter(new THREE55.Vector3());
-  const size4 = box.getSize(new THREE55.Vector3());
+  const box = new THREE56.Box3().setFromObject(scene);
+  const center = box.getCenter(new THREE56.Vector3());
+  const size4 = box.getSize(new THREE56.Vector3());
   scene.position.sub(center);
   const maxDim = Math.max(size4.x, size4.y, size4.z);
   if (maxDim > 0) {