@tscircuit/3d-viewer 0.0.627 → 0.0.628

package/README.md

@@ -82,7 +82,7 @@ viewer. The host can switch tabs and focus the schematic using the source ID.
 Omit the callback when schematic navigation is unavailable.
 
 ```tsx
-<CadViewer
+;<CadViewer
   circuitJson={circuitJson}
   onViewSchematicComponent={({ source_component_id }) => {
     // Find the schematic component with this source ID and focus it.
@@ -96,9 +96,9 @@ Omit the callback when schematic navigation is unavailable.
 When using the SVG converter in Node.js environments, you'll need to provide JSDOM:
 
 ```typescript
-import { JSDOM } from 'jsdom'
-import { convert3dCircuitToSvg } from '@tscircuit/3d-viewer/3d'
-import { applyJsdomShim } from '@tscircuit/3d-viewer/utils'
+import { JSDOM } from "jsdom"
+import { convert3dCircuitToSvg } from "@tscircuit/3d-viewer/3d"
+import { applyJsdomShim } from "@tscircuit/3d-viewer/utils"
 
 // Setup JSDOM environment
 const dom = new JSDOM()
@@ -113,8 +113,8 @@ const options = {
   zoom: 50,
   camera: {
     position: { x: 0, y: 0, z: 100 },
-    lookAt: { x: 0, y: 0, z: 0 }
-  }
+    lookAt: { x: 0, y: 0, z: 0 },
+  },
 }
 
 const svgString = await convert3dCircuitToSvg(circuitJson, options)
@@ -137,7 +137,6 @@ The `convert3dCircuitToSvg` function accepts the following options:
 Main component for rendering the 3D PCB viewer.
 
 Props:
-
 - `circuit-json`: (optional) An array of AnyCircuitElement objects representing the PCB layout.
 - `children`: (optional) React children elements describing the PCB layout (alternative to using `circuit-json`).
 - `resolveStaticAsset`: (optional) Function that receives each component model URL (`obj`, `wrl`, `stl`, `gltf`, `glb`, `step`) and returns the resolved URL to load.
@@ -147,14 +146,12 @@ Props:
 Defines the PCB board dimensions.
 
 Props:
-
 - `width`: Width of the board (e.g., "20mm").
 - `height`: Height of the board (e.g., "20mm").
 
 ### Component Elements
 
 Various component elements can be used as children of the `<board>` element:
-
 - `<resistor>`
 - `<capacitor>`
 - `<chip>`
@@ -269,7 +266,7 @@ input remains a distinct diagnostic, not the mounted pose's zero-angle control.
 You can define custom 3D models for components using the `cadModel` prop:
 
 ```jsx
-<chip
+;<chip
   name="U1"
   footprint="soic8"
   cadModel={{
@@ -284,7 +281,7 @@ You can define custom 3D models for components using the `cadModel` prop:
 For more complex or programmatically defined models, you can use JSCAD:
 
 ```jsx
-<bug
+;<bug
   footprint="soic8"
   name="U1"
   cadModel={{

package/dist/index.js

@@ -233,11 +233,11 @@ var require_constants = __commonJS({
   "node_modules/@jscad/modeling/src/maths/constants.js"(exports, module) {
     "use strict";
     var spatialResolution = 1e5;
-    var EPS3 = 1e-5;
+    var EPS4 = 1e-5;
     var NEPS = 1e-13;
     var TAU = Math.PI * 2;
     module.exports = {
-      EPS: EPS3,
+      EPS: EPS4,
       NEPS,
       TAU,
       spatialResolution
@@ -288,13 +288,13 @@ var require_identity = __commonJS({
 var require_fromRotation = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/fromRotation.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var { sin, cos } = require_trigonometry();
     var identity7 = require_identity();
     var fromRotation6 = (out, rad, axis) => {
       let [x, y, z] = axis;
       const lengthSquared = x * x + y * y + z * z;
-      if (Math.abs(lengthSquared) < EPS3) {
+      if (Math.abs(lengthSquared) < EPS4) {
         return identity7(out);
       }
       const len6 = 1 / Math.sqrt(lengthSquared);
@@ -1221,13 +1221,13 @@ var require_multiply2 = __commonJS({
 var require_rotate = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/rotate.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var { sin, cos } = require_trigonometry();
     var copy10 = require_copy();
     var rotate7 = (out, matrix, radians, axis) => {
       let [x, y, z] = axis;
       const lengthSquared = x * x + y * y + z * z;
-      if (Math.abs(lengthSquared) < EPS3) {
+      if (Math.abs(lengthSquared) < EPS4) {
         return copy10(out, matrix);
       }
       const len6 = 1 / Math.sqrt(lengthSquared);
@@ -3716,19 +3716,19 @@ var require_fromPoints3 = __commonJS({
 var require_fromPointsRandom = __commonJS({
   "node_modules/@jscad/modeling/src/maths/plane/fromPointsRandom.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = 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) < EPS3) {
+      if (vec3.length(ba) < EPS4) {
         ba = vec3.orthogonal(ba, ca);
       }
-      if (vec3.length(ca) < EPS3) {
+      if (vec3.length(ca) < EPS4) {
         ca = vec3.orthogonal(ca, ba);
       }
       let normal = vec3.cross(vec3.create(), ba, ca);
-      if (vec3.length(normal) < EPS3) {
+      if (vec3.length(normal) < EPS4) {
         ca = vec3.orthogonal(ca, ba);
         normal = vec3.cross(normal, ba, ca);
       }
@@ -4411,7 +4411,7 @@ var require_isA3 = __commonJS({
 var require_isConvex2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_isA3();
     var toPolygons = require_toPolygons();
@@ -4442,7 +4442,7 @@ var require_isConvex2 = __commonJS({
         for (let j = 0; j < vertices.length; j++) {
           const v = vertices[j];
           const distance5 = vec3.dot(plane, v) - plane[3];
-          if (distance5 > EPS3) {
+          if (distance5 > EPS4) {
             return false;
           }
         }
@@ -4634,7 +4634,7 @@ var require_clone8 = __commonJS({
 var require_close = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/path2/close.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var vec2 = require_vec2();
     var clone10 = require_clone8();
     var close = (geometry) => {
@@ -4645,7 +4645,7 @@ var require_close = __commonJS({
         const points = cloned.points;
         const p0 = points[0];
         let pn = points[points.length - 1];
-        while (vec2.distance(p0, pn) < EPS3 * EPS3) {
+        while (vec2.distance(p0, pn) < EPS4 * EPS4) {
           points.pop();
           if (points.length === 1) break;
           pn = points[points.length - 1];
@@ -4680,7 +4680,7 @@ var require_create8 = __commonJS({
 var require_fromPoints5 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/path2/fromPoints.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var vec2 = require_vec2();
     var close = require_close();
     var create10 = require_create8();
@@ -4692,7 +4692,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) < EPS3 * EPS3) {
+        if (vec2.distance(p0, pn) < EPS4 * EPS4) {
           closed = true;
         }
       }
@@ -6519,12 +6519,12 @@ var require_fromPlanes = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var { solve2Linear } = require_utils();
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var fromPointAndDirection = require_fromPointAndDirection();
     var fromPlanes = (out, plane1, plane2) => {
       let direction = vec3.cross(vec3.create(), plane1, plane2);
       let length6 = vec3.length(direction);
-      if (length6 < EPS3) {
+      if (length6 < EPS4) {
         throw new Error("parallel planes do not intersect");
       }
       length6 = 1 / length6;
@@ -6863,13 +6863,13 @@ var require_measureAggregateBoundingBox = __commonJS({
 var require_calculateEpsilonFromBounds = __commonJS({
   "node_modules/@jscad/modeling/src/measurements/calculateEpsilonFromBounds.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var calculateEpsilonFromBounds = (bounds, dimensions) => {
       let total = 0;
       for (let i = 0; i < dimensions; i++) {
         total += bounds[1][i] - bounds[0][i];
       }
-      return EPS3 * total / dimensions;
+      return EPS4 * total / dimensions;
     };
     module.exports = calculateEpsilonFromBounds;
   }
@@ -7238,7 +7238,7 @@ var require_commonChecks = __commonJS({
 var require_arc = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/arc.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec2 = require_vec2();
     var path2 = require_path2();
     var { isGT, isGTE, isNumberArray } = require_commonChecks();
@@ -7266,7 +7266,7 @@ var require_arc = __commonJS({
       if (startAngle > endAngle) {
         rotation = endAngle + (TAU - startAngle);
       }
-      const minangle = Math.acos((radius * radius + radius * radius - EPS3 * EPS3) / (2 * radius * radius));
+      const minangle = Math.acos((radius * radius + radius * radius - EPS4 * EPS4) / (2 * radius * radius));
       const centerv = vec2.clone(center);
       let point;
       const pointArray = [];
@@ -7304,7 +7304,7 @@ var require_arc = __commonJS({
 var require_ellipse = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/ellipse.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { sin, cos } = require_trigonometry();
@@ -7335,7 +7335,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 - EPS3 * EPS3) / (2 * minradius * minradius));
+      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS4 * EPS4) / (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);
@@ -7447,7 +7447,7 @@ var require_cube = __commonJS({
 var require_cylinderElliptic = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/cylinderElliptic.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
     var poly3 = require_poly3();
@@ -7484,7 +7484,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 - EPS3 * EPS3) / (2 * minradius * minradius));
+      const minangle = Math.acos((minradius * minradius + minradius * minradius - EPS4 * EPS4) / (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, -(height / 2));
@@ -7933,7 +7933,7 @@ var require_rectangle = __commonJS({
 var require_roundedCuboid = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedCuboid.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec2 = require_vec2();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
@@ -7949,7 +7949,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 > EPS3 ? layerradius : 0;
+      layerradius = layerradius > EPS4 ? 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]);
@@ -8044,7 +8044,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] - EPS3 || roundRadius > size4[1] - EPS3 || roundRadius > size4[2] - EPS3) throw new Error("roundRadius must be smaller than the radius of all dimensions");
+      if (roundRadius > size4[0] - EPS4 || roundRadius > size4[1] - EPS4 || roundRadius > size4[2] - EPS4) throw new Error("roundRadius must be smaller than the radius of all dimensions");
       segments = Math.floor(segments / 4);
       let prevCornersPos = null;
       let prevCornersNeg = null;
@@ -8086,7 +8086,7 @@ var require_roundedCuboid = __commonJS({
 var require_roundedCylinder = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedCylinder.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec3 = require_vec3();
     var geom3 = require_geom3();
     var poly3 = require_poly3();
@@ -8114,7 +8114,7 @@ var require_roundedCylinder = __commonJS({
       const end = [0, 0, height / 2];
       const direction = vec3.subtract(vec3.create(), end, start);
       const length6 = vec3.length(direction);
-      if (2 * roundRadius > length6 - EPS3) throw new Error("height must be larger than twice roundRadius");
+      if (2 * roundRadius > length6 - EPS4) 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);
@@ -8199,7 +8199,7 @@ var require_roundedCylinder = __commonJS({
 var require_roundedRectangle = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/roundedRectangle.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
     var { isGTE, isNumberArray } = require_commonChecks();
@@ -8220,7 +8220,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] - EPS3 || roundRadius > size4[1] - EPS3) throw new Error("roundRadius must be smaller than the radius of all dimensions");
+      if (roundRadius > size4[0] - EPS4 || roundRadius > size4[1] - EPS4) 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]);
@@ -9284,7 +9284,7 @@ var require_repair = __commonJS({
 var require_extrudeWalls = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/extrudeWalls.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var slice = require_slice();
@@ -9324,7 +9324,7 @@ var require_extrudeWalls = __commonJS({
       });
       return newEdges;
     };
-    var EPSAREA = EPS3 * EPS3 / 2 * Math.sin(Math.PI / 3);
+    var EPSAREA = EPS4 * EPS4 / 2 * Math.sin(Math.PI / 3);
     var extrudeWalls = (slice0, slice1) => {
       let edges0 = slice.toEdges(slice0);
       let edges1 = slice.toEdges(slice1);
@@ -10307,7 +10307,7 @@ var require_OrthoNormalBasis = __commonJS({
 var require_reTesselateCoplanarPolygons = __commonJS({
   "node_modules/@jscad/modeling/src/operations/modifiers/reTesselateCoplanarPolygons.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var line2 = require_line2();
     var vec2 = require_vec2();
     var OrthoNormalBasis = require_OrthoNormalBasis();
@@ -10325,7 +10325,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
       const topy2polygonindexes = /* @__PURE__ */ new Map();
       const ycoordinatetopolygonindexes = /* @__PURE__ */ new Map();
       const ycoordinatebins = /* @__PURE__ */ new Map();
-      const ycoordinateBinningFactor = 10 / EPS3;
+      const ycoordinateBinningFactor = 10 / EPS4;
       for (let polygonindex = 0; polygonindex < numpolygons; polygonindex++) {
         const poly3d = sourcepolygons[polygonindex];
         let vertices2d = [];
@@ -10505,7 +10505,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 < EPS3 && d2 < EPS3) {
+            if (d1 < EPS4 && d2 < EPS4) {
               outpolygon.topleft = prevoutpolygon.topleft;
               outpolygon.leftline = prevoutpolygon.leftline;
               outpolygon.bottomleft = prevoutpolygon.bottomleft;
@@ -10522,8 +10522,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) < EPS3) {
-                  if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS3) {
+                if (vec2.distance(prevpolygon.bottomleft, thispolygon.topleft) < EPS4) {
+                  if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS4) {
                     matchedindexes.add(ii);
                     const v1 = line2.direction(thispolygon.leftline);
                     const v2 = line2.direction(prevpolygon.leftline);
@@ -10531,8 +10531,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) < EPS3;
-                    const rightlinecontinues = Math.abs(d2) < EPS3;
+                    const leftlinecontinues = Math.abs(d1) < EPS4;
+                    const rightlinecontinues = Math.abs(d2) < EPS4;
                     const leftlineisconvex = leftlinecontinues || d1 >= 0;
                     const rightlineisconvex = rightlinecontinues || d2 >= 0;
                     if (leftlineisconvex && rightlineisconvex) {
@@ -10551,7 +10551,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) > EPS3) {
+              if (vec2.distance(prevpolygon.bottomright, prevpolygon.bottomleft) > EPS4) {
                 prevpolygon.outpolygon.leftpoints.push(prevpolygon.bottomleft);
               }
               prevpolygon.outpolygon.leftpoints.reverse();
@@ -10570,7 +10570,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
               rightpoints: []
             };
             thispolygon.outpolygon.leftpoints.push(thispolygon.topleft);
-            if (vec2.distance(thispolygon.topleft, thispolygon.topright) > EPS3) {
+            if (vec2.distance(thispolygon.topleft, thispolygon.topright) > EPS4) {
               thispolygon.outpolygon.rightpoints.push(thispolygon.topright);
             }
           } else {
@@ -10671,7 +10671,7 @@ var require_retessellate = __commonJS({
 var require_mayOverlap = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/mayOverlap.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var measureBoundingBox2 = require_measureBoundingBox2();
     var mayOverlap = (geometry1, geometry2) => {
       if (geometry1.polygons.length === 0 || geometry2.polygons.length === 0) {
@@ -10683,12 +10683,12 @@ var require_mayOverlap = __commonJS({
       const bounds2 = measureBoundingBox2(geometry2);
       const min22 = bounds2[0];
       const max22 = bounds2[1];
-      if (min22[0] - max1[0] > EPS3) return false;
-      if (min1[0] - max22[0] > EPS3) return false;
-      if (min22[1] - max1[1] > EPS3) return false;
-      if (min1[1] - max22[1] > EPS3) return false;
-      if (min22[2] - max1[2] > EPS3) return false;
-      if (min1[2] - max22[2] > EPS3) return false;
+      if (min22[0] - max1[0] > EPS4) return false;
+      if (min1[0] - max22[0] > EPS4) return false;
+      if (min22[1] - max1[1] > EPS4) return false;
+      if (min1[1] - max22[1] > EPS4) return false;
+      if (min22[2] - max1[2] > EPS4) return false;
+      if (min1[2] - max22[2] > EPS4) return false;
       return true;
     };
     module.exports = mayOverlap;
@@ -10838,12 +10838,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: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var plane = require_plane();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitLineSegmentByPlane = require_splitLineSegmentByPlane();
-    var EPS_SQUARED = EPS3 * EPS3;
+    var EPS_SQUARED = EPS4 * EPS4;
     var removeConsecutiveDuplicates = (vertices) => {
       const result = [];
       let prevvertex = vertices[vertices.length - 1];
@@ -10871,12 +10871,12 @@ var require_splitPolygonByPlane = __commonJS({
         let hasfront = false;
         let hasback = false;
         const vertexIsBack = [];
-        const MINEPS = -EPS3;
+        const MINEPS = -EPS4;
         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 > EPS3) hasfront = true;
+          if (t > EPS4) hasfront = true;
           if (t < MINEPS) hasback = true;
         }
         if (!hasfront && !hasback) {
@@ -10941,7 +10941,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: EPS3 } = require_constants();
+    var { EPS: EPS4 } = require_constants();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitPolygonByPlane = require_splitPolygonByPlane();
@@ -11044,7 +11044,7 @@ var require_PolygonTreeNode = __commonJS({
         const polygon2 = this.polygon;
         if (polygon2) {
           const bound = poly3.measureBoundingSphere(polygon2);
-          const sphereradius = bound[3] + EPS3;
+          const sphereradius = bound[3] + EPS4;
           const spherecenter = bound;
           const d = vec3.dot(splane, spherecenter) - splane[3];
           if (d > sphereradius) {
@@ -11760,7 +11760,7 @@ var require_booleans = __commonJS({
 var require_offsetFromPoints = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/offsetFromPoints.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var intersect3 = require_intersect();
     var line2 = require_line2();
     var vec2 = require_vec2();
@@ -11773,7 +11773,7 @@ var require_offsetFromPoints = __commonJS({
         segments: 16
       };
       let { delta, corners, closed, segments } = Object.assign({}, defaults, options);
-      if (Math.abs(delta) < EPS3) return points;
+      if (Math.abs(delta) < EPS4) return points;
       let rotation = options.closed ? area2(points) : 1;
       if (rotation === 0) rotation = 1;
       const orientation2 = rotation > 0 && delta >= 0 || rotation < 0 && delta < 0;
@@ -11960,7 +11960,7 @@ var require_extrudePolygon = __commonJS({
 var require_expandShell = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/expandShell.js"(exports, module) {
     "use strict";
-    var { EPS: EPS3, TAU } = require_constants();
+    var { EPS: EPS4, TAU } = require_constants();
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var fnNumberSort = require_fnNumberSort();
@@ -12065,7 +12065,7 @@ var require_expandShell = __commonJS({
           const p2 = vec3.add(vec3.create(), endpoint, v1);
           let skip = false;
           if (i >= 0) {
-            if (vec3.distance(p1, prevp1) < EPS3) {
+            if (vec3.distance(p1, prevp1) < EPS4) {
               skip = true;
             }
           }
@@ -20991,7 +20991,7 @@ import * as THREE27 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.626",
+  version: "0.0.627",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/3d-viewer"
@@ -21046,7 +21046,7 @@ var package_default = {
     "@tscircuit/circuit-json-util": "*"
   },
   devDependencies: {
-    "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.5.tgz",
+    "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.8.tgz",
     "@biomejs/biome": "^2.1.4",
     "@chromatic-com/storybook": "^1.9.0",
     "@jscad/modeling": "^2.12.5",
@@ -28130,30 +28130,265 @@ function signedArea(data, start, end, dim) {
 }
 
 // node_modules/@tscircuit/flex-utils/dist/index.js
+var PcbFoldError = class extends Error {
+  constructor(issue) {
+    super(issue.message);
+    this.issue = issue;
+    this.name = "PcbFoldError";
+  }
+  issue;
+};
 var EPS = 1e-7;
-function createPcbFold(records, thickness) {
+var samePoint = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < EPS;
+function pointInPolygon(point, polygon2, includeBoundary = true) {
+  let inside = false;
+  for (let i = 0; i < polygon2.length; i++) {
+    const a = polygon2[i], b = polygon2[(i + 1) % polygon2.length];
+    const cross4 = (point.x - a.x) * (b.y - a.y) - (point.y - a.y) * (b.x - a.x);
+    if (Math.abs(cross4) < EPS * Math.max(1, Math.hypot(b.x - a.x, b.y - a.y)) && point.x >= Math.min(a.x, b.x) - EPS && point.x <= Math.max(a.x, b.x) + EPS && point.y >= Math.min(a.y, b.y) - EPS && point.y <= Math.max(a.y, b.y) + EPS)
+      return includeBoundary;
+    if (a.y > point.y !== b.y > point.y && point.x < a.x + (b.x - a.x) * (point.y - a.y) / (b.y - a.y))
+      inside = !inside;
+  }
+  return inside;
+}
+function lineCrossings(outline, nx, ny, d) {
+  const crossings = [];
+  for (let edge = 0; edge < outline.length; edge++) {
+    const a = outline[edge], b = outline[(edge + 1) % outline.length];
+    const da = a.x * nx + a.y * ny - d, db = b.x * nx + b.y * ny - d;
+    if (Math.abs(da) < EPS && Math.abs(db) < EPS) continue;
+    if (da > EPS && db > EPS || da < -EPS && db < -EPS) continue;
+    if (Math.abs(da - db) < EPS) continue;
+    const fraction = Math.max(0, Math.min(1, da / (da - db)));
+    const point = {
+      x: a.x + (b.x - a.x) * fraction,
+      y: a.y + (b.y - a.y) * fraction
+    };
+    if (crossings.some((crossing) => samePoint(crossing.point, point))) continue;
+    crossings.push(
+      fraction > 1 - EPS ? { point: b, edge: (edge + 1) % outline.length, fraction: 0 } : { point, edge, fraction }
+    );
+  }
+  return crossings.sort(
+    (a, b) => -ny * a.point.x + nx * a.point.y - (-ny * b.point.x + nx * b.point.y)
+  );
+}
+function movingPolygon(outline, a, b, nx, ny) {
+  const polygon2 = [];
+  for (let edge = 0; edge < outline.length; edge++) {
+    polygon2.push(outline[edge]);
+    for (const crossing of [a, b].filter((c) => c.edge === edge).sort((a2, b2) => a2.fraction - b2.fraction))
+      if (crossing.fraction > EPS) polygon2.push(crossing.point);
+  }
+  const start = polygon2.findIndex((p) => samePoint(p, a.point));
+  const end = polygon2.findIndex((p) => samePoint(p, b.point));
+  if (start < 0 || end < 0)
+    throw new Error("Cannot resolve PCB bend boundary crossings");
+  const path = (from, to) => {
+    const points = [polygon2[from]];
+    while (from !== to) {
+      from = (from + 1) % polygon2.length;
+      points.push(polygon2[from]);
+    }
+    return points;
+  };
+  const area2 = outline.reduce((sum, p, i) => {
+    const next = outline[(i + 1) % outline.length];
+    return sum + p.x * next.y - next.x * p.y;
+  }, 0);
+  const side = Math.sign(area2) * ((b.point.y - a.point.y) * nx - (b.point.x - a.point.x) * ny);
+  return side > 0 ? path(start, end) : path(end, start);
+}
+function getFiniteBendRegion({
+  bendId,
+  outline,
+  nx,
+  ny,
+  center,
+  proximal,
+  axisMin,
+  axisMax
+}) {
+  const finiteCrossings = lineCrossings(outline, nx, ny, center).filter(
+    ({ point }) => {
+      const along = -ny * point.x + nx * point.y;
+      return along >= axisMin - EPS && along <= axisMax + EPS;
+    }
+  );
+  if (finiteCrossings.length !== 2)
+    throw new PcbFoldError({
+      code: "invalid_finite_bend_region",
+      message: "A finite PCB bend must cut one board cross-section from boundary to boundary",
+      bendId
+    });
+  const [a, b] = finiteCrossings;
+  const middle = {
+    x: (a.point.x + b.point.x) / 2,
+    y: (a.point.y + b.point.y) / 2
+  };
+  if (!pointInPolygon(middle, outline, false))
+    throw new PcbFoldError({
+      code: "invalid_finite_bend_region",
+      message: "A finite PCB bend must pass through the board interior",
+      bendId
+    });
+  const centerRegion = movingPolygon(outline, a, b, nx, ny);
+  const alongMiddle = -ny * middle.x + nx * middle.y;
+  const proximalCrossings = lineCrossings(outline, nx, ny, proximal);
+  for (let i = 0; i + 1 < proximalCrossings.length; i++) {
+    const left = proximalCrossings[i], right = proximalCrossings[i + 1];
+    const lo = -ny * left.point.x + nx * left.point.y;
+    const hi = -ny * right.point.x + nx * right.point.y;
+    if (alongMiddle <= lo + EPS || alongMiddle >= hi - EPS) continue;
+    const midpoint2 = {
+      x: (left.point.x + right.point.x) / 2,
+      y: (left.point.y + right.point.y) / 2
+    };
+    if (!pointInPolygon(midpoint2, outline, false)) continue;
+    const region = movingPolygon(outline, left, right, nx, ny);
+    if (region.some((p) => p.x * nx + p.y * ny < proximal - EPS) || centerRegion.some((p) => !pointInPolygon(p, region)) || region.some(
+      (p) => p.x * nx + p.y * ny >= center - EPS && !pointInPolygon(p, centerRegion)
+    ))
+      break;
+    return region;
+  }
+  throw new PcbFoldError({
+    code: "invalid_finite_bend_region",
+    message: "The finite PCB bend zone must remain in one connected board cross-section",
+    bendId
+  });
+}
+function polygonsTouch(a, b) {
+  if (a.some((p) => pointInPolygon(p, b)) || b.some((p) => pointInPolygon(p, a)))
+    return true;
+  const cross4 = (p, q, r) => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
+  for (let i = 0; i < a.length; i++)
+    for (let j = 0; j < b.length; j++) {
+      const p = a[i], q = a[(i + 1) % a.length], r = b[j], s = b[(j + 1) % b.length];
+      if (cross4(p, q, r) * cross4(p, q, s) < -EPS && cross4(r, s, p) * cross4(r, s, q) < -EPS)
+        return true;
+    }
+  return false;
+}
+function polygonContainsPolygon(boundary, polygon2) {
+  if (polygon2.some((p) => !pointInPolygon(p, boundary))) return false;
+  for (let i = 0; i < polygon2.length; i++) {
+    const a = polygon2[i], b = polygon2[(i + 1) % polygon2.length];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared < EPS * EPS) continue;
+    const crossings = [0, 1];
+    for (let j = 0; j < boundary.length; j++) {
+      const c = boundary[j], d = boundary[(j + 1) % boundary.length];
+      const ex = d.x - c.x, ey = d.y - c.y;
+      const denominator = dx * ey - dy * ex;
+      const cx = c.x - a.x, cy = c.y - a.y;
+      if (Math.abs(denominator) < EPS) {
+        if (Math.abs(cx * dy - cy * dx) > EPS) continue;
+        for (const p of [c, d]) {
+          const t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSquared;
+          if (t > 0 && t < 1) crossings.push(t);
+        }
+      } else {
+        const t = (cx * ey - cy * ex) / denominator;
+        const u = (cx * dy - cy * dx) / denominator;
+        if (t > 0 && t < 1 && u >= -EPS && u <= 1 + EPS) crossings.push(t);
+      }
+    }
+    crossings.sort((a2, b2) => a2 - b2);
+    for (let j = 1; j < crossings.length; j++) {
+      const t = (crossings[j - 1] + crossings[j]) / 2;
+      if (!pointInPolygon({ x: a.x + t * dx, y: a.y + t * dy }, boundary))
+        return false;
+    }
+  }
+  return true;
+}
+var EPS2 = 1e-7;
+function orderPcbBends(bends) {
+  const sorted = [...bends].sort(
+    (a, b) => a.start - b.start || a.nx - b.nx || a.ny - b.ny || a.id.localeCompare(b.id)
+  );
+  const parents = /* @__PURE__ */ new Map();
+  const overlap = (bend) => {
+    throw new PcbFoldError({
+      code: "overlapping_bend_zones",
+      message: "Overlapping PCB bend zones or incompatible moving regions are not supported",
+      bendId: bend.id
+    });
+  };
+  for (let i = 0; i < sorted.length; i++)
+    for (let j = i + 1; j < sorted.length; j++) {
+      const a = sorted[i], b = sorted[j];
+      if (a.movingOutline && b.movingOutline) {
+        if (!polygonsTouch(a.movingOutline, b.movingOutline)) continue;
+        const aContainsB = polygonContainsPolygon(
+          a.movingOutline,
+          b.movingOutline
+        );
+        const bContainsA = polygonContainsPolygon(
+          b.movingOutline,
+          a.movingOutline
+        );
+        if (aContainsB === bContainsA) overlap(b);
+        const parent = aContainsB ? a : b, child = aContainsB ? b : a;
+        if (child.movingOutline.some(
+          (p) => p.x * parent.nx + p.y * parent.ny < parent.end - EPS2
+        ))
+          overlap(child);
+        parents.set(child, [...parents.get(child) ?? [], parent]);
+      } else {
+        if (Math.abs(a.nx - b.nx) > EPS2 || Math.abs(a.ny - b.ny) > EPS2)
+          throw new PcbFoldError({
+            code: "nonparallel_bends",
+            message: "Nonparallel PCB bends or bends with opposite moving directions require a board outline to resolve their moving regions"
+          });
+        if (b.start < a.end - EPS2) overlap(b);
+        parents.set(b, [...parents.get(b) ?? [], a]);
+      }
+    }
+  const ordered = [], visited = /* @__PURE__ */ new Set();
+  const visit = (bend) => {
+    if (visited.has(bend)) return;
+    for (const parent of parents.get(bend) ?? []) visit(parent);
+    visited.add(bend);
+    ordered.push(bend);
+  };
+  for (const bend of sorted) visit(bend);
+  return ordered;
+}
+function createPcbFold(records, thickness, { outline } = {}) {
   if (!Number.isFinite(thickness) || thickness < 0)
     throw new Error("Board thickness must be finite and nonnegative");
+  if (outline && (outline.length < 3 || outline.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))))
+    throw new Error(
+      "A finite board outline with at least three points is required"
+    );
   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`
-      );
+      throw new PcbFoldError({
+        code: "invalid_bend_geometry",
+        message: `Invalid PCB bend ${b.pcb_bend_id}: finite geometry and radius greater than half the board thickness are required`,
+        bendId: b.pcb_bend_id
+      });
     }
     const length6 = Math.hypot(end.x - start.x, end.y - start.y);
-    if (length6 < EPS || Math.abs(degrees) > 180)
-      throw new Error(
-        `Unsupported PCB bend ${b.pcb_bend_id}: distinct endpoints and angles within \xB1180 degrees are required`
-      );
+    if (length6 < EPS2 || Math.abs(degrees) > 180)
+      throw new PcbFoldError({
+        code: "unsupported_bend_geometry",
+        message: `Unsupported PCB bend ${b.pcb_bend_id}: distinct endpoints and angles within \xB1180 degrees are required`,
+        bendId: b.pcb_bend_id
+      });
     const sign = b.bend_side === "right" ? 1 : -1;
     const nx = sign * (end.y - start.y) / length6;
     const ny = -sign * (end.x - start.x) / length6;
     const angle3 = degrees * Math.PI / 180;
     const width = radius * Math.abs(angle3);
     const center = start.x * nx + start.y * ny;
-    return {
+    const geometry = {
       id: b.pcb_bend_id,
       nx,
       ny,
@@ -28170,21 +28405,21 @@ function createPcbFold(records, thickness) {
         -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();
+    if (outline && Math.abs(angle3) > EPS2)
+      geometry.movingOutline = getFiniteBendRegion({
+        bendId: b.pcb_bend_id,
+        outline,
+        nx,
+        ny,
+        center,
+        proximal: geometry.start,
+        axisMin: geometry.axisMin,
+        axisMax: geometry.axisMax
+      });
+    return geometry;
+  }).filter((b) => Math.abs(b.angle) > EPS2);
+  const proximalFirst = orderPcbBends(bends);
+  const distalFirst = [...proximalFirst].reverse();
   const transform = ({
     p,
     anchor,
@@ -28192,6 +28427,7 @@ function createPcbFold(records, thickness) {
   }) => {
     let result = { ...p };
     for (const b of distalFirst) {
+      if (b.movingOutline && !pointInPolygon(anchor, b.movingOutline)) continue;
       const width = b.end - b.start;
       const s = anchor.x * b.nx + anchor.y * b.ny - b.start;
       const q = Math.max(0, Math.min(width, s));
@@ -28232,21 +28468,28 @@ function createPcbFold(records, thickness) {
     return { x: dot6(axes2[0]), y: dot6(axes2[1]), z: dot6(axes2[2]) };
   };
   return {
-    bends,
+    bends: proximalFirst,
     inversePoint: (p, anchor) => inverse4({ p, anchor, direction: false }),
     inverseDirection: (p, anchor) => inverse4({ 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}`);
+        const width = b.end - b.start;
+        const progress = points.map(
+          (p) => b.movingOutline && !pointInPolygon(p, b.movingOutline) ? 0 : Math.max(0, Math.min(width, p.x * b.nx + p.y * b.ny - b.start))
+        );
+        if (Math.max(...progress) > EPS2 && Math.min(...progress) < width - EPS2)
+          throw new PcbFoldError({
+            code: "rigid_bend_zone_intersection",
+            message: `${label} intersects PCB bend zone ${b.id}`,
+            bendId: b.id
+          });
       }
     }
   };
 }
-var EPS2 = 1e-7;
+var EPS3 = 1e-7;
 function boundsOfTriangles(triangles) {
   const points = triangles.flatMap((t) => t.vertices);
   if (!points.length)
@@ -28276,7 +28519,7 @@ function foldSurfaceMesh(mesh, fold) {
     d
   }) => {
     const distances = polygon2.map(({ p }) => nx * p.x + ny * p.y - d);
-    if (Math.min(...distances) >= -EPS2 || Math.max(...distances) <= EPS2)
+    if (Math.min(...distances) >= -EPS3 || Math.max(...distances) <= EPS3)
       return [polygon2];
     const halves = [[], []];
     for (let side = 0; side < 2; side++) {
@@ -28284,8 +28527,8 @@ function foldSurfaceMesh(mesh, fold) {
       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) {
+        if (da >= -EPS3) halves[side].push(a);
+        if (da > EPS3 && db < -EPS3 || da < -EPS3 && db > EPS3) {
           const t = da / (da - db);
           halves[side].push({
             p: {
@@ -28321,14 +28564,17 @@ function foldSurfaceMesh(mesh, fold) {
       );
     for (const polygon2 of polygons) {
       for (const b of fold.bends) {
+        if (b.movingOutline) continue;
         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 }) => {
+        if (mid > b.start + EPS3 && mid < b.end - EPS3 && polygon2.some(({ p }) => {
           const along = -b.ny * p.x + b.nx * p.y;
-          return along < b.axisMin - EPS2 || along > b.axisMax + EPS2;
+          return along < b.axisMin - EPS3 || along > b.axisMax + EPS3;
         }))
-          throw new Error(
-            `PCB bend ${b.id} must span the full board cross-section through its bend zone`
-          );
+          throw new PcbFoldError({
+            code: "incomplete_bend_cross_section",
+            message: `PCB bend ${b.id} must span the full board cross-section through its bend zone`,
+            bendId: b.id
+          });
       }
       for (let i = 1; i + 1 < polygon2.length; i++) {
         const verts = [polygon2[0], polygon2[i], polygon2[i + 1]];
@@ -28454,7 +28700,12 @@ function getCadFoldContext(cadComponent, json) {
     (e) => e.type === "pcb_bend" && e.pcb_board_id === board.pcb_board_id
   );
   return {
-    fold: createPcbFold(bends, board.thickness ?? 1.6),
+    fold: createPcbFold(bends, board.thickness ?? 1.6, {
+      outline: board.outline?.map((p) => ({
+        x: p.x - board.center.x,
+        y: p.y - board.center.y
+      }))
+    }),
     boardCenter: board.center,
     flatMount: pcb.center,
     defaultRotation: {
@@ -28551,6 +28802,43 @@ function extrudePolygon({
   }
   return { triangles, boundingBox: boundsOfTriangles(triangles) };
 }
+function foldRigidMesh(mesh, fold, { flatAnchor, label = "Rigid mesh", mount }) {
+  if (mount) fold.assertRigid([mount], `${label} mount`);
+  fold.assertRigid(
+    mesh.triangles.flatMap((t) => t.vertices),
+    label
+  );
+  const triangles = mesh.triangles.map((t) => ({
+    ...t,
+    vertices: t.vertices.map(
+      (p) => fold.point(p, flatAnchor)
+    ),
+    normal: fold.direction(t.normal, flatAnchor)
+  }));
+  return { ...mesh, triangles, boundingBox: boundsOfTriangles(triangles) };
+}
+function getStiffenerOutline(stiffener) {
+  if (stiffener.shape === "polygon") return 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)
+  }));
+}
+function getStiffenerAnchor(outline) {
+  return {
+    x: outline.reduce((s, p) => s + p.x, 0) / outline.length,
+    y: outline.reduce((s, p) => s + p.y, 0) / outline.length,
+    z: 0
+  };
+}
 function createStiffenerMesh({
   stiffener,
   boardThickness,
@@ -28559,20 +28847,7 @@ function createStiffenerMesh({
   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 outline = getStiffenerOutline(stiffener);
   const near = boardThickness / 2 + adhesive, far = near + stiffener.thickness;
   const mesh = extrudePolygon({
     outline,
@@ -28580,21 +28855,10 @@ function createStiffenerMesh({
     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) };
+  return foldRigidMesh(mesh, fold, {
+    flatAnchor: getStiffenerAnchor(outline),
+    label: stiffener.pcb_stiffener_id
+  });
 }
 
 // src/CadViewerManifold.tsx
@@ -29984,14 +30248,60 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson, visibility) => {
 
 // src/utils/flex-meshes.ts
 import * as THREE53 from "three";
-function meshToSurface(mesh, center) {
+function restoreOutlinePrecision(point, outline, tolerance) {
+  let distanceSquared = tolerance * tolerance;
+  let closest;
+  for (let i = 0; i < outline.length; i++) {
+    const a = outline[i];
+    const b = outline[(i + 1) % outline.length];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) continue;
+    const t = Math.max(
+      0,
+      Math.min(
+        1,
+        ((point.x - a.x) * dx + (point.y - a.y) * dy) / lengthSquared
+      )
+    );
+    const x = a.x + t * dx;
+    const y = a.y + t * dy;
+    const distance5 = (x - point.x) ** 2 + (y - point.y) ** 2;
+    if (distance5 <= distanceSquared) {
+      distanceSquared = distance5;
+      closest = { x, y };
+    }
+  }
+  if (closest) point.set(closest.x, closest.y, point.z);
+}
+function meshToSurface(mesh, center, outline) {
   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 THREE53.Vector3().fromBufferAttribute(position, i + j).applyMatrix4(mesh.matrix);
+      const v = new THREE53.Vector3().fromBufferAttribute(position, i + j);
+      const localMagnitude = Math.max(
+        1,
+        Math.abs(v.x),
+        Math.abs(v.y),
+        Math.abs(v.z)
+      );
+      v.applyMatrix4(mesh.matrix);
+      if (outline && position.array instanceof Float32Array) {
+        const m = mesh.matrix.elements;
+        const xyScale = Math.max(
+          Math.abs(m[0]) + Math.abs(m[4]) + Math.abs(m[8]),
+          Math.abs(m[1]) + Math.abs(m[5]) + Math.abs(m[9])
+        );
+        restoreOutlinePrecision(
+          v,
+          outline,
+          localMagnitude * 2 ** -22 * xyScale + Math.max(1, Math.abs(v.x), Math.abs(v.y)) * Number.EPSILON * 4
+        );
+      }
       return { x: v.x - center.x, y: v.y - center.y, z: v.z };
     });
     const [a, b, c] = vertices;
@@ -30048,13 +30358,21 @@ function createFlexMeshes(geometryMeshes, textureMeshes, json, foldPcbs) {
     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 fold = foldPcbs ? createPcbFold(bends, board.thickness ?? 1.6, {
+    outline: board.outline?.map((point) => ({
+      x: point.x - board.center.x,
+      y: point.y - board.center.y
+    }))
+  }) : void 0;
   const body = geometryMeshes.find((m) => m.name === "board-geom");
-  const flatBody = body ? meshToSurface(body, board.center) : void 0;
+  const flatBody = fold && body ? meshToSurface(body, board.center, board.outline) : void 0;
   const geometry = fold ? geometryMeshes.map(
     (mesh) => replaceGeometry(
       mesh,
-      foldSurfaceMesh(meshToSurface(mesh, board.center), fold),
+      foldSurfaceMesh(
+        mesh === body && flatBody ? flatBody : meshToSurface(mesh, board.center, board.outline),
+        fold
+      ),
       board
     )
   ) : [...geometryMeshes];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.627",
+  "version": "0.0.628",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/3d-viewer"
@@ -55,7 +55,7 @@
     "@tscircuit/circuit-json-util": "*"
   },
   "devDependencies": {
-    "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.5.tgz",
+    "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.8.tgz",
     "@biomejs/biome": "^2.1.4",
     "@chromatic-com/storybook": "^1.9.0",
     "@jscad/modeling": "^2.12.5",