@tscircuit/cli 0.1.125 → 0.1.127

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.126";
 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,9 +441949,11 @@ 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"
+    "typed-ky": "^0.0.4",
+    "circuit-json-to-simple-3d": "^0.0.3",
+    "@tscircuit/simple-3d-svg": "^0.0.10"
   },
   peerDependencies: {
     typescript: "^5.0.0"
@@ -464847,21 +464850,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 +465137,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 +468282,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 +468333,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 +468351,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 +468386,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 +468395,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 +468411,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 +469463,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 +469670,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 +469682,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 +469694,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 +469706,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 +469715,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 +471411,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 +471434,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 +471459,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 +472469,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 +472678,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 +472700,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 +472725,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 +472754,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 +473219,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 +473272,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 +473283,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 +473310,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 +479201,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 +480119,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 +480667,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 +480825,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 +480835,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 +480857,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 +480873,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 +480882,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 +480921,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 +481052,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 +481114,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 +481146,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 +481171,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 +482106,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 +484179,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) {
@@ -495909,9 +495784,648 @@ var registerBuild = (program3) => {
 import fs24 from "node:fs";
 import path24 from "node:path";
 init_dist6();
+
+// node_modules/circuit-json-to-simple-3d/dist/index.js
+init_dist4();
+
+// node_modules/@tscircuit/simple-3d-svg/dist/index.js
+var stlCache = /* @__PURE__ */ new Map;
+async function loadSTL(url) {
+  if (stlCache.has(url)) {
+    return stlCache.get(url);
+  }
+  const response = await fetch(url);
+  const buffer = await response.arrayBuffer();
+  const mesh = parseSTL(buffer);
+  stlCache.set(url, mesh);
+  return mesh;
+}
+function parseSTL(buffer) {
+  const view = new DataView(buffer);
+  const header = new TextDecoder().decode(buffer.slice(0, 5));
+  if (header.toLowerCase() === "solid") {
+    return parseASCIISTL(buffer);
+  } else {
+    return parseBinarySTL(view);
+  }
+}
+function parseASCIISTL(buffer) {
+  const text = new TextDecoder().decode(buffer);
+  const lines = text.split(`
+`).map((line) => line.trim());
+  const triangles = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line && line.startsWith("facet normal")) {
+      const normalMatch = line.match(/facet normal\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/);
+      const normal = normalMatch ? {
+        x: parseFloat(normalMatch[1]),
+        y: parseFloat(normalMatch[2]),
+        z: parseFloat(normalMatch[3])
+      } : { x: 0, y: 0, z: 1 };
+      i++;
+      const vertices = [];
+      while (i < lines.length && lines[i] && !lines[i].startsWith("endfacet")) {
+        const vertexLine = lines[i];
+        if (vertexLine.startsWith("vertex")) {
+          const vertexMatch = vertexLine.match(/vertex\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s+([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/);
+          if (vertexMatch) {
+            vertices.push({
+              x: parseFloat(vertexMatch[1]),
+              y: parseFloat(vertexMatch[2]),
+              z: parseFloat(vertexMatch[3])
+            });
+          }
+        }
+        i++;
+      }
+      if (vertices.length === 3) {
+        triangles.push({
+          vertices: [vertices[0], vertices[1], vertices[2]],
+          normal
+        });
+      }
+    }
+    i++;
+  }
+  return {
+    triangles,
+    boundingBox: calculateBoundingBox(triangles)
+  };
+}
+function parseBinarySTL(view) {
+  let offset = 80;
+  const numTriangles = view.getUint32(offset, true);
+  offset += 4;
+  const triangles = [];
+  for (let i = 0;i < numTriangles; i++) {
+    const normal = {
+      x: view.getFloat32(offset, true),
+      y: view.getFloat32(offset + 4, true),
+      z: view.getFloat32(offset + 8, true)
+    };
+    offset += 12;
+    const vertices = [
+      {
+        x: view.getFloat32(offset, true),
+        y: view.getFloat32(offset + 4, true),
+        z: view.getFloat32(offset + 8, true)
+      },
+      {
+        x: view.getFloat32(offset + 12, true),
+        y: view.getFloat32(offset + 16, true),
+        z: view.getFloat32(offset + 20, true)
+      },
+      {
+        x: view.getFloat32(offset + 24, true),
+        y: view.getFloat32(offset + 28, true),
+        z: view.getFloat32(offset + 32, true)
+      }
+    ];
+    offset += 36;
+    offset += 2;
+    triangles.push({ vertices, normal });
+  }
+  return {
+    triangles,
+    boundingBox: calculateBoundingBox(triangles)
+  };
+}
+function calculateBoundingBox(triangles) {
+  if (triangles.length === 0) {
+    return {
+      min: { x: 0, y: 0, z: 0 },
+      max: { x: 0, y: 0, z: 0 }
+    };
+  }
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (const triangle of triangles) {
+    for (const vertex of triangle.vertices) {
+      minX = Math.min(minX, vertex.x);
+      minY = Math.min(minY, vertex.y);
+      minZ = Math.min(minZ, vertex.z);
+      maxX = Math.max(maxX, vertex.x);
+      maxY = Math.max(maxY, vertex.y);
+      maxZ = Math.max(maxZ, vertex.z);
+    }
+  }
+  return {
+    min: { x: minX, y: minY, z: minZ },
+    max: { x: maxX, y: maxY, z: maxZ }
+  };
+}
+function colorToCss(c) {
+  return typeof c === "string" ? c : `rgba(${c[0]},${c[1]},${c[2]},${c[3]})`;
+}
+function add(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function cross3(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function scale9(v, k) {
+  return { x: v.x * k, y: v.y * k, z: v.z * k };
+}
+function len(v) {
+  return Math.sqrt(dot(v, v));
+}
+function norm(v) {
+  const l = len(v) || 1;
+  return scale9(v, 1 / l);
+}
+function rotLocal(p, r = { x: 0, y: 0, z: 0 }) {
+  let { x, y, z: z3 } = p;
+  if (r.x) {
+    const c = Math.cos(r.x);
+    const s = Math.sin(r.x);
+    const y2 = y * c - z3 * s;
+    z3 = y * s + z3 * c;
+    y = y2;
+  }
+  if (r.y) {
+    const c = Math.cos(r.y);
+    const s = Math.sin(r.y);
+    const x2 = x * c + z3 * s;
+    z3 = -x * s + z3 * c;
+    x = x2;
+  }
+  if (r.z) {
+    const c = Math.cos(r.z);
+    const s = Math.sin(r.z);
+    const x2 = x * c - y * s;
+    y = x * s + y * c;
+    x = x2;
+  }
+  return { x, y, z: z3 };
+}
+var W_DEF = 400;
+var H_DEF = 400;
+var FOCAL = 2;
+function axes(cam) {
+  const f = norm(sub(cam.lookAt, cam.position));
+  const wUp = { x: 0, y: 1, z: 0 };
+  let r = norm(cross3(f, wUp));
+  if (!len(r))
+    r = { x: 1, y: 0, z: 0 };
+  const u = cross3(r, f);
+  return { r, u, f };
+}
+function toCam(p, cam) {
+  const { r, u, f } = axes(cam);
+  const d = sub(p, cam.position);
+  return { x: dot(d, r), y: dot(d, u), z: dot(d, f) };
+}
+function proj(p, w, h, focal) {
+  if (p.z <= 0)
+    return null;
+  const s = focal / p.z;
+  return { x: p.x * s * w / 2, y: -p.y * s * h / 2, z: p.z };
+}
+var FACES = [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [0, 1, 5, 4],
+  [3, 2, 6, 7],
+  [1, 2, 6, 5],
+  [0, 3, 7, 4]
+];
+var TOP = [3, 2, 6, 7];
+function verts(b) {
+  const {
+    size: { x: sx, y: sy, z: sz },
+    center,
+    rotation: rotation4
+  } = b;
+  const offs = [
+    { x: -sx / 2, y: -sy / 2, z: -sz / 2 },
+    { x: sx / 2, y: -sy / 2, z: -sz / 2 },
+    { x: sx / 2, y: sy / 2, z: -sz / 2 },
+    { x: -sx / 2, y: sy / 2, z: -sz / 2 },
+    { x: -sx / 2, y: -sy / 2, z: sz / 2 },
+    { x: sx / 2, y: -sy / 2, z: sz / 2 },
+    { x: sx / 2, y: sy / 2, z: sz / 2 },
+    { x: -sx / 2, y: sy / 2, z: sz / 2 }
+  ];
+  return offs.map((o) => add(center, rotLocal(o, rotation4)));
+}
+function inv3(m2) {
+  const a = m2[0][0], d = m2[0][1], g = m2[0][2];
+  const b = m2[1][0], e = m2[1][1], h = m2[1][2];
+  const c = m2[2][0], f = m2[2][1], i = m2[2][2];
+  const A = e * i - f * h;
+  const B = -(d * i - f * g);
+  const C = d * h - e * g;
+  const D = -(b * i - c * h);
+  const E = a * i - c * g;
+  const F = -(a * h - b * g);
+  const G = b * f - c * e;
+  const H = -(a * f - c * d);
+  const I = a * e - b * d;
+  const det = a * A + d * D + g * G;
+  const invDet = det ? 1 / det : 0;
+  return [
+    [A * invDet, B * invDet, C * invDet],
+    [D * invDet, E * invDet, F * invDet],
+    [G * invDet, H * invDet, I * invDet]
+  ];
+}
+function mul3(a, b) {
+  const r = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  for (let i = 0;i < 3; i++) {
+    for (let j = 0;j < 3; j++) {
+      r[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
+    }
+  }
+  return r;
+}
+function affineMatrix(src, dst) {
+  const S = [
+    [src[0].x, src[1].x, src[2].x],
+    [src[0].y, src[1].y, src[2].y],
+    [1, 1, 1]
+  ];
+  const D = [
+    [dst[0].x, dst[1].x, dst[2].x],
+    [dst[0].y, dst[1].y, dst[2].y],
+    [1, 1, 1]
+  ];
+  const M = mul3(D, inv3(S));
+  return `matrix(${M[0][0]} ${M[1][0]} ${M[0][1]} ${M[1][1]} ${M[0][2]} ${M[1][2]})`;
+}
+function scaleAndPositionMesh(mesh, box) {
+  const { boundingBox } = mesh;
+  const meshSize = sub(boundingBox.max, boundingBox.min);
+  const boxSize = box.size;
+  const scaleX = boxSize.x / meshSize.x;
+  const scaleY = boxSize.y / meshSize.y;
+  const scaleZ = boxSize.z / meshSize.z;
+  const uniformScale = Math.min(scaleX, scaleY, scaleZ);
+  const meshCenter = scale9(add(boundingBox.min, boundingBox.max), 0.5);
+  const transformedVertices = [];
+  for (const triangle of mesh.triangles) {
+    for (const vertex of triangle.vertices) {
+      let transformed = sub(vertex, meshCenter);
+      transformed = scale9(transformed, uniformScale);
+      if (box.stlRotation) {
+        transformed = rotLocal(transformed, box.stlRotation);
+      }
+      if (box.stlPosition) {
+        transformed = add(transformed, box.stlPosition);
+      }
+      if (box.rotation) {
+        transformed = rotLocal(transformed, box.rotation);
+      }
+      transformed = add(transformed, box.center);
+      transformedVertices.push(transformed);
+    }
+  }
+  return transformedVertices;
+}
+async function renderScene(scene, opt = {}) {
+  const W = opt.width ?? W_DEF;
+  const H = opt.height ?? H_DEF;
+  const focal = scene.camera.focalLength ?? FOCAL;
+  const faces = [];
+  const images = [];
+  const labels = [];
+  let clipSeq = 0;
+  const texId = /* @__PURE__ */ new Map;
+  const stlMeshes = /* @__PURE__ */ new Map;
+  for (const box of scene.boxes) {
+    if (box.stlUrl && !stlMeshes.has(box.stlUrl)) {
+      try {
+        const mesh = await loadSTL(box.stlUrl);
+        stlMeshes.set(box.stlUrl, mesh);
+      } catch (error) {
+        console.warn(`Failed to load STL from ${box.stlUrl}:`, error);
+      }
+    }
+  }
+  for (const box of scene.boxes) {
+    if (box.stlUrl && stlMeshes.has(box.stlUrl)) {
+      const mesh = stlMeshes.get(box.stlUrl);
+      const transformedVertices = scaleAndPositionMesh(mesh, box);
+      for (let i = 0;i < mesh.triangles.length; i++) {
+        const triangle = mesh.triangles[i];
+        const vertexStart = i * 3;
+        const v0w = transformedVertices[vertexStart];
+        const v1w = transformedVertices[vertexStart + 1];
+        const v2w = transformedVertices[vertexStart + 2];
+        const v0c = toCam(v0w, scene.camera);
+        const v1c = toCam(v1w, scene.camera);
+        const v2c = toCam(v2w, scene.camera);
+        const v0p = proj(v0c, W, H, focal);
+        const v1p = proj(v1c, W, H, focal);
+        const v2p = proj(v2c, W, H, focal);
+        if (v0p && v1p && v2p) {
+          const edge1 = sub(v1c, v0c);
+          const edge2 = sub(v2c, v0c);
+          const faceNormal = cross3(edge1, edge2);
+          if (faceNormal.z < 0) {
+            const depth = Math.max(v0c.z, v1c.z, v2c.z);
+            faces.push({
+              pts: [v0p, v1p, v2p],
+              depth,
+              fill: colorToCss(box.color)
+            });
+          }
+        }
+      }
+    } else {
+      const vw = verts(box);
+      const vc = vw.map((v) => toCam(v, scene.camera));
+      const vp = vc.map((v) => proj(v, W, H, focal));
+      for (const idx of FACES) {
+        const p4 = [];
+        let zMax = -Infinity;
+        let behind = false;
+        for (const i of idx) {
+          const p = vp[i];
+          if (!p) {
+            behind = true;
+            break;
+          }
+          p4.push(p);
+          zMax = Math.max(zMax, vc[i].z);
+        }
+        if (behind)
+          continue;
+        const [a, b, c] = idx;
+        const n2 = cross3(sub(vc[b], vc[a]), sub(vc[c], vc[a]));
+        if (n2.z >= 0)
+          continue;
+        faces.push({
+          pts: p4,
+          depth: zMax,
+          fill: colorToCss(box.color)
+        });
+      }
+      if (box.faceImages?.top) {
+        const pts = TOP.map((i) => vp[i]);
+        if (pts.every(Boolean)) {
+          const dst = pts;
+          const cz = Math.max(...TOP.map((i) => vc[i].z));
+          const href = box.faceImages.top;
+          if (!texId.has(href)) {
+            texId.set(href, `tex${texId.size}`);
+          }
+          const sym = texId.get(href);
+          const subdivisions = box.projectionSubdivision ?? 2;
+          const quadsPerSide = subdivisions;
+          for (let row = 0;row < quadsPerSide; row++) {
+            for (let col = 0;col < quadsPerSide; col++) {
+              const u0 = col / quadsPerSide;
+              const u1 = (col + 1) / quadsPerSide;
+              const v0 = row / quadsPerSide;
+              const v1 = (row + 1) / quadsPerSide;
+              const lerp = (a, b, t2) => ({
+                x: a.x * (1 - t2) + b.x * t2,
+                y: a.y * (1 - t2) + b.y * t2,
+                z: a.z * (1 - t2) + b.z * t2
+              });
+              const p00 = lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v0);
+              const p10 = lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v0);
+              const p01 = lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v1);
+              const p11 = lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v1);
+              const tri0Mat = affineMatrix([
+                { x: u0, y: v0 },
+                { x: u1, y: v0 },
+                { x: u1, y: v1 }
+              ], [p00, p10, p11]);
+              const id0 = `clip${clipSeq++}`;
+              images.push({
+                matrix: tri0Mat,
+                depth: cz,
+                href,
+                clip: id0,
+                points: `${u0},${v0} ${u1},${v0} ${u1},${v1}`,
+                sym
+              });
+              const tri1Mat = affineMatrix([
+                { x: u0, y: v0 },
+                { x: u1, y: v1 },
+                { x: u0, y: v1 }
+              ], [p00, p11, p01]);
+              const id1 = `clip${clipSeq++}`;
+              images.push({
+                matrix: tri1Mat,
+                depth: cz,
+                href,
+                clip: id1,
+                points: `${u0},${v0} ${u1},${v1} ${u0},${v1}`,
+                sym
+              });
+            }
+          }
+        }
+      }
+      if (box.topLabel) {
+        const pts = TOP.map((i) => vp[i]);
+        if (pts.every(Boolean)) {
+          const p0 = pts[0];
+          const p1 = pts[1];
+          const p3 = pts[3];
+          const u = sub(p1, p0);
+          const v = sub(p3, p0);
+          const lu = len(u);
+          const lv = len(v);
+          if (lu && lv) {
+            const uN = scale9(u, 1 / lu);
+            const vN = scale9(v, 1 / lv);
+            const cx = pts.reduce((s, p) => s + p.x, 0) / 4;
+            const cy = pts.reduce((s, p) => s + p.y, 0) / 4;
+            const cz = Math.max(...TOP.map((i) => vc[i].z));
+            const m2 = `matrix(${uN.x} ${uN.y} ${vN.x} ${vN.y} ${cx} ${cy})`;
+            const fillCol = box.topLabelColor ?? [0, 0, 0, 1];
+            labels.push({
+              matrix: m2,
+              depth: cz,
+              text: box.topLabel,
+              fill: colorToCss(fillCol)
+            });
+          }
+        }
+      }
+    }
+  }
+  const allElements = [
+    ...faces.map((f) => ({ type: "face", data: f })),
+    ...images.map((i) => ({ type: "image", data: i })),
+    ...labels.map((l) => ({ type: "label", data: l }))
+  ];
+  allElements.sort((a, b) => b.data.depth - a.data.depth);
+  const out = [];
+  out.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="${-W / 2} ${-H / 2} ${W} ${H}">`);
+  if (opt.backgroundColor) {
+    out.push(`  <rect x="${-W / 2}" y="${-H / 2}" width="${W}" height="${H}" fill="${colorToCss(opt.backgroundColor)}" />
+`);
+  }
+  if (images.length) {
+    out.push(`  <defs>
+`);
+    for (const [href, id] of texId) {
+      out.push(`    <image id="${id}" href="${href}" width="1" height="1" preserveAspectRatio="none" style="image-rendering:pixelated"/>
+`);
+    }
+    for (const img of images) {
+      out.push(`    <clipPath id="${img.clip}" clipPathUnits="objectBoundingBox"><polygon points="${img.points}" /></clipPath>
+`);
+    }
+    out.push(`  </defs>
+`);
+  }
+  let inStrokeGroup = false;
+  for (const element of allElements) {
+    if (element.type === "face" || element.type === "image") {
+      if (!inStrokeGroup) {
+        out.push(`  <g stroke="#000" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
+`);
+        inStrokeGroup = true;
+      }
+      if (element.type === "face") {
+        const f = element.data;
+        out.push(`    <polygon fill="${f.fill}" points="${f.pts.map((p) => `${p.x},${p.y}`).join(" ")}" />
+`);
+      } else {
+        const img = element.data;
+        out.push(`    <g transform="${img.matrix}" clip-path="url(#${img.clip})"><use href="#${img.sym}"/></g>
+`);
+      }
+    } else if (element.type === "label") {
+      if (inStrokeGroup) {
+        out.push(`  </g>
+`);
+        inStrokeGroup = false;
+      }
+      const l = element.data;
+      out.push(`  <g font-family="sans-serif" font-size="14" text-anchor="middle" dominant-baseline="central" transform="${l.matrix}"><text x="0" y="0" fill="${l.fill}">${l.text}</text></g>
+`);
+    }
+  }
+  if (inStrokeGroup) {
+    out.push(`  </g>
+`);
+  }
+  out.push("</svg>");
+  return out.join("");
+}
+
+// node_modules/circuit-json-to-simple-3d/dist/index.js
+init_dist6();
+function getDefaultCameraForPcbBoard(pcbBoard, anglePreset = "angle1") {
+  const w = pcbBoard.width;
+  const h = pcbBoard.height;
+  const cx = pcbBoard.center?.x;
+  const cz = pcbBoard.center?.y;
+  const dist = Math.max(w, h) * 1.5;
+  let position4;
+  if (anglePreset === "angle1") {
+    position4 = { x: cx - dist, y: dist, z: cz - dist };
+  } else if (anglePreset === "angle2") {
+    position4 = { x: cx + dist, y: dist, z: cz - dist };
+  } else if (anglePreset === "left") {
+    position4 = { x: cx - dist, y: 0, z: 0 };
+  } else if (anglePreset === "right") {
+    position4 = { x: cx + dist, y: 0, z: 0 };
+  } else if (anglePreset === "left-raised") {
+    position4 = { x: cx - dist, y: dist, z: 0 };
+  } else if (anglePreset === "right-raised") {
+    position4 = { x: cx + dist, y: dist, z: 0 };
+  } else {
+    throw new Error(`Unknown angle preset: ${anglePreset}`);
+  }
+  return {
+    position: position4,
+    lookAt: { x: cx, y: 0, z: cz },
+    focalLength: 2
+  };
+}
+async function convertCircuitJsonToSimple3dSvg(circuitJson, opts = {}) {
+  const db = cju_default(circuitJson);
+  const boxes = [];
+  const pcbTopSvg = convertCircuitJsonToPcbSvg(circuitJson, {
+    layer: "top",
+    matchBoardAspectRatio: true,
+    backgroundColor: "transparent",
+    drawPaddingOutsideBoard: false,
+    colorOverrides: {
+      copper: {
+        top: "#ffe066",
+        bottom: "#ffe066"
+      },
+      drill: "rgba(0,0,0,0.5)"
+    }
+  }).replace("<svg", "<svg transform='scale(1, -1)'");
+  const pcbBoard = db.pcb_board.list()[0];
+  if (!pcbBoard)
+    throw new Error("No pcb_board, can't render to 3d");
+  const camera = opts.camera ?? getDefaultCameraForPcbBoard(pcbBoard, opts.anglePreset ?? "angle1");
+  if (!camera.focalLength) {
+    camera.focalLength = 1;
+  }
+  boxes.push({
+    center: {
+      x: pcbBoard.center.x,
+      y: 0,
+      z: pcbBoard.center.y
+    },
+    size: {
+      x: pcbBoard.width,
+      y: pcbBoard.thickness,
+      z: pcbBoard.height
+    },
+    faceImages: {
+      top: `data:image/svg+xml;base64,${btoa(pcbTopSvg)}`
+    },
+    projectionSubdivision: 10,
+    color: "rgba(0,140,0,0.8)"
+  });
+  const DEFAULT_COMP_HEIGHT = 2;
+  for (const comp of db.pcb_component.list()) {
+    const sourceComponent = db.source_component.get(comp.source_component_id);
+    const compHeight = Math.min(Math.min(comp.width, comp.height), DEFAULT_COMP_HEIGHT);
+    boxes.push({
+      center: {
+        x: comp.center.x,
+        y: pcbBoard.thickness / 2 + compHeight / 2,
+        z: comp.center.y
+      },
+      size: {
+        x: comp.width,
+        y: compHeight,
+        z: comp.height
+      },
+      color: "rgba(128,128,128,0.5)",
+      topLabel: sourceComponent?.name ?? "?",
+      topLabelColor: "white"
+    });
+  }
+  return await renderScene({ boxes, camera }, {
+    backgroundColor: "lightgray"
+  });
+}
+
+// lib/shared/snapshot-project.ts
 var snapshotProject = async ({
   update = false,
   ignored = [],
+  threeD = false,
   onExit = (code) => process.exit(code),
   onError = (msg) => console.error(msg),
   onSuccess = (msg) => console.log(msg)
@@ -495938,13 +496452,18 @@ var snapshotProject = async ({
     const { circuitJson } = await generateCircuitJson({ filePath: file });
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson);
     const schSvg = convertCircuitJsonToSchematicSvg(circuitJson);
+    const svg3d = threeD ? await convertCircuitJsonToSimple3dSvg(circuitJson) : null;
     const snapDir = path24.join(path24.dirname(file), "__snapshots__");
     fs24.mkdirSync(snapDir, { recursive: true });
     const base = path24.basename(file).replace(/\.tsx$/, "");
-    for (const [type, svg] of [
+    const snapshotPairs = [
       ["pcb", pcbSvg],
       ["schematic", schSvg]
-    ]) {
+    ];
+    if (threeD && svg3d) {
+      snapshotPairs.push(["3d", svg3d]);
+    }
+    for (const [type, svg] of snapshotPairs) {
       const snapPath = path24.join(snapDir, `${base}-${type}.snap.svg`);
       if (update || !fs24.existsSync(snapPath)) {
         fs24.writeFileSync(snapPath, svg);
@@ -495971,9 +496490,10 @@ ${mismatches.join(`
 
 // cli/snapshot/register.ts
 var registerSnapshot = (program3) => {
-  program3.command("snapshot").description("Generate schematic and PCB snapshots").option("-u, --update", "Update snapshots on disk").action(async (options) => {
+  program3.command("snapshot").description("Generate schematic and PCB snapshots (add --3d for 3d preview)").option("-u, --update", "Update snapshots on disk").option("--3d", "Generate 3d preview snapshots").action(async (options) => {
     await snapshotProject({
       update: options.update ?? false,
+      threeD: options["3d"] ?? false,
       onExit: (code) => process.exit(code),
       onError: (msg) => console.error(msg),
       onSuccess: (msg) => console.log(msg)