@tscircuit/3d-viewer 0.0.611 → 0.0.612

package/dist/index.js

@@ -284,29 +284,29 @@ var require_fromRotation = __commonJS({
     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;
+      let [x, y, z27] = axis;
+      const lengthSquared = x * x + y * y + z27 * z27;
       if (Math.abs(lengthSquared) < EPS3) {
         return identity(out);
       }
       const len = 1 / Math.sqrt(lengthSquared);
       x *= len;
       y *= len;
-      z42 *= len;
+      z27 *= len;
       const s = sin(rad);
       const c = cos(rad);
       const t = 1 - c;
       out[0] = x * x * t + c;
-      out[1] = y * x * t + z42 * s;
-      out[2] = z42 * x * t - y * s;
+      out[1] = y * x * t + z27 * s;
+      out[2] = z27 * x * t - y * s;
       out[3] = 0;
-      out[4] = x * y * t - z42 * s;
+      out[4] = x * y * t - z27 * s;
       out[5] = y * y * t + c;
-      out[6] = z42 * y * t + x * s;
+      out[6] = z27 * y * t + x * s;
       out[7] = 0;
-      out[8] = x * z42 * t + y * s;
-      out[9] = y * z42 * t - x * s;
-      out[10] = z42 * z42 * t + c;
+      out[8] = x * z27 * t + y * s;
+      out[9] = y * z27 * t - x * s;
+      out[10] = z27 * z27 * t + c;
       out[11] = 0;
       out[12] = 0;
       out[13] = 0;
@@ -560,8 +560,8 @@ var require_distance = __commonJS({
     var distance6 = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
-      const z42 = b[2] - a[2];
-      return Math.sqrt(x * x + y * y + z42 * z42);
+      const z27 = b[2] - a[2];
+      return Math.sqrt(x * x + y * y + z27 * z27);
     };
     module.exports = distance6;
   }
@@ -609,11 +609,11 @@ var require_fromValues2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/fromValues.js"(exports, module) {
     "use strict";
     var create = require_create2();
-    var fromValues = (x, y, z42) => {
+    var fromValues = (x, y, z27) => {
       const out = create();
       out[0] = x;
       out[1] = y;
-      out[2] = z42;
+      out[2] = z27;
       return out;
     };
     module.exports = fromValues;
@@ -624,10 +624,10 @@ var require_fromValues2 = __commonJS({
 var require_fromVec2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/fromVec2.js"(exports, module) {
     "use strict";
-    var fromVector2 = (out, vector, z42 = 0) => {
+    var fromVector2 = (out, vector, z27 = 0) => {
       out[0] = vector[0];
       out[1] = vector[1];
-      out[2] = z42;
+      out[2] = z27;
       return out;
     };
     module.exports = fromVector2;
@@ -641,8 +641,8 @@ var require_length = __commonJS({
     var length83 = (vector) => {
       const x = vector[0];
       const y = vector[1];
-      const z42 = vector[2];
-      return Math.sqrt(x * x + y * y + z42 * z42);
+      const z27 = vector[2];
+      return Math.sqrt(x * x + y * y + z27 * z27);
     };
     module.exports = length83;
   }
@@ -725,14 +725,14 @@ var require_normalize = __commonJS({
     var normalize = (out, vector) => {
       const x = vector[0];
       const y = vector[1];
-      const z42 = vector[2];
-      let len = x * x + y * y + z42 * z42;
+      const z27 = vector[2];
+      let len = x * x + y * y + z27 * z27;
       if (len > 0) {
         len = 1 / Math.sqrt(len);
       }
       out[0] = x * len;
       out[1] = y * len;
-      out[2] = z42 * len;
+      out[2] = z27 * len;
       return out;
     };
     module.exports = normalize;
@@ -856,8 +856,8 @@ var require_squaredDistance = __commonJS({
     var squaredDistance = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
-      const z42 = b[2] - a[2];
-      return x * x + y * y + z42 * z42;
+      const z27 = b[2] - a[2];
+      return x * x + y * y + z27 * z27;
     };
     module.exports = squaredDistance;
   }
@@ -870,8 +870,8 @@ var require_squaredLength = __commonJS({
     var squaredLength = (vector) => {
       const x = vector[0];
       const y = vector[1];
-      const z42 = vector[2];
-      return x * x + y * y + z42 * z42;
+      const z27 = vector[2];
+      return x * x + y * y + z27 * z27;
     };
     module.exports = squaredLength;
   }
@@ -907,12 +907,12 @@ var require_transform = __commonJS({
     var transform = (out, vector, matrix) => {
       const x = vector[0];
       const y = vector[1];
-      const z42 = vector[2];
-      let w = matrix[3] * x + matrix[7] * y + matrix[11] * z42 + matrix[15];
+      const z27 = vector[2];
+      let w = matrix[3] * x + matrix[7] * y + matrix[11] * z27 + matrix[15];
       w = w || 1;
-      out[0] = (matrix[0] * x + matrix[4] * y + matrix[8] * z42 + matrix[12]) / w;
-      out[1] = (matrix[1] * x + matrix[5] * y + matrix[9] * z42 + matrix[13]) / w;
-      out[2] = (matrix[2] * x + matrix[6] * y + matrix[10] * z42 + matrix[14]) / w;
+      out[0] = (matrix[0] * x + matrix[4] * y + matrix[8] * z27 + matrix[12]) / w;
+      out[1] = (matrix[1] * x + matrix[5] * y + matrix[9] * z27 + matrix[13]) / w;
+      out[2] = (matrix[2] * x + matrix[6] * y + matrix[10] * z27 + matrix[14]) / w;
       return out;
     };
     module.exports = transform;
@@ -1114,8 +1114,8 @@ var require_isMirroring = __commonJS({
     var isMirroring = (matrix) => {
       const x = matrix[4] * matrix[9] - matrix[8] * matrix[5];
       const y = matrix[8] * matrix[1] - matrix[0] * matrix[9];
-      const z42 = matrix[0] * matrix[5] - matrix[4] * matrix[1];
-      const d = x * matrix[2] + y * matrix[6] + z42 * matrix[10];
+      const z27 = matrix[0] * matrix[5] - matrix[4] * matrix[1];
+      const d = x * matrix[2] + y * matrix[6] + z27 * matrix[10];
       return d < 0;
     };
     module.exports = isMirroring;
@@ -1217,15 +1217,15 @@ var require_rotate = __commonJS({
     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;
+      let [x, y, z27] = axis;
+      const lengthSquared = x * x + y * y + z27 * z27;
       if (Math.abs(lengthSquared) < EPS3) {
         return copy(out, matrix);
       }
       const len = 1 / Math.sqrt(lengthSquared);
       x *= len;
       y *= len;
-      z42 *= len;
+      z27 *= len;
       const s = sin(radians);
       const c = cos(radians);
       const t = 1 - c;
@@ -1242,14 +1242,14 @@ var require_rotate = __commonJS({
       const a22 = matrix[10];
       const a23 = matrix[11];
       const b00 = x * x * t + c;
-      const b01 = y * x * t + z42 * s;
-      const b02 = z42 * x * t - y * s;
-      const b10 = x * y * t - z42 * s;
+      const b01 = y * x * t + z27 * s;
+      const b02 = z27 * x * t - y * s;
+      const b10 = x * y * t - z27 * s;
       const b11 = y * y * t + c;
-      const b12 = z42 * y * t + x * s;
-      const b20 = x * z42 * t + y * s;
-      const b21 = y * z42 * t - x * s;
-      const b22 = z42 * z42 * t + c;
+      const b12 = z27 * y * t + x * s;
+      const b20 = x * z27 * t + y * s;
+      const b21 = y * z27 * t - x * s;
+      const b22 = z27 * z27 * t + c;
       out[0] = a00 * b00 + a10 * b01 + a20 * b02;
       out[1] = a01 * b00 + a11 * b01 + a21 * b02;
       out[2] = a02 * b00 + a12 * b01 + a22 * b02;
@@ -1401,7 +1401,7 @@ var require_scale2 = __commonJS({
     var scale2 = (out, matrix, dimensions) => {
       const x = dimensions[0];
       const y = dimensions[1];
-      const z42 = dimensions[2];
+      const z27 = dimensions[2];
       out[0] = matrix[0] * x;
       out[1] = matrix[1] * x;
       out[2] = matrix[2] * x;
@@ -1410,10 +1410,10 @@ var require_scale2 = __commonJS({
       out[5] = matrix[5] * y;
       out[6] = matrix[6] * y;
       out[7] = matrix[7] * y;
-      out[8] = matrix[8] * z42;
-      out[9] = matrix[9] * z42;
-      out[10] = matrix[10] * z42;
-      out[11] = matrix[11] * z42;
+      out[8] = matrix[8] * z27;
+      out[9] = matrix[9] * z27;
+      out[10] = matrix[10] * z27;
+      out[11] = matrix[11] * z27;
       out[12] = matrix[12];
       out[13] = matrix[13];
       out[14] = matrix[14];
@@ -1467,7 +1467,7 @@ var require_translate = __commonJS({
     var translate6 = (out, matrix, offsets) => {
       const x = offsets[0];
       const y = offsets[1];
-      const z42 = offsets[2];
+      const z27 = offsets[2];
       let a00;
       let a01;
       let a02;
@@ -1481,10 +1481,10 @@ var require_translate = __commonJS({
       let a22;
       let a23;
       if (matrix === out) {
-        out[12] = matrix[0] * x + matrix[4] * y + matrix[8] * z42 + matrix[12];
-        out[13] = matrix[1] * x + matrix[5] * y + matrix[9] * z42 + matrix[13];
-        out[14] = matrix[2] * x + matrix[6] * y + matrix[10] * z42 + matrix[14];
-        out[15] = matrix[3] * x + matrix[7] * y + matrix[11] * z42 + matrix[15];
+        out[12] = matrix[0] * x + matrix[4] * y + matrix[8] * z27 + matrix[12];
+        out[13] = matrix[1] * x + matrix[5] * y + matrix[9] * z27 + matrix[13];
+        out[14] = matrix[2] * x + matrix[6] * y + matrix[10] * z27 + matrix[14];
+        out[15] = matrix[3] * x + matrix[7] * y + matrix[11] * z27 + matrix[15];
       } else {
         a00 = matrix[0];
         a01 = matrix[1];
@@ -1510,10 +1510,10 @@ var require_translate = __commonJS({
         out[9] = a21;
         out[10] = a22;
         out[11] = a23;
-        out[12] = a00 * x + a10 * y + a20 * z42 + matrix[12];
-        out[13] = a01 * x + a11 * y + a21 * z42 + matrix[13];
-        out[14] = a02 * x + a12 * y + a22 * z42 + matrix[14];
-        out[15] = a03 * x + a13 * y + a23 * z42 + matrix[15];
+        out[12] = a00 * x + a10 * y + a20 * z27 + matrix[12];
+        out[13] = a01 * x + a11 * y + a21 * z27 + matrix[13];
+        out[14] = a02 * x + a12 * y + a22 * z27 + matrix[14];
+        out[15] = a03 * x + a13 * y + a23 * z27 + matrix[15];
       }
       return out;
     };
@@ -2351,7 +2351,7 @@ var require_validate = __commonJS({
     var vec2 = require_vec2();
     var isA = require_isA();
     var toOutlines = require_toOutlines();
-    var validate = (object) => {
+    var validate2 = (object) => {
       if (!isA(object)) {
         throw new Error("invalid geom2 structure");
       }
@@ -2365,7 +2365,7 @@ var require_validate = __commonJS({
         throw new Error(`geom2 invalid transforms ${object.transforms}`);
       }
     };
-    module.exports = validate;
+    module.exports = validate2;
   }
 });
 
@@ -2616,9 +2616,9 @@ var require_HalfEdge = __commonJS({
     var distance6 = require_distance();
     var squaredDistance = require_squaredDistance();
     var HalfEdge = class {
-      constructor(vertex, face) {
+      constructor(vertex, face2) {
         this.vertex = vertex;
-        this.face = face;
+        this.face = face2;
         this.next = null;
         this.prev = null;
         this.opposite = null;
@@ -2844,16 +2844,16 @@ var require_Face = __commonJS({
         return indices;
       }
       static createTriangle(v0, v1, v2, minArea = 0) {
-        const face = new _Face();
-        const e0 = new HalfEdge(v0, face);
-        const e1 = new HalfEdge(v1, face);
-        const e2 = new HalfEdge(v2, face);
+        const face2 = new _Face();
+        const e0 = new HalfEdge(v0, face2);
+        const e1 = new HalfEdge(v1, face2);
+        const e2 = new HalfEdge(v2, face2);
         e0.next = e2.prev = e1;
         e1.next = e0.prev = e2;
         e2.next = e1.prev = e0;
-        face.edge = e0;
-        face.computeNormalAndCentroid(minArea);
-        return face;
+        face2.edge = e0;
+        face2.computeNormalAndCentroid(minArea);
+        return face2;
       }
     };
     module.exports = {
@@ -2899,14 +2899,14 @@ var require_QuickHull = __commonJS({
         this.discardedFaces = [];
         this.vertexPointIndices = [];
       }
-      addVertexToFace(vertex, face) {
-        vertex.face = face;
-        if (!face.outside) {
+      addVertexToFace(vertex, face2) {
+        vertex.face = face2;
+        if (!face2.outside) {
           this.claimed.add(vertex);
         } else {
-          this.claimed.insertBefore(face.outside, vertex);
+          this.claimed.insertBefore(face2.outside, vertex);
         }
-        face.outside = vertex;
+        face2.outside = vertex;
       }
       /**
        * Removes `vertex` for the `claimed` list of vertices, it also makes sure
@@ -2916,12 +2916,12 @@ var require_QuickHull = __commonJS({
        * @param {Vertex} vertex
        * @param {Face} face
        */
-      removeVertexFromFace(vertex, face) {
-        if (vertex === face.outside) {
-          if (vertex.next && vertex.next.face === face) {
-            face.outside = vertex.next;
+      removeVertexFromFace(vertex, face2) {
+        if (vertex === face2.outside) {
+          if (vertex.next && vertex.next.face === face2) {
+            face2.outside = vertex.next;
           } else {
-            face.outside = null;
+            face2.outside = null;
           }
         }
         this.claimed.remove(vertex);
@@ -2934,15 +2934,15 @@ var require_QuickHull = __commonJS({
        * @return {Vertex|undefined} If face had visible vertices returns
        * `face.outside`, otherwise undefined
        */
-      removeAllVerticesFromFace(face) {
-        if (face.outside) {
-          let end = face.outside;
-          while (end.next && end.next.face === face) {
+      removeAllVerticesFromFace(face2) {
+        if (face2.outside) {
+          let end = face2.outside;
+          while (end.next && end.next.face === face2) {
             end = end.next;
           }
-          this.claimed.removeChain(face.outside, end);
+          this.claimed.removeChain(face2.outside, end);
           end.next = null;
-          return face.outside;
+          return face2.outside;
         }
       }
       /**
@@ -2959,8 +2959,8 @@ var require_QuickHull = __commonJS({
        * @param {Face} face
        * @param {Face} [absorbingFace]
        */
-      deleteFaceVertices(face, absorbingFace) {
-        const faceVertices = this.removeAllVerticesFromFace(face);
+      deleteFaceVertices(face2, absorbingFace) {
+        const faceVertices = this.removeAllVerticesFromFace(face2);
         if (faceVertices) {
           if (!absorbingFace) {
             this.unclaimed.addAll(faceVertices);
@@ -2991,12 +2991,12 @@ var require_QuickHull = __commonJS({
           let maxDistance = this.tolerance;
           let maxFace;
           for (let i = 0; i < newFaces.length; i += 1) {
-            const face = newFaces[i];
-            if (face.mark === VISIBLE) {
-              const dist = face.distanceToPlane(vertex.point);
+            const face2 = newFaces[i];
+            if (face2.mark === VISIBLE) {
+              const dist = face2.distanceToPlane(vertex.point);
               if (dist > maxDistance) {
                 maxDistance = dist;
-                maxFace = face;
+                maxFace = face2;
               }
               if (maxDistance > 1e3 * this.tolerance) {
                 break;
@@ -3142,9 +3142,9 @@ var require_QuickHull = __commonJS({
       reindexFaceAndVertices() {
         const activeFaces = [];
         for (let i = 0; i < this.faces.length; i += 1) {
-          const face = this.faces[i];
-          if (face.mark === VISIBLE) {
-            activeFaces.push(face);
+          const face2 = this.faces[i];
+          if (face2.mark === VISIBLE) {
+            activeFaces.push(face2);
           }
         }
         this.faces = activeFaces;
@@ -3205,12 +3205,12 @@ var require_QuickHull = __commonJS({
        * @param {HalfEdge[]} horizon - The edges that form part of the horizon in
        * ccw order
        */
-      computeHorizon(eyePoint, crossEdge, face, horizon) {
-        this.deleteFaceVertices(face);
-        face.mark = DELETED;
+      computeHorizon(eyePoint, crossEdge, face2, horizon) {
+        this.deleteFaceVertices(face2);
+        face2.mark = DELETED;
         let edge;
         if (!crossEdge) {
-          edge = crossEdge = face.getEdge(0);
+          edge = crossEdge = face2.getEdge(0);
         } else {
           edge = crossEdge.next;
         }
@@ -3236,14 +3236,14 @@ var require_QuickHull = __commonJS({
        * @return {HalfEdge} The half edge whose vertex is the eyeVertex
        */
       addAdjoiningFace(eyeVertex, horizonEdge) {
-        const face = Face.createTriangle(
+        const face2 = Face.createTriangle(
           eyeVertex,
           horizonEdge.tail(),
           horizonEdge.head()
         );
-        this.faces.push(face);
-        face.getEdge(-1).setOpposite(horizonEdge.opposite);
-        return face.getEdge(0);
+        this.faces.push(face2);
+        face2.getEdge(-1).setOpposite(horizonEdge.opposite);
+        return face2.getEdge(0);
       }
       /**
        * Adds horizon.length faces to the hull, each face will be 'linked' with the
@@ -3318,12 +3318,12 @@ var require_QuickHull = __commonJS({
        * @param {number} mergeType - Either MERGE_NON_CONVEX_WRT_LARGER_FACE or
        * MERGE_NON_CONVEX
        */
-      doAdjacentMerge(face, mergeType) {
-        let edge = face.edge;
+      doAdjacentMerge(face2, mergeType) {
+        let edge = face2.edge;
         let convex = true;
         let it = 0;
         do {
-          if (it >= face.nVertices) {
+          if (it >= face2.nVertices) {
             throw Error("merge recursion limit exceeded");
           }
           const oppositeFace = edge.opposite.face;
@@ -3333,7 +3333,7 @@ var require_QuickHull = __commonJS({
               merge = true;
             }
           } else {
-            if (face.area > oppositeFace.area) {
+            if (face2.area > oppositeFace.area) {
               if (this.oppositeFaceDistance(edge) > -this.tolerance) {
                 merge = true;
               } else if (this.oppositeFaceDistance(edge.opposite) > -this.tolerance) {
@@ -3348,17 +3348,17 @@ var require_QuickHull = __commonJS({
             }
           }
           if (merge) {
-            const discardedFaces = face.mergeAdjacentFaces(edge, []);
+            const discardedFaces = face2.mergeAdjacentFaces(edge, []);
             for (let i = 0; i < discardedFaces.length; i += 1) {
-              this.deleteFaceVertices(discardedFaces[i], face);
+              this.deleteFaceVertices(discardedFaces[i], face2);
             }
             return true;
           }
           edge = edge.next;
           it += 1;
-        } while (edge !== face.edge);
+        } while (edge !== face2.edge);
         if (!convex) {
-          face.mark = NON_CONVEX;
+          face2.mark = NON_CONVEX;
         }
         return false;
       }
@@ -3387,17 +3387,17 @@ var require_QuickHull = __commonJS({
         this.computeHorizon(eyeVertex.point, null, eyeVertex.face, horizon);
         this.addNewFaces(eyeVertex, horizon);
         for (let i = 0; i < this.newFaces.length; i += 1) {
-          const face = this.newFaces[i];
-          if (face.mark === VISIBLE) {
-            while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {
+          const face2 = this.newFaces[i];
+          if (face2.mark === VISIBLE) {
+            while (this.doAdjacentMerge(face2, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {
             }
           }
         }
         for (let i = 0; i < this.newFaces.length; i += 1) {
-          const face = this.newFaces[i];
-          if (face.mark === NON_CONVEX) {
-            face.mark = VISIBLE;
-            while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {
+          const face2 = this.newFaces[i];
+          if (face2.mark === NON_CONVEX) {
+            face2.mark = VISIBLE;
+            while (this.doAdjacentMerge(face2, MERGE_NON_CONVEX)) {
             }
           }
         }
@@ -3583,11 +3583,11 @@ var require_fromValues4 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec4/fromValues.js"(exports, module) {
     "use strict";
     var create = require_create7();
-    var fromValues = (x, y, z42, w) => {
+    var fromValues = (x, y, z27, w) => {
       const out = create();
       out[0] = x;
       out[1] = y;
-      out[2] = z42;
+      out[2] = z27;
       out[3] = w;
       return out;
     };
@@ -3745,8 +3745,8 @@ var require_projectionOfPoint = __commonJS({
       const a = point[0] * plane[0] + point[1] * plane[1] + point[2] * plane[2] - plane[3];
       const x = point[0] - a * plane[0];
       const y = point[1] - a * plane[1];
-      const z42 = point[2] - a * plane[2];
-      return vec3.fromValues(x, y, z42);
+      const z27 = point[2] - a * plane[2];
+      return vec3.fromValues(x, y, z27);
     };
     module.exports = projectionOfPoint;
   }
@@ -4050,11 +4050,11 @@ var require_transform5 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec4/transform.js"(exports, module) {
     "use strict";
     var transform = (out, vector, matrix) => {
-      const [x, y, z42, w] = vector;
-      out[0] = matrix[0] * x + matrix[4] * y + matrix[8] * z42 + matrix[12] * w;
-      out[1] = matrix[1] * x + matrix[5] * y + matrix[9] * z42 + matrix[13] * w;
-      out[2] = matrix[2] * x + matrix[6] * y + matrix[10] * z42 + matrix[14] * w;
-      out[3] = matrix[3] * x + matrix[7] * y + matrix[11] * z42 + matrix[15] * w;
+      const [x, y, z27, w] = vector;
+      out[0] = matrix[0] * x + matrix[4] * y + matrix[8] * z27 + matrix[12] * w;
+      out[1] = matrix[1] * x + matrix[5] * y + matrix[9] * z27 + matrix[13] * w;
+      out[2] = matrix[2] * x + matrix[6] * y + matrix[10] * z27 + matrix[14] * w;
+      out[3] = matrix[3] * x + matrix[7] * y + matrix[11] * z27 + matrix[15] * w;
       return out;
     };
     module.exports = transform;
@@ -4116,8 +4116,8 @@ var require_measureBoundingSphere = __commonJS({
       out[2] = (minz[2] + maxz[2]) * 0.5;
       const x = out[0] - maxx[0];
       const y = out[1] - maxy[1];
-      const z42 = out[2] - maxz[2];
-      out[3] = Math.sqrt(x * x + y * y + z42 * z42);
+      const z27 = out[2] - maxz[2];
+      out[3] = Math.sqrt(x * x + y * y + z27 * z27);
       cache.set(polygon2, out);
       return out;
     };
@@ -4200,7 +4200,7 @@ var require_validate2 = __commonJS({
     var isConvex = require_isConvex();
     var measureArea = require_measureArea();
     var plane = require_plane2();
-    var validate = (object) => {
+    var validate2 = (object) => {
       if (!isA(object)) {
         throw new Error("invalid poly3 structure");
       }
@@ -4233,7 +4233,7 @@ var require_validate2 = __commonJS({
         });
       }
     };
-    module.exports = validate;
+    module.exports = validate2;
   }
 });
 
@@ -4274,8 +4274,8 @@ var require_fromPointsConvex = __commonJS({
         throw new Error("the given points must be an array");
       }
       const faces = quickhull(uniquePoints, { skipTriangulation: true });
-      const polygons = faces.map((face) => {
-        const vertices = face.map((index2) => uniquePoints[index2]);
+      const polygons = faces.map((face2) => {
+        const vertices = face2.map((index2) => uniquePoints[index2]);
         return poly3.create(vertices);
       });
       return create(polygons);
@@ -4552,7 +4552,7 @@ var require_validate3 = __commonJS({
     "use strict";
     var poly3 = require_poly3();
     var isA = require_isA3();
-    var validate = (object) => {
+    var validate2 = (object) => {
       if (!isA(object)) {
         throw new Error("invalid geom3 structure");
       }
@@ -4586,7 +4586,7 @@ var require_validate3 = __commonJS({
 ${nonManifold.join("\n")}`);
       }
     };
-    module.exports = validate;
+    module.exports = validate2;
   }
 });
 
@@ -5146,7 +5146,7 @@ var require_validate4 = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var isA = require_isA4();
-    var validate = (object) => {
+    var validate2 = (object) => {
       if (!isA(object)) {
         throw new Error("invalid path2 structure");
       }
@@ -5166,7 +5166,7 @@ var require_validate4 = __commonJS({
         throw new Error(`path2 invalid transforms ${object.transforms}`);
       }
     };
-    module.exports = validate;
+    module.exports = validate2;
   }
 });
 
@@ -5816,17 +5816,17 @@ var require_lengths = __commonJS({
   "node_modules/@jscad/modeling/src/curves/bezier/lengths.js"(exports, module) {
     "use strict";
     var valueAt = require_valueAt();
-    var lengths = (segments, bezier) => {
+    var lengths3 = (segments, bezier) => {
       let sum = 0;
-      const lengths2 = [0];
+      const lengths4 = [0];
       let previous = valueAt(0, bezier);
       for (let index2 = 1; index2 <= segments; index2++) {
         const current = valueAt(index2 / segments, bezier);
         sum += distanceBetween(current, previous);
-        lengths2.push(sum);
+        lengths4.push(sum);
         previous = current;
       }
-      return lengths2;
+      return lengths4;
     };
     var distanceBetween = (a, b) => {
       if (Number.isFinite(a) && Number.isFinite(b)) {
@@ -5844,7 +5844,7 @@ var require_lengths = __commonJS({
         throw new Error("The operands must be of the same type, either number or array.");
       }
     };
-    module.exports = lengths;
+    module.exports = lengths3;
   }
 });
 
@@ -5852,8 +5852,8 @@ var require_lengths = __commonJS({
 var require_length3 = __commonJS({
   "node_modules/@jscad/modeling/src/curves/bezier/length.js"(exports, module) {
     "use strict";
-    var lengths = require_lengths();
-    var length83 = (segments, bezier) => lengths(segments, bezier)[segments];
+    var lengths3 = require_lengths();
+    var length83 = (segments, bezier) => lengths3(segments, bezier)[segments];
     module.exports = length83;
   }
 });
@@ -5862,14 +5862,14 @@ var require_length3 = __commonJS({
 var require_arcLengthToT = __commonJS({
   "node_modules/@jscad/modeling/src/curves/bezier/arcLengthToT.js"(exports, module) {
     "use strict";
-    var lengths = require_lengths();
+    var lengths3 = require_lengths();
     var arcLengthToT = (options, bezier) => {
       const defaults2 = {
         distance: 0,
         segments: 100
       };
       const { distance: distance6, segments } = Object.assign({}, defaults2, options);
-      const arcLengths = lengths(segments, bezier);
+      const arcLengths = lengths3(segments, bezier);
       let startIndex = 0;
       let endIndex = segments;
       while (startIndex <= endIndex) {
@@ -7354,7 +7354,7 @@ var require_circle = __commonJS({
     var { TAU } = require_constants();
     var ellipse3 = require_ellipse();
     var { isGTE } = require_commonChecks();
-    var circle = (options) => {
+    var circle2 = (options) => {
       const defaults2 = {
         center: [0, 0],
         radius: 1,
@@ -7367,7 +7367,7 @@ var require_circle = __commonJS({
       radius = [radius, radius];
       return ellipse3({ center, radius, startAngle, endAngle, segments });
     };
-    module.exports = circle;
+    module.exports = circle2;
   }
 });
 
@@ -7682,15 +7682,15 @@ var require_polyhedron = __commonJS({
       points.forEach((point, i) => {
         if (!isNumberArray(point, 3)) throw new Error(`point ${i} must be an array of X, Y, Z values`);
       });
-      faces.forEach((face, i) => {
-        if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`);
-        if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`);
+      faces.forEach((face2, i) => {
+        if (face2.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`);
+        if (!isNumberArray(face2, face2.length)) throw new Error(`face ${i} must be an array of numbers`);
       });
       if (orientation2 !== "outward") {
-        faces.forEach((face) => face.reverse());
+        faces.forEach((face2) => face2.reverse());
       }
-      const polygons = faces.map((face, findex) => {
-        const polygon2 = poly3.create(face.map((pindex) => points[pindex]));
+      const polygons = faces.map((face2, findex) => {
+        const polygon2 = poly3.create(face2.map((pindex) => points[pindex]));
         if (colors2 && colors2[findex]) polygon2.color = colors2[findex];
         return polygon2;
       });
@@ -9594,7 +9594,7 @@ var require_torus = __commonJS({
     var extrudeRotate = require_extrudeRotate();
     var { rotate: rotate2 } = require_rotate3();
     var { translate: translate6 } = require_translate2();
-    var circle = require_circle();
+    var circle2 = require_circle();
     var { isGT, isGTE } = require_commonChecks();
     var torus = (options) => {
       const defaults2 = {
@@ -9614,7 +9614,7 @@ var require_torus = __commonJS({
       if (!isGTE(startAngle, 0)) throw new Error("startAngle must be positive");
       if (!isGT(outerRotation, 0)) throw new Error("outerRotation must be greater than zero");
       if (innerRadius >= outerRadius) throw new Error("inner circle is too large to rotate about the outer circle");
-      let innerCircle = circle({ radius: innerRadius, segments: innerSegments });
+      let innerCircle = circle2({ radius: innerRadius, segments: innerSegments });
       if (innerRotation !== 0) {
         innerCircle = rotate2([0, 0, innerRotation], innerCircle);
       }
@@ -9694,10 +9694,10 @@ var require_triangle2 = __commonJS({
       const b = c / Math.sin(C) * Math.sin(B);
       return createTriangle(A, B, C, a, b, c);
     };
-    var solveSSS = (lengths) => {
-      const a = lengths[1];
-      const b = lengths[2];
-      const c = lengths[0];
+    var solveSSS = (lengths3) => {
+      const a = lengths3[1];
+      const b = lengths3[2];
+      const c = lengths3[0];
       if (a + b <= c || b + c <= a || c + a <= b) {
         throw new Error("SSS triangle is incorrect, as the longest side is longer than the sum of the other sides");
       }
@@ -10056,11 +10056,11 @@ var require_areAllShapesTheSameType = __commonJS({
     var path2 = require_path2();
     var areAllShapesTheSameType = (shapes) => {
       let previousType;
-      for (const shape of shapes) {
+      for (const shape2 of shapes) {
         let currentType = 0;
-        if (geom2.isA(shape)) currentType = 1;
-        if (geom3.isA(shape)) currentType = 2;
-        if (path2.isA(shape)) currentType = 3;
+        if (geom2.isA(shape2)) currentType = 1;
+        if (geom3.isA(shape2)) currentType = 2;
+        if (path2.isA(shape2)) currentType = 3;
         if (previousType && currentType !== previousType) return false;
         previousType = currentType;
       }
@@ -11309,8 +11309,8 @@ var require_hullPoints3 = __commonJS({
     var quickhull = require_quickhull();
     var hullPoints3 = (uniquePoints) => {
       const faces = quickhull(uniquePoints, { skipTriangulation: true });
-      const polygons = faces.map((face) => {
-        const vertices = face.map((index2) => uniquePoints[index2]);
+      const polygons = faces.map((face2) => {
+        const vertices = face2.map((index2) => uniquePoints[index2]);
         return poly3.create(vertices);
       });
       return polygons;
@@ -13770,10 +13770,10 @@ var require_dist = __commonJS({
         })
       },
       colors: {
-        colorize: (color, shape) => ({
+        colorize: (color, shape2) => ({
           type: "colorize",
           color,
-          shape
+          shape: shape2
         })
       },
       primitives: {
@@ -13803,32 +13803,32 @@ var require_dist = __commonJS({
         })
       },
       transforms: {
-        rotate: (angles, shape) => ({
+        rotate: (angles, shape2) => ({
           type: "rotate",
           angles,
-          shape
+          shape: shape2
         }),
-        scale: (factors, shape) => ({
+        scale: (factors, shape2) => ({
           type: "scale",
           factors,
-          shape
+          shape: shape2
         }),
-        translate: (vector, shape) => ({
+        translate: (vector, shape2) => ({
           type: "translate",
           vector,
-          shape
+          shape: shape2
         })
       },
       extrusions: {
-        extrudeLinear: (options, shape) => ({
+        extrudeLinear: (options, shape2) => ({
           type: "extrudeLinear",
           options,
-          shape
+          shape: shape2
         }),
-        extrudeRotate: (options, shape) => ({
+        extrudeRotate: (options, shape2) => ({
           type: "extrudeRotate",
           options,
-          shape
+          shape: shape2
         })
       },
       maths: {
@@ -13837,8 +13837,8 @@ var require_dist = __commonJS({
           fromValues: (x, y) => [x, y]
         },
         vec3: {
-          create: (x, y, z42) => [x, y, z42],
-          fromValues: (x, y, z42) => [x, y, z42]
+          create: (x, y, z27) => [x, y, z27],
+          fromValues: (x, y, z27) => [x, y, z27]
         }
       },
       geometries: {
@@ -13862,17 +13862,17 @@ var require_dist = __commonJS({
         }
       },
       measurements: {
-        measureBoundingBox: (shape) => ({
+        measureBoundingBox: (shape2) => ({
           type: "measureBoundingBox",
-          shape
+          shape: shape2
         }),
-        measureArea: (shape) => ({
+        measureArea: (shape2) => ({
           type: "measureArea",
-          shape
+          shape: shape2
         }),
-        measureVolume: (shape) => ({
+        measureVolume: (shape2) => ({
           type: "measureVolume",
-          shape
+          shape: shape2
         })
       },
       utils: {
@@ -13880,77 +13880,77 @@ var require_dist = __commonJS({
         radToDeg: (radians) => radians * 180 / Math.PI
       }
     };
-    var executeJscadOperations3 = (jscad3, operation) => {
+    var executeJscadOperations3 = (jscad5, operation) => {
       if (Array.isArray(operation) && operation.length === 1) {
-        return executeJscadOperations3(jscad3, operation[0]);
+        return executeJscadOperations3(jscad5, operation[0]);
       }
       if (Array.isArray(operation)) {
         throw new Error(
           `executeJscadOperations currently doesn't support Array<JscadOperation>, try adding a root union or or executing each element individually`
         );
       }
-      const recurse = (op) => executeJscadOperations3(jscad3, op);
+      const recurse = (op) => executeJscadOperations3(jscad5, op);
       const { type, ...params } = operation;
       switch (type) {
         case "intersect":
-          return jscad3.booleans.intersect(...operation.shapes.map(recurse));
+          return jscad5.booleans.intersect(...operation.shapes.map(recurse));
         case "subtract":
-          return jscad3.booleans.subtract(...operation.shapes.map(recurse));
+          return jscad5.booleans.subtract(...operation.shapes.map(recurse));
         case "union":
-          return jscad3.booleans.union(...operation.shapes.map(recurse));
+          return jscad5.booleans.union(...operation.shapes.map(recurse));
         case "hull":
-          return jscad3.hulls.hull(...operation.shapes.map(recurse));
+          return jscad5.hulls.hull(...operation.shapes.map(recurse));
         case "hullChain":
-          return jscad3.hulls.hullChain(...operation.shapes.map(recurse));
+          return jscad5.hulls.hullChain(...operation.shapes.map(recurse));
         case "colorize":
-          return jscad3.colors.colorize(operation.color, recurse(operation.shape));
+          return jscad5.colors.colorize(operation.color, recurse(operation.shape));
         case "cube":
-          return jscad3.primitives.cube(params);
+          return jscad5.primitives.cube(params);
         case "sphere":
-          return jscad3.primitives.sphere(params);
+          return jscad5.primitives.sphere(params);
         case "cylinder":
-          return jscad3.primitives.cylinder(params);
+          return jscad5.primitives.cylinder(params);
         case "polygon":
-          return jscad3.primitives.polygon(params);
+          return jscad5.primitives.polygon(params);
         case "cuboid":
-          return jscad3.primitives.cuboid(params);
+          return jscad5.primitives.cuboid(params);
         case "roundedCuboid":
-          return jscad3.primitives.roundedCuboid(params);
+          return jscad5.primitives.roundedCuboid(params);
         case "rotate":
-          return jscad3.transforms.rotate(operation.angles, recurse(operation.shape));
+          return jscad5.transforms.rotate(operation.angles, recurse(operation.shape));
         case "scale":
-          return jscad3.transforms.scale(operation.factors, recurse(operation.shape));
+          return jscad5.transforms.scale(operation.factors, recurse(operation.shape));
         case "translate":
-          return jscad3.transforms.translate(
+          return jscad5.transforms.translate(
             operation.vector,
             recurse(operation.shape)
           );
         case "extrudeLinear":
-          return jscad3.extrusions.extrudeLinear(
+          return jscad5.extrusions.extrudeLinear(
             operation.options,
             recurse(operation.shape)
           );
         case "extrudeRotate":
-          return jscad3.extrusions.extrudeRotate(
+          return jscad5.extrusions.extrudeRotate(
             operation.options,
             recurse(operation.shape)
           );
         case "createGeom2":
-          return jscad3.geometries.geom2.create(operation.points);
+          return jscad5.geometries.geom2.create(operation.points);
         case "createGeom3":
-          return jscad3.geometries.geom3.create(operation.polygons);
+          return jscad5.geometries.geom3.create(operation.polygons);
         case "createPath2":
-          return jscad3.geometries.path2.create(operation.points);
+          return jscad5.geometries.path2.create(operation.points);
         case "measureBoundingBox":
-          return jscad3.measurements.measureBoundingBox(recurse(operation.shape));
+          return jscad5.measurements.measureBoundingBox(recurse(operation.shape));
         case "measureArea":
-          return jscad3.measurements.measureArea(recurse(operation.shape));
+          return jscad5.measurements.measureArea(recurse(operation.shape));
         case "measureVolume":
-          return jscad3.measurements.measureVolume(recurse(operation.shape));
+          return jscad5.measurements.measureVolume(recurse(operation.shape));
         case "degToRad":
-          return jscad3.utils.degToRad(operation.degrees);
+          return jscad5.utils.degToRad(operation.degrees);
         case "radToDeg":
-          return jscad3.utils.radToDeg(operation.radians);
+          return jscad5.utils.radToDeg(operation.radians);
         default:
           if (operation.type === void 0) {
             throw new Error(
@@ -14789,15 +14789,8 @@ var Html = ({ children, position, style }) => {
   return portal;
 };
 
-// node_modules/@tscircuit/footprinter/dist/index.js
-import {
-  length as length82
-} from "circuit-json";
-import { length } from "circuit-json";
-import { z as z3 } from "zod";
+// node_modules/@tscircuit/modelprinter/index.js
 import { z as z2 } from "zod";
-import { z } from "zod";
-import { z as z4 } from "zod";
 
 // node_modules/@tscircuit/mm/dist/index.js
 var unitToMm = {
@@ -14810,6 +14803,11 @@ var unitToMm = {
   ft: 304.8,
   feet: 304.8
 };
+var mmNumberFormatter = new Intl.NumberFormat("en-US", {
+  useGrouping: false,
+  notation: "standard",
+  maximumFractionDigits: 12
+});
 var mm = (n) => {
   let unit = typeof n === "number" ? "mm" : n.replace(/^[^a-zA-Z]+/g, "").toLowerCase();
   if (!unit)
@@ -14820,15 +14818,958 @@ var mm = (n) => {
   }
   throw new Error(`Unsupported unit: ${unit}`);
 };
-var mm_default = mm;
+
+// node_modules/@tscircuit/modelprinter/index.js
+import { z } from "zod";
+import { z as z3 } from "zod";
+import { z as z5 } from "zod";
+import { z as z4 } from "zod";
+var modelLengthSchema = z.union([z.number(), z.string()]).transform((value, context) => {
+  try {
+    const parsed = mm(value);
+    if (!Number.isFinite(parsed)) throw new Error("Length is not finite");
+    return parsed;
+  } catch {
+    context.addIssue({
+      code: "custom",
+      message: `Invalid model length: ${String(value)}`
+    });
+    return z.NEVER;
+  }
+});
+var positiveModelLengthSchema = modelLengthSchema.refine(
+  (value) => value > 0,
+  "Length must be greater than zero"
+);
+var nonnegativeModelLengthSchema = modelLengthSchema.refine(
+  (value) => value >= 0,
+  "Length cannot be negative"
+);
+var nemaSizeSchema = z2.union([
+  z2.literal(8),
+  z2.literal(17),
+  z2.literal(23)
+]);
+var nemaMotorDimensions = {
+  8: {
+    bodyWidth: 20.3,
+    bodyLength: 33,
+    mountingHoleSpacing: 16,
+    mountingHoleDiameter: 2,
+    mountingHoleDepth: 2,
+    mountingHoleThrough: false,
+    pilotDiameter: 15,
+    pilotLength: 1.5,
+    shaftDiameter: 4,
+    shaftLength: 15,
+    shaftShape: "round",
+    shaftFlatDepth: 0.5,
+    shaftFlatLength: 10,
+    shaftFlatAngle: 0,
+    frontCapLength: 3.5,
+    rearCapLength: 3.5,
+    faceCornerChamfer: 0.5,
+    bodyCornerChamfer: 3
+  },
+  17: {
+    bodyWidth: 42.3,
+    bodyLength: 38,
+    mountingHoleSpacing: 31,
+    mountingHoleDiameter: 3,
+    mountingHoleDepth: 4.5,
+    mountingHoleThrough: false,
+    pilotDiameter: 22,
+    pilotLength: 2,
+    shaftDiameter: 5,
+    shaftLength: 24,
+    shaftShape: "d",
+    shaftFlatDepth: 0.5,
+    shaftFlatLength: 15,
+    shaftFlatAngle: 0,
+    frontCapLength: 5,
+    rearCapLength: 5,
+    faceCornerChamfer: 3,
+    bodyCornerChamfer: 6
+  },
+  23: {
+    bodyWidth: 56.4,
+    bodyLength: 51,
+    mountingHoleSpacing: 47.14,
+    mountingHoleDiameter: 5,
+    mountingHoleDepth: 5,
+    mountingHoleThrough: true,
+    pilotDiameter: 38.1,
+    pilotLength: 1.6,
+    shaftDiameter: 6.35,
+    shaftLength: 20.6,
+    shaftShape: "d",
+    shaftFlatDepth: 0.5,
+    shaftFlatLength: 15,
+    shaftFlatAngle: 0,
+    frontCapLength: 5,
+    rearCapLength: 5,
+    faceCornerChamfer: 2,
+    bodyCornerChamfer: 15
+  }
+};
+var shape = {
+  nemaSize: nemaSizeSchema,
+  bodyWidth: positiveModelLengthSchema.optional(),
+  bodyLength: positiveModelLengthSchema.optional(),
+  mountingHoleSpacing: positiveModelLengthSchema.optional(),
+  mountingHoleDiameter: positiveModelLengthSchema.optional(),
+  mountingHoleDepth: positiveModelLengthSchema.optional(),
+  mountingHoleThrough: z2.boolean().optional(),
+  pilotDiameter: positiveModelLengthSchema.optional(),
+  pilotLength: positiveModelLengthSchema.optional(),
+  /** Distance from mounting face Z=0 to shaft tip, including pilot height. */
+  shaftLength: positiveModelLengthSchema.optional(),
+  shaftDiameter: positiveModelLengthSchema.optional(),
+  shaftShape: z2.enum(["round", "d"]).optional(),
+  /** Radial material removed from the +X side before rotation. */
+  shaftFlatDepth: nonnegativeModelLengthSchema.optional(),
+  /** Flat extends back from the tip; leaves a round shoulder above the pilot. */
+  shaftFlatLength: nonnegativeModelLengthSchema.optional(),
+  /** Degrees around +Z, counterclockwise; zero puts the flat on +X. */
+  shaftFlatAngle: z2.number().finite().optional(),
+  frontCapLength: positiveModelLengthSchema.optional(),
+  rearCapLength: positiveModelLengthSchema.optional(),
+  faceCornerChamfer: nonnegativeModelLengthSchema.optional(),
+  bodyCornerChamfer: nonnegativeModelLengthSchema.optional()
+};
+var resolve = (p) => {
+  const d = nemaMotorDimensions[p.nemaSize];
+  return {
+    nemaSize: p.nemaSize,
+    bodyWidth: p.bodyWidth ?? d.bodyWidth,
+    bodyLength: p.bodyLength ?? d.bodyLength,
+    mountingHoleSpacing: p.mountingHoleSpacing ?? d.mountingHoleSpacing,
+    mountingHoleDiameter: p.mountingHoleDiameter ?? d.mountingHoleDiameter,
+    mountingHoleDepth: p.mountingHoleDepth ?? d.mountingHoleDepth,
+    mountingHoleThrough: p.mountingHoleThrough ?? d.mountingHoleThrough,
+    pilotDiameter: p.pilotDiameter ?? d.pilotDiameter,
+    pilotLength: p.pilotLength ?? d.pilotLength,
+    shaftDiameter: p.shaftDiameter ?? d.shaftDiameter,
+    shaftLength: p.shaftLength ?? d.shaftLength,
+    shaftShape: p.shaftShape ?? d.shaftShape,
+    shaftFlatDepth: p.shaftFlatDepth ?? d.shaftFlatDepth,
+    shaftFlatLength: p.shaftFlatLength ?? d.shaftFlatLength,
+    shaftFlatAngle: p.shaftFlatAngle ?? d.shaftFlatAngle,
+    frontCapLength: p.frontCapLength ?? d.frontCapLength,
+    rearCapLength: p.rearCapLength ?? d.rearCapLength,
+    faceCornerChamfer: p.faceCornerChamfer ?? d.faceCornerChamfer,
+    bodyCornerChamfer: p.bodyCornerChamfer ?? d.bodyCornerChamfer
+  };
+};
+var validate = (p, ctx) => {
+  const issue = (message) => ctx.addIssue({ code: "custom", message });
+  const r = p.mountingHoleDiameter / 2;
+  if (p.frontCapLength + p.rearCapLength >= p.bodyLength)
+    issue("End caps must leave a positive body length");
+  if (p.faceCornerChamfer >= p.bodyWidth / 2 || p.bodyCornerChamfer >= p.bodyWidth / 2)
+    issue("Chamfer must be smaller than half the body width");
+  if (p.mountingHoleSpacing + 2 * r >= p.bodyWidth || p.bodyWidth - p.faceCornerChamfer - p.mountingHoleSpacing <= r * Math.SQRT2)
+    issue("Mounting holes must fit entirely inside the front face");
+  if (p.pilotDiameter >= p.bodyWidth || p.pilotDiameter <= p.shaftDiameter)
+    issue(
+      "Pilot diameter must exceed the shaft diameter and fit inside the face"
+    );
+  if (p.mountingHoleSpacing / Math.SQRT2 <= p.pilotDiameter / 2 + r)
+    issue("Mounting holes must clear the pilot");
+  if (!p.mountingHoleThrough && p.mountingHoleDepth >= p.frontCapLength)
+    issue("Blind mounting hole depth must be less than the front cap length");
+  if (p.mountingHoleThrough && p.bodyWidth - p.bodyCornerChamfer - p.mountingHoleSpacing >= -r * Math.SQRT2)
+    issue("Body and rear cap must clear through mounting holes");
+  if (p.shaftLength <= p.pilotLength)
+    issue("Shaft tip must extend beyond the pilot");
+  if (p.shaftShape === "d" && (p.shaftFlatDepth <= 0 || p.shaftFlatDepth >= p.shaftDiameter / 2 || p.shaftFlatLength <= 0 || p.shaftFlatLength > p.shaftLength - p.pilotLength))
+    issue(
+      "D flat must have positive depth less than the shaft radius and fit above the pilot"
+    );
+};
+var nemaMotorModelPropsSchema = z2.object(shape).strict().transform(resolve).superRefine(validate);
+var nemaMotorModelDefinitionSchema = z2.object({ fn: z2.literal("nema"), ...shape }).strict().transform(({ fn, ...props }) => ({ fn, ...resolve(props) })).superRefine(validate);
+var holePosition = {
+  panel: z3.enum(["base", "left", "right"]),
+  /** Panel-local mm, centered on its straight section: u along its length,
+   * v along the sheet width. Side-panel u increases upward. */
+  u: modelLengthSchema,
+  v: modelLengthSchema
+};
+var sheetMetalHoleSchema = z3.discriminatedUnion("shape", [
+  z3.object({
+    ...holePosition,
+    shape: z3.literal("round"),
+    diameter: positiveModelLengthSchema
+  }).strict(),
+  z3.object({
+    ...holePosition,
+    shape: z3.literal("slot"),
+    length: positiveModelLengthSchema,
+    width: positiveModelLengthSchema,
+    axis: z3.enum(["u", "v"]).default("v")
+  }).strict()
+]);
+var sheetMetalShape = {
+  profile: z3.enum(["plate", "angle", "channel"]).default("plate"),
+  width: positiveModelLengthSchema,
+  /** Straight base length between bend tangencies, not overall width. */
+  baseLength: positiveModelLengthSchema,
+  /** Straight flange length above the bend tangent. */
+  flangeHeight: positiveModelLengthSchema.default(12),
+  thickness: positiveModelLengthSchema.default(1),
+  insideBendRadius: positiveModelLengthSchema.default(1),
+  holes: z3.array(sheetMetalHoleSchema).max(100).default([])
+};
+var sheetMetalModelPropsSchema = z3.object(sheetMetalShape).strict();
+var sheetMetalModelDefinitionSchema = z3.object({ fn: z3.literal("sheetmetal"), ...sheetMetalShape }).strict();
+var hexSocketBoltDimensions = {
+  M2: {
+    diameter: 2,
+    threadPitch: 0.4,
+    headDiameter: 3.8,
+    headHeight: 2,
+    socketWidth: 1.5,
+    socketDepth: 1
+  },
+  "M2.5": {
+    diameter: 2.5,
+    threadPitch: 0.45,
+    headDiameter: 4.5,
+    headHeight: 2.5,
+    socketWidth: 2,
+    socketDepth: 1.1
+  },
+  M3: {
+    diameter: 3,
+    threadPitch: 0.5,
+    headDiameter: 5.5,
+    headHeight: 3,
+    socketWidth: 2.5,
+    socketDepth: 1.3
+  },
+  M4: {
+    diameter: 4,
+    threadPitch: 0.7,
+    headDiameter: 7,
+    headHeight: 4,
+    socketWidth: 3,
+    socketDepth: 2
+  },
+  M5: {
+    diameter: 5,
+    threadPitch: 0.8,
+    headDiameter: 8.5,
+    headHeight: 5,
+    socketWidth: 4,
+    socketDepth: 2.5
+  },
+  M6: {
+    diameter: 6,
+    threadPitch: 1,
+    headDiameter: 10,
+    headHeight: 6,
+    socketWidth: 5,
+    socketDepth: 3
+  },
+  M8: {
+    diameter: 8,
+    threadPitch: 1.25,
+    headDiameter: 13,
+    headHeight: 8,
+    socketWidth: 6,
+    socketDepth: 4
+  },
+  M10: {
+    diameter: 10,
+    threadPitch: 1.5,
+    headDiameter: 16,
+    headHeight: 10,
+    socketWidth: 8,
+    socketDepth: 5
+  },
+  M12: {
+    diameter: 12,
+    threadPitch: 1.75,
+    headDiameter: 18,
+    headHeight: 12,
+    socketWidth: 10,
+    socketDepth: 6
+  }
+};
+var metricBoltSizeSchema = z4.enum([
+  "M2",
+  "M2.5",
+  "M3",
+  "M4",
+  "M5",
+  "M6",
+  "M8",
+  "M10",
+  "M12"
+]);
+var hexSocketBoltModelPropsShape = {
+  metricSize: metricBoltSizeSchema,
+  /** Length under the head, excluding the head itself. */
+  length: positiveModelLengthSchema,
+  showThreads: z4.boolean().default(true)
+};
+var hexSocketBoltModelPropsSchema = z4.object(hexSocketBoltModelPropsShape).strict();
+var hexSocketBoltModelDefinitionSchema = z4.object({
+  fn: z4.literal("hexsocketbolt"),
+  ...hexSocketBoltModelPropsShape
+}).strict();
+var flexScreenOrientationSchema = z5.enum([
+  "sitsFlat",
+  "sitsFlatBelowBoard",
+  "foldedToFaceAboveBoard",
+  "foldedToFaceBelowBoard",
+  "foldedToRightAngleAboveBoard",
+  "foldedToRightAngleBelowBoard"
+]);
+var positiveFiniteNumberSchema = z5.number().finite().positive();
+var aspectRatioStringSchema = z5.string().refine((value) => {
+  const parts = value.split(":");
+  if (parts.length !== 2) return false;
+  const width10 = Number(parts[0]);
+  const height10 = Number(parts[1]);
+  return Number.isFinite(width10) && Number.isFinite(height10) && width10 > 0 && height10 > 0;
+}, 'Aspect ratio must look like "16:9"').transform((value) => value);
+var flexScreenAspectRatioSchema = z5.union([
+  positiveFiniteNumberSchema,
+  aspectRatioStringSchema,
+  z5.tuple([positiveFiniteNumberSchema, positiveFiniteNumberSchema])
+]);
+var modelPointSchema = z5.object({
+  x: modelLengthSchema.optional(),
+  y: modelLengthSchema.optional(),
+  z: modelLengthSchema.optional()
+}).strict();
+var rotationValueSchema = z5.union([z5.number().finite(), z5.string().min(1)]);
+var modelRotationSchema = z5.tuple([
+  rotationValueSchema,
+  rotationValueSchema,
+  rotationValueSchema
+]);
+var orientationShortcutKeys = [
+  "sitsFlat",
+  "sitsFlatBelowBoard",
+  "foldedToFaceAboveBoard",
+  "foldedToFaceBelowBoard",
+  "foldsAboveBoard",
+  "foldsBelowBoard",
+  "foldedToRightAngleAboveBoard",
+  "foldedToRightAngleBelowBoard"
+];
+var flexScreenModelPropsShape = {
+  width: positiveModelLengthSchema.optional(),
+  height: positiveModelLengthSchema.optional(),
+  diagonal: positiveModelLengthSchema.optional(),
+  aspectRatio: flexScreenAspectRatioSchema.optional(),
+  ratio: flexScreenAspectRatioSchema.optional(),
+  defaultDiagonal: positiveModelLengthSchema.optional(),
+  orientation: flexScreenOrientationSchema.optional(),
+  sitsFlat: z5.boolean().optional(),
+  sitsFlatBelowBoard: z5.boolean().optional(),
+  foldedToFaceAboveBoard: z5.boolean().optional(),
+  foldedToFaceBelowBoard: z5.boolean().optional(),
+  foldsAboveBoard: z5.boolean().optional(),
+  foldsBelowBoard: z5.boolean().optional(),
+  foldedToRightAngleAboveBoard: z5.boolean().optional(),
+  foldedToRightAngleBelowBoard: z5.boolean().optional(),
+  screenThickness: positiveModelLengthSchema.optional(),
+  bezelInset: nonnegativeModelLengthSchema.optional(),
+  bezelDepth: positiveModelLengthSchema.optional(),
+  activeAreaWidth: positiveModelLengthSchema.optional(),
+  activeAreaHeight: positiveModelLengthSchema.optional(),
+  screenColor: z5.string().min(1).optional(),
+  bezelColor: z5.string().min(1).optional(),
+  showScreen: z5.boolean().optional(),
+  flexCableLength: positiveModelLengthSchema.optional(),
+  flexCableWidth: positiveModelLengthSchema.optional(),
+  flexCableThickness: positiveModelLengthSchema.optional(),
+  flexCableColor: z5.string().min(1).optional(),
+  conductorCount: z5.number().int().positive().optional(),
+  conductorPitch: positiveModelLengthSchema.optional(),
+  conductorWidth: positiveModelLengthSchema.optional(),
+  conductorThickness: positiveModelLengthSchema.optional(),
+  conductorColor: z5.string().min(1).optional(),
+  cableEdgeMargin: nonnegativeModelLengthSchema.optional(),
+  exposedContactLength: nonnegativeModelLengthSchema.optional(),
+  showConductors: z5.boolean().optional(),
+  showFlexCable: z5.boolean().optional(),
+  showStiffeners: z5.boolean().optional(),
+  stiffenerLength: nonnegativeModelLengthSchema.optional(),
+  stiffenerThickness: positiveModelLengthSchema.optional(),
+  stiffenerColor: z5.string().min(1).optional(),
+  bendRadius: positiveModelLengthSchema.optional(),
+  bendSegments: z5.number().int().min(2).optional(),
+  rightAngleVerticalLead: nonnegativeModelLengthSchema.optional(),
+  distanceAboveBoard: nonnegativeModelLengthSchema.optional(),
+  distanceBelowBoard: nonnegativeModelLengthSchema.optional(),
+  foldDistanceFromConnector: nonnegativeModelLengthSchema.optional(),
+  foldOutset: positiveModelLengthSchema.optional(),
+  foldSegments: z5.number().int().min(4).optional(),
+  screenGap: nonnegativeModelLengthSchema.optional(),
+  boardTopZ: modelLengthSchema.optional(),
+  boardThickness: positiveModelLengthSchema.optional(),
+  boardClearance: nonnegativeModelLengthSchema.optional(),
+  cableStartX: modelLengthSchema.optional(),
+  cableStartY: modelLengthSchema.optional(),
+  cableStartZ: modelLengthSchema.optional(),
+  cableLateralOffset: modelLengthSchema.optional(),
+  screenOffset: modelPointSchema.optional(),
+  screenRotation: modelRotationSchema.optional(),
+  rotation: modelRotationSchema.optional(),
+  offset: modelPointSchema.optional()
+};
+var addOrientationShortcutIssue = (props, addIssue) => {
+  const selectedShortcuts = orientationShortcutKeys.filter(
+    (key) => props[key] === true
+  );
+  if (selectedShortcuts.length > 1) addIssue(selectedShortcuts[1]);
+};
+var flexScreenModelPropsSchema = z5.object(flexScreenModelPropsShape).strict().superRefine((props, context) => {
+  addOrientationShortcutIssue(props, (path) => {
+    context.addIssue({
+      code: "custom",
+      message: "Only one FlexScreen orientation shortcut can be true",
+      path: [path]
+    });
+  });
+});
+var flexScreenModelDefinitionSchema = z5.object({
+  fn: z5.literal("flexscreen"),
+  ...flexScreenModelPropsShape
+}).strict().superRefine((model, context) => {
+  addOrientationShortcutIssue(model, (path) => {
+    context.addIssue({
+      code: "custom",
+      message: "Only one FlexScreen orientation shortcut can be true",
+      path: [path]
+    });
+  });
+});
+var modelDefinitionSchema = z5.union([
+  nemaMotorModelDefinitionSchema,
+  sheetMetalModelDefinitionSchema,
+  flexScreenModelDefinitionSchema,
+  hexSocketBoltModelDefinitionSchema
+]);
+function splitModelStringTokens(value) {
+  const tokens = [];
+  let depth = 0;
+  let start = 0;
+  for (let index2 = 0; index2 < value.length; index2++) {
+    const character = value[index2];
+    if (character === "(") depth++;
+    if (character === ")") depth--;
+    if (depth < 0 || depth > 1) throw new Error("Invalid feature parentheses");
+    if (character === "_" && depth === 0) {
+      tokens.push(value.slice(start, index2));
+      start = index2 + 1;
+    }
+  }
+  if (depth !== 0) throw new Error("Unclosed feature parentheses");
+  tokens.push(value.slice(start));
+  if (tokens.some((token) => !token))
+    throw new Error("Model strings cannot contain empty tokens");
+  return tokens;
+}
+var parsePart = (part) => {
+  const match = part.match(/^([a-zA-Z]+)([\(\d\.\+\-].*)?$/);
+  if (!match?.[1]) return void 0;
+  return {
+    fn: match[1].toLowerCase(),
+    value: match[2]
+  };
+};
+var parseModelStringParams = (definition) => {
+  const normalizedDefinition = definition.trim();
+  if (!normalizedDefinition) throw new Error("Model string cannot be empty");
+  const parts = splitModelStringTokens(normalizedDefinition);
+  const firstPart = parts[0];
+  const first = parsePart(firstPart);
+  const params = {};
+  const fn = first?.fn ?? firstPart.toLowerCase();
+  params[fn] = true;
+  params.fn = fn;
+  if (first?.value) {
+    const numericValue = Number.parseFloat(first.value);
+    if (Number.isFinite(numericValue)) params.num_pins = numericValue;
+  }
+  for (const part of parts.slice(1)) {
+    if (!part) throw new Error("Model strings cannot contain empty tokens");
+    const parsed = parsePart(part);
+    if (!parsed) throw new Error(`Invalid model string token "${part}"`);
+    params[parsed.fn] = parsed.value ?? true;
+  }
+  params.string = normalizedDefinition;
+  return params;
+};
+var lengths = {
+  l: "bodyLength",
+  length: "bodyLength",
+  bodylength: "bodyLength",
+  bodywidth: "bodyWidth",
+  shaftlength: "shaftLength",
+  shaftdiameter: "shaftDiameter",
+  flatdepth: "shaftFlatDepth",
+  flatlength: "shaftFlatLength",
+  holespacing: "mountingHoleSpacing",
+  holediameter: "mountingHoleDiameter",
+  holedepth: "mountingHoleDepth",
+  pilotdiameter: "pilotDiameter",
+  pilotlength: "pilotLength",
+  frontcap: "frontCapLength",
+  rearcap: "rearCapLength",
+  facechamfer: "faceCornerChamfer",
+  bodychamfer: "bodyCornerChamfer"
+};
+function parseNemaMotorModelParams(raw) {
+  const tokens = raw.string.split("_");
+  const match = tokens[0]?.match(/^nema(8|17|23)$/i);
+  if (!match) throw new Error("Expected nema8, nema17 or nema23");
+  const props = {
+    fn: "nema",
+    nemaSize: Number(match[1])
+  };
+  for (const token of tokens.slice(1)) {
+    const match2 = token.match(/^([a-z]+)(.*)$/i);
+    if (!match2) throw new Error(`Invalid NEMA token "${token}"`);
+    const name = match2[1].toLowerCase(), value = match2[2];
+    let property, parsed;
+    if (name in lengths) {
+      property = lengths[name];
+      parsed = value;
+    } else if (name === "flatangle") {
+      property = "shaftFlatAngle";
+      if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:deg)?$/i.test(value))
+        throw new Error("flatangle requires a numeric angle in degrees");
+      parsed = Number(value.replace(/deg$/i, ""));
+    } else if (["round", "dshaft", "throughholes", "blindholes"].includes(name)) {
+      if (value) throw new Error(`NEMA flag "${name}" does not accept a value`);
+      property = name === "round" || name === "dshaft" ? "shaftShape" : "mountingHoleThrough";
+      parsed = name === "round" ? "round" : name === "dshaft" ? "d" : name === "throughholes";
+    } else throw new Error(`Unknown NEMA motor token "${token}"`);
+    if (property in props)
+      throw new Error(`NEMA property "${property}" is set more than once`);
+    props[property] = parsed;
+  }
+  return nemaMotorModelDefinitionSchema.parse(props);
+}
+function parseSheetMetalFeature(feature, profile) {
+  const match = feature.match(/^(hole|slot)[1-9]\d*\(([^()]+)\)$/);
+  if (!match) throw new Error(`Invalid sheet metal feature "${feature}"`);
+  const kind = match[1];
+  const values = {};
+  for (const token of match[2].split("_")) {
+    const parameter = token.match(
+      /^(leftofcenter|rightofcenter|abovecenter|belowcenter|r|d|l|w)([0-9.].*)$/
+    );
+    const key = parameter?.[1] ?? token;
+    if (key in values) throw new Error(`Duplicate ${key} in ${feature}`);
+    values[key] = parameter?.[2] ?? "";
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    "bottomface",
+    "angledface",
+    "leftface",
+    "rightface",
+    "leftofcenter",
+    "rightofcenter",
+    "abovecenter",
+    "belowcenter",
+    ...kind === "hole" ? ["r", "d"] : ["l", "w", "horizontal", "vertical"]
+  ]);
+  for (const key of Object.keys(values)) {
+    if (!allowed.has(key)) throw new Error(`Unknown ${key} in ${feature}`);
+  }
+  const faces = ["bottomface", "angledface", "leftface", "rightface"].filter(
+    (face22) => face22 in values
+  );
+  if (faces.length !== 1)
+    throw new Error(`Specify exactly one face in ${feature}`);
+  const face2 = faces[0];
+  if (face2 === "angledface" && profile !== "angle" || ["leftface", "rightface"].includes(face2) && profile !== "channel")
+    throw new Error(`No ${face2} on ${profile}`);
+  for (const [a, b] of [
+    ["leftofcenter", "rightofcenter"],
+    ["abovecenter", "belowcenter"],
+    ["horizontal", "vertical"],
+    ["r", "d"]
+  ]) {
+    if (a in values && b in values)
+      throw new Error(`Conflicting ${a} and ${b} in ${feature}`);
+  }
+  const distance6 = (key) => key in values ? positiveModelLengthSchema.parse(values[key]) : 0;
+  const horizontal = distance6("rightofcenter") - distance6("leftofcenter");
+  const vertical = distance6("abovecenter") - distance6("belowcenter");
+  const panel = face2 === "bottomface" ? "base" : face2 === "leftface" ? "left" : "right";
+  const position = {
+    panel,
+    u: panel === "base" ? horizontal : vertical,
+    v: panel === "base" ? vertical : horizontal * (panel === "left" ? -1 : 1)
+  };
+  if (kind === "hole") {
+    if (!("r" in values) && !("d" in values))
+      throw new Error(`Hole requires r or d in ${feature}`);
+    return sheetMetalHoleSchema.parse({
+      ...position,
+      shape: "round",
+      diameter: "r" in values ? 2 * distance6("r") : distance6("d")
+    });
+  }
+  if (!("l" in values) || !("w" in values))
+    throw new Error(`Slot requires l and w in ${feature}`);
+  const length83 = distance6("l"), width10 = distance6("w");
+  if (length83 < width10) throw new Error("Slot length must be at least its width");
+  return sheetMetalHoleSchema.parse({
+    ...position,
+    shape: "slot",
+    length: length83,
+    width: width10,
+    axis: panel === "base" === !("vertical" in values) ? "u" : "v"
+  });
+}
+var lengths2 = {
+  w: "width",
+  l: "baseLength",
+  h: "flangeHeight",
+  t: "thickness",
+  r: "insideBendRadius"
+};
+function parseSheetMetalModelParams(raw) {
+  const props = {};
+  const tokens = splitModelStringTokens(raw.string);
+  if (tokens[0] !== "sheetmetal") throw new Error("Expected sheetmetal");
+  const features = [];
+  const featureNames = /* @__PURE__ */ new Set();
+  for (const token of tokens.slice(1)) {
+    if (/^(hole|slot)[1-9]\d*\(/.test(token)) {
+      const name = token.slice(0, token.indexOf("("));
+      if (featureNames.has(name)) throw new Error(`Duplicate feature "${name}"`);
+      featureNames.add(name);
+      features.push(token);
+      continue;
+    }
+    if (["plate", "angle", "channel"].includes(token)) {
+      if (props.profile) throw new Error("Duplicate sheet metal profile");
+      props.profile = token;
+      continue;
+    }
+    const key = lengths2[token[0]];
+    if (!key || token.length < 2)
+      throw new Error(`Unknown sheet metal token "${token}"`);
+    if (key in props) throw new Error(`Duplicate sheet metal property "${key}"`);
+    props[key] = token.slice(1);
+  }
+  const definition = sheetMetalModelDefinitionSchema.parse({
+    fn: "sheetmetal",
+    ...props
+  });
+  definition.holes = features.map(
+    (feature) => parseSheetMetalFeature(feature, definition.profile)
+  );
+  return definition;
+}
+var parseHexSocketBoltModelParams = (raw) => {
+  if (raw.fn !== "hexsocketbolt") {
+    throw new Error(`Expected hexsocketbolt params, got "${raw.fn}"`);
+  }
+  const tokens = raw.string.split("_");
+  if (tokens[0]?.toLowerCase() !== "hexsocketbolt") {
+    throw new Error(
+      "The hexsocketbolt function does not accept an inline value"
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of tokens.slice(1)) {
+    const name = token.match(/^[a-z]+/i)?.[0]?.toLowerCase();
+    if (name && seen.has(name))
+      throw new Error(`Duplicate bolt token "${name}"`);
+    if (name) seen.add(name);
+  }
+  const props = {};
+  for (const [token, value] of Object.entries(raw)) {
+    if (["fn", "string", "hexsocketbolt"].includes(token)) continue;
+    let property;
+    let parsed = value;
+    if (token === "m") {
+      property = "metricSize";
+      parsed = `M${String(value)}`;
+    } else if (token === "l" || token === "length") {
+      property = "length";
+    } else if (token === "threads" || token === "nothreads") {
+      if (value !== true)
+        throw new Error(`Bolt token "${token}" does not accept a value`);
+      property = "showThreads";
+      parsed = token === "threads";
+    } else {
+      throw new Error(
+        `Unknown hex socket bolt model token "${token}${String(value)}"`
+      );
+    }
+    if (property in props)
+      throw new Error(`Bolt property "${property}" is set more than once`);
+    props[property] = parsed;
+  }
+  return hexSocketBoltModelDefinitionSchema.parse({
+    fn: "hexsocketbolt",
+    ...props
+  });
+};
+var orientationTokens = {
+  sitsflat: "sitsFlat",
+  sitsflatbelow: "sitsFlatBelowBoard",
+  sitsflatbelowboard: "sitsFlatBelowBoard",
+  foldsabove: "foldedToFaceAboveBoard",
+  foldsaboveboard: "foldedToFaceAboveBoard",
+  foldedtofaceaboveboard: "foldedToFaceAboveBoard",
+  foldsbelow: "foldedToFaceBelowBoard",
+  foldsbelowboard: "foldedToFaceBelowBoard",
+  foldedtofacebelowboard: "foldedToFaceBelowBoard",
+  rightangleabove: "foldedToRightAngleAboveBoard",
+  rightangleaboveboard: "foldedToRightAngleAboveBoard",
+  foldedtorightangleaboveboard: "foldedToRightAngleAboveBoard",
+  rightanglebelow: "foldedToRightAngleBelowBoard",
+  rightanglebelowboard: "foldedToRightAngleBelowBoard",
+  foldedtorightanglebelowboard: "foldedToRightAngleBelowBoard"
+};
+var lengthProperties = {
+  width: ["width", "w"],
+  height: ["height", "h"],
+  diagonal: ["diagonal", "diag", "d"],
+  defaultDiagonal: ["defaultdiagonal", "defaultdiag"],
+  screenThickness: ["screenthickness"],
+  bezelInset: ["bezelinset"],
+  bezelDepth: ["bezeldepth"],
+  activeAreaWidth: ["activeareawidth", "activew"],
+  activeAreaHeight: ["activeareaheight", "activeh"],
+  flexCableLength: ["flexcablelength", "flexlength", "flex"],
+  flexCableWidth: ["flexcablewidth", "flexwidth"],
+  flexCableThickness: ["flexcablethickness", "flexthickness"],
+  conductorPitch: ["conductorpitch"],
+  conductorWidth: ["conductorwidth"],
+  conductorThickness: ["conductorthickness"],
+  cableEdgeMargin: ["cableedgemargin", "edgemargin"],
+  exposedContactLength: ["exposedcontactlength", "contactlength"],
+  stiffenerLength: ["stiffenerlength"],
+  stiffenerThickness: ["stiffenerthickness"],
+  bendRadius: ["bendradius"],
+  rightAngleVerticalLead: ["rightangleverticallead", "verticallead"],
+  distanceAboveBoard: ["distanceaboveboard", "distanceabove"],
+  distanceBelowBoard: ["distancebelowboard", "distancebelow"],
+  foldDistanceFromConnector: [
+    "folddistancefromconnector",
+    "folddistance",
+    "foldstart"
+  ],
+  foldOutset: ["foldoutset", "outset"],
+  screenGap: ["screengap"],
+  boardTopZ: ["boardtopz"],
+  boardThickness: ["boardthickness"],
+  boardClearance: ["boardclearance"],
+  cableStartX: ["cablestartx"],
+  cableStartY: ["cablestarty"],
+  cableStartZ: ["cablestartz"],
+  cableLateralOffset: ["cablelateraloffset", "lateraloffset"]
+};
+var lengthTokenToProperty = Object.fromEntries(
+  Object.entries(lengthProperties).flatMap(
+    ([property, tokens]) => tokens.map((token) => [token, property])
+  )
+);
+var integerTokenToProperty = {
+  conductorcount: "conductorCount",
+  conductors: "conductorCount",
+  bendsegments: "bendSegments",
+  foldsegments: "foldSegments"
+};
+var booleanTokens = {
+  showscreen: ["showScreen", true],
+  hidescreen: ["showScreen", false],
+  showflex: ["showFlexCable", true],
+  hideflex: ["showFlexCable", false],
+  showconductors: ["showConductors", true],
+  hideconductors: ["showConductors", false],
+  showstiffeners: ["showStiffeners", true],
+  hidestiffeners: ["showStiffeners", false]
+};
+var colorProperties = {
+  screencolor: "screenColor",
+  bezelcolor: "bezelColor",
+  flexcolor: "flexCableColor",
+  conductorcolor: "conductorColor",
+  stiffenercolor: "stiffenerColor"
+};
+var parseAspectRatio = (value) => {
+  const normalized = String(value).toLowerCase().replace("x", ":");
+  if (normalized.includes(":")) {
+    const [width10, height10, extra] = normalized.split(":");
+    const numericWidth = Number(width10);
+    const numericHeight = Number(height10);
+    if (extra !== void 0 || !Number.isFinite(numericWidth) || !Number.isFinite(numericHeight) || numericWidth <= 0 || numericHeight <= 0) {
+      throw new Error(`Invalid FlexScreen aspect ratio "${String(value)}"`);
+    }
+    return `${numericWidth}:${numericHeight}`;
+  }
+  const numeric = Number(normalized);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`Invalid FlexScreen aspect ratio "${String(value)}"`);
+  }
+  return numeric;
+};
+var unwrapFunctionValue = (value, token) => {
+  if (typeof value !== "string" || !/^\(.+\)$/.test(value)) {
+    throw new Error(`FlexScreen token "${token}" requires a value in (...)`);
+  }
+  return value.slice(1, -1);
+};
+var assertBareToken = (value, token) => {
+  if (value !== true) {
+    throw new Error(`FlexScreen token "${token}" does not accept a value`);
+  }
+};
+var parseFlexScreenModelParams = (rawParams) => {
+  if (rawParams.fn !== "flexscreen") {
+    throw new Error(`Expected FlexScreen params, got "${rawParams.fn}"`);
+  }
+  const props = {};
+  let orientation2;
+  let relativeDistance;
+  for (const [token, value] of Object.entries(rawParams)) {
+    if (token === "fn" || token === "string" || token === "flexscreen") {
+      continue;
+    }
+    const tokenOrientation = orientationTokens[token];
+    if (tokenOrientation) {
+      assertBareToken(value, token);
+      if (orientation2 && orientation2 !== tokenOrientation) {
+        throw new Error(
+          "A FlexScreen model string can only set one orientation"
+        );
+      }
+      orientation2 = tokenOrientation;
+      props.orientation = tokenOrientation;
+      continue;
+    }
+    if (token in booleanTokens) {
+      assertBareToken(value, token);
+      const [property, enabled] = booleanTokens[token];
+      props[property] = enabled;
+      continue;
+    }
+    const colorProperty = colorProperties[token];
+    if (colorProperty) {
+      props[colorProperty] = unwrapFunctionValue(value, token);
+      continue;
+    }
+    if (token === "ratio") {
+      props.aspectRatio = parseAspectRatio(value);
+      continue;
+    }
+    const lengthProperty = lengthTokenToProperty[token];
+    if (lengthProperty) {
+      props[lengthProperty] = value;
+      continue;
+    }
+    if (token === "distance") {
+      relativeDistance = value;
+      continue;
+    }
+    const integerProperty = integerTokenToProperty[token];
+    if (integerProperty) {
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(
+          `Invalid positive integer in FlexScreen token "${token}${String(value)}"`
+        );
+      }
+      props[integerProperty] = parsed;
+      continue;
+    }
+    throw new Error(`Unknown FlexScreen model token "${token}${String(value)}"`);
+  }
+  if (relativeDistance !== void 0) {
+    if (orientation2 === "foldedToFaceAboveBoard") {
+      props.distanceAboveBoard = relativeDistance;
+    } else if (orientation2 === "foldedToFaceBelowBoard") {
+      props.distanceBelowBoard = relativeDistance;
+    } else {
+      throw new Error(
+        'The "distance" token requires foldsabove or foldsbelow; use distanceabove or distancebelow for an explicit side'
+      );
+    }
+  }
+  return flexScreenModelDefinitionSchema.parse({ fn: "flexscreen", ...props });
+};
+var modelFunctions = {
+  nema: parseNemaMotorModelParams,
+  sheetmetal: parseSheetMetalModelParams,
+  flexscreen: parseFlexScreenModelParams,
+  hexsocketbolt: parseHexSocketBoltModelParams
+};
+var modelParamsToJson = (params) => {
+  const modelFunction = modelFunctions[params.fn];
+  if (modelFunction) {
+    return modelFunction(params);
+  }
+  throw new Error(`Unsupported modelprinter function "${params.fn}"`);
+};
+var string = (value) => {
+  const params = parseModelStringParams(value);
+  return {
+    params: () => params,
+    json: () => modelParamsToJson(params)
+  };
+};
+var modelprinter = {
+  string,
+  getModelNames: () => Object.keys(modelFunctions)
+};
+var mp = modelprinter;
+
+// node_modules/@tscircuit/footprinter/dist/index.js
+import {
+  length as length82
+} from "circuit-json";
+import { length } from "circuit-json";
+import { z as z32 } from "zod";
+import { z as z22 } from "zod";
+import { z as z6 } from "zod";
+import { z as z42 } from "zod";
+
+// node_modules/@tscircuit/footprinter/node_modules/@tscircuit/mm/dist/index.js
+var unitToMm2 = {
+  in: 25.4,
+  inch: 25.4,
+  mil: 0.0254,
+  mm: 1,
+  m: 1e3,
+  cm: 10,
+  ft: 304.8,
+  feet: 304.8
+};
+var mm2 = (n) => {
+  let unit = typeof n === "number" ? "mm" : n.replace(/^[^a-zA-Z]+/g, "").toLowerCase();
+  if (!unit)
+    unit = "mm";
+  const val = typeof n === "number" ? n : Number.parseFloat(n.split(unit)[0]);
+  if (unit in unitToMm2) {
+    return val * unitToMm2[unit];
+  }
+  throw new Error(`Unsupported unit: ${unit}`);
+};
+var mm_default = mm2;
 
 // node_modules/@tscircuit/footprinter/dist/index.js
 import {
   length as length2
 } from "circuit-json";
-import { z as z5 } from "zod";
+import { z as z52 } from "zod";
 import { distance, length as length3 } from "circuit-json";
-import { z as z6 } from "zod";
+import { z as z62 } from "zod";
 import {
   length as length4
 } from "circuit-json";
@@ -14871,7 +15812,7 @@ import {
 } from "circuit-json";
 import { z as z21 } from "zod";
 import { length as length19 } from "circuit-json";
-import { z as z22 } from "zod";
+import { z as z222 } from "zod";
 import { length as length20 } from "circuit-json";
 import { z as z23 } from "zod";
 import { z as z24 } from "zod";
@@ -14892,7 +15833,7 @@ import {
   length as length26
 } from "circuit-json";
 import { z as z31 } from "zod";
-import { z as z32 } from "zod";
+import { z as z322 } from "zod";
 import { length as length27 } from "circuit-json";
 import {
   length as length28
@@ -14947,7 +15888,7 @@ import { z as z50 } from "zod";
 import { length as length44 } from "circuit-json";
 import { z as z51 } from "zod";
 import { length as length45 } from "circuit-json";
-import { z as z52 } from "zod";
+import { z as z522 } from "zod";
 import { length as length46 } from "circuit-json";
 import { z as z53 } from "zod";
 import { length as length47 } from "circuit-json";
@@ -14968,7 +15909,7 @@ import { z as z60 } from "zod";
 import { length as length53 } from "circuit-json";
 import { z as z61 } from "zod";
 import { length as length54 } from "circuit-json";
-import { z as z62 } from "zod";
+import { z as z622 } from "zod";
 import { length as length55 } from "circuit-json";
 import { z as z63 } from "zod";
 import { length as length56 } from "circuit-json";
@@ -15172,7 +16113,7 @@ var silkscreenRef = (x, y, font_size) => {
     anchor_alignment: "center"
   };
 };
-var function_call = z.string().or(z.array(z.any())).transform((a) => {
+var function_call = z6.string().or(z6.array(z6.any())).transform((a) => {
   if (Array.isArray(a)) return a;
   if (a.startsWith("(") && a.endsWith(")")) {
     a = a.slice(1, -1);
@@ -15181,32 +16122,32 @@ var function_call = z.string().or(z.array(z.any())).transform((a) => {
     const numVal = Number(v);
     return isNaN(numVal) ? v : numVal;
   });
-}).pipe(z.array(z.string().or(z.number())));
-var horizontalSide = z2.enum(["leftside", "rightside"]);
-var verticalSide = z2.enum(["topside", "bottomside"]);
-var horizontalAlignment = z2.enum(["left", "right"]);
-var verticalAlignment = z2.enum(["top", "bottom"]);
+}).pipe(z6.array(z6.string().or(z6.number())));
+var horizontalSide = z22.enum(["leftside", "rightside"]);
+var verticalSide = z22.enum(["topside", "bottomside"]);
+var horizontalAlignment = z22.enum(["left", "right"]);
+var verticalAlignment = z22.enum(["top", "bottom"]);
 var pin1_location = function_call.pipe(
-  z2.union([
-    z2.tuple([horizontalSide, verticalAlignment]),
-    z2.tuple([verticalSide, horizontalAlignment])
+  z22.union([
+    z22.tuple([horizontalSide, verticalAlignment]),
+    z22.tuple([verticalSide, horizontalAlignment])
   ])
 );
-var base_def = z3.object({
-  norefdes: z3.boolean().optional().describe("disable reference designator label"),
-  invert: z3.boolean().optional().describe(
+var base_def = z32.object({
+  norefdes: z32.boolean().optional().describe("disable reference designator label"),
+  invert: z32.boolean().optional().describe(
     "install the part backwards: for a pin header, the LONG pins pass through the board instead of the short ones. It does not change which side of the board the part is on \u2014 that is the component's `layer`"
   ),
-  faceup: z3.boolean().optional().describe(
+  faceup: z32.boolean().optional().describe(
     "DEPRECATED, and a no-op for through-hole parts. It meant 'the male pin header should face upwards, out of the top layer', which is what a correctly mounted header does by default; its other effect was to delete the pins below the board, leaving a through-hole part that cannot be soldered into its own plated holes. Use `layer` for which side of the board a part is on, and `invert` to install it backwards"
   ),
-  nosilkscreen: z3.boolean().optional().describe("omit all silkscreen elements from the footprint"),
+  nosilkscreen: z32.boolean().optional().describe("omit all silkscreen elements from the footprint"),
   rounded: length.refine((radius) => radius >= 0, {
     message: "rounded radius must be non-negative"
   }).optional().describe("corner radius applied to all rectangular copper pads"),
   pin1location: pin1_location.optional().describe("rotate the footprint to place pin 1 on a requested side"),
-  cathodepin: z3.coerce.number().pipe(z3.union([z3.literal(1), z3.literal(2)])).optional().describe("identify which diode pad is the cathode"),
-  anodepin: z3.coerce.number().pipe(z3.union([z3.literal(1), z3.literal(2)])).optional().describe("identify which diode pad is the anode")
+  cathodepin: z32.coerce.number().pipe(z32.union([z32.literal(1), z32.literal(2)])).optional().describe("identify which diode pad is the cathode"),
+  anodepin: z32.coerce.number().pipe(z32.union([z32.literal(1), z32.literal(2)])).optional().describe("identify which diode pad is the anode")
 });
 var platedhole = (pn, x, y, id, od) => {
   return {
@@ -15215,8 +16156,8 @@ var platedhole = (pn, x, y, id, od) => {
     shape: "circle",
     x,
     y,
-    hole_diameter: mm(id),
-    outer_diameter: mm(od),
+    hole_diameter: mm2(id),
+    outer_diameter: mm2(od),
     pcb_port_id: "",
     layers: ["top", "bottom"],
     port_hints: [pn.toString()]
@@ -15240,11 +16181,11 @@ var platedHoleWithRectPad = (options) => {
     shape: "circular_hole_with_rect_pad",
     x,
     y,
-    hole_diameter: mm(holeDiameter),
+    hole_diameter: mm2(holeDiameter),
     hole_shape: "circle",
     pad_shape: "rect",
-    rect_pad_width: mm(rectPadWidth),
-    rect_pad_height: mm(rectPadHeight),
+    rect_pad_width: mm2(rectPadWidth),
+    rect_pad_height: mm2(rectPadHeight),
     ...rectBorderRadius !== void 0 && {
       rect_border_radius: rectBorderRadius
     },
@@ -15364,17 +16305,17 @@ function convertMilToMm(value) {
   }
   return Number(value);
 }
-var lengthInMm = z4.union([z4.string(), z4.number()]).transform((val) => convertMilToMm(val));
+var lengthInMm = z42.union([z42.string(), z42.number()]).transform((val) => convertMilToMm(val));
 var extendDipDef = (newDefaults) => base_def.extend({
-  fn: z4.string(),
-  num_pins: z4.number().optional().default(6),
-  wide: z4.boolean().optional(),
-  narrow: z4.boolean().optional(),
+  fn: z42.string(),
+  num_pins: z42.number().optional().default(6),
+  wide: z42.boolean().optional(),
+  narrow: z42.boolean().optional(),
   w: lengthInMm.optional(),
   p: lengthInMm.default(newDefaults.p ?? "2.54mm"),
   id: lengthInMm.optional(),
   od: lengthInMm.optional(),
-  nosquareplating: z4.boolean().optional().default(false).describe("do not use rectangular pad for pin 1")
+  nosquareplating: z42.boolean().optional().default(false).describe("do not use rectangular pad for pin 1")
 }).transform((v) => {
   if (!v.id && !v.od) {
     if (Math.abs(v.p - 1.27) < 0.01) {
@@ -15554,8 +16495,8 @@ var silkscreenpath = (route, options = {}) => {
   };
 };
 var dpak_def = base_def.extend({
-  fn: z5.string(),
-  num_pins: z5.union([z5.literal(3), z5.literal(6)]).default(3),
+  fn: z52.string(),
+  num_pins: z52.union([z52.literal(3), z52.literal(6)]).default(3),
   p: length2.default("2.29mm").describe("pitch between adjacent lead positions"),
   pw: length2.default("1.6mm").describe("lead pad width along the pin column"),
   pl: length2.default("3mm").describe("lead pad length toward the package"),
@@ -15564,7 +16505,7 @@ var dpak_def = base_def.extend({
   span: length2.default("6.85mm").describe("center-to-center distance from the leads to the tab"),
   w: length2.default("6.6mm").describe("package body width"),
   h: length2.default("6.5mm").describe("package body height"),
-  string: z5.string().optional()
+  string: z52.string().optional()
 });
 var d2pakDefaults = {
   p: "2.54mm",
@@ -15838,9 +16779,9 @@ var createCourtyardRect = (width10, height10) => ({
   layer: "top"
 });
 var passive_def = base_def.extend({
-  fn: z6.string().optional(),
-  string: z6.string().optional(),
-  tht: z6.boolean(),
+  fn: z62.string().optional(),
+  string: z62.string().optional(),
+  tht: z62.boolean(),
   p: length3.optional(),
   pw: length3.optional(),
   ph: length3.optional(),
@@ -15850,9 +16791,9 @@ var passive_def = base_def.extend({
   h: length3.optional(),
   cyw: length3.optional().describe("courtyard width"),
   cyh: length3.optional().describe("courtyard height"),
-  nonpolarized: z6.boolean().optional(),
-  textbottom: z6.boolean().optional(),
-  roundedPads: z6.boolean().optional()
+  nonpolarized: z62.boolean().optional(),
+  textbottom: z62.boolean().optional(),
+  roundedPads: z62.boolean().optional()
 });
 var passive = (params) => {
   let {
@@ -17818,16 +18759,16 @@ var mlp = (parameters) => {
   return quad(parameters);
 };
 var ssop_def = base_def.extend({
-  fn: z22.string(),
-  num_pins: z22.number().optional().default(8),
+  fn: z222.string(),
+  num_pins: z222.number().optional().default(8),
   w: length19.default(length19.parse("3.9mm")),
   p: length19.default(length19.parse("1.27mm")),
   pw: length19.optional(),
   pl: length19.optional(),
-  legsoutside: z22.boolean().optional().default(false),
+  legsoutside: z222.boolean().optional().default(false),
   thermalpad: dim2d.optional(),
   ...thermalPadOffsetFields,
-  silkscreen_stroke_width: z22.number().optional().default(0.1)
+  silkscreen_stroke_width: z222.number().optional().default(0.1)
 }).transform((v) => {
   if (v.pw == null && v.pl == null) {
     v.pw = length19.parse("0.51mm");
@@ -19377,13 +20318,13 @@ var sot723WithoutParsing = (parameters) => {
   return pads;
 };
 var sod_def = base_def.extend({
-  fn: z32.string(),
-  num_pins: z32.literal(2).default(2),
-  w: z32.string().default("2.36mm"),
-  h: z32.string().default("1.22mm"),
-  pl: z32.string().default("0.9mm"),
-  pw: z32.string().default("1.2mm"),
-  p: z32.string().default("3.30mm")
+  fn: z322.string(),
+  num_pins: z322.literal(2).default(2),
+  w: z322.string().default("2.36mm"),
+  h: z322.string().default("1.22mm"),
+  pl: z322.string().default("0.9mm"),
+  pw: z322.string().default("1.2mm"),
+  p: z322.string().default("3.30mm")
 });
 var sod123 = (raw_params) => {
   const parameters = sod_def.parse(raw_params);
@@ -21067,8 +22008,8 @@ var pad_def = base_def.extend({
 });
 var pad = (params) => {
   const { w, h: h2 } = params;
-  const width10 = mm(w);
-  const height10 = mm(h2);
+  const width10 = mm2(w);
+  const height10 = mm2(h2);
   return {
     circuitJson: [
       rectpad(1, 0, 0, width10, height10),
@@ -21084,10 +22025,10 @@ var platedHolePill = (pn, x, y, holeDiameter, outerWidth, outerHeight) => {
     shape: "pill",
     x,
     y,
-    outer_width: mm(outerWidth),
-    outer_height: mm(outerHeight),
-    hole_width: mm(holeDiameter),
-    hole_height: mm(holeDiameter),
+    outer_width: mm2(outerWidth),
+    outer_height: mm2(outerHeight),
+    hole_width: mm2(holeDiameter),
+    hole_height: mm2(holeDiameter),
     pcb_port_id: "",
     layers: ["top", "bottom"],
     port_hints: [pn.toString()],
@@ -22011,13 +22952,13 @@ var sodWithoutParsing8 = (parameters) => {
   return pads;
 };
 var sod123FL_def = base_def.extend({
-  fn: z52.string(),
-  num_pins: z52.literal(2).default(2),
-  w: z52.string().default("4.4mm"),
-  h: z52.string().default("2.1mm"),
-  pl: z52.string().default("0.91mm"),
-  pw: z52.string().default("1.22mm"),
-  p: z52.string().default("3.146mm")
+  fn: z522.string(),
+  num_pins: z522.literal(2).default(2),
+  w: z522.string().default("4.4mm"),
+  h: z522.string().default("2.1mm"),
+  pl: z522.string().default("0.91mm"),
+  pw: z522.string().default("1.22mm"),
+  p: z522.string().default("3.146mm")
 });
 var sod123fl = (raw_params) => {
   const parameters = sod123FL_def.parse(raw_params);
@@ -22599,9 +23540,9 @@ var to220f = (raw_params) => {
         i + 1,
         x,
         holeY,
-        mm(parameters.id),
-        mm(parameters.od),
-        mm(parameters.ph)
+        mm2(parameters.id),
+        mm2(parameters.od),
+        mm2(parameters.ph)
       );
     }
   );
@@ -22970,13 +23911,13 @@ var microMelfWithoutParsing = (parameters) => {
   return pads;
 };
 var sma_def = base_def.extend({
-  fn: z62.string(),
-  num_pins: z62.literal(2).default(2),
-  w: z62.string().default("7.10mm"),
-  h: z62.string().default("3.40mm"),
-  pl: z62.string().default("2.50mm"),
-  pw: z62.string().default("1.80mm"),
-  p: z62.string().default("4.00mm")
+  fn: z622.string(),
+  num_pins: z622.literal(2).default(2),
+  w: z622.string().default("7.10mm"),
+  h: z622.string().default("3.40mm"),
+  pl: z622.string().default("2.50mm"),
+  pw: z622.string().default("1.80mm"),
+  p: z622.string().default("4.00mm")
 });
 var sma = (raw_params) => {
   const parameters = sma_def.parse(raw_params);
@@ -26335,40 +27276,40 @@ var smtpad_def = base_def.extend({
   size: length73.optional(),
   string: z85.string().optional()
 }).transform((v) => {
-  let shape = "rect";
-  if (v.circle) shape = "circle";
-  if (v.square) shape = "square";
-  if (v.rect) shape = "rect";
-  if (v.pill) shape = "pill";
+  let shape2 = "rect";
+  if (v.circle) shape2 = "circle";
+  if (v.square) shape2 = "square";
+  if (v.rect) shape2 = "rect";
+  if (v.pill) shape2 = "pill";
   let radius;
   let width10;
   let height10;
-  if (shape === "circle") {
-    if (v.r !== void 0) radius = mm(v.r);
-    else if (v.pr !== void 0) radius = mm(v.pr);
-    else if (v.radius !== void 0) radius = mm(v.radius);
-    else if (v.d !== void 0) radius = mm(v.d) / 2;
-    else if (v.pd !== void 0) radius = mm(v.pd) / 2;
-    else if (v.diameter !== void 0) radius = mm(v.diameter) / 2;
-    else radius = mm("1mm") / 2;
+  if (shape2 === "circle") {
+    if (v.r !== void 0) radius = mm2(v.r);
+    else if (v.pr !== void 0) radius = mm2(v.pr);
+    else if (v.radius !== void 0) radius = mm2(v.radius);
+    else if (v.d !== void 0) radius = mm2(v.d) / 2;
+    else if (v.pd !== void 0) radius = mm2(v.pd) / 2;
+    else if (v.diameter !== void 0) radius = mm2(v.diameter) / 2;
+    else radius = mm2("1mm") / 2;
   } else {
-    if (v.w !== void 0) width10 = mm(v.w);
-    else if (v.pw !== void 0) width10 = mm(v.pw);
-    else if (v.width !== void 0) width10 = mm(v.width);
-    else if (v.s !== void 0) width10 = mm(v.s);
-    else if (v.size !== void 0) width10 = mm(v.size);
-    else width10 = mm("1mm");
-    if (v.h !== void 0) height10 = mm(v.h);
-    else if (v.ph !== void 0) height10 = mm(v.ph);
-    else if (v.height !== void 0) height10 = mm(v.height);
-    else if (shape === "square") height10 = width10;
-    else if (shape === "rect")
+    if (v.w !== void 0) width10 = mm2(v.w);
+    else if (v.pw !== void 0) width10 = mm2(v.pw);
+    else if (v.width !== void 0) width10 = mm2(v.width);
+    else if (v.s !== void 0) width10 = mm2(v.s);
+    else if (v.size !== void 0) width10 = mm2(v.size);
+    else width10 = mm2("1mm");
+    if (v.h !== void 0) height10 = mm2(v.h);
+    else if (v.ph !== void 0) height10 = mm2(v.ph);
+    else if (v.height !== void 0) height10 = mm2(v.height);
+    else if (shape2 === "square") height10 = width10;
+    else if (shape2 === "rect")
       height10 = width10;
-    else height10 = mm("1mm");
+    else height10 = mm2("1mm");
   }
   return {
     fn: v.fn,
-    shape,
+    shape: shape2,
     radius,
     width: width10,
     height: height10
@@ -26376,13 +27317,13 @@ var smtpad_def = base_def.extend({
 });
 var smtpad = (raw_params) => {
   const params = smtpad_def.parse(raw_params);
-  const { shape, radius, width: width10, height: height10 } = params;
+  const { shape: shape2, radius, width: width10, height: height10 } = params;
   let pad2;
   let silkscreenOffset;
-  if (shape === "circle") {
+  if (shape2 === "circle") {
     pad2 = circlepad(1, { x: 0, y: 0, radius });
     silkscreenOffset = radius + 0.5;
-  } else if (shape === "pill") {
+  } else if (shape2 === "pill") {
     pad2 = pillpad(1, 0, 0, width10, height10);
     silkscreenOffset = Math.max(width10, height10) / 2 + 0.5;
   } else {
@@ -26763,14 +27704,14 @@ var platedhole_def = base_def.extend({
   squarepad: z90.boolean().optional().default(false)
 }).transform((v) => {
   let holeD;
-  if (v.d !== void 0) holeD = mm(v.d);
-  else if (v.hd !== void 0) holeD = mm(v.hd);
-  else if (v.r !== void 0) holeD = mm(v.r) * 2;
-  else if (v.hr !== void 0) holeD = mm(v.hr) * 2;
-  else holeD = mm("1mm");
+  if (v.d !== void 0) holeD = mm2(v.d);
+  else if (v.hd !== void 0) holeD = mm2(v.hd);
+  else if (v.r !== void 0) holeD = mm2(v.r) * 2;
+  else if (v.hr !== void 0) holeD = mm2(v.hr) * 2;
+  else holeD = mm2("1mm");
   let padD;
-  if (v.pd !== void 0) padD = mm(v.pd);
-  else if (v.pr !== void 0) padD = mm(v.pr) * 2;
+  if (v.pd !== void 0) padD = mm2(v.pd);
+  else if (v.pr !== void 0) padD = mm2(v.pr) * 2;
   else padD = holeD * (1.5 / 1);
   return {
     fn: v.fn,
@@ -28269,7 +29210,7 @@ var applyPin1Location = (elements, pin1Location) => {
 var clampRadius = (radius, width10, height10) => Math.min(radius, width10 / 2, height10 / 2);
 var applyRounded = (elements, rounded) => {
   if (rounded === void 0) return elements;
-  const radius = mm(rounded);
+  const radius = mm2(rounded);
   if (!Number.isFinite(radius) || radius < 0) {
     throw new Error(
       `rounded radius must be a non-negative length, got "${rounded}"`
@@ -28437,425 +29378,551 @@ footprinter.string = string2;
 footprinter.getFootprintNames = getFootprintNames;
 var fp = footprinter;
 
-// node_modules/@tscircuit/modelprinter/node_modules/@tscircuit/mm/dist/index.js
-var unitToMm2 = {
-  in: 25.4,
-  inch: 25.4,
-  mil: 0.0254,
-  mm: 1,
-  m: 1e3,
-  cm: 10,
-  ft: 304.8,
-  feet: 304.8
-};
-var mmNumberFormatter = new Intl.NumberFormat("en-US", {
-  useGrouping: false,
-  notation: "standard",
-  maximumFractionDigits: 12
-});
-var mm2 = (n) => {
-  let unit = typeof n === "number" ? "mm" : n.replace(/^[^a-zA-Z]+/g, "").toLowerCase();
-  if (!unit)
-    unit = "mm";
-  const val = typeof n === "number" ? n : Number.parseFloat(n.split(unit)[0]);
-  if (unit in unitToMm2) {
-    return val * unitToMm2[unit];
-  }
-  throw new Error(`Unsupported unit: ${unit}`);
-};
+// node_modules/jscad-electronics/dist/vanilla.js
+var import_modeling = __toESM(require_src(), 1);
 
-// node_modules/@tscircuit/modelprinter/dist/index.js
-import { z as z27 } from "zod";
-var modelLengthSchema = z27.union([z27.number(), z27.string()]).transform((value, context) => {
-  try {
-    const parsed = mm2(value);
-    if (!Number.isFinite(parsed)) throw new Error("Length is not finite");
-    return parsed;
-  } catch {
-    context.addIssue({
-      code: "custom",
-      message: `Invalid model length: ${String(value)}`
-    });
-    return z27.NEVER;
+// 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;
   }
-});
-var positiveModelLengthSchema = modelLengthSchema.refine(
-  (value) => value > 0,
-  "Length must be greater than zero"
-);
-var nonnegativeModelLengthSchema = modelLengthSchema.refine(
-  (value) => value >= 0,
-  "Length cannot be negative"
-);
-var flexScreenOrientationSchema = z27.enum([
-  "sitsFlat",
-  "sitsFlatBelowBoard",
-  "foldedToFaceAboveBoard",
-  "foldedToFaceBelowBoard",
-  "foldedToRightAngleAboveBoard",
-  "foldedToRightAngleBelowBoard"
-]);
-var positiveFiniteNumberSchema = z27.number().finite().positive();
-var aspectRatioStringSchema = z27.string().refine((value) => {
-  const parts = value.split(":");
-  if (parts.length !== 2) return false;
-  const width10 = Number(parts[0]);
-  const height10 = Number(parts[1]);
-  return Number.isFinite(width10) && Number.isFinite(height10) && width10 > 0 && height10 > 0;
-}, 'Aspect ratio must look like "16:9"').transform((value) => value);
-var flexScreenAspectRatioSchema = z27.union([
-  positiveFiniteNumberSchema,
-  aspectRatioStringSchema,
-  z27.tuple([positiveFiniteNumberSchema, positiveFiniteNumberSchema])
-]);
-var modelPointSchema = z27.object({
-  x: modelLengthSchema.optional(),
-  y: modelLengthSchema.optional(),
-  z: modelLengthSchema.optional()
-}).strict();
-var rotationValueSchema = z27.union([z27.number().finite(), z27.string().min(1)]);
-var modelRotationSchema = z27.tuple([
-  rotationValueSchema,
-  rotationValueSchema,
-  rotationValueSchema
-]);
-var orientationShortcutKeys = [
-  "sitsFlat",
-  "sitsFlatBelowBoard",
-  "foldedToFaceAboveBoard",
-  "foldedToFaceBelowBoard",
-  "foldsAboveBoard",
-  "foldsBelowBoard",
-  "foldedToRightAngleAboveBoard",
-  "foldedToRightAngleBelowBoard"
-];
-var flexScreenModelPropsShape = {
-  width: positiveModelLengthSchema.optional(),
-  height: positiveModelLengthSchema.optional(),
-  diagonal: positiveModelLengthSchema.optional(),
-  aspectRatio: flexScreenAspectRatioSchema.optional(),
-  ratio: flexScreenAspectRatioSchema.optional(),
-  defaultDiagonal: positiveModelLengthSchema.optional(),
-  orientation: flexScreenOrientationSchema.optional(),
-  sitsFlat: z27.boolean().optional(),
-  sitsFlatBelowBoard: z27.boolean().optional(),
-  foldedToFaceAboveBoard: z27.boolean().optional(),
-  foldedToFaceBelowBoard: z27.boolean().optional(),
-  foldsAboveBoard: z27.boolean().optional(),
-  foldsBelowBoard: z27.boolean().optional(),
-  foldedToRightAngleAboveBoard: z27.boolean().optional(),
-  foldedToRightAngleBelowBoard: z27.boolean().optional(),
-  screenThickness: positiveModelLengthSchema.optional(),
-  bezelInset: nonnegativeModelLengthSchema.optional(),
-  bezelDepth: positiveModelLengthSchema.optional(),
-  activeAreaWidth: positiveModelLengthSchema.optional(),
-  activeAreaHeight: positiveModelLengthSchema.optional(),
-  screenColor: z27.string().min(1).optional(),
-  bezelColor: z27.string().min(1).optional(),
-  showScreen: z27.boolean().optional(),
-  flexCableLength: positiveModelLengthSchema.optional(),
-  flexCableWidth: positiveModelLengthSchema.optional(),
-  flexCableThickness: positiveModelLengthSchema.optional(),
-  flexCableColor: z27.string().min(1).optional(),
-  conductorCount: z27.number().int().positive().optional(),
-  conductorPitch: positiveModelLengthSchema.optional(),
-  conductorWidth: positiveModelLengthSchema.optional(),
-  conductorThickness: positiveModelLengthSchema.optional(),
-  conductorColor: z27.string().min(1).optional(),
-  cableEdgeMargin: nonnegativeModelLengthSchema.optional(),
-  exposedContactLength: nonnegativeModelLengthSchema.optional(),
-  showConductors: z27.boolean().optional(),
-  showFlexCable: z27.boolean().optional(),
-  showStiffeners: z27.boolean().optional(),
-  stiffenerLength: nonnegativeModelLengthSchema.optional(),
-  stiffenerThickness: positiveModelLengthSchema.optional(),
-  stiffenerColor: z27.string().min(1).optional(),
-  bendRadius: positiveModelLengthSchema.optional(),
-  bendSegments: z27.number().int().min(2).optional(),
-  rightAngleVerticalLead: nonnegativeModelLengthSchema.optional(),
-  distanceAboveBoard: nonnegativeModelLengthSchema.optional(),
-  distanceBelowBoard: nonnegativeModelLengthSchema.optional(),
-  foldDistanceFromConnector: nonnegativeModelLengthSchema.optional(),
-  foldOutset: positiveModelLengthSchema.optional(),
-  foldSegments: z27.number().int().min(4).optional(),
-  screenGap: nonnegativeModelLengthSchema.optional(),
-  boardTopZ: modelLengthSchema.optional(),
-  boardThickness: positiveModelLengthSchema.optional(),
-  boardClearance: nonnegativeModelLengthSchema.optional(),
-  cableStartX: modelLengthSchema.optional(),
-  cableStartY: modelLengthSchema.optional(),
-  cableStartZ: modelLengthSchema.optional(),
-  cableLateralOffset: modelLengthSchema.optional(),
-  screenOffset: modelPointSchema.optional(),
-  screenRotation: modelRotationSchema.optional(),
-  rotation: modelRotationSchema.optional(),
-  offset: modelPointSchema.optional()
-};
-var addOrientationShortcutIssue = (props, addIssue) => {
-  const selectedShortcuts = orientationShortcutKeys.filter(
-    (key) => props[key] === true
-  );
-  if (selectedShortcuts.length > 1) addIssue(selectedShortcuts[1]);
-};
-var flexScreenModelPropsSchema = z27.object(flexScreenModelPropsShape).strict().superRefine((props, context) => {
-  addOrientationShortcutIssue(props, (path) => {
-    context.addIssue({
-      code: "custom",
-      message: "Only one FlexScreen orientation shortcut can be true",
-      path: [path]
-    });
-  });
-});
-var flexScreenModelDefinitionSchema = z27.object({
-  fn: z27.literal("flexscreen"),
-  ...flexScreenModelPropsShape
-}).strict().superRefine((model, context) => {
-  addOrientationShortcutIssue(model, (path) => {
-    context.addIssue({
-      code: "custom",
-      message: "Only one FlexScreen orientation shortcut can be true",
-      path: [path]
-    });
-  });
-});
-var parsePart = (part) => {
-  const match = part.match(/^([a-zA-Z]+)([\(\d\.\+\-].*)?$/);
-  if (!match?.[1]) return void 0;
-  return {
-    fn: match[1].toLowerCase(),
-    value: match[2]
-  };
-};
-var parseModelStringParams = (definition) => {
-  const normalizedDefinition = definition.trim();
-  if (!normalizedDefinition) throw new Error("Model string cannot be empty");
-  const parts = normalizedDefinition.split("_");
-  const firstPart = parts[0];
-  const first = parsePart(firstPart);
-  const params = {};
-  const fn = first?.fn ?? firstPart.toLowerCase();
-  params[fn] = true;
-  params.fn = fn;
-  if (first?.value) {
-    const numericValue = Number.parseFloat(first.value);
-    if (Number.isFinite(numericValue)) params.num_pins = numericValue;
+  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);
   }
-  for (const part of parts.slice(1)) {
-    if (!part) throw new Error("Model strings cannot contain empty tokens");
-    const parsed = parsePart(part);
-    if (!parsed) throw new Error(`Invalid model string token "${part}"`);
-    params[parsed.fn] = parsed.value ?? true;
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
   }
-  params.string = normalizedDefinition;
-  return params;
-};
-var orientationTokens = {
-  sitsflat: "sitsFlat",
-  sitsflatbelow: "sitsFlatBelowBoard",
-  sitsflatbelowboard: "sitsFlatBelowBoard",
-  foldsabove: "foldedToFaceAboveBoard",
-  foldsaboveboard: "foldedToFaceAboveBoard",
-  foldedtofaceaboveboard: "foldedToFaceAboveBoard",
-  foldsbelow: "foldedToFaceBelowBoard",
-  foldsbelowboard: "foldedToFaceBelowBoard",
-  foldedtofacebelowboard: "foldedToFaceBelowBoard",
-  rightangleabove: "foldedToRightAngleAboveBoard",
-  rightangleaboveboard: "foldedToRightAngleAboveBoard",
-  foldedtorightangleaboveboard: "foldedToRightAngleAboveBoard",
-  rightanglebelow: "foldedToRightAngleBelowBoard",
-  rightanglebelowboard: "foldedToRightAngleBelowBoard",
-  foldedtorightanglebelowboard: "foldedToRightAngleBelowBoard"
-};
-var lengthProperties = {
-  width: ["width", "w"],
-  height: ["height", "h"],
-  diagonal: ["diagonal", "diag", "d"],
-  defaultDiagonal: ["defaultdiagonal", "defaultdiag"],
-  screenThickness: ["screenthickness"],
-  bezelInset: ["bezelinset"],
-  bezelDepth: ["bezeldepth"],
-  activeAreaWidth: ["activeareawidth", "activew"],
-  activeAreaHeight: ["activeareaheight", "activeh"],
-  flexCableLength: ["flexcablelength", "flexlength", "flex"],
-  flexCableWidth: ["flexcablewidth", "flexwidth"],
-  flexCableThickness: ["flexcablethickness", "flexthickness"],
-  conductorPitch: ["conductorpitch"],
-  conductorWidth: ["conductorwidth"],
-  conductorThickness: ["conductorthickness"],
-  cableEdgeMargin: ["cableedgemargin", "edgemargin"],
-  exposedContactLength: ["exposedcontactlength", "contactlength"],
-  stiffenerLength: ["stiffenerlength"],
-  stiffenerThickness: ["stiffenerthickness"],
-  bendRadius: ["bendradius"],
-  rightAngleVerticalLead: ["rightangleverticallead", "verticallead"],
-  distanceAboveBoard: ["distanceaboveboard", "distanceabove"],
-  distanceBelowBoard: ["distancebelowboard", "distancebelow"],
-  foldDistanceFromConnector: [
-    "folddistancefromconnector",
-    "folddistance",
-    "foldstart"
-  ],
-  foldOutset: ["foldoutset", "outset"],
-  screenGap: ["screengap"],
-  boardTopZ: ["boardtopz"],
-  boardThickness: ["boardthickness"],
-  boardClearance: ["boardclearance"],
-  cableStartX: ["cablestartx"],
-  cableStartY: ["cablestarty"],
-  cableStartZ: ["cablestartz"],
-  cableLateralOffset: ["cablelateraloffset", "lateraloffset"]
-};
-var lengthTokenToProperty = Object.fromEntries(
-  Object.entries(lengthProperties).flatMap(
-    ([property, tokens]) => tokens.map((token) => [token, property])
-  )
-);
-var integerTokenToProperty = {
-  conductorcount: "conductorCount",
-  conductors: "conductorCount",
-  bendsegments: "bendSegments",
-  foldsegments: "foldSegments"
-};
-var booleanTokens = {
-  showscreen: ["showScreen", true],
-  hidescreen: ["showScreen", false],
-  showflex: ["showFlexCable", true],
-  hideflex: ["showFlexCable", false],
-  showconductors: ["showConductors", true],
-  hideconductors: ["showConductors", false],
-  showstiffeners: ["showStiffeners", true],
-  hidestiffeners: ["showStiffeners", false]
-};
-var colorProperties = {
-  screencolor: "screenColor",
-  bezelcolor: "bezelColor",
-  flexcolor: "flexCableColor",
-  conductorcolor: "conductorColor",
-  stiffenercolor: "stiffenerColor"
-};
-var parseAspectRatio = (value) => {
-  const normalized = String(value).toLowerCase().replace("x", ":");
-  if (normalized.includes(":")) {
-    const [width10, height10, extra] = normalized.split(":");
-    const numericWidth = Number(width10);
-    const numericHeight = Number(height10);
-    if (extra !== void 0 || !Number.isFinite(numericWidth) || !Number.isFinite(numericHeight) || numericWidth <= 0 || numericHeight <= 0) {
-      throw new Error(`Invalid FlexScreen aspect ratio "${String(value)}"`);
+  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;
     }
-    return `${numericWidth}:${numericHeight}`;
-  }
-  const numeric = Number(normalized);
-  if (!Number.isFinite(numeric) || numeric <= 0) {
-    throw new Error(`Invalid FlexScreen aspect ratio "${String(value)}"`);
   }
-  return numeric;
-};
-var unwrapFunctionValue = (value, token) => {
-  if (typeof value !== "string" || !/^\(.+\)$/.test(value)) {
-    throw new Error(`FlexScreen token "${token}" requires a value in (...)`);
+}
+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 value.slice(1, -1);
-};
-var assertBareToken = (value, token) => {
-  if (value !== true) {
-    throw new Error(`FlexScreen token "${token}" does not accept a value`);
+  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;
   }
-};
-var parseFlexScreenModelParams = (rawParams) => {
-  if (rawParams.fn !== "flexscreen") {
-    throw new Error(`Expected FlexScreen params, got "${rawParams.fn}"`);
+  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;
   }
-  const props = {};
-  let orientation2;
-  let relativeDistance;
-  for (const [token, value] of Object.entries(rawParams)) {
-    if (token === "fn" || token === "string" || token === "flexscreen") {
-      continue;
+  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;
     }
-    const tokenOrientation = orientationTokens[token];
-    if (tokenOrientation) {
-      assertBareToken(value, token);
-      if (orientation2 && orientation2 !== tokenOrientation) {
-        throw new Error(
-          "A FlexScreen model string can only set one orientation"
-        );
+    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;
       }
-      orientation2 = tokenOrientation;
-      props.orientation = tokenOrientation;
-      continue;
-    }
-    if (token in booleanTokens) {
-      assertBareToken(value, token);
-      const [property, enabled] = booleanTokens[token];
-      props[property] = enabled;
-      continue;
-    }
-    const colorProperty = colorProperties[token];
-    if (colorProperty) {
-      props[colorProperty] = unwrapFunctionValue(value, token);
-      continue;
-    }
-    if (token === "ratio") {
-      props.aspectRatio = parseAspectRatio(value);
-      continue;
-    }
-    const lengthProperty = lengthTokenToProperty[token];
-    if (lengthProperty) {
-      props[lengthProperty] = value;
-      continue;
-    }
-    if (token === "distance") {
-      relativeDistance = value;
-      continue;
+      b = b.next;
     }
-    const integerProperty = integerTokenToProperty[token];
-    if (integerProperty) {
-      const parsed = Number(value);
-      if (!Number.isInteger(parsed) || parsed < 1) {
-        throw new Error(
-          `Invalid positive integer in FlexScreen token "${token}${String(value)}"`
-        );
+    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 = p.x, minY = p.y, maxX = p.x, maxY = p.y;
+    let k = 0;
+    do {
+      const c = p.next;
+      p.z = b;
+      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;
+          }
+        }
       }
-      props[integerProperty] = parsed;
+      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;
+  sortArr.fill(
+    /** @type {Node} */
+    /** @type {unknown} */
+    null,
+    0,
+    n
+  );
+  sortBuf.fill(
+    /** @type {Node} */
+    /** @type {unknown} */
+    null,
+    0,
+    n
+  );
+}
+function sortNodes(n) {
+  if (n <= 32) {
+    for (let i = 1; i < n; i++) {
+      const node = sortArr[i], z27 = node.z;
+      let j = i - 1;
+      while (j >= 0 && sortArr[j].z > z27) {
+        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 z27 = srcZ[i];
+    const pos = counts[z27 >>> shift4 & 255]++;
+    dst[pos] = src[i];
+    dstZ[pos] = z27;
+  }
+}
+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 && onSegment(p1, p2, q1)) return true;
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+  return false;
+}
+function onSegment(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;
     }
-    throw new Error(`Unknown FlexScreen model token "${token}${String(value)}"`);
+    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;
   }
-  if (relativeDistance !== void 0) {
-    if (orientation2 === "foldedToFaceAboveBoard") {
-      props.distanceAboveBoard = relativeDistance;
-    } else if (orientation2 === "foldedToFaceBelowBoard") {
-      props.distanceBelowBoard = relativeDistance;
-    } else {
-      throw new Error(
-        'The "distance" token requires foldsabove or foldsbelow; use distanceabove or distancebelow for an explicit side'
-      );
+  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 flexScreenModelDefinitionSchema.parse({ fn: "flexscreen", ...props });
-};
-var modelFunctions = {
-  flexscreen: parseFlexScreenModelParams
+  return sum;
+}
+
+// node_modules/jscad-electronics/dist/vanilla.js
+var import_modeling2 = __toESM(require_src(), 1);
+
+// node_modules/jscad-electronics/node_modules/@tscircuit/mm/dist/index.js
+var unitToMm3 = {
+  in: 25.4,
+  inch: 25.4,
+  mil: 0.0254,
+  mm: 1,
+  m: 1e3,
+  cm: 10,
+  ft: 304.8,
+  feet: 304.8
 };
-var modelParamsToJson = (params) => {
-  const modelFunction = modelFunctions[params.fn];
-  if (modelFunction) {
-    return modelFunction(params);
+var mm3 = (n) => {
+  let unit = typeof n === "number" ? "mm" : n.replace(/^[^a-zA-Z]+/g, "").toLowerCase();
+  if (!unit)
+    unit = "mm";
+  const val = typeof n === "number" ? n : Number.parseFloat(n.split(unit)[0]);
+  if (unit in unitToMm3) {
+    return val * unitToMm3[unit];
   }
-  throw new Error(`Unsupported modelprinter function "${params.fn}"`);
-};
-var string = (value) => {
-  const params = parseModelStringParams(value);
-  return {
-    params: () => params,
-    json: () => modelParamsToJson(params)
-  };
-};
-var modelprinter = {
-  string,
-  getModelNames: () => Object.keys(modelFunctions)
+  throw new Error(`Unsupported unit: ${unit}`);
 };
-var mp = modelprinter;
 
 // node_modules/jscad-electronics/dist/vanilla.js
 import {
@@ -28895,6 +29962,7 @@ var Colorize = /* @__PURE__ */ Symbol("Colorize");
 var Polygon = /* @__PURE__ */ Symbol("Polygon");
 var ExtrudeLinear = /* @__PURE__ */ Symbol("ExtrudeLinear");
 var RoundedCylinder = /* @__PURE__ */ Symbol("RoundedCylinder");
+var Custom = /* @__PURE__ */ Symbol("Custom");
 var Fragment2 = Fragment;
 var jsx3 = (type, props, _key) => h(type, props);
 var jsxs = (type, props, _key) => h(type, props);
@@ -28985,6 +30053,363 @@ var FootprintPlatedHole = ({
   }
   throw new Error("Shape not supported: " + hole.shape);
 };
+var createHexSocketBoltMesh = (input) => {
+  const props = hexSocketBoltModelPropsSchema.parse(input);
+  const {
+    diameter,
+    threadPitch: pitch,
+    headDiameter,
+    headHeight,
+    socketWidth,
+    socketDepth
+  } = hexSocketBoltDimensions[props.metricSize];
+  const { length: length83, showThreads } = props;
+  const segments = 96;
+  const steps = Math.max(2, Math.ceil(length83 / pitch * 24));
+  if (steps > 24e3)
+    throw new Error(
+      "Bolt length exceeds mesh resolution limit (1000 thread turns)"
+    );
+  const positions = [];
+  const indices = [];
+  const radius = diameter / 2;
+  const depth = pitch * 0.61343;
+  const bevel = Math.min(0.2, headHeight * 0.08);
+  const tipBevel = Math.min(pitch * 0.6, length83 / 3);
+  const ring = (z27, radiusAt) => {
+    const start = positions.length / 3;
+    for (let i = 0; i < segments; i++) {
+      const angle = i * Math.PI * 2 / segments;
+      const r = radiusAt(angle);
+      positions.push(r * Math.cos(angle), r * Math.sin(angle), z27);
+    }
+    return start;
+  };
+  const connect = (a, b) => {
+    for (let i = 0; i < segments; i++) {
+      const next = (i + 1) % segments;
+      indices.push(a + i, a + next, b + next, a + i, b + next, b + i);
+    }
+  };
+  const cap2 = (start, z27, upward) => {
+    const center = positions.length / 3;
+    positions.push(0, 0, z27);
+    for (let i = 0; i < segments; i++) {
+      const a = start + i;
+      const b = start + (i + 1) % segments;
+      indices.push(center, upward ? a : b, upward ? b : a);
+    }
+  };
+  let previous = -1;
+  for (let step = 0; step <= steps; step++) {
+    const z27 = -length83 + length83 * step / steps;
+    const current = ring(z27, (angle) => {
+      const phase = ((z27 / pitch - angle / (2 * Math.PI)) % 1 + 1) % 1;
+      const distance22 = Math.min(phase, 1 - phase);
+      const groove = Math.min(
+        depth,
+        Math.max(0, (distance22 - 1 / 16) * pitch * Math.sqrt(3))
+      );
+      const endRamp = Math.min(
+        1,
+        (z27 + length83) / tipBevel,
+        -z27 / Math.min(pitch / 2, length83 / 3)
+      );
+      const tipCut = tipBevel * Math.max(0, 1 - (z27 + length83) / tipBevel);
+      return radius - (showThreads ? groove * endRamp : 0) - tipCut;
+    });
+    if (previous < 0) cap2(current, z27, false);
+    else connect(previous, current);
+    previous = current;
+  }
+  const addRing = (z27, radiusAt) => {
+    const current = ring(z27, radiusAt);
+    connect(previous, current);
+    previous = current;
+  };
+  addRing(0, () => headDiameter / 2 - bevel);
+  addRing(bevel, () => headDiameter / 2);
+  addRing(headHeight - bevel, () => headDiameter / 2);
+  addRing(headHeight, () => headDiameter / 2 - bevel);
+  const hexRadius = (angle, acrossFlats) => acrossFlats / 2 / Math.cos((angle + Math.PI / 6) % (Math.PI / 3) - Math.PI / 6);
+  addRing(headHeight, (angle) => hexRadius(angle, socketWidth + bevel));
+  addRing(headHeight - bevel / 2, (angle) => hexRadius(angle, socketWidth));
+  addRing(headHeight - socketDepth, (angle) => hexRadius(angle, socketWidth));
+  cap2(previous, headHeight - socketDepth, true);
+  return { positions, indices };
+};
+function indexedMeshToGeom3(mesh) {
+  const polygons = [];
+  for (let i = 0; i < mesh.indices.length; i += 3)
+    polygons.push(
+      mesh.indices.slice(i, i + 3).map((index2) => [
+        mesh.positions[index2 * 3],
+        mesh.positions[index2 * 3 + 1],
+        mesh.positions[index2 * 3 + 2]
+      ])
+    );
+  return import_modeling.default.geometries.geom3.fromPoints(polygons);
+}
+function createHexSocketBoltGeom(input) {
+  return indexedMeshToGeom3(createHexSocketBoltMesh(input));
+}
+function HexSocketBolt({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3(Colorize, { color, children: /* @__PURE__ */ jsx3(Custom, { geometry: createHexSocketBoltGeom(props) }) });
+}
+function holeOutline(hole) {
+  const radius = (hole.shape === "round" ? hole.diameter : hole.width) / 2;
+  const straight = hole.shape === "slot" ? (hole.length - hole.width) / 2 : 0;
+  if (straight < 0) throw new Error("Slot length must be at least its width");
+  return Array.from({ length: 64 }, (_, i) => {
+    if (hole.shape === "round") {
+      const angle2 = i * Math.PI / 32;
+      return {
+        u: hole.u + radius * Math.cos(angle2),
+        v: hole.v + radius * Math.sin(angle2)
+      };
+    }
+    const half = i < 32 ? 1 : -1;
+    const angle = -Math.PI / 2 + (i < 32 ? i : i - 32) * Math.PI / 31 + (i < 32 ? 0 : Math.PI);
+    const along = half * straight + radius * Math.cos(angle);
+    const across = radius * Math.sin(angle);
+    return hole.shape === "slot" && hole.axis === "v" ? { u: hole.u - across, v: hole.v + along } : { u: hole.u + along, v: hole.v + across };
+  });
+}
+function createSheetMetalMesh(input) {
+  const props = sheetMetalModelPropsSchema.parse(input);
+  const { width: width10, baseLength, flangeHeight, thickness, profile } = props;
+  const radius = props.insideBendRadius + thickness / 2;
+  const positions = [];
+  const indices = [];
+  const addTriangle = (vertices, reverse = false) => {
+    const start = positions.length / 3;
+    for (const vertex of vertices) positions.push(...vertex);
+    indices.push(start, start + (reverse ? 2 : 1), start + (reverse ? 1 : 2));
+  };
+  const addQuad = (vertices, reverse = false) => {
+    addTriangle([vertices[0], vertices[1], vertices[2]], reverse);
+    addTriangle([vertices[0], vertices[2], vertices[3]], reverse);
+  };
+  const panels = profile === "plate" ? ["base"] : profile === "angle" ? ["base", "right"] : ["base", "left", "right"];
+  for (const hole of props.holes) {
+    if (!panels.includes(hole.panel))
+      throw new Error(`No ${hole.panel} panel on ${profile}`);
+  }
+  for (const panel of panels) {
+    const length83 = panel === "base" ? baseLength : flangeHeight;
+    const holes = props.holes.filter((hole) => hole.panel === panel).map(holeOutline);
+    const bounds = holes.map((outline2) => ({
+      minU: Math.min(...outline2.map((p) => p.u)),
+      maxU: Math.max(...outline2.map((p) => p.u)),
+      minV: Math.min(...outline2.map((p) => p.v)),
+      maxV: Math.max(...outline2.map((p) => p.v))
+    }));
+    for (const [i, box] of bounds.entries()) {
+      if (box.minU <= -length83 / 2 || box.maxU >= length83 / 2 || box.minV <= -width10 / 2 || box.maxV >= width10 / 2)
+        throw new Error(`Hole crosses ${panel} panel edge or bend tangent`);
+      for (const previous of bounds.slice(0, i))
+        if (box.minU <= previous.maxU && box.maxU >= previous.minU && box.minV <= previous.maxV && box.maxV >= previous.minV)
+          throw new Error("Hole bounding boxes must not overlap");
+    }
+    const outline = [
+      { u: -length83 / 2, v: -width10 / 2 },
+      { u: length83 / 2, v: -width10 / 2 },
+      { u: length83 / 2, v: width10 / 2 },
+      { u: -length83 / 2, v: width10 / 2 }
+    ];
+    const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
+    const points = loops.flat();
+    const starts = holes.map((_, i) => 4 + i * 64);
+    const triangles = earcut(
+      points.flatMap((p) => [p.u, p.v]),
+      starts
+    );
+    const project = (point, offset4) => panel === "base" ? [point.u, point.v, offset4] : [
+      (panel === "left" ? -1 : 1) * (baseLength / 2 + radius - offset4),
+      point.v,
+      radius + flangeHeight / 2 + point.u
+    ];
+    const reverse = panel === "left";
+    for (let i = 0; i < triangles.length; i += 3) {
+      const face2 = triangles.slice(i, i + 3).map((index2) => points[index2]);
+      addTriangle(
+        face2.map((p) => project(p, thickness / 2)),
+        reverse
+      );
+      addTriangle(
+        face2.map((p) => project(p, -thickness / 2)),
+        !reverse
+      );
+    }
+    for (const [loopIndex, loop] of loops.entries())
+      for (let i = 0; i < loop.length; i++) {
+        const a = loop[i], b = loop[(i + 1) % loop.length];
+        if (loopIndex === 0 && a.u === b.u && (panel === "base" && (a.u > 0 && profile !== "plate" || a.u < 0 && profile === "channel") || panel !== "base" && a.u < 0))
+          continue;
+        addQuad(
+          [
+            project(a, -thickness / 2),
+            project(b, -thickness / 2),
+            project(b, thickness / 2),
+            project(a, thickness / 2)
+          ],
+          reverse
+        );
+      }
+  }
+  const sides2 = profile === "plate" ? [] : profile === "angle" ? [1] : [-1, 1];
+  for (const side of sides2) {
+    const project = (angle, crossSection) => {
+      const r = radius - crossSection.offset;
+      return [
+        side * (baseLength / 2 + r * Math.sin(angle)),
+        crossSection.y,
+        radius - r * Math.cos(angle)
+      ];
+    };
+    for (let i = 0; i < 32; i++) {
+      const a = i * Math.PI / 64, b = (i + 1) * Math.PI / 64;
+      for (const offset4 of [-thickness / 2, thickness / 2]) {
+        addQuad(
+          [
+            project(a, { y: -width10 / 2, offset: offset4 }),
+            project(b, { y: -width10 / 2, offset: offset4 }),
+            project(b, { y: width10 / 2, offset: offset4 }),
+            project(a, { y: width10 / 2, offset: offset4 })
+          ],
+          offset4 < 0 !== side < 0
+        );
+      }
+      for (const y of [-width10 / 2, width10 / 2]) {
+        addQuad(
+          [
+            project(a, { y, offset: -thickness / 2 }),
+            project(b, { y, offset: -thickness / 2 }),
+            project(b, { y, offset: thickness / 2 }),
+            project(a, { y, offset: thickness / 2 })
+          ],
+          y > 0 !== side < 0
+        );
+      }
+    }
+  }
+  return { positions, indices };
+}
+function createSheetMetalGeom(input) {
+  return indexedMeshToGeom3(createSheetMetalMesh(input));
+}
+function SheetMetal({ color = "#737e8f", ...props }) {
+  return /* @__PURE__ */ jsx3(Colorize, { color, children: /* @__PURE__ */ jsx3(Custom, { geometry: createSheetMetalGeom(props) }) });
+}
+var resolveNemaMotorProps = nemaMotorModelPropsSchema.parse.bind(
+  nemaMotorModelPropsSchema
+);
+var circle = (radius, x = 0, y = 0) => Array.from({ length: 96 }, (_, i) => [
+  x + radius * Math.cos(i * Math.PI / 48),
+  y + radius * Math.sin(i * Math.PI / 48)
+]);
+var face = (width10, chamfer) => {
+  const h2 = width10 / 2, c = chamfer;
+  if (c === 0)
+    return [
+      [-h2, -h2],
+      [h2, -h2],
+      [h2, h2],
+      [-h2, h2]
+    ];
+  return [
+    [-h2 + c, -h2],
+    [h2 - c, -h2],
+    [h2, -h2 + c],
+    [h2, h2 - c],
+    [h2 - c, h2],
+    [-h2 + c, h2],
+    [-h2, h2 - c],
+    [-h2, -h2 + c]
+  ];
+};
+function createNemaMotorSections(input) {
+  const p = resolveNemaMotorProps(input);
+  const sections = [];
+  const add = (name, outline, zMin, zMax, holes2 = []) => {
+    if (zMax > zMin) sections.push({ name, outline, holes: holes2, zMin, zMax });
+  };
+  const front = face(p.bodyWidth, p.faceCornerChamfer);
+  const core = face(p.bodyWidth, p.bodyCornerChamfer);
+  const h2 = p.mountingHoleSpacing / 2;
+  const centers = [
+    [-h2, -h2],
+    [h2, -h2],
+    [h2, h2],
+    [-h2, h2]
+  ];
+  const holes = centers.map(
+    ([x, y]) => circle(p.mountingHoleDiameter / 2, x, y)
+  );
+  const holeDepth = p.mountingHoleThrough ? p.frontCapLength : p.mountingHoleDepth;
+  add("frontCap", front, -holeDepth, 0, holes);
+  add("frontCap", front, -p.frontCapLength, -holeDepth);
+  add("body", core, -p.bodyLength + p.rearCapLength, -p.frontCapLength);
+  add(
+    "rearCap",
+    p.mountingHoleThrough ? core : front,
+    -p.bodyLength,
+    -p.bodyLength + p.rearCapLength
+  );
+  add("pilot", circle(p.pilotDiameter / 2), 0, p.pilotLength);
+  const r = p.shaftDiameter / 2;
+  const round2 = circle(r);
+  if (p.shaftShape === "round")
+    add("shaft", round2, p.pilotLength, p.shaftLength);
+  else {
+    const cut = r - p.shaftFlatDepth;
+    const angle = Math.acos(cut / r);
+    const profile = Array.from({ length: 97 }, (_, i) => {
+      const a = angle + (2 * Math.PI - 2 * angle) * i / 96;
+      return [r * Math.cos(a), r * Math.sin(a)];
+    });
+    const rotation = p.shaftFlatAngle * Math.PI / 180;
+    const d = profile.map(([x, y]) => [
+      x * Math.cos(rotation) - y * Math.sin(rotation),
+      x * Math.sin(rotation) + y * Math.cos(rotation)
+    ]);
+    add("shaft", round2, p.pilotLength, p.shaftLength - p.shaftFlatLength);
+    add("shaft", d, p.shaftLength - p.shaftFlatLength, p.shaftLength);
+  }
+  return sections;
+}
+function NemaMotor({
+  bodyColor = "#242830",
+  capColor = "#aeb5bd",
+  shaftColor = "#b8bec6",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3(Fragment2, { children: createNemaMotorSections(props).map((section, index2) => {
+    const outline = import_modeling2.default.geometries.geom2.fromPoints(section.outline);
+    const profile = section.holes.length ? import_modeling2.default.booleans.subtract(
+      outline,
+      ...section.holes.map((h2) => import_modeling2.default.geometries.geom2.fromPoints(h2))
+    ) : outline;
+    const geometry = import_modeling2.default.transforms.translate(
+      [0, 0, section.zMin],
+      import_modeling2.default.extrusions.extrudeLinear(
+        { height: section.zMax - section.zMin },
+        profile
+      )
+    );
+    return /* @__PURE__ */ jsx3(
+      Colorize,
+      {
+        color: section.name === "body" ? bodyColor : section.name === "shaft" ? shaftColor : capColor,
+        children: /* @__PURE__ */ jsx3(Custom, { geometry })
+      },
+      `${section.name}-${index2}`
+    );
+  }) });
+}
 function LGA(p) {
   for (const k of [
     "bodyWidth",
@@ -29167,7 +30592,7 @@ function createDualRowGullWing(p) {
       ]);
     }
     points.push([root, midZ]);
-    const section = ([x, z42]) => /* @__PURE__ */ jsx3(Translate, { offset: { x: side * x, y, z: z42 }, children: /* @__PURE__ */ jsx3(Cuboid, { size: [slice, leadWidth, leadThickness] }) });
+    const section = ([x, z27]) => /* @__PURE__ */ jsx3(Translate, { offset: { x: side * x, y, z: z27 }, children: /* @__PURE__ */ jsx3(Cuboid, { size: [slice, leadWidth, leadThickness] }) });
     return /* @__PURE__ */ jsx3(Union, { children: points.slice(1).map((point, i) => /* @__PURE__ */ jsxs(Hull, { children: [
       section(points[i]),
       section(point)
@@ -29423,10 +30848,10 @@ var svgPathPoints = normalizeOnY([
 ]);
 var DIP_PIN_HEIGHT = 5.47;
 var heightAboveSurface = 0.5;
-var DipPinLeg = ({ x, y, z: z42 }) => {
+var DipPinLeg = ({ x, y, z: z27 }) => {
   const isRotated = x > 0;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
-    /* @__PURE__ */ jsx3(Translate, { offset: { x: x + 0.25 / 2, y, z: z42 }, children: /* @__PURE__ */ jsx3(Rotate, { rotation: ["-90deg", 0, "90deg"], children: /* @__PURE__ */ jsx3(ExtrudeLinear, { height: 0.25, children: /* @__PURE__ */ jsx3(
+    /* @__PURE__ */ jsx3(Translate, { offset: { x: x + 0.25 / 2, y, z: z27 }, children: /* @__PURE__ */ jsx3(Rotate, { rotation: ["-90deg", 0, "90deg"], children: /* @__PURE__ */ jsx3(ExtrudeLinear, { height: 0.25, children: /* @__PURE__ */ jsx3(
       Polygon,
       {
         points: svgPathPoints.slice().reverse().map((p) => [p.x, p.y])
@@ -29438,7 +30863,7 @@ var DipPinLeg = ({ x, y, z: z42 }) => {
         offset: {
           x,
           y: y + (isRotated ? 1 : -1),
-          z: z42
+          z: z27
         },
         children: /* @__PURE__ */ jsx3(Rotate, { rotation: ["-90deg", "90deg", isRotated ? "180deg" : "0deg"], children: /* @__PURE__ */ jsx3(ExtrudeLinear, { height: 2, children: /* @__PURE__ */ jsx3(
           Polygon,
@@ -29723,6 +31148,64 @@ var A0603 = ({ color = "#333" }) => {
     )
   ] });
 };
+var smdLedDimensions = {
+  "0402": { length: 1, width: 0.5, height: 0.5, terminalLength: 0.2 },
+  "0603": { length: 1.62, width: 0.8, height: 0.615, terminalLength: 0.21 },
+  "0805": { length: 2, width: 1.25, height: 0.75, terminalLength: 0.35 }
+};
+function SmdLED({
+  footprint,
+  color = "#ffe8a0"
+}) {
+  const p = smdLedDimensions[footprint];
+  if (footprint === "0603")
+    return /* @__PURE__ */ jsxs(Fragment2, { children: [
+      /* @__PURE__ */ jsx3(Colorize, { color: "#f0eee7", children: /* @__PURE__ */ jsx3(
+        RoundedCuboid,
+        {
+          size: [1.2, 0.79, 0.6],
+          roundRadius: 0.02,
+          center: [0, 0, 0.31]
+        }
+      ) }),
+      /* @__PURE__ */ jsx3(Colorize, { color: "#c7c9ca", children: [-1, 1].map((sign) => /* @__PURE__ */ jsx3(
+        Cuboid,
+        {
+          size: [0.21, 0.8, 0.22],
+          center: [sign * 0.705, 0, 0.11]
+        },
+        sign
+      )) }),
+      /* @__PURE__ */ jsx3(Colorize, { color, children: /* @__PURE__ */ jsx3(Cuboid, { size: [0.72, 0.52, 0.01], center: [0, 0, 0.61] }) })
+    ] });
+  const terminalThickness = Math.min(0.1, p.height / 4);
+  const apertureHeight = 0.02;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx3(Colorize, { color: "#f0eee7", children: /* @__PURE__ */ jsx3(Translate, { z: (p.height + terminalThickness - apertureHeight) / 2, children: /* @__PURE__ */ jsx3(
+      Cuboid,
+      {
+        size: [
+          p.length,
+          p.width,
+          p.height - terminalThickness - apertureHeight
+        ]
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx3(Colorize, { color: "#c7c9ca", children: [-1, 1].map((sign) => /* @__PURE__ */ jsx3(
+      Translate,
+      {
+        offset: [
+          sign * (p.length - p.terminalLength) / 2,
+          0,
+          terminalThickness / 2
+        ],
+        children: /* @__PURE__ */ jsx3(Cuboid, { size: [p.terminalLength, p.width, terminalThickness] })
+      },
+      sign
+    )) }),
+    /* @__PURE__ */ jsx3(Colorize, { color, children: /* @__PURE__ */ jsx3(Translate, { z: p.height - apertureHeight / 2, children: /* @__PURE__ */ jsx3(Cuboid, { size: [p.length * 0.45, p.width * 0.65, apertureHeight] }) }) })
+  ] });
+}
 var fullLength3 = 2;
 var width3 = 1.25;
 var height3 = 0.55;
@@ -30012,7 +31495,7 @@ var PinRow = ({
   const xoff = -((pinsPerRow - 1) / 2) * pitch;
   const throughHole = !smd && !rightangle;
   const flipped = throughHole ? !invert : Boolean(invert);
-  const flipZ = (z42) => flipped ? -z42 + bodyHeight : z42;
+  const flipZ = (z27) => flipped ? -z27 + bodyHeight : z27;
   return /* @__PURE__ */ jsx3(Fragment2, { children: Array.from({ length: numberOfPins }, (_, i) => {
     const row = Math.floor(i / pinsPerRow);
     const col = i % pinsPerRow;
@@ -30743,7 +32226,7 @@ var A2512 = ({ color = "#333" }) => {
 var FemaleHeader = ({
   x,
   y,
-  z: z42 = 0,
+  z: z27 = 0,
   pitch = 2.54,
   legsLength = 3,
   innerDiameter = 0.945,
@@ -30758,8 +32241,8 @@ var FemaleHeader = ({
   const socketEntryWidth = socketWidth * 1.8;
   const socketEntryHeight = Math.min(bodyHeight * 0.18, pitch * 0.24);
   const socketDepth = bodyHeight + 0.1;
-  const socketCenterZ = flipZ(z42 + socketDepth / 2);
-  const socketEntryBaseZ = z42 + bodyHeight - socketEntryHeight;
+  const socketCenterZ = flipZ(z27 + socketDepth / 2);
+  const socketEntryBaseZ = z27 + bodyHeight - socketEntryHeight;
   const gapWidth = pinThickness * 1.6;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     /* @__PURE__ */ jsx3(Colorize, { color: "#1a1a1a", children: /* @__PURE__ */ jsxs(Subtract, { children: [
@@ -30768,7 +32251,7 @@ var FemaleHeader = ({
         {
           color: "#000",
           size: [bodyLength10, bodyWidth, bodyHeight],
-          center: [x, y, flipZ(z42 + bodyHeight / 2)]
+          center: [x, y, flipZ(z27 + bodyHeight / 2)]
         }
       ),
       /* @__PURE__ */ jsx3(
@@ -30790,7 +32273,7 @@ var FemaleHeader = ({
           Cuboid,
           {
             size: [socketEntryWidth, socketEntryWidth, 0.01],
-            center: [x, y, flipZ(z42 + bodyHeight)]
+            center: [x, y, flipZ(z27 + bodyHeight)]
           }
         )
       ] })
@@ -30802,7 +32285,7 @@ var FemaleHeader = ({
           {
             color: "silver",
             size: [pinThickness, pinThickness, legsLength * 0.9],
-            center: [x, y, flipZ(z42 + -legsLength / 2 * 0.9)]
+            center: [x, y, flipZ(z27 + -legsLength / 2 * 0.9)]
           }
         ),
         /* @__PURE__ */ jsx3(
@@ -30810,7 +32293,7 @@ var FemaleHeader = ({
           {
             color: "silver",
             size: [pinThickness / 1.8, pinThickness / 1.8, legsLength],
-            center: [x, y, flipZ(z42 + -legsLength / 2)]
+            center: [x, y, flipZ(z27 + -legsLength / 2)]
           }
         )
       ] }),
@@ -30819,7 +32302,7 @@ var FemaleHeader = ({
         {
           color: "silver",
           size: [gapWidth, gapWidth, gapWidth * 0.5],
-          center: [x, y, flipZ(z42 + gapWidth / 2 * 0.5)]
+          center: [x, y, flipZ(z27 + gapWidth / 2 * 0.5)]
         }
       )
     ] })
@@ -30837,7 +32320,7 @@ var FemaleHeaderRow = ({
   const pinsPerRow = Math.ceil(numberOfPins / rows);
   const rowSpacing = 2.54;
   const xoff = -((pinsPerRow - 1) / 2) * pitch;
-  const flipZ = (z42) => invert ? -z42 + bodyHeight : z42;
+  const flipZ = (z27) => invert ? -z27 + bodyHeight : z27;
   return /* @__PURE__ */ jsx3(Fragment2, { children: Array.from({ length: numberOfPins }, (_, i) => {
     const row = Math.floor(i / pinsPerRow);
     const col = i % pinsPerRow;
@@ -32227,13 +33710,13 @@ function createPhysicalLqfp(p) {
       ]);
     }
     points.push([root, midZ]);
-    const section = ([x, z42]) => /* @__PURE__ */ jsx3(
+    const section = ([x, z27]) => /* @__PURE__ */ jsx3(
       Translate,
       {
         offset: {
           x: horizontal ? sign * x : along,
           y: horizontal ? along : sign * x,
-          z: z42
+          z: z27
         },
         children: /* @__PURE__ */ jsx3(
           Cuboid,
@@ -34064,7 +35547,7 @@ var MountedPcbModule = ({
       shortSidePinLength,
       longSidePinLength,
       bodyHeight: pinBodyHeight,
-      flipZ: (z42) => z42
+      flipZ: (z27) => z27
     },
     `pin-3d-${index2}`
   ));
@@ -34073,7 +35556,7 @@ var MountedPcbModule = ({
     {
       x: pin.x,
       y: pin.y,
-      flipZ: (z42) => -z42
+      flipZ: (z27) => -z27
     },
     `female-pin-3d-${index2}`
   ));
@@ -34603,7 +36086,7 @@ function isJstShFootprint(footprint) {
   const p = fp.string(footprint).json();
   if (p.fn !== "jst") return false;
   return Boolean(
-    p.sh || p.smd && Math.abs(mm(p.p) - 1) < 0.01 && Math.abs(mm(p.mpx ?? 0) - (p.num_pins - 1 + 2.6)) < 0.15 && Math.abs(mm(p.mpy ?? 0) - 2.525) < 0.15
+    p.sh || p.smd && Math.abs(mm3(p.p) - 1) < 0.01 && Math.abs(mm3(p.mpx ?? 0) - (p.num_pins - 1 + 2.6)) < 0.15 && Math.abs(mm3(p.mpy ?? 0) - 2.525) < 0.15
   );
 }
 var JstSh = ({ footprint = "jst6_sh" }) => {
@@ -34724,7 +36207,7 @@ var getRoundedRectProfile = ({
   length: length83,
   radius,
   height: height10,
-  z: z42
+  z: z27
 }) => {
   const x = width10 / 2 - radius;
   const y = length83 / 2 - radius;
@@ -34736,11 +36219,11 @@ var getRoundedRectProfile = ({
   ].map(([cornerX, cornerY], index2) => /* @__PURE__ */ jsx3(
     Cylinder,
     {
-      center: [cornerX, cornerY, z42 + height10 / 2],
+      center: [cornerX, cornerY, z27 + height10 / 2],
       height: height10,
       radius
     },
-    `${z42}-${index2}`
+    `${z27}-${index2}`
   ));
 };
 var Crystal = ({
@@ -36718,6 +38201,18 @@ var Footprinter3d = ({ footprint }) => {
   if (mp.getModelNames().includes(modelFn)) {
     const model = mp.string(footprint).json();
     switch (model.fn) {
+      case "nema": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx3(NemaMotor, { ...props });
+      }
+      case "hexsocketbolt": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx3(HexSocketBolt, { ...props });
+      }
+      case "sheetmetal": {
+        const { fn, ...props } = model;
+        return /* @__PURE__ */ jsx3(SheetMetal, { ...props });
+      }
       case "flexscreen": {
         const { fn: _, ...flexScreenProps } = model;
         return /* @__PURE__ */ jsx3(FlexScreen, { ...flexScreenProps });
@@ -36743,7 +38238,7 @@ var Footprinter3d = ({ footprint }) => {
   const color = colorMatch ? colorMatch[1] : void 0;
   const dim = (value, fallback) => {
     if (value === void 0 || value === null) return fallback;
-    const parsed = mm(value);
+    const parsed = mm3(value);
     return Number.isFinite(parsed) ? parsed : fallback;
   };
   const bodyModel = renderFootprinterBodyModel(fpJson);
@@ -36848,7 +38343,8 @@ var Footprinter3d = ({ footprint }) => {
         }
       );
     }
-    case "pinrow": {
+    case "pinrow":
+    case "headermodule": {
       const rowsMatch = footprint.match(/_rows(\d+)/);
       const rows = rowsMatch && rowsMatch[1] ? parseInt(rowsMatch[1], 10) : 1;
       if (fpJson.male)
@@ -36884,6 +38380,12 @@ var Footprinter3d = ({ footprint }) => {
       );
     case "led5050":
       return /* @__PURE__ */ jsx3(Led5050, { color });
+    case "led": {
+      const imperial = String(fpJson.imperial);
+      if (imperial === "0402" || imperial === "0603" || imperial === "0805")
+        return /* @__PURE__ */ jsx3(SmdLED, { footprint: imperial, color });
+      break;
+    }
     case "cap": {
       switch (fpJson.imperial) {
         case "0402":
@@ -37361,8 +38863,8 @@ var Footprinter3d = ({ footprint }) => {
       return /* @__PURE__ */ jsx3(A2512, { color });
   }
   if ((fpJson.fn === "res" || fpJson.fn === "cap") && fpJson.p !== void 0 && fpJson.ph !== void 0) {
-    const padPitch = mm(fpJson.p);
-    const padHeight = mm(fpJson.ph);
+    const padPitch = mm3(fpJson.p);
+    const padHeight = mm3(fpJson.ph);
     if (Number.isFinite(padPitch) && Number.isFinite(padHeight)) {
       return /* @__PURE__ */ jsx3(
         ParametricChip,
@@ -37452,6 +38954,9 @@ function renderNode(node, colorCtx, renderCtx) {
     else geom = hulls.hull(geoms);
     return [{ geom, color: colorCtx }];
   }
+  if (type === Custom) {
+    return [{ geom: props.geometry, color: colorCtx }];
+  }
   if (type === Polygon) {
     const points = props?.points ?? [];
     const g2 = geometries.geom2.fromPoints(points);
@@ -37512,8 +39017,8 @@ function renderNode(node, colorCtx, renderCtx) {
   }
   return (children ?? []).flatMap((c) => renderNode(c, colorCtx, renderCtx));
 }
-function render(root, jscad3) {
-  const geometries = renderNode(root, void 0, { jscad: jscad3 });
+function render(root, jscad32) {
+  const geometries = renderNode(root, void 0, { jscad: jscad32 });
   return { geometries };
 }
 function convertCSGToThreeGeom(csg) {
@@ -37592,9 +39097,9 @@ function convertCSGToThreeGeom(csg) {
   console.error("Invalid CSG object: neither polygons nor sides found");
   return new BufferGeometry();
 }
-function getJscadModelForFootprint(footprint, jscad3) {
+function getJscadModelForFootprint(footprint, jscad32) {
   const vnode = h(Footprinter3d, { footprint });
-  return render(vnode, jscad3);
+  return render(vnode, jscad32);
 }
 
 // src/three-components/FootprinterModel.tsx
@@ -38197,7 +39702,7 @@ function GltfModel({
 
 // src/three-components/JscadModel.tsx
 var import_jscad_planner = __toESM(require_dist(), 1);
-var import_modeling = __toESM(require_src(), 1);
+var import_modeling3 = __toESM(require_src(), 1);
 import * as THREE11 from "three";
 import { useState as useState6, useEffect as useEffect9 } from "react";
 import { jsx as jsx8 } from "react/jsx-runtime";
@@ -38218,7 +39723,7 @@ var JscadModel = ({
 }) => {
   const [mesh, setMesh] = useState6(null);
   useEffect9(() => {
-    const jscadObject = (0, import_jscad_planner.executeJscadOperations)(import_modeling.default, jscadPlan);
+    const jscadObject = (0, import_jscad_planner.executeJscadOperations)(import_modeling3.default, jscadPlan);
     if (!jscadObject || !jscadObject.polygons && !jscadObject.sides) {
       setMesh(null);
       return;
@@ -38597,12 +40102,12 @@ async function convertStepUrlToGlb(stepUrl) {
   }
   const group = occtMeshesToGroup(result.meshes);
   const exporter = new GLTFExporter();
-  const glb = await new Promise((resolve, reject) => {
+  const glb = await new Promise((resolve2, reject) => {
     exporter.parse(
       group,
       (output) => {
         if (output instanceof ArrayBuffer) {
-          resolve(output);
+          resolve2(output);
         } else {
           reject(new Error("GLTFExporter did not return binary output"));
         }
@@ -38782,9 +40287,9 @@ var StepModel = ({
 // src/utils/cad-model-loader-transform.ts
 import * as THREE13 from "three";
 function applyCoordinateTransform(point, config) {
-  let { x, y, z: z42 } = point;
+  let { x, y, z: z27 } = point;
   if (config.axisMapping) {
-    const original = { x, y, z: z42 };
+    const original = { x, y, z: z27 };
     if (config.axisMapping.x) {
       x = getAxisValue(original, config.axisMapping.x);
     }
@@ -38792,30 +40297,30 @@ function applyCoordinateTransform(point, config) {
       y = getAxisValue(original, config.axisMapping.y);
     }
     if (config.axisMapping.z) {
-      z42 = getAxisValue(original, config.axisMapping.z);
+      z27 = getAxisValue(original, config.axisMapping.z);
     }
   }
   x *= config.flipX ?? 1;
   y *= config.flipY ?? 1;
-  z42 *= config.flipZ ?? 1;
+  z27 *= config.flipZ ?? 1;
   if (config.rotation) {
     if (config.rotation.x) {
       const rad = config.rotation.x * Math.PI / 180;
       const cos = Math.cos(rad);
       const sin = Math.sin(rad);
-      const newY = y * cos - z42 * sin;
-      const newZ = y * sin + z42 * cos;
+      const newY = y * cos - z27 * sin;
+      const newZ = y * sin + z27 * cos;
       y = newY;
-      z42 = newZ;
+      z27 = newZ;
     }
     if (config.rotation.y) {
       const rad = config.rotation.y * Math.PI / 180;
       const cos = Math.cos(rad);
       const sin = Math.sin(rad);
-      const newX = x * cos + z42 * sin;
-      const newZ = -x * sin + z42 * cos;
+      const newX = x * cos + z27 * sin;
+      const newZ = -x * sin + z27 * cos;
       x = newX;
-      z42 = newZ;
+      z27 = newZ;
     }
     if (config.rotation.z) {
       const rad = config.rotation.z * Math.PI / 180;
@@ -38827,7 +40332,7 @@ function applyCoordinateTransform(point, config) {
       y = newY;
     }
   }
-  return { x, y, z: z42 };
+  return { x, y, z: z27 };
 }
 function getAxisValue(original, mapping) {
   switch (mapping) {
@@ -39383,7 +40888,7 @@ import * as THREE25 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.610",
+  version: "0.0.611",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/3d-viewer"
@@ -39459,7 +40964,7 @@ var package_default = {
     "bun-match-svg": "^0.0.9",
     "bun-types": "1.2.1",
     debug: "^4.4.0",
-    "jscad-electronics": "^0.0.178",
+    "jscad-electronics": "^0.0.182",
     "jscad-planner": "^0.0.13",
     jsdom: "^26.0.0",
     "manifold-3d": "^3.2.1",
@@ -39472,11 +40977,14 @@ var package_default = {
     vite: "^7.1.5",
     "vite-tsconfig-paths": "^4.3.2",
     "circuit-json-to-gltf": "0.0.129",
-    modelprinter: "https://jscdn.tscircuit.com/@tscircuit/modelprinter/0.0.4.tgz",
-    zod: "^3.25.67"
+    zod: "^3.25.67",
+    "@tscircuit/modelprinter": "^0.0.4"
   },
   patchedDependencies: {
     "@tscircuit/fanout-solver@0.0.78": "patches/@tscircuit%2Ffanout-solver@0.0.78.patch"
+  },
+  engines: {
+    node: "24.x"
   }
 };
 
@@ -39587,11 +41095,11 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
     new THREE15.Euler(0, 0, 0)
   );
   const baseDistance = useMemo11(() => {
-    const [x, y, z42] = initialCameraPosition ?? [5, -5, 5];
+    const [x, y, z27] = initialCameraPosition ?? [5, -5, 5];
     const distance6 = Math.hypot(
       x - defaultTarget.x,
       y - defaultTarget.y,
-      z42 - defaultTarget.z
+      z27 - defaultTarget.z
     );
     return distance6 > 0 ? distance6 : 5;
   }, [initialCameraPosition, defaultTarget]);
@@ -40640,37 +42148,37 @@ var createRoundedRectangleShape = (width10, height10, radius) => {
   const halfWidth = width10 / 2;
   const halfHeight = height10 / 2;
   const safeRadius = Math.min(radius, halfWidth, halfHeight);
-  const shape = new THREE23.Shape();
-  shape.moveTo(-halfWidth + safeRadius, -halfHeight);
-  shape.lineTo(halfWidth - safeRadius, -halfHeight);
-  shape.quadraticCurveTo(
+  const shape2 = new THREE23.Shape();
+  shape2.moveTo(-halfWidth + safeRadius, -halfHeight);
+  shape2.lineTo(halfWidth - safeRadius, -halfHeight);
+  shape2.quadraticCurveTo(
     halfWidth,
     -halfHeight,
     halfWidth,
     -halfHeight + safeRadius
   );
-  shape.lineTo(halfWidth, halfHeight - safeRadius);
-  shape.quadraticCurveTo(
+  shape2.lineTo(halfWidth, halfHeight - safeRadius);
+  shape2.quadraticCurveTo(
     halfWidth,
     halfHeight,
     halfWidth - safeRadius,
     halfHeight
   );
-  shape.lineTo(-halfWidth + safeRadius, halfHeight);
-  shape.quadraticCurveTo(
+  shape2.lineTo(-halfWidth + safeRadius, halfHeight);
+  shape2.quadraticCurveTo(
     -halfWidth,
     halfHeight,
     -halfWidth,
     halfHeight - safeRadius
   );
-  shape.lineTo(-halfWidth, -halfHeight + safeRadius);
-  shape.quadraticCurveTo(
+  shape2.lineTo(-halfWidth, -halfHeight + safeRadius);
+  shape2.quadraticCurveTo(
     -halfWidth,
     -halfHeight,
     -halfWidth + safeRadius,
     -halfHeight
   );
-  return shape;
+  return shape2;
 };
 var createRoundedPrismGeometry = (width10, height10, depth, radius) => {
   return createPrismGeometryFromShape(
@@ -40678,8 +42186,8 @@ var createRoundedPrismGeometry = (width10, height10, depth, radius) => {
     depth
   );
 };
-var createPrismGeometryFromShape = (shape, depth) => {
-  const geometry = new THREE23.ExtrudeGeometry(shape, {
+var createPrismGeometryFromShape = (shape2, depth) => {
+  const geometry = new THREE23.ExtrudeGeometry(shape2, {
     depth,
     bevelEnabled: false,
     curveSegments: 24
@@ -41292,11 +42800,11 @@ var createBoardGeomWithOutline = (board, depth = 1.2, options = {}) => {
   if (arePointsClockwise(outlineVec2)) {
     outlineVec2 = outlineVec2.reverse();
   }
-  let shape = (0, import_primitives.polygon)({ points: outlineVec2 });
+  let shape2 = (0, import_primitives.polygon)({ points: outlineVec2 });
   if (xyOutset !== 0) {
-    shape = (0, import_expansions.expand)({ delta: xyOutset, corners: "edge" }, shape);
+    shape2 = (0, import_expansions.expand)({ delta: xyOutset, corners: "edge" }, shape2);
   }
-  let boardGeom = (0, import_extrusions.extrudeLinear)({ height: depth }, shape);
+  let boardGeom = (0, import_extrusions.extrudeLinear)({ height: depth }, shape2);
   boardGeom = (0, import_transforms.translate)([0, 0, -depth / 2], boardGeom);
   return boardGeom;
 };
@@ -41619,19 +43127,19 @@ var platedHole = (plated_hole, ctx, options = {}) => {
     const holeWidth = plated_hole.hole_width || 0;
     const holeHeight = plated_hole.hole_height || 0;
     const copperBody = (() => {
-      const circle = (0, import_primitives4.cylinder)({
+      const circle2 = (0, import_primitives4.cylinder)({
         center: [0, 0, 0],
         radius: 1,
         height: copperFillHeight,
         segments: 64
         // High segment count for smooth ellipse
       });
-      const scaled = (0, import_transforms3.scale)([outerWidth / 2, outerHeight / 2, 1], circle);
+      const scaled = (0, import_transforms3.scale)([outerWidth / 2, outerHeight / 2, 1], circle2);
       return (0, import_transforms4.translate)([plated_hole.x, plated_hole.y, 0], scaled);
     })();
     const copperSolid = maybeClip(copperBody, clipGeom);
     const drill = (() => {
-      const circle = (0, import_primitives4.cylinder)({
+      const circle2 = (0, import_primitives4.cylinder)({
         center: [0, 0, 0],
         radius: 1,
         height: throughDrillHeight,
@@ -41640,7 +43148,7 @@ var platedHole = (plated_hole, ctx, options = {}) => {
       });
       const scaled = (0, import_transforms3.scale)(
         [Math.max(holeWidth / 2, 0.01), Math.max(holeHeight / 2, 0.01), 1],
-        circle
+        circle2
       );
       return (0, import_transforms4.translate)([plated_hole.x, plated_hole.y, 0], scaled);
     })();
@@ -42732,7 +44240,7 @@ var useBoardGeomBuilder = (circuitJson) => {
         while (!isDone && !isCancelled) {
           isDone = builder.step(1);
           if (!isDone) {
-            await new Promise((resolve) => setTimeout(resolve, 0));
+            await new Promise((resolve2) => setTimeout(resolve2, 0));
           }
         }
         if (!isCancelled) {
@@ -45619,524 +47127,6 @@ 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 = p.x, minY = p.y, maxX = p.x, maxY = p.y;
-    let k = 0;
-    do {
-      const c = p.next;
-      p.z = b;
-      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;
-  sortArr.fill(
-    /** @type {Node} */
-    /** @type {unknown} */
-    null,
-    0,
-    n
-  );
-  sortBuf.fill(
-    /** @type {Node} */
-    /** @type {unknown} */
-    null,
-    0,
-    n
-  );
-}
-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) {
@@ -46313,7 +47303,7 @@ function foldSurfaceMesh(mesh, fold) {
   };
   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");
+    const face2 = triangle.pcbFace ?? (triangle.normal.z > 0.8 ? "top" : triangle.normal.z < -0.8 ? "bottom" : "side");
     let polygons = [
       triangle.vertices.map((p, index2) => ({
         p,
@@ -46356,7 +47346,7 @@ function foldSurfaceMesh(mesh, fold) {
           ...triangle,
           vertices,
           normal: { x: n.x / l, y: n.y / l, z: n.z / l },
-          pcbFace: face,
+          pcbFace: face2,
           uvs: verts.map(({ uv }) => uv)
         });
       }
@@ -46370,12 +47360,12 @@ var axes = [
   { x: 0, y: 0, z: 1 }
 ];
 function rotateVector(v, degrees) {
-  const [x, y, z42] = [degrees.x, degrees.y, degrees.z].map(
+  const [x, y, z27] = [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,
+    x: Math.cos(z27) * v.x - Math.sin(z27) * v.y,
+    y: Math.sin(z27) * v.x + Math.cos(z27) * v.y,
     z: v.z
   };
   const b = {
@@ -47195,8 +48185,8 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
     depth,
     sizeDelta = 0
   }) => {
-    const shape = ph.shape;
-    if (shape !== "hole_with_polygon_pad") {
+    const shape2 = ph.shape;
+    if (shape2 !== "hole_with_polygon_pad") {
       return null;
     }
     const padOutline = ph.pad_outline;
@@ -56711,7 +57701,7 @@ function createGeometryFromPolygons(polygons) {
 }
 
 // src/utils/render-component.tsx
-var import_modeling2 = __toESM(require_src(), 1);
+var import_modeling4 = __toESM(require_src(), 1);
 var import_jscad_planner2 = __toESM(require_dist(), 1);
 var jscadModeling2 = __toESM(require_src(), 1);
 import * as THREE57 from "three";
@@ -56774,7 +57764,7 @@ async function renderComponent(component, scene) {
   }
   if (component.model_jscad) {
     const jscadObject = (0, import_jscad_planner2.executeJscadOperations)(
-      import_modeling2.default,
+      import_modeling4.default,
       component.model_jscad
     );
     if (jscadObject && (jscadObject.polygons || jscadObject.sides)) {
@@ -56996,7 +57986,7 @@ function useExportGltfUrl(options = {}) {
 function useParser(options = {}) {
   const exporter = useMemo34(() => new GLTFExporter3(), []);
   return (instance) => {
-    const { promise, resolve, reject } = Promise.withResolvers();
+    const { promise, resolve: resolve2, reject } = Promise.withResolvers();
     exporter.parse(
       instance,
       (gltf) => {
@@ -57005,7 +57995,7 @@ function useParser(options = {}) {
           [gltf instanceof ArrayBuffer ? gltf : JSON.stringify(gltf)],
           { type: `model/${type}` }
         );
-        resolve(URL.createObjectURL(blob));
+        resolve2(URL.createObjectURL(blob));
       },
       reject,
       options