circuit-json-to-gltf 0.0.72 → 0.0.74

package/dist/index.js

@@ -4378,6 +4378,52 @@ var require_isA3 = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js
+var require_isConvex2 = __commonJS({
+  "node_modules/@jscad/modeling/src/geometries/geom3/isConvex.js"(exports, module) {
+    "use strict";
+    var { EPS } = require_constants();
+    var vec3 = require_vec3();
+    var geom33 = require_isA3();
+    var toPolygons3 = require_toPolygons();
+    var poly3 = require_poly3();
+    var isConvex = (geometry) => {
+      if (!geom33(geometry)) {
+        throw new Error("isConvex requires a geom3 geometry");
+      }
+      const polygons = toPolygons3(geometry);
+      if (polygons.length === 0) {
+        return true;
+      }
+      const vertices = [];
+      const found = /* @__PURE__ */ new Set();
+      for (let i = 0; i < polygons.length; i++) {
+        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);
+            vertices.push(v);
+          }
+        }
+      }
+      for (let i = 0; i < polygons.length; i++) {
+        const plane = poly3.plane(polygons[i]);
+        for (let j = 0; j < vertices.length; j++) {
+          const v = vertices[j];
+          const distance = vec3.dot(plane, v) - plane[3];
+          if (distance > EPS) {
+            return false;
+          }
+        }
+      }
+      return true;
+    };
+    module.exports = isConvex;
+  }
+});
+
 // node_modules/@jscad/modeling/src/geometries/geom3/toPoints.js
 var require_toPoints3 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/geom3/toPoints.js"(exports, module) {
@@ -4535,6 +4581,7 @@ var require_geom3 = __commonJS({
       fromCompactBinary: require_fromCompactBinary2(),
       invert: require_invert3(),
       isA: require_isA3(),
+      isConvex: require_isConvex2(),
       toPoints: require_toPoints3(),
       toPolygons: require_toPolygons(),
       toString: require_toString7(),
@@ -4731,7 +4778,7 @@ var require_appendArc = __commonJS({
         } else if (sweepFlag && deltatheta < 0) {
           deltatheta += TAU;
         }
-        let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1;
+        let numsteps = Math.floor(segments * (Math.abs(deltatheta) / TAU));
         if (numsteps < 1) numsteps = 1;
         for (let step = 1; step < numsteps; step++) {
           const theta = theta1 + step / numsteps * deltatheta;
@@ -7200,7 +7247,7 @@ var require_arc = __commonJS({
         vec2.add(point, point, centerv);
         pointArray.push(point);
       } else {
-        const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1;
+        const numsteps = Math.floor(segments * (Math.abs(rotation) / TAU));
         let edgestepsize = numsteps * 0.5 / rotation;
         if (edgestepsize > 0.25) edgestepsize = 0.25;
         const totalsteps = makeTangent ? numsteps + 2 : numsteps;
@@ -11233,6 +11280,205 @@ var require_intersect2 = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js
+var require_hullPoints3 = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js"(exports, module) {
+    "use strict";
+    var poly3 = require_poly3();
+    var quickhull = require_quickhull();
+    var hullPoints3 = (uniquePoints) => {
+      const faces = quickhull(uniquePoints, { skipTriangulation: true });
+      const polygons = faces.map((face) => {
+        const vertices = face.map((index) => uniquePoints[index]);
+        return poly3.create(vertices);
+      });
+      return polygons;
+    };
+    module.exports = hullPoints3;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js
+var require_unionGeom3Sub = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js"(exports, module) {
+    "use strict";
+    var geom33 = require_geom3();
+    var mayOverlap = require_mayOverlap();
+    var { Tree } = require_trees();
+    var unionSub = (geometry1, geometry2) => {
+      if (!mayOverlap(geometry1, geometry2)) {
+        return unionForNonIntersecting(geometry1, geometry2);
+      }
+      const a = new Tree(geom33.toPolygons(geometry1));
+      const b = new Tree(geom33.toPolygons(geometry2));
+      a.clipTo(b, false);
+      b.clipTo(a);
+      b.invert();
+      b.clipTo(a);
+      b.invert();
+      const newpolygons = a.allPolygons().concat(b.allPolygons());
+      const result = geom33.create(newpolygons);
+      return result;
+    };
+    var unionForNonIntersecting = (geometry1, geometry2) => {
+      let newpolygons = geom33.toPolygons(geometry1);
+      newpolygons = newpolygons.concat(geom33.toPolygons(geometry2));
+      return geom33.create(newpolygons);
+    };
+    module.exports = unionSub;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js
+var require_unionGeom3 = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js"(exports, module) {
+    "use strict";
+    var flatten = require_flatten();
+    var retessellate = require_retessellate();
+    var unionSub = require_unionGeom3Sub();
+    var union3 = (...geometries) => {
+      geometries = flatten(geometries);
+      let i;
+      for (i = 1; i < geometries.length; i += 2) {
+        geometries.push(unionSub(geometries[i - 1], geometries[i]));
+      }
+      let newgeometry = geometries[i - 1];
+      newgeometry = retessellate(newgeometry);
+      return newgeometry;
+    };
+    module.exports = union3;
+  }
+});
+
+// node_modules/@jscad/modeling/src/operations/minkowski/minkowskiSum.js
+var require_minkowskiSum = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/minkowski/minkowskiSum.js"(exports, module) {
+    "use strict";
+    var flatten = require_flatten();
+    var geom33 = require_geom3();
+    var poly3 = require_poly3();
+    var hullPoints3 = require_hullPoints3();
+    var unionGeom3 = require_unionGeom3();
+    var minkowskiSum = (...geometries) => {
+      geometries = flatten(geometries);
+      if (geometries.length !== 2) {
+        throw new Error("minkowskiSum requires exactly two geometries");
+      }
+      const [geomA, geomB] = geometries;
+      if (!geom33.isA(geomA) || !geom33.isA(geomB)) {
+        throw new Error("minkowskiSum requires geom3 geometries");
+      }
+      const aConvex = geom33.isConvex(geomA);
+      const bConvex = geom33.isConvex(geomB);
+      if (aConvex && bConvex) {
+        return minkowskiSumConvex(geomA, geomB);
+      }
+      if (!aConvex && bConvex) {
+        return minkowskiSumNonConvexConvex(geomA, geomB);
+      }
+      if (aConvex && !bConvex) {
+        return minkowskiSumNonConvexConvex(geomB, geomA);
+      }
+      throw new Error("minkowskiSum of two non-convex geometries is not yet supported");
+    };
+    var minkowskiSumNonConvexConvex = (geomA, geomB) => {
+      const tetrahedra = decomposeIntoTetrahedra(geomA);
+      if (tetrahedra.length === 0) {
+        return geom33.create();
+      }
+      const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB));
+      if (parts.length === 1) {
+        return parts[0];
+      }
+      return unionGeom3(parts);
+    };
+    var decomposeIntoTetrahedra = (geometry) => {
+      const polygons = geom33.toPolygons(geometry);
+      if (polygons.length === 0) {
+        return [];
+      }
+      const tetrahedra = [];
+      for (let i = 0; i < polygons.length; i++) {
+        const polygon3 = polygons[i];
+        const vertices = polygon3.vertices;
+        let cx = 0, cy = 0, cz = 0;
+        for (let k = 0; k < vertices.length; k++) {
+          cx += vertices[k][0];
+          cy += vertices[k][1];
+          cz += vertices[k][2];
+        }
+        cx /= vertices.length;
+        cy /= vertices.length;
+        cz /= vertices.length;
+        const plane = poly3.plane(polygon3);
+        const nx = plane[0], ny = plane[1], nz = plane[2];
+        const offset = 0.1;
+        const apex = [
+          // Vertex used as apex in tetrahedron polygons below
+          cx - nx * offset,
+          cy - ny * offset,
+          cz - nz * offset
+        ];
+        for (let j = 1; j < vertices.length - 1; j++) {
+          const v0 = vertices[0];
+          const v1 = vertices[j];
+          const v2 = vertices[j + 1];
+          const tetPolygons = createTetrahedronPolygons(apex, v0, v1, v2);
+          tetrahedra.push(geom33.create(tetPolygons));
+        }
+      }
+      return tetrahedra;
+    };
+    var createTetrahedronPolygons = (p0, p1, p2, p3) => {
+      return [
+        poly3.create([p0, p2, p1]),
+        // base seen from p3
+        poly3.create([p0, p1, p3]),
+        // face opposite p2
+        poly3.create([p1, p2, p3]),
+        // face opposite p0
+        poly3.create([p2, p0, p3])
+        // face opposite p1
+      ];
+    };
+    var minkowskiSumConvex = (geomA, geomB) => {
+      const pointsA = extractUniqueVertices(geomA);
+      const pointsB = extractUniqueVertices(geomB);
+      if (pointsA.length === 0 || pointsB.length === 0) {
+        return geom33.create();
+      }
+      const summedPoints = [];
+      for (let i = 0; i < pointsA.length; i++) {
+        const a = pointsA[i];
+        for (let j = 0; j < pointsB.length; j++) {
+          const b = pointsB[j];
+          summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]]);
+        }
+      }
+      const hullPolygons = hullPoints3(summedPoints);
+      return geom33.create(hullPolygons);
+    };
+    var extractUniqueVertices = (geometry) => {
+      const found = /* @__PURE__ */ new Set();
+      const unique = [];
+      const polygons = geom33.toPolygons(geometry);
+      for (let i = 0; i < polygons.length; i++) {
+        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);
+            unique.push(v);
+          }
+        }
+      }
+      return unique;
+    };
+    module.exports = minkowskiSum;
+  }
+});
+
 // node_modules/@jscad/modeling/src/operations/booleans/scissionGeom3.js
 var require_scissionGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/scissionGeom3.js"(exports, module) {
@@ -11421,58 +11667,6 @@ var require_subtract4 = __commonJS({
   }
 });
 
-// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js
-var require_unionGeom3Sub = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js"(exports, module) {
-    "use strict";
-    var geom33 = require_geom3();
-    var mayOverlap = require_mayOverlap();
-    var { Tree } = require_trees();
-    var unionSub = (geometry1, geometry2) => {
-      if (!mayOverlap(geometry1, geometry2)) {
-        return unionForNonIntersecting(geometry1, geometry2);
-      }
-      const a = new Tree(geom33.toPolygons(geometry1));
-      const b = new Tree(geom33.toPolygons(geometry2));
-      a.clipTo(b, false);
-      b.clipTo(a);
-      b.invert();
-      b.clipTo(a);
-      b.invert();
-      const newpolygons = a.allPolygons().concat(b.allPolygons());
-      const result = geom33.create(newpolygons);
-      return result;
-    };
-    var unionForNonIntersecting = (geometry1, geometry2) => {
-      let newpolygons = geom33.toPolygons(geometry1);
-      newpolygons = newpolygons.concat(geom33.toPolygons(geometry2));
-      return geom33.create(newpolygons);
-    };
-    module.exports = unionSub;
-  }
-});
-
-// node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js
-var require_unionGeom3 = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3.js"(exports, module) {
-    "use strict";
-    var flatten = require_flatten();
-    var retessellate = require_retessellate();
-    var unionSub = require_unionGeom3Sub();
-    var union = (...geometries) => {
-      geometries = flatten(geometries);
-      let i;
-      for (i = 1; i < geometries.length; i += 2) {
-        geometries.push(unionSub(geometries[i - 1], geometries[i]));
-      }
-      let newgeometry = geometries[i - 1];
-      newgeometry = retessellate(newgeometry);
-      return newgeometry;
-    };
-    module.exports = union;
-  }
-});
-
 // node_modules/@jscad/modeling/src/operations/booleans/unionGeom2.js
 var require_unionGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/unionGeom2.js"(exports, module) {
@@ -11483,14 +11677,14 @@ var require_unionGeom2 = __commonJS({
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
     var unionGeom3 = require_unionGeom3();
-    var union = (...geometries) => {
+    var union3 = (...geometries) => {
       geometries = flatten(geometries);
       const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = unionGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
       return fromFakePolygons(epsilon, geom33.toPolygons(newgeom3));
     };
-    module.exports = union;
+    module.exports = union3;
   }
 });
 
@@ -11504,7 +11698,7 @@ var require_union = __commonJS({
     var geom33 = require_geom3();
     var unionGeom2 = require_unionGeom2();
     var unionGeom3 = require_unionGeom3();
-    var union = (...geometries) => {
+    var union3 = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("wrong number of arguments");
       if (!areAllShapesTheSameType(geometries)) {
@@ -11515,7 +11709,7 @@ var require_union = __commonJS({
       if (geom33.isA(geometry)) return unionGeom3(geometries);
       return geometry;
     };
-    module.exports = union;
+    module.exports = union3;
   }
 });
 
@@ -11525,6 +11719,7 @@ var require_booleans = __commonJS({
     "use strict";
     module.exports = {
       intersect: require_intersect2(),
+      minkowski: require_minkowskiSum(),
       scission: require_scission(),
       subtract: require_subtract4(),
       union: require_union()
@@ -11905,7 +12100,7 @@ var require_expandGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/expandGeom3.js"(exports, module) {
     "use strict";
     var geom33 = require_geom3();
-    var union = require_union();
+    var union3 = require_union();
     var expandShell = require_expandShell();
     var expandGeom3 = (options, geometry) => {
       const defaults = {
@@ -11921,7 +12116,7 @@ var require_expandGeom3 = __commonJS({
       if (polygons.length === 0) throw new Error("the given geometry cannot be empty");
       options = { delta, corners, segments };
       const expanded = expandShell(options, geometry);
-      return union(geometry, expanded);
+      return union3(geometry, expanded);
     };
     module.exports = expandGeom3;
   }
@@ -12564,24 +12759,6 @@ var require_hullGeom2 = __commonJS({
   }
 });
 
-// node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js
-var require_hullPoints3 = __commonJS({
-  "node_modules/@jscad/modeling/src/operations/hulls/hullPoints3.js"(exports, module) {
-    "use strict";
-    var poly3 = require_poly3();
-    var quickhull = require_quickhull();
-    var hullPoints3 = (uniquePoints) => {
-      const faces = quickhull(uniquePoints, { skipTriangulation: true });
-      const polygons = faces.map((face) => {
-        const vertices = face.map((index) => uniquePoints[index]);
-        return poly3.create(vertices);
-      });
-      return polygons;
-    };
-    module.exports = hullPoints3;
-  }
-});
-
 // node_modules/@jscad/modeling/src/operations/hulls/hullGeom3.js
 var require_hullGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/hullGeom3.js"(exports, module) {
@@ -12633,7 +12810,7 @@ var require_hullChain = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/hullChain.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var union = require_union();
+    var union3 = require_union();
     var hull = require_hull();
     var hullChain = (...geometries) => {
       geometries = flatten(geometries);
@@ -12642,7 +12819,7 @@ var require_hullChain = __commonJS({
       for (let i = 1; i < geometries.length; i++) {
         hulls.push(hull(geometries[i - 1], geometries[i]));
       }
-      return union(hulls);
+      return union3(hulls);
     };
     module.exports = hullChain;
   }
@@ -12661,6 +12838,16 @@ var require_hulls = __commonJS({
   }
 });
 
+// node_modules/@jscad/modeling/src/operations/minkowski/index.js
+var require_minkowski = __commonJS({
+  "node_modules/@jscad/modeling/src/operations/minkowski/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      minkowskiSum: require_minkowskiSum()
+    };
+  }
+});
+
 // node_modules/@jscad/modeling/src/operations/modifiers/snapPolygons.js
 var require_snapPolygons = __commonJS({
   "node_modules/@jscad/modeling/src/operations/modifiers/snapPolygons.js"(exports, module) {
@@ -13502,6 +13689,7 @@ var require_src = __commonJS({
       expansions: require_expansions(),
       extrusions: require_extrusions(),
       hulls: require_hulls(),
+      minkowski: require_minkowski(),
       modifiers: require_modifiers(),
       transforms: require_transforms()
     };
@@ -14613,7 +14801,20 @@ var occtModulePromise = null;
 async function getOcctModule() {
   if (!occtModulePromise) {
     const occtimportjs = (await import("occt-import-js")).default;
-    occtModulePromise = occtimportjs();
+    const isBrowser = typeof window !== "undefined" || typeof self !== "undefined";
+    if (isBrowser) {
+      let wasmUrl;
+      try {
+        wasmUrl = (await import("occt-import-js/dist/occt-import-js.wasm?url")).default;
+      } catch {
+        wasmUrl = void 0;
+      }
+      occtModulePromise = occtimportjs({
+        locateFile: (path) => path.endsWith(".wasm") && wasmUrl ? wasmUrl : path
+      });
+    } else {
+      occtModulePromise = occtimportjs();
+    }
   }
   return occtModulePromise;
 }
@@ -15001,6 +15202,8 @@ var import_extrusions = __toESM(require_extrusions(), 1);
 var import_primitives = __toESM(require_primitives(), 1);
 var import_transforms = __toESM(require_transforms(), 1);
 var DEFAULT_SEGMENTS = 64;
+var REDUCED_SEGMENTS = 16;
+var HOLE_COUNT_THRESHOLD = 50;
 var toBoardSpaceVec2 = (point, center) => [point.x - center.x, -(point.y - center.y)];
 var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 var arePointsClockwise = (points) => {
@@ -15013,11 +15216,11 @@ var arePointsClockwise = (points) => {
   const signedArea = area / 2;
   return signedArea <= 0;
 };
-var createCircularHole = (x, y, radius, thickness) => (0, import_primitives.cylinder)({
+var createCircularHole = (x, y, radius, thickness, segments = DEFAULT_SEGMENTS) => (0, import_primitives.cylinder)({
   center: [x, y, 0],
   height: thickness + 1,
   radius,
-  segments: DEFAULT_SEGMENTS
+  segments
 });
 var createCutoutGeoms = (boardCenter, thickness, cutouts = []) => {
   const geoms = [];
@@ -15129,9 +15332,36 @@ var filterCutoutsForBoard = (cutouts, board) => {
 var import_extrusions2 = __toESM(require_extrusions(), 1);
 var import_primitives2 = __toESM(require_primitives(), 1);
 var import_transforms2 = __toESM(require_transforms(), 1);
-var import_booleans = __toESM(require_booleans(), 1);
+var import_booleans2 = __toESM(require_booleans(), 1);
 var geom3 = __toESM(require_geom3(), 1);
 var import_measureBoundingBox = __toESM(require_measureBoundingBox2(), 1);
+
+// lib/utils/batched-union.ts
+var import_booleans = __toESM(require_booleans(), 1);
+var batchedUnion = (geoms, batchSize = 50) => {
+  if (geoms.length === 0) {
+    throw new Error("Cannot union empty array");
+  }
+  if (geoms.length === 1) {
+    return geoms[0];
+  }
+  let results = [...geoms];
+  while (results.length > 1) {
+    const newResults = [];
+    for (let i = 0; i < results.length; i += batchSize) {
+      const batch = results.slice(i, i + batchSize);
+      if (batch.length === 1) {
+        newResults.push(batch[0]);
+      } else {
+        newResults.push((0, import_booleans.union)(...batch));
+      }
+    }
+    results = newResults;
+  }
+  return results[0];
+};
+
+// lib/utils/pcb-board-geometry.ts
 var RADIUS_EPSILON = 1e-4;
 var getNumberProperty = (obj, key) => {
   const value = obj[key];
@@ -15157,14 +15387,14 @@ var createBoardOutlineGeom = (board, center, thickness) => {
   geom = (0, import_transforms2.translate)([0, 0, -thickness / 2], geom);
   return geom;
 };
-var createPillHole = (x, y, width, height, thickness, rotate) => {
+var createPillHoleWithSegments = (x, y, width, height, thickness, rotate, segments = DEFAULT_SEGMENTS) => {
   const minDimension = Math.min(width, height);
   const maxAllowedRadius = Math.max(0, minDimension / 2 - RADIUS_EPSILON);
   const roundRadius = maxAllowedRadius <= 0 ? 0 : Math.min(height / 2, maxAllowedRadius);
   const hole2d = (0, import_primitives2.roundedRectangle)({
     size: [width, height],
     roundRadius,
-    segments: DEFAULT_SEGMENTS
+    segments
   });
   let hole3d = (0, import_extrusions2.extrudeLinear)({ height: thickness + 1 }, hole2d);
   hole3d = (0, import_transforms2.translate)([0, 0, -(thickness + 1) / 2], hole3d);
@@ -15173,7 +15403,7 @@ var createPillHole = (x, y, width, height, thickness, rotate) => {
   }
   return (0, import_transforms2.translate)([x, y, 0], hole3d);
 };
-var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) => {
+var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = [], segments = DEFAULT_SEGMENTS) => {
   const holeGeoms = [];
   for (const hole of holes) {
     const holeRecord = hole;
@@ -15187,13 +15417,14 @@ var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) =>
       const rotate = holeHeight > holeWidth;
       const width = rotate ? holeHeight : holeWidth;
       const height = rotate ? holeWidth : holeHeight;
-      const pillHole = createPillHole(
+      const pillHole = createPillHoleWithSegments(
         relX,
         relY,
         width,
         height,
         thickness,
-        rotate
+        rotate,
+        segments
       );
       holeGeoms.push(pillHole);
       continue;
@@ -15210,7 +15441,7 @@ var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) =>
       const hole2d = (0, import_primitives2.roundedRectangle)({
         size: [holeWidth, holeHeight],
         roundRadius,
-        segments: DEFAULT_SEGMENTS
+        segments
       });
       let hole3d = (0, import_extrusions2.extrudeLinear)({ height: thickness + 1 }, hole2d);
       hole3d = (0, import_transforms2.translate)([0, 0, -(thickness + 1) / 2], hole3d);
@@ -15224,7 +15455,7 @@ var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) =>
     const diameter = getNumberProperty(holeRecord, "hole_diameter") ?? getNumberProperty(holeRecord, "diameter");
     if (!diameter) continue;
     const radius = diameter / 2;
-    holeGeoms.push(createCircularHole(relX, relY, radius, thickness));
+    holeGeoms.push(createCircularHole(relX, relY, radius, thickness, segments));
   }
   for (const plated of platedHoles) {
     const platedRecord = plated;
@@ -15240,13 +15471,23 @@ var createHoleGeoms = (boardCenter, thickness, holes = [], platedHoles = []) =>
       const width = rotate ? holeHeight : holeWidth;
       const height = rotate ? holeWidth : holeHeight;
       holeGeoms.push(
-        createPillHole(relX, relY, width, height, thickness, rotate)
+        createPillHoleWithSegments(
+          relX,
+          relY,
+          width,
+          height,
+          thickness,
+          rotate,
+          segments
+        )
       );
       continue;
     }
     const diameter = getNumberProperty(platedRecord, "hole_diameter") ?? getNumberProperty(platedRecord, "outer_diameter");
     if (!diameter) continue;
-    holeGeoms.push(createCircularHole(relX, relY, diameter / 2, thickness));
+    holeGeoms.push(
+      createCircularHole(relX, relY, diameter / 2, thickness, segments)
+    );
   }
   return holeGeoms;
 };
@@ -15302,11 +15543,21 @@ var createBoardMesh = (board, options) => {
   const { thickness, holes = [], platedHoles = [], cutouts = [] } = options;
   const center = board.center ?? { x: 0, y: 0 };
   let boardGeom = createBoardOutlineGeom(board, center, thickness);
-  const holeGeoms = createHoleGeoms(center, thickness, holes, platedHoles);
+  const totalHoleCount = holes.length + platedHoles.length;
+  const useReducedSegments = totalHoleCount > HOLE_COUNT_THRESHOLD;
+  const segments = useReducedSegments ? REDUCED_SEGMENTS : DEFAULT_SEGMENTS;
+  const holeGeoms = createHoleGeoms(
+    center,
+    thickness,
+    holes,
+    platedHoles,
+    segments
+  );
   const cutoutGeoms = createCutoutGeoms(center, thickness, cutouts);
   const subtractGeoms = [...holeGeoms, ...cutoutGeoms];
   if (subtractGeoms.length > 0) {
-    boardGeom = (0, import_booleans.subtract)(boardGeom, ...subtractGeoms);
+    const unifiedHoles = batchedUnion(subtractGeoms);
+    boardGeom = (0, import_booleans2.subtract)(boardGeom, unifiedHoles);
   }
   boardGeom = (0, import_transforms2.rotateX)(-Math.PI / 2, boardGeom);
   const polygons = geom3.toPolygons(boardGeom);
@@ -15321,7 +15572,7 @@ var createBoardMesh = (board, options) => {
 
 // lib/utils/pcb-panel-geometry.ts
 var import_transforms3 = __toESM(require_transforms(), 1);
-var import_booleans2 = __toESM(require_booleans(), 1);
+var import_booleans3 = __toESM(require_booleans(), 1);
 var geom32 = __toESM(require_geom3(), 1);
 var import_measureBoundingBox2 = __toESM(require_measureBoundingBox2(), 1);
 var createPanelMesh = (panel, options) => {
@@ -15332,7 +15583,7 @@ var createPanelMesh = (panel, options) => {
   const cutoutGeoms = createCutoutGeoms(center, thickness, cutouts);
   const subtractGeoms = [...holeGeoms, ...cutoutGeoms];
   if (subtractGeoms.length > 0) {
-    panelGeom = (0, import_booleans2.subtract)(panelGeom, ...subtractGeoms);
+    panelGeom = (0, import_booleans3.subtract)(panelGeom, ...subtractGeoms);
   }
   panelGeom = (0, import_transforms3.rotateX)(-Math.PI / 2, panelGeom);
   const polygons = geom32.toPolygons(panelGeom);

package/package.json

@@ -2,9 +2,10 @@
   "name": "circuit-json-to-gltf",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.72",
+  "version": "0.0.74",
   "scripts": {
     "test": "bun test tests/",
+    "test:playwright": "playwright test",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "build:site": "cosmos-export",
@@ -23,6 +24,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.1.4",
+    "@playwright/test": "^1.58.2",
     "@google/model-viewer": "^4.1.0",
     "@resvg/resvg-js": "^2.6.2",
     "@resvg/resvg-wasm": "^2.6.2",