@tscircuit/cli 0.1.125 → 0.1.126

package/dist/main.js

@@ -305499,9 +305499,9 @@ var require_color_string = __commonJS((exports2, module2) => {
       return null;
     }
     for (i = 0;i < 3; i++) {
-      rgb2[i] = clamp7(rgb2[i], 0, 255);
+      rgb2[i] = clamp5(rgb2[i], 0, 255);
     }
-    rgb2[3] = clamp7(rgb2[3], 0, 1);
+    rgb2[3] = clamp5(rgb2[3], 0, 1);
     return rgb2;
   };
   cs.get.hsl = function(string) {
@@ -305513,9 +305513,9 @@ var require_color_string = __commonJS((exports2, module2) => {
     if (match) {
       var alpha = parseFloat(match[4]);
       var h = (parseFloat(match[1]) % 360 + 360) % 360;
-      var s = clamp7(parseFloat(match[2]), 0, 100);
-      var l = clamp7(parseFloat(match[3]), 0, 100);
-      var a = clamp7(isNaN(alpha) ? 1 : alpha, 0, 1);
+      var s = clamp5(parseFloat(match[2]), 0, 100);
+      var l = clamp5(parseFloat(match[3]), 0, 100);
+      var a = clamp5(isNaN(alpha) ? 1 : alpha, 0, 1);
       return [h, s, l, a];
     }
     return null;
@@ -305529,9 +305529,9 @@ var require_color_string = __commonJS((exports2, module2) => {
     if (match) {
       var alpha = parseFloat(match[4]);
       var h = (parseFloat(match[1]) % 360 + 360) % 360;
-      var w = clamp7(parseFloat(match[2]), 0, 100);
-      var b = clamp7(parseFloat(match[3]), 0, 100);
-      var a = clamp7(isNaN(alpha) ? 1 : alpha, 0, 1);
+      var w = clamp5(parseFloat(match[2]), 0, 100);
+      var b = clamp5(parseFloat(match[3]), 0, 100);
+      var a = clamp5(isNaN(alpha) ? 1 : alpha, 0, 1);
       return [h, w, b, a];
     }
     return null;
@@ -305566,7 +305566,7 @@ var require_color_string = __commonJS((exports2, module2) => {
   cs.to.keyword = function(rgb2) {
     return reverseNames[rgb2.slice(0, 3)];
   };
-  function clamp7(num, min, max) {
+  function clamp5(num, min, max) {
     return Math.min(Math.max(min, num), max);
   }
   function hexDouble(num) {
@@ -305720,9 +305720,9 @@ var require_conversions = __commonJS((exports2, module2) => {
     let currentClosestKeyword;
     for (const keyword of Object.keys(cssKeywords)) {
       const value2 = cssKeywords[keyword];
-      const distance8 = comparativeDistance(rgb2, value2);
-      if (distance8 < currentClosestDistance) {
-        currentClosestDistance = distance8;
+      const distance6 = comparativeDistance(rgb2, value2);
+      if (distance6 < currentClosestDistance) {
+        currentClosestDistance = distance6;
         currentClosestKeyword = keyword;
       }
     }
@@ -441906,7 +441906,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.124";
+var version = "0.1.125";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -441917,6 +441917,7 @@ var package_default = {
     "@tscircuit/fake-snippets": "^0.0.75",
     "@tscircuit/file-server": "^0.0.24",
     "@tscircuit/runframe": "^0.0.566",
+    "@tscircuit/math-utils": "^0.0.18",
     "@types/bun": "^1.2.2",
     "@types/configstore": "^6.0.2",
     "@types/debug": "^4.1.12",
@@ -441948,7 +441949,7 @@ var package_default = {
     redaxios: "^0.5.1",
     semver: "^7.6.3",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.485",
+    tscircuit: "^0.0.491",
     "@tscircuit/circuit-json-util": "^0.0.47",
     "typed-ky": "^0.0.4"
   },
@@ -464847,21 +464848,221 @@ init_dist2();
 // node_modules/@tscircuit/math-utils/dist/index.js
 var exports_dist3 = {};
 __export2(exports_dist3, {
+  segmentToSegmentMinDistance: () => segmentToSegmentMinDistance,
+  segmentToCircleMinDistance: () => segmentToCircleMinDistance,
+  segmentToBoxMinDistance: () => segmentToBoxMinDistance,
+  segmentToBoundsMinDistance: () => segmentToBoundsMinDistance,
   pointToSegmentDistance: () => pointToSegmentDistance2,
+  pointToSegmentClosestPoint: () => pointToSegmentClosestPoint,
+  pointToBoxDistance: () => pointToBoxDistance,
+  pointToBoundsDistance: () => pointToBoundsDistance,
   orientation: () => orientation2,
   onSegment: () => onSegment2,
+  midpoint: () => midpoint,
   grid: () => grid,
   getUnitVectorFromPointAToB: () => getUnitVectorFromPointAToB,
   getUnitVectorFromDirection: () => getUnitVectorFromDirection,
+  getSegmentIntersection: () => getSegmentIntersection,
   getBoundingBox: () => getBoundingBox2,
   findNearestPointsBetweenBoxSets: () => findNearestPointsBetweenBoxSets2,
   doesLineIntersectLine: () => doesLineIntersectLine2,
   doSegmentsIntersect: () => doSegmentsIntersect2,
   distance: () => distance4,
+  distSq: () => distSq,
   computeDistanceBetweenBoxes: () => computeDistanceBetweenBoxes2,
   clamp: () => clamp2
 });
 
+// node_modules/@tscircuit/math-utils/dist/chunk-3453HRP7.js
+function doesLineIntersectLine2([a1, a2], [b1, b2], {
+  lineThickness = 0
+} = {}) {
+  if (lineThickness === 0) {
+    return doSegmentsIntersect2(a1, a2, b1, b2);
+  }
+  const minDist = segmentsDistance2(a1, a2, b1, b2);
+  return minDist <= lineThickness;
+}
+function doSegmentsIntersect2(p1, q1, p2, q2) {
+  const o1 = orientation2(p1, q1, p2);
+  const o2 = orientation2(p1, q1, q2);
+  const o3 = orientation2(p2, q2, p1);
+  const o4 = orientation2(p2, q2, q1);
+  if (o1 !== o2 && o3 !== o4) {
+    return true;
+  }
+  if (o1 === 0 && onSegment2(p1, p2, q1))
+    return true;
+  if (o2 === 0 && onSegment2(p1, q2, q1))
+    return true;
+  if (o3 === 0 && onSegment2(p2, p1, q2))
+    return true;
+  if (o4 === 0 && onSegment2(p2, q1, q2))
+    return true;
+  return false;
+}
+function orientation2(p, q, r) {
+  const val54 = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  if (val54 === 0)
+    return 0;
+  return val54 > 0 ? 1 : 2;
+}
+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 segmentsDistance2(a1, a2, b1, b2) {
+  if (a1.x === a2.x && a1.y === a2.y) {
+    return pointToSegmentDistance2(a1, b1, b2);
+  }
+  if (b1.x === b2.x && b1.y === b2.y) {
+    return pointToSegmentDistance2(b1, a1, a2);
+  }
+  if (doSegmentsIntersect2(a1, a2, b1, b2)) {
+    return 0;
+  }
+  const distances = [
+    pointToSegmentDistance2(a1, b1, b2),
+    pointToSegmentDistance2(a2, b1, b2),
+    pointToSegmentDistance2(b1, a1, a2),
+    pointToSegmentDistance2(b2, a1, a2)
+  ];
+  return Math.min(...distances);
+}
+function pointToSegmentDistance2(p, v, w) {
+  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
+  if (l2 === 0)
+    return distance4(p, v);
+  let t2 = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+  t2 = Math.max(0, Math.min(1, t2));
+  const projection = {
+    x: v.x + t2 * (w.x - v.x),
+    y: v.y + t2 * (w.y - v.y)
+  };
+  return distance4(p, projection);
+}
+function distance4(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function getSegmentIntersection(a, b, u, v) {
+  const dx1 = b.x - a.x;
+  const dy1 = b.y - a.y;
+  const dx2 = v.x - u.x;
+  const dy2 = v.y - u.y;
+  const dx3 = a.x - u.x;
+  const dy3 = a.y - u.y;
+  const denominator = dx1 * dy2 - dy1 * dx2;
+  if (Math.abs(denominator) < 0.0000000001) {
+    return null;
+  }
+  const t2 = (dy3 * dx2 - dx3 * dy2) / denominator;
+  const s = (dx1 * dy3 - dy1 * dx3) / denominator;
+  const epsilon = 0.000000001;
+  if (t2 >= -epsilon && t2 <= 1 + epsilon && s >= -epsilon && s <= 1 + epsilon) {
+    const intersectionX = a.x + t2 * dx1;
+    const intersectionY = a.y + t2 * dy1;
+    return { x: intersectionX, y: intersectionY };
+  }
+  return null;
+}
+
+// node_modules/@tscircuit/math-utils/dist/chunk-FWQGMQBW.js
+function segmentToSegmentMinDistance(a, b, u, v) {
+  if (a.x === b.x && a.y === b.y) {
+    return pointToSegmentDistance2(a, u, v);
+  }
+  if (u.x === v.x && u.y === v.y) {
+    return pointToSegmentDistance2(u, a, b);
+  }
+  if (doSegmentsIntersect2(a, b, u, v)) {
+    return 0;
+  }
+  const distances = [
+    pointToSegmentDistance2(a, u, v),
+    pointToSegmentDistance2(b, u, v),
+    pointToSegmentDistance2(u, a, b),
+    pointToSegmentDistance2(v, a, b)
+  ];
+  return Math.min(...distances);
+}
+function segmentToBoundsMinDistance(a, b, bounds6) {
+  const topLeft = { x: bounds6.minX, y: bounds6.minY };
+  const topRight = { x: bounds6.maxX, y: bounds6.minY };
+  const bottomLeft = { x: bounds6.minX, y: bounds6.maxY };
+  const bottomRight = { x: bounds6.maxX, y: bounds6.maxY };
+  if (doSegmentsIntersect2(a, b, topLeft, topRight) || doSegmentsIntersect2(a, b, topRight, bottomRight) || doSegmentsIntersect2(a, b, bottomRight, bottomLeft) || doSegmentsIntersect2(a, b, bottomLeft, topLeft)) {
+    return 0;
+  }
+  if (a.x >= bounds6.minX && a.x <= bounds6.maxX && a.y >= bounds6.minY && a.y <= bounds6.maxY && b.x >= bounds6.minX && b.x <= bounds6.maxX && b.y >= bounds6.minY && b.y <= bounds6.maxY) {
+    return 0;
+  }
+  const distances = [
+    pointToSegmentDistance2(topLeft, a, b),
+    pointToSegmentDistance2(topRight, a, b),
+    pointToSegmentDistance2(bottomLeft, a, b),
+    pointToSegmentDistance2(bottomRight, a, b)
+  ];
+  if (a.x >= bounds6.minX && a.x <= bounds6.maxX && a.y >= bounds6.minY && a.y <= bounds6.maxY) {
+    return 0;
+  }
+  if (b.x >= bounds6.minX && b.x <= bounds6.maxX && b.y >= bounds6.minY && b.y <= bounds6.maxY) {
+    return 0;
+  }
+  if (a.x < bounds6.minX || a.x > bounds6.maxX || a.y < bounds6.minY || a.y > bounds6.maxY) {
+    const closestX = clamp2(a.x, bounds6.minX, bounds6.maxX);
+    const closestY = clamp2(a.y, bounds6.minY, bounds6.maxY);
+    distances.push(distance4(a, { x: closestX, y: closestY }));
+  }
+  if (b.x < bounds6.minX || b.x > bounds6.maxX || b.y < bounds6.minY || b.y > bounds6.maxY) {
+    const closestX = clamp2(b.x, bounds6.minX, bounds6.maxX);
+    const closestY = clamp2(b.y, bounds6.minY, bounds6.maxY);
+    distances.push(distance4(b, { x: closestX, y: closestY }));
+  }
+  return Math.min(...distances);
+}
+function segmentToBoxMinDistance(a, b, box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  const bounds6 = {
+    minX: box.center.x - halfWidth,
+    maxX: box.center.x + halfWidth,
+    minY: box.center.y - halfHeight,
+    maxY: box.center.y + halfHeight
+  };
+  return segmentToBoundsMinDistance(a, b, bounds6);
+}
+function segmentToCircleMinDistance(a, b, circle) {
+  const circleCenter = { x: circle.x, y: circle.y };
+  if (a.x === b.x && a.y === b.y) {
+    return Math.max(0, distance4(a, circleCenter) - circle.radius);
+  }
+  const ab = { x: b.x - a.x, y: b.y - a.y };
+  const ac = { x: circleCenter.x - a.x, y: circleCenter.y - a.y };
+  const abLengthSq = ab.x * ab.x + ab.y * ab.y;
+  const t2 = Math.max(0, Math.min(1, (ab.x * ac.x + ab.y * ac.y) / abLengthSq));
+  const closestPoint = {
+    x: a.x + t2 * ab.x,
+    y: a.y + t2 * ab.y
+  };
+  const distToCenter = distance4(closestPoint, circleCenter);
+  return Math.max(0, distToCenter - circle.radius);
+}
+function pointToSegmentClosestPoint(p, a, b) {
+  const dx_ab = b.x - a.x;
+  const dy_ab = b.y - a.y;
+  const l2 = dx_ab * dx_ab + dy_ab * dy_ab;
+  if (l2 === 0)
+    return { x: a.x, y: a.y };
+  let t2 = ((p.x - a.x) * dx_ab + (p.y - a.y) * dy_ab) / l2;
+  t2 = Math.max(0, Math.min(1, t2));
+  const closestPoint = {
+    x: a.x + t2 * dx_ab,
+    y: a.y + t2 * dy_ab
+  };
+  return closestPoint;
+}
+
 // node_modules/@tscircuit/math-utils/dist/chunk-GIGMPRPV.js
 var getUnitVectorFromPointAToB = (a, b) => {
   const delta = {
@@ -464934,77 +465135,39 @@ function grid({
   return cells;
 }
 
-// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
-function doesLineIntersectLine2([a1, a2], [b1, b2], {
-  lineThickness = 0
-} = {}) {
-  if (lineThickness === 0) {
-    return doSegmentsIntersect2(a1, a2, b1, b2);
-  }
-  const minDist = segmentsDistance2(a1, a2, b1, b2);
-  return minDist <= lineThickness;
-}
-function doSegmentsIntersect2(p1, q1, p2, q2) {
-  const o1 = orientation2(p1, q1, p2);
-  const o2 = orientation2(p1, q1, q2);
-  const o3 = orientation2(p2, q2, p1);
-  const o4 = orientation2(p2, q2, q1);
-  if (o1 !== o2 && o3 !== o4) {
-    return true;
-  }
-  if (o1 === 0 && onSegment2(p1, p2, q1))
-    return true;
-  if (o2 === 0 && onSegment2(p1, q2, q1))
-    return true;
-  if (o3 === 0 && onSegment2(p2, p1, q2))
-    return true;
-  if (o4 === 0 && onSegment2(p2, q1, q2))
-    return true;
-  return false;
-}
-function orientation2(p, q, r) {
-  const val54 = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  if (val54 === 0)
+// node_modules/@tscircuit/math-utils/dist/chunk-SLG2OU3P.js
+function pointToBoxDistance(p, box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  const minX = box.center.x - halfWidth;
+  const maxX = box.center.x + halfWidth;
+  const minY = box.center.y - halfHeight;
+  const maxY = box.center.y + halfHeight;
+  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
     return 0;
-  return val54 > 0 ? 1 : 2;
-}
-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 segmentsDistance2(a1, a2, b1, b2) {
-  if (a1.x === a2.x && a1.y === a2.y) {
-    return pointToSegmentDistance2(a1, b1, b2);
   }
-  if (b1.x === b2.x && b1.y === b2.y) {
-    return pointToSegmentDistance2(b1, a1, a2);
-  }
-  if (doSegmentsIntersect2(a1, a2, b1, b2)) {
+  const closestX = clamp2(p.x, minX, maxX);
+  const closestY = clamp2(p.y, minY, maxY);
+  return distance4(p, { x: closestX, y: closestY });
+}
+function pointToBoundsDistance(p, bounds6) {
+  if (p.x >= bounds6.minX && p.x <= bounds6.maxX && p.y >= bounds6.minY && p.y <= bounds6.maxY) {
     return 0;
   }
-  const distances = [
-    pointToSegmentDistance2(a1, b1, b2),
-    pointToSegmentDistance2(a2, b1, b2),
-    pointToSegmentDistance2(b1, a1, a2),
-    pointToSegmentDistance2(b2, a1, a2)
-  ];
-  return Math.min(...distances);
+  const closestX = clamp2(p.x, bounds6.minX, bounds6.maxX);
+  const closestY = clamp2(p.y, bounds6.minY, bounds6.maxY);
+  return distance4(p, { x: closestX, y: closestY });
 }
-function pointToSegmentDistance2(p, v, w) {
-  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
-  if (l2 === 0)
-    return distance4(p, v);
-  let t2 = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
-  t2 = Math.max(0, Math.min(1, t2));
-  const projection = {
-    x: v.x + t2 * (w.x - v.x),
-    y: v.y + t2 * (w.y - v.y)
+function midpoint(p1, p2) {
+  return {
+    x: (p1.x + p2.x) / 2,
+    y: (p1.y + p2.y) / 2
   };
-  return distance4(p, projection);
 }
-function distance4(p1, p2) {
+function distSq(p1, p2) {
   const dx = p1.x - p2.x;
   const dy = p1.y - p2.y;
-  return Math.sqrt(dx * dx + dy * dy);
+  return dx * dx + dy * dy;
 }
 
 // node_modules/@tscircuit/core/dist/index.js
@@ -468117,7 +468280,7 @@ function distance5(p1, p2) {
   const dy = p1.y - p2.y;
   return Math.sqrt(dx * dx + dy * dy);
 }
-function getSegmentIntersection(a, b, u, v) {
+function getSegmentIntersection2(a, b, u, v) {
   const dx1 = b.x - a.x;
   const dy1 = b.y - a.y;
   const dx2 = v.x - u.x;
@@ -468168,7 +468331,7 @@ function computeDistanceBetweenBoxes3(boxA, boxB) {
 function clamp3(value2, min, max) {
   return Math.max(min, Math.min(max, value2));
 }
-function segmentToSegmentMinDistance(a, b, u, v) {
+function segmentToSegmentMinDistance2(a, b, u, v) {
   if (a.x === b.x && a.y === b.y) {
     return pointToSegmentDistance3(a, u, v);
   }
@@ -468186,7 +468349,7 @@ function segmentToSegmentMinDistance(a, b, u, v) {
   ];
   return Math.min(...distances);
 }
-function segmentToBoundsMinDistance(a, b, bounds6) {
+function segmentToBoundsMinDistance2(a, b, bounds6) {
   const topLeft = { x: bounds6.minX, y: bounds6.minY };
   const topRight = { x: bounds6.maxX, y: bounds6.minY };
   const bottomLeft = { x: bounds6.minX, y: bounds6.maxY };
@@ -468221,7 +468384,7 @@ function segmentToBoundsMinDistance(a, b, bounds6) {
   }
   return Math.min(...distances);
 }
-function segmentToBoxMinDistance(a, b, box) {
+function segmentToBoxMinDistance2(a, b, box) {
   const halfWidth = box.width / 2;
   const halfHeight = box.height / 2;
   const bounds6 = {
@@ -468230,9 +468393,9 @@ function segmentToBoxMinDistance(a, b, box) {
     minY: box.center.y - halfHeight,
     maxY: box.center.y + halfHeight
   };
-  return segmentToBoundsMinDistance(a, b, bounds6);
+  return segmentToBoundsMinDistance2(a, b, bounds6);
 }
-function pointToSegmentClosestPoint(p, a, b) {
+function pointToSegmentClosestPoint2(p, a, b) {
   const dx_ab = b.x - a.x;
   const dy_ab = b.y - a.y;
   const l2 = dx_ab * dx_ab + dy_ab * dy_ab;
@@ -468246,7 +468409,7 @@ function pointToSegmentClosestPoint(p, a, b) {
   };
   return closestPoint;
 }
-function midpoint(p1, p2) {
+function midpoint2(p1, p2) {
   return {
     x: (p1.x + p2.x) / 2,
     y: (p1.y + p2.y) / 2
@@ -469298,7 +469461,7 @@ function computeDumbbellPaths({
   margin,
   subdivisions = 0
 }) {
-  const midpoint2 = (p1, p2) => ({
+  const midpoint22 = (p1, p2) => ({
     x: (p1.x + p2.x) / 2,
     y: (p1.y + p2.y) / 2
   });
@@ -469505,8 +469668,8 @@ function computeDumbbellPaths({
       innerPoints.B_Left,
       innerPoints.B_Opp,
       innerPoints.B_Right,
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.B_Right, innerPoints.A_Right)),
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Left, innerPoints.B_Left)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.B_Right, innerPoints.A_Right)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Left, innerPoints.B_Left)),
       innerPoints.A_Left,
       innerPoints.A_Opp,
       innerPoints.A_Right,
@@ -469517,8 +469680,8 @@ function computeDumbbellPaths({
       innerPoints.B_Right,
       innerPoints.B_Opp,
       innerPoints.B_Left,
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Left, innerPoints.B_Left)),
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Right, innerPoints.B_Right)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Left, innerPoints.B_Left)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Right, innerPoints.B_Right)),
       innerPoints.A_Right,
       innerPoints.A_Opp,
       innerPoints.A_Left,
@@ -469529,8 +469692,8 @@ function computeDumbbellPaths({
       innerPoints.B_Left,
       innerPoints.B_Opp,
       innerPoints.B_Right,
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Right, innerPoints.B_Right)),
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Left, innerPoints.B_Left)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Right, innerPoints.B_Right)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Left, innerPoints.B_Left)),
       innerPoints.A_Left,
       innerPoints.A_Opp,
       innerPoints.A_Right,
@@ -469541,8 +469704,8 @@ function computeDumbbellPaths({
       innerPoints.B_Right,
       innerPoints.B_Opp,
       innerPoints.B_Left,
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Left, innerPoints.B_Left)),
-      midpoint2(innerPoints.midpoint, midpoint2(innerPoints.A_Right, innerPoints.B_Right)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Left, innerPoints.B_Left)),
+      midpoint22(innerPoints.midpoint, midpoint22(innerPoints.A_Right, innerPoints.B_Right)),
       innerPoints.A_Right,
       innerPoints.A_Opp,
       innerPoints.A_Left,
@@ -469550,8 +469713,8 @@ function computeDumbbellPaths({
     ]
   ];
   const getJLines = () => {
-    const mid_AR_BR = midpoint2(innerPoints.A_Right, innerPoints.B_Right);
-    const mid_AL_BL = midpoint2(innerPoints.B_Left, innerPoints.A_Left);
+    const mid_AR_BR = midpoint22(innerPoints.A_Right, innerPoints.B_Right);
+    const mid_AL_BL = midpoint22(innerPoints.B_Left, innerPoints.A_Left);
     return [
       { startsAt: "E", goesTo: "B", points: [E, B] },
       { startsAt: "E", goesTo: "A", points: [E, A] },
@@ -471246,7 +471409,7 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
           if (segment[0].z !== this.currentHead.z) {
             continue;
           }
-          const intersection = getSegmentIntersection(proposedSegment[0], proposedSegment[1], segment[0], segment[1]);
+          const intersection = getSegmentIntersection2(proposedSegment[0], proposedSegment[1], segment[0], segment[1]);
           if (intersection) {
             const distToIntersection = distance5(this.currentHead, intersection);
             if (distToIntersection < 0.000001)
@@ -471269,7 +471432,7 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
       let viaXY;
       const distToIntersection = closestIntersection.dist;
       if (distToIntersection < this.VIA_INTERSECTION_BUFFER_DISTANCE) {
-        viaXY = midpoint(this.currentHead, closestIntersection.point);
+        viaXY = midpoint2(this.currentHead, closestIntersection.point);
       } else {
         const intersectionPoint = closestIntersection.point;
         const vectorX = intersectionPoint.x - this.currentHead.x;
@@ -471294,7 +471457,7 @@ var ViaPossibilitiesSolver2 = class extends BaseSolver {
       let viaXY;
       const distToTarget = distance5(this.currentHead, targetEnd);
       if (distToTarget < this.VIA_INTERSECTION_BUFFER_DISTANCE) {
-        viaXY = midpoint(this.currentHead, targetEnd);
+        viaXY = midpoint2(this.currentHead, targetEnd);
       } else {
         const vectorX = targetEnd.x - this.currentHead.x;
         const vectorY = targetEnd.y - this.currentHead.y;
@@ -472304,7 +472467,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
           const path2Segments = path2SegmentsByLayer.get(zLayer) ?? [];
           for (const segment1 of path1Segments) {
             for (const segment2 of path2Segments) {
-              minGap = Math.min(minGap, segmentToSegmentMinDistance(segment1[0], segment1[1], segment2[0], segment2[1]) - this.traceWidth);
+              minGap = Math.min(minGap, segmentToSegmentMinDistance2(segment1[0], segment1[1], segment2[0], segment2[1]) - this.traceWidth);
             }
           }
           for (const via of path1Vias) {
@@ -472513,7 +472676,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
         for (const seg1 of segments1) {
           for (const seg2 of segments2) {
             if (seg1.layer === seg2.layer) {
-              const minDist = segmentToSegmentMinDistance(seg1.p1, seg1.p2, seg2.p1, seg2.p2);
+              const minDist = segmentToSegmentMinDistance2(seg1.p1, seg1.p2, seg2.p1, seg2.p2);
               if (minDist < EPSILON4)
                 continue;
               const center1 = {
@@ -472535,7 +472698,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
                 const sourceIdSeg2 = `seg:${j}:${seg2.p1Idx}:${seg2.p2Idx}`;
                 const sourceIdSeg1 = `seg:${i}:${seg1.p1Idx}:${seg1.p2Idx}`;
                 const endpointForce = (ep, epIdx, otherSeg, targetLine, oppLine, srcIdOpp, srcIdThis) => {
-                  const cp = pointToSegmentClosestPoint(ep, otherSeg.p1, otherSeg.p2);
+                  const cp = pointToSegmentClosestPoint2(ep, otherSeg.p1, otherSeg.p2);
                   const dx2 = ep.x - cp.x;
                   const dy2 = ep.y - cp.y;
                   const dSq2 = dx2 * dx2 + dy2 * dy2;
@@ -472560,7 +472723,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
         for (const via1 of vias1) {
           for (const seg2 of segments2) {
             if (via1.layers.includes(seg2.layer)) {
-              const closestPointOnSeg = pointToSegmentClosestPoint(via1.point, seg2.p1, seg2.p2);
+              const closestPointOnSeg = pointToSegmentClosestPoint2(via1.point, seg2.p1, seg2.p2);
               const dx = via1.point.x - closestPointOnSeg.x;
               const dy = via1.point.y - closestPointOnSeg.y;
               const dSq = dx * dx + dy * dy;
@@ -472589,7 +472752,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
         for (const via2 of vias2) {
           for (const seg1 of segments1) {
             if (via2.layers.includes(seg1.layer)) {
-              const closestPointOnSeg = pointToSegmentClosestPoint(via2.point, seg1.p1, seg1.p2);
+              const closestPointOnSeg = pointToSegmentClosestPoint2(via2.point, seg1.p1, seg1.p2);
               const dx = via2.point.x - closestPointOnSeg.x;
               const dy = via2.point.y - closestPointOnSeg.y;
               const dSq = dx * dx + dy * dy;
@@ -473054,7 +473217,7 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
       }
     };
     const endpointForce = (ep, epIdx, otherSeg, targetLine, oppLine) => {
-      const cp = pointToSegmentClosestPoint(ep, otherSeg.p1, otherSeg.p2);
+      const cp = pointToSegmentClosestPoint2(ep, otherSeg.p1, otherSeg.p2);
       const dx = ep.x - cp.x;
       const dy = ep.y - cp.y;
       const dSq = dx * dx + dy * dy;
@@ -473107,7 +473270,7 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
         for (const seg1 of segments1) {
           for (const seg2 of segments2) {
             if (seg1.layer === seg2.layer) {
-              const minDist = segmentToSegmentMinDistance(seg1.p1, seg1.p2, seg2.p1, seg2.p2);
+              const minDist = segmentToSegmentMinDistance2(seg1.p1, seg1.p2, seg2.p1, seg2.p2);
               endpointForce(seg1.p1, seg1.p1Idx, seg2, i, j);
               endpointForce(seg1.p2, seg1.p2Idx, seg2, i, j);
               endpointForce(seg2.p1, seg2.p1Idx, seg1, j, i);
@@ -473118,7 +473281,7 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
         for (const via1 of vias1) {
           for (const seg2 of segments2) {
             if (via1.layers.includes(seg2.layer)) {
-              const closestPointOnSeg = pointToSegmentClosestPoint(via1.point, seg2.p1, seg2.p2);
+              const closestPointOnSeg = pointToSegmentClosestPoint2(via1.point, seg2.p1, seg2.p2);
               const dx = via1.point.x - closestPointOnSeg.x;
               const dy = via1.point.y - closestPointOnSeg.y;
               const dSq = dx * dx + dy * dy;
@@ -473145,7 +473308,7 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
         for (const via2 of vias2) {
           for (const seg1 of segments1) {
             if (via2.layers.includes(seg1.layer)) {
-              const closestPointOnSeg = pointToSegmentClosestPoint(via2.point, seg1.p1, seg1.p2);
+              const closestPointOnSeg = pointToSegmentClosestPoint2(via2.point, seg1.p1, seg1.p2);
               const dx = via2.point.x - closestPointOnSeg.x;
               const dy = via2.point.y - closestPointOnSeg.y;
               const dSq = dx * dx + dy * dy;
@@ -479036,7 +479199,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       if (!obstacle.zLayers?.includes(start.z)) {
         continue;
       }
-      const distToObstacle = segmentToBoxMinDistance(start, end, obstacle);
+      const distToObstacle = segmentToBoxMinDistance2(start, end, obstacle);
       if (distToObstacle < this.OBSTACLE_MARGIN + this.TRACE_THICKNESS / 2) {
         return false;
       }
@@ -479954,7 +480117,7 @@ var SingleRouteUselessViaRemovalSolver = class extends BaseSolver {
       };
       const obstacles = this.obstacleSHI.searchArea(segmentBox.centerX, segmentBox.centerY, segmentBox.width + (this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) * 2, segmentBox.height + (this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) * 2);
       for (const obstacle of obstacles) {
-        const distToObstacle = segmentToBoxMinDistance(A, B, obstacle);
+        const distToObstacle = segmentToBoxMinDistance2(A, B, obstacle);
         if (distToObstacle < this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) {
           return false;
         }
@@ -480502,303 +480665,13 @@ init_dist2();
 // node_modules/@tscircuit/checks/dist/index.js
 init_dist4();
 init_dist4();
-
-// node_modules/@tscircuit/checks/node_modules/circuit-json-to-connectivity-map/dist/index.js
-function findConnectedNetworks2(connections) {
-  const networks = /* @__PURE__ */ new Map;
-  let netCounter = 0;
-  function getOrCreateNetwork(nodeId) {
-    for (const [, network] of networks) {
-      if (network.has(nodeId)) {
-        return network;
-      }
-    }
-    const newNetwork = /* @__PURE__ */ new Set;
-    networks.set(`connectivity_net${netCounter++}`, newNetwork);
-    return newNetwork;
-  }
-  for (const connection of connections) {
-    let network = null;
-    for (const nodeId of connection) {
-      if (!network) {
-        network = getOrCreateNetwork(nodeId);
-      } else if (!network.has(nodeId)) {
-        const existingNetwork = getOrCreateNetwork(nodeId);
-        if (existingNetwork !== network) {
-          for (const node of existingNetwork) {
-            network.add(node);
-          }
-          networks.delete(Array.from(networks.entries()).find(([, net2]) => net2 === existingNetwork)[0]);
-        }
-      }
-      network.add(nodeId);
-    }
-  }
-  return Object.fromEntries(Array.from(networks.entries()).map(([netId, connectedNodes]) => [
-    netId,
-    Array.from(connectedNodes)
-  ]));
-}
-var ConnectivityMap3 = class {
-  netMap;
-  idToNetMap;
-  constructor(netMap) {
-    this.netMap = netMap;
-    this.idToNetMap = {};
-    for (const [netId, ids] of Object.entries(netMap)) {
-      for (const id of ids) {
-        this.idToNetMap[id] = netId;
-      }
-    }
-  }
-  addConnections(connections) {
-    for (const connection of connections) {
-      const existingNets = /* @__PURE__ */ new Set;
-      for (const id of connection) {
-        const existingNetId = this.idToNetMap[id];
-        if (existingNetId) {
-          existingNets.add(existingNetId);
-        }
-      }
-      let targetNetId;
-      if (existingNets.size === 0) {
-        targetNetId = `connectivity_net${Object.keys(this.netMap).length}`;
-        this.netMap[targetNetId] = [];
-      } else if (existingNets.size === 1) {
-        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
-      } else {
-        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
-        for (const netId of existingNets) {
-          if (netId !== targetNetId) {
-            this.netMap[targetNetId].push(...this.netMap[netId]);
-            this.netMap[netId] = this.netMap[targetNetId];
-            for (const id of this.netMap[targetNetId]) {
-              this.idToNetMap[id] = targetNetId;
-            }
-          }
-        }
-      }
-      for (const id of connection) {
-        if (!this.netMap[targetNetId].includes(id)) {
-          this.netMap[targetNetId].push(id);
-        }
-        this.idToNetMap[id] = targetNetId;
-      }
-    }
-  }
-  getIdsConnectedToNet(netId) {
-    return this.netMap[netId] || [];
-  }
-  getNetConnectedToId(id) {
-    return this.idToNetMap[id];
-  }
-  areIdsConnected(id1, id2) {
-    if (id1 === id2)
-      return true;
-    const netId1 = this.getNetConnectedToId(id1);
-    if (!netId1)
-      return false;
-    const netId2 = this.getNetConnectedToId(id2);
-    if (!netId2)
-      return false;
-    return netId1 === netId2 || netId2 === id1 || netId2 === id1;
-  }
-  areAllIdsConnected(ids) {
-    const netId = this.getNetConnectedToId(ids[0]);
-    for (const id of ids) {
-      const nextNetId = this.getNetConnectedToId(id);
-      if (nextNetId === undefined) {
-        return false;
-      }
-      if (nextNetId !== netId) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-var getFullConnectivityMapFromCircuitJson2 = (circuitJson) => {
-  const connections = [];
-  for (const element of circuitJson) {
-    if (element.type === "source_trace") {
-      connections.push([
-        element.source_trace_id,
-        ...element.connected_source_port_ids ?? [],
-        ...element.connected_source_net_ids ?? []
-      ].filter(Boolean));
-    } else if (element.type === "pcb_port") {
-      const { pcb_port_id, source_port_id } = element;
-      if (source_port_id && pcb_port_id) {
-        connections.push([source_port_id, pcb_port_id]);
-      }
-    } else if (element.type === "pcb_smtpad") {
-      const { pcb_smtpad_id, pcb_port_id } = element;
-      if (pcb_port_id && pcb_smtpad_id) {
-        connections.push([pcb_smtpad_id, pcb_port_id]);
-      }
-    } else if (element.type === "pcb_plated_hole") {
-      const { pcb_plated_hole_id, pcb_port_id } = element;
-      if (pcb_port_id && pcb_plated_hole_id) {
-        connections.push([pcb_plated_hole_id, pcb_port_id]);
-      }
-    } else if (element.type === "pcb_trace") {
-      const { pcb_trace_id, source_trace_id } = element;
-      const route = Array.isArray(element.route) ? element.route.filter((rp) => rp && rp.route_type === "wire") : [];
-      if (source_trace_id && pcb_trace_id) {
-        connections.push([pcb_trace_id, source_trace_id]);
-      }
-      if (Array.isArray(route)) {
-        const startId = route.find((rp) => rp && rp.start_pcb_port_id)?.start_pcb_port_id;
-        const endId = route.find((rp) => rp && rp.end_pcb_port_id)?.end_pcb_port_id;
-        if (startId && pcb_trace_id && endId) {
-          connections.push([startId, pcb_trace_id, endId]);
-        }
-      }
-    } else if (element.type === "pcb_via") {
-      const { pcb_via_id, pcb_trace_id } = element;
-      if (pcb_trace_id && pcb_via_id) {
-        connections.push([pcb_via_id, pcb_trace_id]);
-      }
-    } else if (element.type === "source_component") {
-      if (element.internally_connected_source_port_ids) {
-        for (const portGroup of element.internally_connected_source_port_ids) {
-          connections.push(portGroup);
-        }
-      }
-    }
-  }
-  const netMap = findConnectedNetworks2(connections);
-  return new ConnectivityMap3(netMap);
-};
-
-// node_modules/@tscircuit/checks/dist/index.js
+init_dist2();
 init_dist4();
-
-// node_modules/@tscircuit/checks/node_modules/@tscircuit/math-utils/dist/chunk-3453HRP7.js
-function doSegmentsIntersect5(p1, q1, p2, q2) {
-  const o1 = orientation5(p1, q1, p2);
-  const o2 = orientation5(p1, q1, q2);
-  const o3 = orientation5(p2, q2, p1);
-  const o4 = orientation5(p2, q2, q1);
-  if (o1 !== o2 && o3 !== o4) {
-    return true;
-  }
-  if (o1 === 0 && onSegment5(p1, p2, q1))
-    return true;
-  if (o2 === 0 && onSegment5(p1, q2, q1))
-    return true;
-  if (o3 === 0 && onSegment5(p2, p1, q2))
-    return true;
-  if (o4 === 0 && onSegment5(p2, q1, q2))
-    return true;
-  return false;
-}
-function orientation5(p, q, r) {
-  const val54 = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  if (val54 === 0)
-    return 0;
-  return val54 > 0 ? 1 : 2;
-}
-function onSegment5(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 pointToSegmentDistance5(p, v, w) {
-  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
-  if (l2 === 0)
-    return distance7(p, v);
-  let t2 = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
-  t2 = Math.max(0, Math.min(1, t2));
-  const projection = {
-    x: v.x + t2 * (w.x - v.x),
-    y: v.y + t2 * (w.y - v.y)
-  };
-  return distance7(p, projection);
-}
-function distance7(p1, p2) {
-  const dx = p1.x - p2.x;
-  const dy = p1.y - p2.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
-// node_modules/@tscircuit/checks/node_modules/@tscircuit/math-utils/dist/chunk-MHHTZHOJ.js
-function clamp5(value2, min, max) {
-  return Math.max(min, Math.min(max, value2));
-}
-
-// node_modules/@tscircuit/checks/node_modules/@tscircuit/math-utils/dist/chunk-FWQGMQBW.js
-function segmentToSegmentMinDistance2(a, b, u, v) {
-  if (a.x === b.x && a.y === b.y) {
-    return pointToSegmentDistance5(a, u, v);
-  }
-  if (u.x === v.x && u.y === v.y) {
-    return pointToSegmentDistance5(u, a, b);
-  }
-  if (doSegmentsIntersect5(a, b, u, v)) {
-    return 0;
-  }
-  const distances = [
-    pointToSegmentDistance5(a, u, v),
-    pointToSegmentDistance5(b, u, v),
-    pointToSegmentDistance5(u, a, b),
-    pointToSegmentDistance5(v, a, b)
-  ];
-  return Math.min(...distances);
-}
-function segmentToBoundsMinDistance2(a, b, bounds6) {
-  const topLeft = { x: bounds6.minX, y: bounds6.minY };
-  const topRight = { x: bounds6.maxX, y: bounds6.minY };
-  const bottomLeft = { x: bounds6.minX, y: bounds6.maxY };
-  const bottomRight = { x: bounds6.maxX, y: bounds6.maxY };
-  if (doSegmentsIntersect5(a, b, topLeft, topRight) || doSegmentsIntersect5(a, b, topRight, bottomRight) || doSegmentsIntersect5(a, b, bottomRight, bottomLeft) || doSegmentsIntersect5(a, b, bottomLeft, topLeft)) {
-    return 0;
-  }
-  if (a.x >= bounds6.minX && a.x <= bounds6.maxX && a.y >= bounds6.minY && a.y <= bounds6.maxY && b.x >= bounds6.minX && b.x <= bounds6.maxX && b.y >= bounds6.minY && b.y <= bounds6.maxY) {
-    return 0;
-  }
-  const distances = [
-    pointToSegmentDistance5(topLeft, a, b),
-    pointToSegmentDistance5(topRight, a, b),
-    pointToSegmentDistance5(bottomLeft, a, b),
-    pointToSegmentDistance5(bottomRight, a, b)
-  ];
-  if (a.x >= bounds6.minX && a.x <= bounds6.maxX && a.y >= bounds6.minY && a.y <= bounds6.maxY) {
-    return 0;
-  }
-  if (b.x >= bounds6.minX && b.x <= bounds6.maxX && b.y >= bounds6.minY && b.y <= bounds6.maxY) {
-    return 0;
-  }
-  if (a.x < bounds6.minX || a.x > bounds6.maxX || a.y < bounds6.minY || a.y > bounds6.maxY) {
-    const closestX = clamp5(a.x, bounds6.minX, bounds6.maxX);
-    const closestY = clamp5(a.y, bounds6.minY, bounds6.maxY);
-    distances.push(distance7(a, { x: closestX, y: closestY }));
-  }
-  if (b.x < bounds6.minX || b.x > bounds6.maxX || b.y < bounds6.minY || b.y > bounds6.maxY) {
-    const closestX = clamp5(b.x, bounds6.minX, bounds6.maxX);
-    const closestY = clamp5(b.y, bounds6.minY, bounds6.maxY);
-    distances.push(distance7(b, { x: closestX, y: closestY }));
-  }
-  return Math.min(...distances);
-}
-function segmentToCircleMinDistance(a, b, circle) {
-  const circleCenter = { x: circle.x, y: circle.y };
-  if (a.x === b.x && a.y === b.y) {
-    return Math.max(0, distance7(a, circleCenter) - circle.radius);
-  }
-  const ab = { x: b.x - a.x, y: b.y - a.y };
-  const ac = { x: circleCenter.x - a.x, y: circleCenter.y - a.y };
-  const abLengthSq = ab.x * ab.x + ab.y * ab.y;
-  const t2 = Math.max(0, Math.min(1, (ab.x * ac.x + ab.y * ac.y) / abLengthSq));
-  const closestPoint = {
-    x: a.x + t2 * ab.x,
-    y: a.y + t2 * ab.y
-  };
-  const distToCenter = distance7(closestPoint, circleCenter);
-  return Math.max(0, distToCenter - circle.radius);
-}
-
-// node_modules/@tscircuit/checks/dist/index.js
 init_dist4();
 init_dist3();
+init_dist4();
+init_dist4();
+init_dist2();
 var SpatialObjectIndex = class {
   buckets;
   objectsById;
@@ -480950,7 +480823,7 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
       };
     }
     if (lenSqrA === 0) {
-      const t22 = clamp6(((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB, 0, 1);
+      const t22 = clamp4(((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB, 0, 1);
       const closestOnB2 = {
         x: b1.x + t22 * vb.x,
         y: b1.y + t22 * vb.y
@@ -480960,7 +480833,7 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
         y: (a1.y + closestOnB2.y) / 2
       };
     }
-    const t2 = clamp6(((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA, 0, 1);
+    const t2 = clamp4(((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA, 0, 1);
     const closestOnA2 = {
       x: a1.x + t2 * va.x,
       y: a1.y + t2 * va.y
@@ -480982,12 +480855,12 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
   }
   let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
   let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
-  tA = clamp6(tA, 0, 1);
-  tB = clamp6(tB, 0, 1);
+  tA = clamp4(tA, 0, 1);
+  tB = clamp4(tB, 0, 1);
   tB = (tA * dotAB + dotBW) / dotBB;
-  tB = clamp6(tB, 0, 1);
+  tB = clamp4(tB, 0, 1);
   tA = (tB * dotAB - dotAW) / dotAA;
-  tA = clamp6(tA, 0, 1);
+  tA = clamp4(tA, 0, 1);
   const closestOnA = {
     x: a1.x + tA * va.x,
     y: a1.y + tA * va.y
@@ -480998,7 +480871,7 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
   };
   const dx = closestOnA.x - closestOnB.x;
   const dy = closestOnA.y - closestOnB.y;
-  const distance23 = Math.sqrt(dx * dx + dy * dy);
+  const distance32 = Math.sqrt(dx * dx + dy * dy);
   const averagePoint = {
     x: (closestOnA.x + closestOnB.x) / 2,
     y: (closestOnA.y + closestOnB.y) / 2
@@ -481007,16 +480880,16 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
 };
 var closestPointsParallelSegments = (a1, a2, b1, b2, va, vb, lenSqrA, lenSqrB) => {
   let tA = ((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA;
-  tA = clamp6(tA, 0, 1);
+  tA = clamp4(tA, 0, 1);
   const pointOnA1 = { x: a1.x + tA * va.x, y: a1.y + tA * va.y };
   let tA2 = ((b2.x - a1.x) * va.x + (b2.y - a1.y) * va.y) / lenSqrA;
-  tA2 = clamp6(tA2, 0, 1);
+  tA2 = clamp4(tA2, 0, 1);
   const pointOnA2 = { x: a1.x + tA2 * va.x, y: a1.y + tA2 * va.y };
   let tB = ((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB;
-  tB = clamp6(tB, 0, 1);
+  tB = clamp4(tB, 0, 1);
   const pointOnB1 = { x: b1.x + tB * vb.x, y: b1.y + tB * vb.y };
   let tB2 = ((a2.x - b1.x) * vb.x + (a2.y - b1.y) * vb.y) / lenSqrB;
-  tB2 = clamp6(tB2, 0, 1);
+  tB2 = clamp4(tB2, 0, 1);
   const pointOnB2 = { x: b1.x + tB2 * vb.x, y: b1.y + tB2 * vb.y };
   const distances = [
     {
@@ -481046,7 +480919,7 @@ var closestPointsParallelSegments = (a1, a2, b1, b2, va, vb, lenSqrA, lenSqrB) =
     y: (closestPair.pointA.y + closestPair.pointB.y) / 2
   };
 };
-var clamp6 = (value2, min, max) => {
+var clamp4 = (value2, min, max) => {
   return Math.max(min, Math.min(max, value2));
 };
 var getRadiusOfCircuitJsonElement = (obj) => {
@@ -481177,7 +481050,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
   connMap
 } = {}) {
   const errors = [];
-  connMap ??= getFullConnectivityMapFromCircuitJson2(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson(circuitJson);
   const pcbTraces = cju_default(circuitJson).pcb_trace.list();
   const pcbTraceSegments = pcbTraces.flatMap((pcbTrace) => {
     const segments = [];
@@ -481239,7 +481112,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           continue;
         if (connMap.areIdsConnected(segmentA.pcb_trace_id, segmentB.pcb_trace_id))
           continue;
-        const gap2 = segmentToSegmentMinDistance2({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, { x: segmentB.x1, y: segmentB.y1 }, { x: segmentB.x2, y: segmentB.y2 }) - segmentA.thickness / 2 - segmentB.thickness / 2;
+        const gap2 = segmentToSegmentMinDistance({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, { x: segmentB.x1, y: segmentB.y1 }, { x: segmentB.x2, y: segmentB.y2 }) - segmentA.thickness / 2 - segmentB.thickness / 2;
         if (gap2 > DEFAULT_TRACE_MARGIN - EPSILON4)
           continue;
         const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${segmentB.pcb_trace_id}`;
@@ -481271,8 +481144,8 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
       const isCircular = obj.type === "pcb_via" || obj.type === "pcb_plated_hole" && obj.shape === "circle" || obj.type === "pcb_hole" || obj.type === "pcb_smtpad" && obj.shape === "circle";
       if (isCircular) {
         const radius = getRadiusOfCircuitJsonElement(obj);
-        const distance23 = segmentToCircleMinDistance({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, { x: obj.x, y: obj.y, radius });
-        const gap2 = distance23 - segmentA.thickness / 2;
+        const distance32 = segmentToCircleMinDistance({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, { x: obj.x, y: obj.y, radius });
+        const gap2 = distance32 - segmentA.thickness / 2;
         if (gap2 > DEFAULT_TRACE_MARGIN - EPSILON4)
           continue;
         const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
@@ -481296,7 +481169,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           ].filter(Boolean)
         });
       }
-      const gap = segmentToBoundsMinDistance2({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, getCollidableBounds(obj)) - segmentA.thickness / 2;
+      const gap = segmentToBoundsMinDistance({ x: segmentA.x1, y: segmentA.y1 }, { x: segmentA.x2, y: segmentA.y2 }, getCollidableBounds(obj)) - segmentA.thickness / 2;
       if (gap + EPSILON4 < requiredMargin) {
         const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
         if (errorIds.has(pcb_trace_error_id))
@@ -482231,8 +482104,8 @@ var PinBuilder = class {
       };
       pathfinder.addObstacle(obstacle);
     }
-    const distance8 = Math.abs(targetX - this.x) + Math.abs(targetY - this.y);
-    if (distance8 < 10) {
+    const distance6 = Math.abs(targetX - this.x) + Math.abs(targetY - this.y);
+    if (distance6 < 10) {
       const path21 = pathfinder.findPath(currentPos, targetPos);
       if (path21.length > 0) {
         for (let i = 1;i < path21.length; i++) {
@@ -484304,9 +484177,9 @@ function findBestPinToRemove(params2) {
         pinNumber: pin.pinNumber
       };
       applyEditOperation(testTemplate, testOp);
-      const distance8 = computeSimilarityDistanceAfterRemoval(testTemplate, target);
-      if (distance8 < bestDistance) {
-        bestDistance = distance8;
+      const distance6 = computeSimilarityDistanceAfterRemoval(testTemplate, target);
+      if (distance6 < bestDistance) {
+        bestDistance = distance6;
         bestPinNumber = pin.pinNumber;
       }
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.125",
+  "version": "0.1.126",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",
@@ -8,6 +8,7 @@
     "@tscircuit/fake-snippets": "^0.0.75",
     "@tscircuit/file-server": "^0.0.24",
     "@tscircuit/runframe": "^0.0.566",
+    "@tscircuit/math-utils": "^0.0.18",
     "@types/bun": "^1.2.2",
     "@types/configstore": "^6.0.2",
     "@types/debug": "^4.1.12",
@@ -39,7 +40,7 @@
     "redaxios": "^0.5.1",
     "semver": "^7.6.3",
     "tempy": "^3.1.0",
-    "tscircuit": "^0.0.485",
+    "tscircuit": "^0.0.491",
     "@tscircuit/circuit-json-util": "^0.0.47",
     "typed-ky": "^0.0.4"
   },