@tscircuit/cli 0.1.2303 → 0.1.2304

package/dist/cli/build/build.worker.js

@@ -35079,15 +35079,20 @@ var fmtNum2 = (n) => Number.isInteger(n) ? `${n}.` : `${n}`;
 var Repository2 = class {
   map = /* @__PURE__ */ new Map;
   order = [];
+  maxId = 0;
   schema = "AP214";
   units = { length: "MM", angle: "RAD", solidAngle: "SR" };
   set(id, e) {
-    if (!this.map.has(id))
+    if (!this.map.has(id)) {
       this.order.push(id);
+      if (id > this.maxId)
+        this.maxId = id;
+    }
     this.map.set(id, e);
   }
   add(e) {
-    const id = eid2(this.order.length ? Math.max(...this.order) + 1 : 1);
+    this.maxId++;
+    const id = eid2(this.maxId);
     this.set(id, e);
     return new Ref2(id);
   }
@@ -35295,6 +35300,103 @@ var Vector2 = class _Vector extends Entity2 {
   }
 };
 register2("VECTOR", Vector2.parse.bind(Vector2));
+var Ellipse2 = class _Ellipse extends Entity2 {
+  constructor(name, placement, semiAxis1, semiAxis2) {
+    super();
+    this.name = name;
+    this.placement = placement;
+    this.semiAxis1 = semiAxis1;
+    this.semiAxis2 = semiAxis2;
+  }
+  type = "ELLIPSE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const placement = ctx.parseRef(a[1]);
+    const semiAxis1 = ctx.parseNumber(a[2]);
+    const semiAxis2 = ctx.parseNumber(a[3]);
+    return new _Ellipse(name, placement, semiAxis1, semiAxis2);
+  }
+  toStep() {
+    return `ELLIPSE(${stepStr2(this.name)},${this.placement},${fmtNum2(this.semiAxis1)},${fmtNum2(this.semiAxis2)})`;
+  }
+};
+register2("ELLIPSE", Ellipse2.parse.bind(Ellipse2));
+var ConicalSurface2 = class _ConicalSurface extends Entity2 {
+  constructor(name, position, radius, semiAngle) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.radius = radius;
+    this.semiAngle = semiAngle;
+  }
+  type = "CONICAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const radius = ctx.parseNumber(a[2]);
+    const semiAngle = ctx.parseNumber(a[3]);
+    return new _ConicalSurface(name, position, radius, semiAngle);
+  }
+  toStep() {
+    return `CONICAL_SURFACE(${stepStr2(this.name)},${this.position},${fmtNum2(this.radius)},${fmtNum2(this.semiAngle)})`;
+  }
+};
+register2("CONICAL_SURFACE", ConicalSurface2.parse.bind(ConicalSurface2));
+var SphericalSurface2 = class _SphericalSurface extends Entity2 {
+  constructor(name, position, radius) {
+    super();
+    this.name = name;
+    this.position = position;
+    this.radius = radius;
+  }
+  type = "SPHERICAL_SURFACE";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const position = ctx.parseRef(a[1]);
+    const radius = ctx.parseNumber(a[2]);
+    return new _SphericalSurface(name, position, radius);
+  }
+  toStep() {
+    return `SPHERICAL_SURFACE(${stepStr2(this.name)},${this.position},${fmtNum2(this.radius)})`;
+  }
+};
+register2("SPHERICAL_SURFACE", SphericalSurface2.parse.bind(SphericalSurface2));
+var BSplineCurveWithKnots2 = class _BSplineCurveWithKnots extends Entity2 {
+  constructor(name, degree, controlPointsList, curveForm, closedCurve, selfIntersect, knotMultiplicities, knots, knotSpec) {
+    super();
+    this.name = name;
+    this.degree = degree;
+    this.controlPointsList = controlPointsList;
+    this.curveForm = curveForm;
+    this.closedCurve = closedCurve;
+    this.selfIntersect = selfIntersect;
+    this.knotMultiplicities = knotMultiplicities;
+    this.knots = knots;
+    this.knotSpec = knotSpec;
+  }
+  type = "B_SPLINE_CURVE_WITH_KNOTS";
+  static parse(a, ctx) {
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const degree = ctx.parseNumber(a[1]);
+    const controlPoints = a[2].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
+    const curveForm = a[3].trim();
+    const closedCurve = a[4].trim() === ".T.";
+    const selfIntersect = a[5].trim() === ".T.";
+    const knotMults = a[6].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knots = a[7].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseNumber(tok.trim()));
+    const knotSpec = a[8].trim();
+    return new _BSplineCurveWithKnots(name, degree, controlPoints, curveForm, closedCurve, selfIntersect, knotMults, knots, knotSpec);
+  }
+  toStep() {
+    const cps = `(${this.controlPointsList.join(",")})`;
+    const kms = `(${this.knotMultiplicities.map(fmtNum2).join(",")})`;
+    const ks = `(${this.knots.map(fmtNum2).join(",")})`;
+    const closed = this.closedCurve ? ".T." : ".F.";
+    const self = this.selfIntersect ? ".T." : ".F.";
+    return `B_SPLINE_CURVE_WITH_KNOTS(${stepStr2(this.name)},${this.degree},${cps},${this.curveForm},${closed},${self},${kms},${ks},${this.knotSpec})`;
+  }
+};
+register2("B_SPLINE_CURVE_WITH_KNOTS", BSplineCurveWithKnots2.parse.bind(BSplineCurveWithKnots2));
 var ColourRgb2 = class _ColourRgb extends Entity2 {
   constructor(name, r, g, b) {
     super();
@@ -35569,9 +35671,9 @@ var Product2 = class _Product extends Entity2 {
   }
   type = "PRODUCT";
   static parse(a, ctx) {
-    const name = ctx.parseString(a[0]);
-    const id = ctx.parseString(a[1]);
-    const description = ctx.parseString(a[2]);
+    const name = a[0] === "$" ? "" : ctx.parseString(a[0]);
+    const id = a[1] === "$" ? "" : ctx.parseString(a[1]);
+    const description = a[2] === "$" ? "" : ctx.parseString(a[2]);
     const refs = a[3].replace(/^\(|\)$/g, "").split(",").filter(Boolean).map((tok) => ctx.parseRef(tok.trim()));
     return new _Product(name, id, description, refs);
   }
@@ -35925,9 +36027,9 @@ var __commonJS2 = (cb, mod) => function __require() {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames2(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key2) && key2 !== except)
+        __defProp2(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -36319,13 +36421,13 @@ var require_add2 = __commonJS2({
 });
 var require_dot = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec3/dot.js"(exports, module) {
-    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-    module.exports = dot2;
+    var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    module.exports = dot3;
   }
 });
 var require_angle = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec3/angle.js"(exports, module) {
-    var dot2 = require_dot();
+    var dot3 = require_dot();
     var angle = (a, b) => {
       const ax = a[0];
       const ay = a[1];
@@ -36336,7 +36438,7 @@ var require_angle = __commonJS2({
       const mag1 = Math.sqrt(ax * ax + ay * ay + az * az);
       const mag2 = Math.sqrt(bx * bx + by * by + bz * bz);
       const mag = mag1 * mag2;
-      const cosine = mag && dot2(a, b) / mag;
+      const cosine = mag && dot3(a, b) / mag;
       return Math.acos(Math.min(Math.max(cosine, -1), 1));
     };
     module.exports = angle;
@@ -36374,7 +36476,7 @@ var require_copy2 = __commonJS2({
 });
 var require_cross = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec3/cross.js"(exports, module) {
-    var cross2 = (out, a, b) => {
+    var cross3 = (out, a, b) => {
       const ax = a[0];
       const ay = a[1];
       const az = a[2];
@@ -36386,7 +36488,7 @@ var require_cross = __commonJS2({
       out[2] = ax * by - ay * bx;
       return out;
     };
-    module.exports = cross2;
+    module.exports = cross3;
   }
 });
 var require_distance = __commonJS2({
@@ -36540,13 +36642,13 @@ var require_orthogonal = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec3/orthogonal.js"(exports, module) {
     var abs = require_abs();
     var create = require_create2();
-    var cross2 = require_cross();
+    var cross3 = require_cross();
     var orthogonal = (out, vector) => {
       const bV = abs(create(), vector);
       const b0 = 0 + (bV[0] < bV[1] && bV[0] < bV[2]);
       const b1 = 0 + (bV[1] <= bV[0] && bV[1] < bV[2]);
       const b2 = 0 + (bV[2] <= bV[0] && bV[2] <= bV[1]);
-      return cross2(out, vector, [b0, b1, b2]);
+      return cross3(out, vector, [b0, b1, b2]);
     };
     module.exports = orthogonal;
   }
@@ -37347,13 +37449,13 @@ var require_copy3 = __commonJS2({
 });
 var require_cross2 = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec2/cross.js"(exports, module) {
-    var cross2 = (out, a, b) => {
+    var cross3 = (out, a, b) => {
       out[0] = 0;
       out[1] = 0;
       out[2] = a[0] * b[1] - a[1] * b[0];
       return out;
     };
-    module.exports = cross2;
+    module.exports = cross3;
   }
 });
 var require_distance2 = __commonJS2({
@@ -37378,8 +37480,8 @@ var require_divide2 = __commonJS2({
 });
 var require_dot2 = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec2/dot.js"(exports, module) {
-    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
-    module.exports = dot2;
+    var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1];
+    module.exports = dot3;
   }
 });
 var require_equals3 = __commonJS2({
@@ -37741,11 +37843,11 @@ var require_toOutlines = __commonJS2({
     var toSharedVertices = (sides) => {
       const unique = /* @__PURE__ */ new Map;
       const getUniqueVertex = (vertex) => {
-        const key = vertex.toString();
-        if (unique.has(key)) {
-          return unique.get(key);
+        const key2 = vertex.toString();
+        if (unique.has(key2)) {
+          return unique.get(key2);
         } else {
-          unique.set(key, vertex);
+          unique.set(key2, vertex);
           return vertex;
         }
       };
@@ -37987,7 +38089,7 @@ var require_create5 = __commonJS2({
 });
 var require_point_line_distance = __commonJS2({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/point-line-distance.js"(exports, module) {
-    var cross2 = require_cross();
+    var cross3 = require_cross();
     var subtract2 = require_subtract();
     var squaredLength = require_squaredLength();
     var distanceSquared = (p, a, b) => {
@@ -37996,7 +38098,7 @@ var require_point_line_distance = __commonJS2({
       const cr = [];
       subtract2(ab, b, a);
       subtract2(ap, p, a);
-      const area = squaredLength(cross2(cr, ap, ab));
+      const area = squaredLength(cross3(cr, ap, ab));
       const s = squaredLength(ab);
       if (s === 0) {
         throw Error("a and b are the same point");
@@ -38009,14 +38111,14 @@ var require_point_line_distance = __commonJS2({
 });
 var require_get_plane_normal = __commonJS2({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/get-plane-normal.js"(exports, module) {
-    var cross2 = require_cross();
+    var cross3 = require_cross();
     var normalize2 = require_normalize();
     var subtract2 = require_subtract();
     var planeNormal = (out, point1, point2, point3) => {
       const tmp = [0, 0, 0];
       subtract2(out, point1, point2);
       subtract2(tmp, point2, point3);
-      cross2(out, out, tmp);
+      cross3(out, out, tmp);
       return normalize2(out, out);
     };
     module.exports = planeNormal;
@@ -38164,8 +38266,8 @@ var require_Face = __commonJS2({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/Face.js"(exports, module) {
     var add = require_add2();
     var copy = require_copy2();
-    var cross2 = require_cross();
-    var dot2 = require_dot();
+    var cross3 = require_cross();
+    var dot3 = require_dot();
     var length = require_length();
     var normalize2 = require_normalize();
     var scale = require_scale();
@@ -38211,7 +38313,7 @@ var require_Face = __commonJS2({
         while (e2 !== e0) {
           copy(v1, v2);
           subtract2(v2, e2.head().point, e0.head().point);
-          add(this.normal, this.normal, cross2(t, v1, v2));
+          add(this.normal, this.normal, cross3(t, v1, v2));
           e2 = e2.next;
           this.nVertices += 1;
         }
@@ -38237,7 +38339,7 @@ var require_Face = __commonJS2({
           const maxVector = subtract2([], p2, p1);
           const maxLength = Math.sqrt(maxSquaredLength);
           scale(maxVector, maxVector, 1 / maxLength);
-          const maxProjection = dot2(this.normal, maxVector);
+          const maxProjection = dot3(this.normal, maxVector);
           scale(maxVector, maxVector, -maxProjection);
           add(this.normal, this.normal, maxVector);
           normalize2(this.normal, this.normal);
@@ -38259,10 +38361,10 @@ var require_Face = __commonJS2({
           this.computeNormal();
         }
         this.computeCentroid();
-        this.offset = dot2(this.normal, this.centroid);
+        this.offset = dot3(this.normal, this.centroid);
       }
       distanceToPlane(point) {
-        return dot2(this.normal, point) - this.offset;
+        return dot3(this.normal, point) - this.offset;
       }
       connectHalfEdges(prev, next) {
         let discardedFace;
@@ -38360,7 +38462,7 @@ var require_Face = __commonJS2({
 });
 var require_QuickHull = __commonJS2({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/QuickHull.js"(exports, module) {
-    var dot2 = require_dot();
+    var dot3 = require_dot();
     var pointLineDistance = require_point_line_distance();
     var getPlaneNormal = require_get_plane_normal();
     var VertexList = require_VertexList();
@@ -38522,12 +38624,12 @@ var require_QuickHull = __commonJS2({
           }
         }
         const normal = getPlaneNormal([], v0.point, v1.point, v2.point);
-        const distPO = dot2(v0.point, normal);
+        const distPO = dot3(v0.point, normal);
         maxDistance = -1;
         for (i = 0;i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1 && vertex !== v2) {
-            const distance = Math.abs(dot2(normal, vertex.point) - distPO);
+            const distance = Math.abs(dot3(normal, vertex.point) - distPO);
             if (distance > maxDistance) {
               maxDistance = distance;
               v3 = vertex;
@@ -38535,7 +38637,7 @@ var require_QuickHull = __commonJS2({
           }
         }
         const faces = [];
-        if (dot2(v3.point, normal) - distPO < 0) {
+        if (dot3(v3.point, normal) - distPO < 0) {
           faces.push(Face.createTriangle(v0, v1, v2), Face.createTriangle(v3, v1, v0), Face.createTriangle(v3, v2, v1), Face.createTriangle(v3, v0, v2));
           for (i = 0;i < 3; i += 1) {
             const j2 = (i + 1) % 3;
@@ -39237,8 +39339,8 @@ var require_measureBoundingBox = __commonJS2({
 });
 var require_dot3 = __commonJS2({
   "node_modules/@jscad/modeling/src/maths/vec4/dot.js"(exports, module) {
-    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-    module.exports = dot2;
+    var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+    module.exports = dot3;
   }
 });
 var require_fromScalar3 = __commonJS2({
@@ -39337,10 +39439,10 @@ var require_measureSignedVolume = __commonJS2({
     var measureSignedVolume = (polygon) => {
       let signedVolume = 0;
       const vertices = polygon.vertices;
-      const cross2 = vec3.create();
+      const cross3 = vec3.create();
       for (let i = 0;i < vertices.length - 2; i++) {
-        vec3.cross(cross2, vertices[i + 1], vertices[i + 2]);
-        signedVolume += vec3.dot(vertices[0], cross2);
+        vec3.cross(cross3, vertices[i + 1], vertices[i + 2]);
+        signedVolume += vec3.dot(vertices[0], cross3);
       }
       signedVolume /= 6;
       return signedVolume;
@@ -39589,9 +39691,9 @@ var require_isConvex2 = __commonJS2({
         const verts = polygons[i].vertices;
         for (let j = 0;j < verts.length; j++) {
           const v = verts[j];
-          const key = `${v[0]},${v[1]},${v[2]}`;
-          if (!found.has(key)) {
-            found.add(key);
+          const key2 = `${v[0]},${v[1]},${v[2]}`;
+          if (!found.has(key2)) {
+            found.add(key2);
             vertices.push(v);
           }
         }
@@ -46327,9 +46429,9 @@ var require_minkowskiSum = __commonJS2({
         const vertices = polygons[i].vertices;
         for (let j = 0;j < vertices.length; j++) {
           const v = vertices[j];
-          const key = `${v[0]},${v[1]},${v[2]}`;
-          if (!found.has(key)) {
-            found.add(key);
+          const key2 = `${v[0]},${v[1]},${v[2]}`;
+          if (!found.has(key2)) {
+            found.add(key2);
             unique.push(v);
           }
         }
@@ -46346,17 +46448,17 @@ var require_scissionGeom3 = __commonJS2({
     var geom3 = require_geom3();
     var sortNb = (array) => array.sort((a, b) => a - b).filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
     var insertMapping = (map, point, index) => {
-      const key = `${point}`;
-      const mapping = map.get(key);
+      const key2 = `${point}`;
+      const mapping = map.get(key2);
       if (mapping === undefined) {
-        map.set(key, [index]);
+        map.set(key2, [index]);
       } else {
         mapping.push(index);
       }
     };
     var findMapping = (map, point) => {
-      const key = `${point}`;
-      return map.get(key);
+      const key2 = `${point}`;
+      return map.get(key2);
     };
     var scissionGeom3 = (geometry) => {
       const eps = measureEpsilon(geometry);
@@ -46777,24 +46879,24 @@ var require_expandShell = __commonJS2({
     var unionGeom3Sub = require_unionGeom3Sub();
     var extrudePolygon = require_extrudePolygon();
     var mapPlaneToVertex = (map, vertex, plane) => {
-      const key = vertex.toString();
-      if (!map.has(key)) {
+      const key2 = vertex.toString();
+      if (!map.has(key2)) {
         const entry = [vertex, [plane]];
-        map.set(key, entry);
+        map.set(key2, entry);
       } else {
-        const planes = map.get(key)[1];
+        const planes = map.get(key2)[1];
         planes.push(plane);
       }
     };
     var mapPlaneToEdge = (map, edge, plane) => {
       const key0 = edge[0].toString();
       const key1 = edge[1].toString();
-      const key = key0 < key1 ? `${key0},${key1}` : `${key1},${key0}`;
-      if (!map.has(key)) {
+      const key2 = key0 < key1 ? `${key0},${key1}` : `${key1},${key0}`;
+      if (!map.has(key2)) {
         const entry = [edge, [plane]];
-        map.set(key, entry);
+        map.set(key2, entry);
       } else {
-        const planes = map.get(key)[1];
+        const planes = map.get(key2)[1];
         planes.push(plane);
       }
     };
@@ -46903,8 +47005,8 @@ var require_expandShell = __commonJS2({
         let bestzaxisorthogonality = 0;
         for (let i = 1;i < planes.length; i++) {
           const normal = planes[i];
-          const cross2 = vec3.cross(v1, xaxis, normal);
-          const crosslength = vec3.length(cross2);
+          const cross3 = vec3.cross(v1, xaxis, normal);
+          const crosslength = vec3.length(cross3);
           if (crosslength > 0.05) {
             if (crosslength > bestzaxisorthogonality) {
               bestzaxisorthogonality = crosslength;
@@ -47498,10 +47600,10 @@ var require_toUniquePoints = __commonJS2({
       const found = /* @__PURE__ */ new Set;
       const uniquePoints = [];
       const addPoint = (point) => {
-        const key = point.toString();
-        if (!found.has(key)) {
+        const key2 = point.toString();
+        if (!found.has(key2)) {
           uniquePoints.push(point);
-          found.add(key);
+          found.add(key2);
         }
       };
       geometries.forEach((geometry) => {
@@ -47683,16 +47785,16 @@ var require_mergePolygons = __commonJS2({
       return edges;
     };
     var insertEdge = (edges, edge) => {
-      const key = `${edge.v1}:${edge.v2}`;
-      edges.set(key, edge);
+      const key2 = `${edge.v1}:${edge.v2}`;
+      edges.set(key2, edge);
     };
     var deleteEdge = (edges, edge) => {
-      const key = `${edge.v1}:${edge.v2}`;
-      edges.delete(key);
+      const key2 = `${edge.v1}:${edge.v2}`;
+      edges.delete(key2);
     };
     var findOppositeEdge = (edges, edge) => {
-      const key = `${edge.v2}:${edge.v1}`;
-      return edges.get(key);
+      const key2 = `${edge.v2}:${edge.v1}`;
+      return edges.get(key2);
     };
     var calculateAnglesBetween = (current, opposite, normal) => {
       let v0 = current.prev.v1;
@@ -48544,6 +48646,194 @@ var newellNormal = (vertices) => {
 var EPS = 0.0000000001;
 var snap = (n) => Math.abs(n) < EPS ? 0 : n;
 var cleanVec3 = (v) => [snap(v[0]), snap(v[1]), snap(v[2])];
+function simpleBoundaries(loops, points, normal) {
+  const drop = normal.map(Math.abs).indexOf(Math.max(...normal.map(Math.abs)));
+  const axes = [0, 1, 2].filter((axis) => axis !== drop);
+  const project = (id) => [
+    points[id][axes[0]],
+    points[id][axes[1]]
+  ];
+  const distance = (p, a, b) => {
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    const t = Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / (dx * dx + dy * dy)));
+    return Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dy);
+  };
+  const orient = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  const edges = loops.flatMap((loop, ring) => loop.map((id, index) => ({
+    a: project(id),
+    b: project(loop[(index + 1) % loop.length]),
+    ring,
+    index,
+    count: loop.length
+  })));
+  for (let i = 0;i < edges.length; i++) {
+    const e = edges[i];
+    for (let j = i + 1;j < edges.length; j++) {
+      const f = edges[j];
+      if (e.ring === f.ring && (j === i + 1 || f.index - e.index === e.count - 1))
+        continue;
+      if ([0, 1].some((axis) => Math.max(e.a[axis], e.b[axis]) + 0.000000001 < Math.min(f.a[axis], f.b[axis]) || Math.max(f.a[axis], f.b[axis]) + 0.000000001 < Math.min(e.a[axis], e.b[axis])))
+        continue;
+      if (orient(e.a, e.b, f.a) * orient(e.a, e.b, f.b) < 0 && orient(f.a, f.b, e.a) * orient(f.a, f.b, e.b) < 0)
+        return false;
+      if (Math.min(distance(e.a, f.a, f.b), distance(e.b, f.a, f.b), distance(f.a, e.a, e.b), distance(f.b, e.a, e.b)) <= 0.000000001)
+        return false;
+    }
+  }
+  return true;
+}
+function mergeCoplanarFaces(polygons, enabled = true) {
+  if (!enabled)
+    return polygons.map((polygon) => ({
+      loops: [polygon],
+      normal: newellNormal(polygon)
+    }));
+  const points = [];
+  const ids = /* @__PURE__ */ new Map;
+  const cycles = polygons.map((polygon) => polygon.map((point) => {
+    const k = vertexKey(point);
+    let id = ids.get(k);
+    if (id === undefined) {
+      id = points.length;
+      ids.set(k, id);
+      points.push(point);
+    }
+    return id;
+  }));
+  const metres = points.map((p) => p.map((v) => v * 0.001));
+  return mergeCoplanarRegions(metres, cycles).map((region) => ({
+    loops: region.loops.map((loop) => loop.map((id) => points[id])),
+    normal: region.normal
+  }));
+}
+var sub = (a, b) => a.map((v, i) => v - b[i]);
+var dot22 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
+var cross2 = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var key = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+function areaVector(loop, points) {
+  const origin = points[loop[0]];
+  const area = [0, 0, 0];
+  for (let i = 1;i < loop.length - 1; i++) {
+    const c = cross2(sub(points[loop[i]], origin), sub(points[loop[i + 1]], origin));
+    for (let axis = 0;axis < 3; axis++)
+      area[axis] += c[axis];
+  }
+  return area;
+}
+function mergeCoplanarRegions(points, cycles) {
+  const normals = cycles.map((cycle) => {
+    const area = areaVector(cycle, points);
+    const magnitude = Math.hypot(...area);
+    return magnitude ? area.map((v) => v / magnitude) : [0, 0, 0];
+  });
+  const uses = /* @__PURE__ */ new Map;
+  cycles.forEach((cycle, face) => cycle.forEach((a, i) => {
+    const k = key(a, cycle[(i + 1) % cycle.length]);
+    const list = uses.get(k) ?? [];
+    list.push(face);
+    uses.set(k, list);
+  }));
+  const visited = /* @__PURE__ */ new Set;
+  const regions = [];
+  for (let seed = 0;seed < cycles.length; seed++) {
+    if (visited.has(seed))
+      continue;
+    const normal = normals[seed];
+    const origin = points[cycles[seed][0]];
+    const matches = (face) => {
+      return dot22(normal, normals[face]) > 0 && Math.hypot(...cross2(normal, normals[face])) <= 0.0000000001 && cycles[face].every((id) => Math.abs(dot22(sub(points[id], origin), normal)) <= 0.000000001);
+    };
+    const group = [seed];
+    visited.add(seed);
+    for (let i = 0;i < group.length; i++) {
+      const cycle = cycles[group[i]];
+      cycle.forEach((a, j) => {
+        const neighbours = uses.get(key(a, cycle[(j + 1) % cycle.length]));
+        if (neighbours.length !== 2)
+          return;
+        for (const other of neighbours) {
+          if (visited.has(other) || !matches(other))
+            continue;
+          visited.add(other);
+          group.push(other);
+        }
+      });
+    }
+    if (group.length === 1) {
+      regions.push({
+        loops: [cycles[seed]],
+        normal: newellNormal(cycles[seed].map((id) => points[id]))
+      });
+      continue;
+    }
+    const members = new Set(group);
+    const boundary = /* @__PURE__ */ new Map;
+    let ambiguous = false;
+    for (const face of group) {
+      const cycle = cycles[face];
+      cycle.forEach((a, j) => {
+        const b = cycle[(j + 1) % cycle.length];
+        const incident = uses.get(key(a, b));
+        if (incident.length > 2)
+          ambiguous = true;
+        if (incident.length === 2 && incident.every((other) => members.has(other))) {
+          const other = cycles[incident.find((id) => id !== face)];
+          if (!other?.some((v, i) => v === b && other[(i + 1) % other.length] === a))
+            ambiguous = true;
+          return;
+        }
+        if (boundary.has(a))
+          ambiguous = true;
+        boundary.set(a, b);
+      });
+    }
+    const loops = [];
+    while (!ambiguous && boundary.size) {
+      const start = boundary.keys().next().value;
+      const loop = [];
+      let current = start;
+      do {
+        const next = boundary.get(current);
+        if (next === undefined) {
+          ambiguous = true;
+          break;
+        }
+        loop.push(current);
+        boundary.delete(current);
+        current = next;
+      } while (current !== start);
+      if (loop.length < 3)
+        ambiguous = true;
+      loops.push(loop);
+    }
+    if (ambiguous || loops.length === 0) {
+      for (const face of group)
+        regions.push({
+          loops: [cycles[face]],
+          normal: normals[face]
+        });
+      continue;
+    }
+    const outer = loops.filter((loop) => dot22(areaVector(loop, points), normal) > 0);
+    if (outer.length !== 1 || !simpleBoundaries(loops, points, normal)) {
+      for (const face of group)
+        regions.push({
+          loops: [cycles[face]],
+          normal: normals[face]
+        });
+      continue;
+    }
+    regions.push({
+      loops: [outer[0], ...loops.filter((loop) => loop !== outer[0])],
+      normal
+    });
+  }
+  return regions;
+}
 function extractPosition(vertex) {
   if (Array.isArray(vertex) && vertex.length >= 3) {
     return [
@@ -48624,17 +48914,17 @@ function splitTJunctions(polygons) {
   }
   return result;
 }
-function geom3ToBrep(repo, geom) {
+function geom3ToBrep(repo, geom, mergeCoplanar = true) {
   const vertexMap = /* @__PURE__ */ new Map;
   const edgeMap = /* @__PURE__ */ new Map;
   function getOrCreateVertex(pos) {
-    const key = vertexKey(pos);
-    let ref = vertexMap.get(key);
+    const key2 = vertexKey(pos);
+    let ref = vertexMap.get(key2);
     if (!ref) {
       const clean = cleanVec3(pos);
       const pt = repo.add(new CartesianPoint2("", clean[0], clean[1], clean[2]));
       ref = repo.add(new VertexPoint2("", pt));
-      vertexMap.set(key, ref);
+      vertexMap.set(key2, ref);
     }
     return ref;
   }
@@ -48674,32 +48964,19 @@ function geom3ToBrep(repo, geom) {
   }
   rawPolygons = splitTJunctions(rawPolygons);
   const faces = [];
-  for (const positions of rawPolygons) {
-    const uniquePositions = [];
-    for (let i = 0;i < positions.length; i++) {
-      const pos = positions[i];
-      const prev = i > 0 ? positions[i - 1] : positions[positions.length - 1];
-      if (vertexKey(pos) !== vertexKey(prev)) {
-        uniquePositions.push(pos);
-      }
-    }
-    if (uniquePositions.length < 3)
-      continue;
-    const vertexRefs = uniquePositions.map((pos) => getOrCreateVertex(pos));
-    const orientedEdges = [];
-    for (let i = 0;i < uniquePositions.length; i++) {
-      const aPos = uniquePositions[i];
-      const bPos = uniquePositions[(i + 1) % uniquePositions.length];
-      const aRef = vertexRefs[i];
-      const bRef = vertexRefs[(i + 1) % uniquePositions.length];
-      if (vertexKey(aPos) === vertexKey(bPos))
-        continue;
-      const { edgeRef, sameDirection } = getOrCreateEdge(aPos, bPos, aRef, bRef);
-      orientedEdges.push(repo.add(new OrientedEdge2("", edgeRef, sameDirection)));
-    }
-    if (orientedEdges.length < 3)
-      continue;
-    const normal = cleanVec3(newellNormal(uniquePositions));
+  rawPolygons = rawPolygons.map((positions) => positions.filter((pos, i) => vertexKey(pos) !== vertexKey(positions[(i + positions.length - 1) % positions.length]))).filter((positions) => positions.length >= 3);
+  function createLoop(positions) {
+    const vertexRefs = positions.map((pos) => getOrCreateVertex(pos));
+    const orientedEdges = positions.map((aPos, i) => {
+      const next = (i + 1) % positions.length;
+      const { edgeRef, sameDirection } = getOrCreateEdge(aPos, positions[next], vertexRefs[i], vertexRefs[next]);
+      return repo.add(new OrientedEdge2("", edgeRef, sameDirection));
+    });
+    return repo.add(new EdgeLoop2("", orientedEdges));
+  }
+  for (const region of mergeCoplanarFaces(rawPolygons, mergeCoplanar)) {
+    const uniquePositions = region.loops[0];
+    const normal = cleanVec3(region.normal);
     const v0 = uniquePositions[0];
     const cleanV0 = cleanVec3(v0);
     const planeOrigin = repo.add(new CartesianPoint2("", cleanV0[0], cleanV0[1], cleanV0[2]));
@@ -48716,9 +48993,11 @@ function geom3ToBrep(repo, geom) {
     const refDir = repo.add(new Direction2("", edge0Dir[0], edge0Dir[1], edge0Dir[2]));
     const placement = repo.add(new Axis2Placement3D2("", planeOrigin, planeNormal, refDir));
     const plane = repo.add(new Plane2("", placement));
-    const edgeLoop = repo.add(new EdgeLoop2("", orientedEdges));
-    const faceOuterBound = repo.add(new FaceOuterBound2("", edgeLoop, true));
-    const face = repo.add(new AdvancedFace2("", [faceOuterBound], plane, true));
+    const bounds = region.loops.map((loop, index) => {
+      const edgeLoop = createLoop(loop);
+      return index === 0 ? repo.add(new FaceOuterBound2("", edgeLoop, true)) : repo.add(new FaceBound2("", edgeLoop, true));
+    });
+    const face = repo.add(new AdvancedFace2("", bounds, plane, true));
     faces.push(face);
   }
   return faces;
@@ -48822,7 +49101,7 @@ function resolveGeometries(input) {
   const result = executeJscadOperations(import_modeling.default, input);
   return Array.isArray(result) ? result : [result];
 }
-function jscadToStep(operation) {
+function jscadToStep(operation, options = {}) {
   const repo = new Repository2;
   const geometries = resolveGeometries(operation);
   const appContext = repo.add(new ApplicationContext2("core data for automotive mechanical design processes"));
@@ -48861,7 +49140,7 @@ function jscadToStep(operation) {
     if (!geom?.polygons || geom.polygons.length === 0)
       continue;
     const { color: _color, ...brepGeom } = geom;
-    const faces = geom3ToBrep(repo, brepGeom);
+    const faces = geom3ToBrep(repo, brepGeom, options.mergeCoplanarFaces ?? true);
     if (faces.length === 0)
       continue;
     const shell = repo.add(new ClosedShell2("", faces));
@@ -49567,7 +49846,7 @@ function normalizeStepNumericExponents(stepText) {
 var package_default = {
   name: "circuit-json-to-step",
   main: "dist/index.js",
-  version: "0.0.43",
+  version: "0.0.47",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-step.git"
@@ -49581,20 +49860,21 @@ var package_default = {
     format: "biome format --write .",
     "format:check": "biome format .",
     start: "bun site/index.html",
-    "build:site": "bun build site/index.html --outdir=site-export"
+    "build:site": "bun build site/index.html --outdir=site-export",
+    prepare: "bun install --frozen-lockfile --ignore-scripts && bun run build"
   },
   devDependencies: {
     "@biomejs/biome": "^2.3.8",
-    "circuit-to-svg": "^0.0.356",
     "@resvg/resvg-js": "^2.6.2",
     "@resvg/resvg-wasm": "^2.6.2",
     "@tscircuit/circuit-json-util": "^0.0.75",
     "@types/bun": "latest",
     "circuit-json": "^0.0.525",
+    "circuit-to-svg": "^0.0.356",
     "looks-same": "^10.0.1",
     "occt-import-js": "^0.0.23",
-    "schematic-symbols": "^0.0.221",
     poppygl: "^0.0.24",
+    "schematic-symbols": "^0.0.221",
     tsup: "^8.5.0"
   },
   peerDependencies: {
@@ -49605,7 +49885,7 @@ var package_default = {
   dependencies: {
     "circuit-json-to-connectivity-map": "^0.0.22",
     "circuit-json-to-gltf": "^0.0.106",
-    "jscad-to-step": "0.0.7",
+    "jscad-to-step": "^0.0.11",
     stepts: "^0.0.4"
   }
 };
@@ -49789,8 +50069,11 @@ function createPillHoleGeometry(repo, hole, zMin, zMax, zDir) {
   }
   return { bottomLoop, topLoop, wallFaces };
 }
-function circuitJsonToAssemblyStep(circuitJson, { productName = "Combined Assembly" } = {}) {
-  const parts = circuitJson.filter((item) => item.type === "source_component").filter((item) => item.ftype === "printedpart");
+function circuitJsonToAssemblyStep(circuitJson, {
+  productName = "Combined Assembly",
+  sourceComponentId
+} = {}) {
+  const parts = circuitJson.filter((item) => item.type === "source_component").filter((item) => item.ftype === "printedpart").filter((item) => sourceComponentId === undefined || item.source_component_id === sourceComponentId);
   if (parts.length === 0) {
     throw new Error("No assembly.printedpart elements found to export");
   }
@@ -49876,9 +50159,27 @@ function circuitJsonToAssemblyStep(circuitJson, { productName = "Combined Assemb
 }
 async function circuitJsonToStep(circuitJson, options = {}) {
   const hasBoard = circuitJson.some((item) => item.type === "pcb_board");
-  const hasPrintedParts = circuitJson.some((item) => item.type === "source_component" && item.ftype === "printedpart");
-  if (options.exportMode === "assembly" || options.exportMode === undefined && !hasBoard && !options.boardWidth && !options.boardHeight && hasPrintedParts) {
-    return circuitJsonToAssemblyStep(circuitJson, options);
+  const printedParts = circuitJson.filter((item) => item.type === "source_component" && item.ftype === "printedpart");
+  if (options.exportMode === "assembly" || options.exportMode === undefined && !hasBoard && !options.boardWidth && !options.boardHeight && printedParts.length > 0) {
+    if (printedParts.length === 0) {
+      throw new Error("No assembly.printedpart elements found to export");
+    }
+    const files = {};
+    const usedNames = /* @__PURE__ */ new Set;
+    for (const part of printedParts) {
+      const baseName = part.name.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "printed-part";
+      let fileName = `${baseName}.step`;
+      let suffix = 2;
+      while (usedNames.has(fileName.toLowerCase())) {
+        fileName = `${baseName}-${suffix++}.step`;
+      }
+      usedNames.add(fileName.toLowerCase());
+      files[fileName] = circuitJsonToAssemblyStep(circuitJson, {
+        productName: options.productName ?? part.name,
+        sourceComponentId: part.source_component_id
+      });
+    }
+    return files;
   }
   const repo = new Repository;
   const pcbBoard = circuitJson.find((item) => item.type === "pcb_board");
@@ -51767,6 +52068,7 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
+    exportMode: "pcb",
     includeComponents: true,
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)

package/dist/cli/main.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/cli/main.js
-size: 46809215 bytes
-sha256: cd67dffd18f98b9ae33dc72a2d9bb98db5103aa71a5a346cc0c21bd67765868d
+size: 46820988 bytes
+sha256: fd367510807bb619d2b456da0a1c787933fd081760a4ac9c388f2cef60d843d0

package/dist/lib/index.js

@@ -69121,7 +69121,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.2302";
+var version = "0.1.2303";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -69179,7 +69179,7 @@ var package_default = {
     "circuit-json-to-pnp-csv": "^0.0.18",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-spice": "^0.0.45",
-    "circuit-json-to-step": "^0.0.45",
+    "circuit-json-to-step": "^0.0.47",
     "circuit-json-to-tscircuit": "^0.0.50",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     "circuit-to-canvas": "^0.0.123",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2303",
+  "version": "0.1.2304",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/cli"
@@ -55,7 +55,7 @@
     "circuit-json-to-pnp-csv": "^0.0.18",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-spice": "^0.0.45",
-    "circuit-json-to-step": "^0.0.45",
+    "circuit-json-to-step": "^0.0.47",
     "circuit-json-to-tscircuit": "^0.0.50",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     "circuit-to-canvas": "^0.0.123",