@tscircuit/capacity-autorouter 0.0.51 → 0.0.53

package/dist/index.js

@@ -948,7 +948,11 @@ var getTunedTotalCapacity1 = (nodeOrWidth, maxCapacityFactor = 1) => {
   const obstacleMargin = 0.2;
   const width = "width" in nodeOrWidth ? nodeOrWidth.width : nodeOrWidth;
   const viaLengthAcross = width / (VIA_DIAMETER / 2 + obstacleMargin);
-  return (viaLengthAcross / 2) ** 1.1 * maxCapacityFactor;
+  const tunedTotalCapacity = (viaLengthAcross / 2) ** 1.1 * maxCapacityFactor;
+  if (nodeOrWidth.availableZ?.length === 1 && tunedTotalCapacity > 1) {
+    return 1;
+  }
+  return tunedTotalCapacity;
 };
 var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxDepth = 16) => {
   let depth = 0;
@@ -969,6 +973,7 @@ var ObstacleSpatialHashIndex = class {
   constructor(obstacles) {
     this.obstacles = obstacles;
     this.buckets = /* @__PURE__ */ new Map();
+    let bucketEntriesCount = 0;
     for (let i = 0; i < obstacles.length; i++) {
       const obstacle = obstacles[i];
       const nodeMinX = obstacle.center.x - obstacle.width / 2;
@@ -983,6 +988,7 @@ var ObstacleSpatialHashIndex = class {
             this.buckets.set(bucketKey, [[obstacle, i]]);
           } else {
             bucket.push([obstacle, i]);
+            bucketEntriesCount++;
           }
         }
       }
@@ -3136,6 +3142,645 @@ var findCircleLineIntersections = (circle, line) => {
   return points;
 };
 
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/computeDumbbellPaths.ts
+function computeDumbbellPaths({
+  A,
+  B,
+  C,
+  D,
+  E,
+  F,
+  radius,
+  margin,
+  subdivisions = 0
+}) {
+  const midpoint = (p1, p2) => ({
+    x: (p1.x + p2.x) / 2,
+    y: (p1.y + p2.y) / 2
+  });
+  const calculatePoints = (a, b, r) => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.sqrt(dx * dx + dy * dy);
+    const ux = dx / len;
+    const uy = dy / len;
+    const px = -uy;
+    const py = ux;
+    return {
+      midpoint: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
+      A_Opp: { x: a.x - ux * r, y: a.y - uy * r },
+      A_Right: { x: a.x + px * r, y: a.y + py * r },
+      A_Left: { x: a.x - px * r, y: a.y - py * r },
+      B_Opp: { x: b.x + ux * r, y: b.y + uy * r },
+      B_Right: { x: b.x + px * r, y: b.y + py * r },
+      B_Left: { x: b.x - px * r, y: b.y - py * r }
+    };
+  };
+  const isPointOnSegment = (point, segment) => {
+    const d1 = distance(point, segment.start);
+    const d2 = distance(point, segment.end);
+    const segmentLength = distance(segment.start, segment.end);
+    const tolerance = 1e-4;
+    return Math.abs(d1 + d2 - segmentLength) < tolerance;
+  };
+  const intersect = (l1, l2) => {
+    const { start: p1, end: p2 } = l1;
+    const { start: p3, end: p4 } = l2;
+    if (isPointOnSegment(p1, l2) || isPointOnSegment(p2, l2) || isPointOnSegment(p3, l1) || isPointOnSegment(p4, l1)) {
+      return true;
+    }
+    const d1x = p2.x - p1.x;
+    const d1y = p2.y - p1.y;
+    const d2x = p4.x - p3.x;
+    const d2y = p4.y - p3.y;
+    const det = d1x * d2y - d1y * d2x;
+    if (Math.abs(det) < 1e-4) return false;
+    const dx = p3.x - p1.x;
+    const dy = p3.y - p1.y;
+    const t = (dx * d2y - dy * d2x) / det;
+    const u = (dx * d1y - dy * d1x) / det;
+    return t > 0 && t < 1 && u > 0 && u < 1;
+  };
+  const doPathsIntersect = (path1, path2) => {
+    const segments1 = [];
+    for (let i = 0; i < path1.length - 1; i++) {
+      segments1.push({ start: path1[i], end: path1[i + 1] });
+    }
+    const segments2 = [];
+    for (let i = 0; i < path2.length - 1; i++) {
+      segments2.push({ start: path2[i], end: path2[i + 1] });
+    }
+    for (const seg1 of segments1) {
+      for (const seg2 of segments2) {
+        if (intersect(seg1, seg2)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  const pathLength = (points) => {
+    let len = 0;
+    for (let i = 1; i < points.length; i++) {
+      const dx = points[i].x - points[i - 1].x;
+      const dy = points[i].y - points[i - 1].y;
+      len += Math.sqrt(dx * dx + dy * dy);
+    }
+    return len;
+  };
+  const closestPointOnSegment = (segment, circleCenter) => {
+    const { start, end } = segment;
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const segmentLengthSquared = dx * dx + dy * dy;
+    if (segmentLengthSquared === 0) return { ...start, t: 0 };
+    const t = Math.max(
+      0,
+      Math.min(
+        1,
+        ((circleCenter.x - start.x) * dx + (circleCenter.y - start.y) * dy) / segmentLengthSquared
+      )
+    );
+    return {
+      x: start.x + t * dx,
+      y: start.y + t * dy,
+      t
+      // Keep track of the parameter for later use
+    };
+  };
+  const getSubdivisionPoint = (segment, circleCenter, r) => {
+    const closestPoint = closestPointOnSegment(segment, circleCenter);
+    const dist = distance(closestPoint, circleCenter);
+    if (dist >= r) return closestPoint;
+    const dirX = closestPoint.x - circleCenter.x;
+    const dirY = closestPoint.y - circleCenter.y;
+    const norm = Math.sqrt(dirX * dirX + dirY * dirY);
+    if (norm === 0) {
+      const segDirX = segment.end.x - segment.start.x;
+      const segDirY = segment.end.y - segment.start.y;
+      const segNorm = Math.sqrt(segDirX * segDirX + segDirY * segDirY);
+      return {
+        x: circleCenter.x + r * segDirX / segNorm,
+        y: circleCenter.y + r * segDirY / segNorm,
+        t: closestPoint.t,
+        isSpecial: true,
+        specialType: circleCenter === A ? "A" : "B"
+      };
+    }
+    return {
+      x: circleCenter.x + r * dirX / norm,
+      y: circleCenter.y + r * dirY / norm,
+      t: closestPoint.t,
+      isSpecial: true,
+      specialType: circleCenter === A ? "A" : "B"
+    };
+  };
+  const subdivideOptimalPath = (path, numSubdivisions) => {
+    if (path.length < 2) return path;
+    const result = [path[0]];
+    for (let i = 0; i < path.length - 1; i++) {
+      const segment = { start: path[i], end: path[i + 1] };
+      const segmentMidpoint = {
+        x: (segment.start.x + segment.end.x) / 2,
+        y: (segment.start.y + segment.end.y) / 2
+      };
+      const midpointDistToA = distance(segmentMidpoint, A);
+      const midpointDistToB = distance(segmentMidpoint, B);
+      const shouldSubdivide = (midpointDistToA <= radius || midpointDistToB <= radius) && Math.abs(midpointDistToA - midpointDistToB) > 1e-4;
+      if (shouldSubdivide) {
+        const closestPointA = closestPointOnSegment(segment, A);
+        const closestPointB = closestPointOnSegment(segment, B);
+        const distToA = distance(closestPointA, A);
+        const distToB = distance(closestPointB, B);
+        const needsRadiusPointA = distToA < radius;
+        const needsRadiusPointB = distToB < radius;
+        const adjustedPointA = needsRadiusPointA ? getSubdivisionPoint(segment, A, radius) : null;
+        const adjustedPointB = needsRadiusPointB ? getSubdivisionPoint(segment, B, radius) : null;
+        let subdivisionPoints = [];
+        const segmentLength = distance(segment.start, segment.end);
+        if (segmentLength > radius / 2 && numSubdivisions > 0) {
+          for (let j = 1; j <= numSubdivisions; j++) {
+            const t = j / (numSubdivisions + 1);
+            const subPoint = {
+              x: segment.start.x + t * (segment.end.x - segment.start.x),
+              y: segment.start.y + t * (segment.end.y - segment.start.y),
+              t,
+              isSpecial: false
+            };
+            const subDistToA = distance(subPoint, A);
+            const subDistToB = distance(subPoint, B);
+            if (subDistToA < radius || subDistToB < radius) {
+              continue;
+            }
+            if (adjustedPointA && Math.abs(subPoint.t - adjustedPointA.t) < 0.1) {
+              continue;
+            }
+            if (adjustedPointB && Math.abs(subPoint.t - adjustedPointB.t) < 0.1) {
+              continue;
+            }
+            subdivisionPoints.push(subPoint);
+          }
+        }
+        if (adjustedPointA) {
+          subdivisionPoints.push(adjustedPointA);
+        }
+        if (adjustedPointB) {
+          subdivisionPoints.push(adjustedPointB);
+        }
+        subdivisionPoints.sort((a, b) => a.t - b.t);
+        if (subdivisionPoints.length > 1) {
+          const filteredPoints = [subdivisionPoints[0]];
+          for (let j = 1; j < subdivisionPoints.length; j++) {
+            const prev = filteredPoints[filteredPoints.length - 1];
+            const curr = subdivisionPoints[j];
+            if (distance(prev, curr) > radius / 10) {
+              filteredPoints.push(curr);
+            }
+          }
+          subdivisionPoints = filteredPoints;
+        }
+        subdivisionPoints.forEach((p) => result.push(p));
+      }
+      result.push(path[i + 1]);
+    }
+    if (result.length > 1) {
+      const filteredResult = [result[0]];
+      for (let i = 1; i < result.length; i++) {
+        const prev = filteredResult[filteredResult.length - 1];
+        const curr = result[i];
+        if (distance(prev, curr) > radius / 10) {
+          filteredResult.push(curr);
+        }
+      }
+      return filteredResult;
+    }
+    return result;
+  };
+  const innerPoints = calculatePoints(A, B, radius);
+  const outerPoints = calculatePoints(A, B, radius + margin);
+  const getPaths = () => [
+    // Path 1: C→B_Left→B_Opp→B_Right→Mid→A_Left→A_Opp→A_Right→D
+    [
+      C,
+      innerPoints.B_Left,
+      innerPoints.B_Opp,
+      innerPoints.B_Right,
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.B_Right, innerPoints.A_Right)
+      ),
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Left, innerPoints.B_Left)
+      ),
+      innerPoints.A_Left,
+      innerPoints.A_Opp,
+      innerPoints.A_Right,
+      D
+    ],
+    // Path 2: C→B_Right→B_Opp→B_Left→Mid→A_Right→A_Opp→A_Left→D
+    [
+      C,
+      innerPoints.B_Right,
+      innerPoints.B_Opp,
+      innerPoints.B_Left,
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Left, innerPoints.B_Left)
+      ),
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Right, innerPoints.B_Right)
+      ),
+      innerPoints.A_Right,
+      innerPoints.A_Opp,
+      innerPoints.A_Left,
+      D
+    ],
+    // Path 3: D→B_Left→B_Opp→B_Right→Mid→A_Left→A_Opp→A_Right→C
+    [
+      D,
+      innerPoints.B_Left,
+      innerPoints.B_Opp,
+      innerPoints.B_Right,
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Right, innerPoints.B_Right)
+      ),
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Left, innerPoints.B_Left)
+      ),
+      innerPoints.A_Left,
+      innerPoints.A_Opp,
+      innerPoints.A_Right,
+      C
+    ],
+    // Path 4: D→B_Right→B_Opp→B_Left→Mid→A_Right→A_Opp→A_Left→C
+    [
+      D,
+      innerPoints.B_Right,
+      innerPoints.B_Opp,
+      innerPoints.B_Left,
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Left, innerPoints.B_Left)
+      ),
+      midpoint(
+        innerPoints.midpoint,
+        midpoint(innerPoints.A_Right, innerPoints.B_Right)
+      ),
+      innerPoints.A_Right,
+      innerPoints.A_Opp,
+      innerPoints.A_Left,
+      C
+    ]
+  ];
+  const getJLines = () => {
+    const mid_AR_BR = midpoint(innerPoints.A_Right, innerPoints.B_Right);
+    const mid_AL_BL = midpoint(innerPoints.B_Left, innerPoints.A_Left);
+    return [
+      /*─────────────────────────  Shortest (straight)  ─────────────────────────*/
+      { startsAt: "E", goesTo: "B", points: [E, B] },
+      { startsAt: "E", goesTo: "A", points: [E, A] },
+      { startsAt: "F", goesTo: "B", points: [F, B] },
+      { startsAt: "F", goesTo: "A", points: [F, A] },
+      /*─────────────────────────  One‑bend variants  ───────────────────────────*/
+      // …via the (AR ↔ BR) right‑side midpoint
+      { startsAt: "E", goesTo: "B", points: [E, mid_AR_BR, B] },
+      { startsAt: "E", goesTo: "A", points: [E, mid_AR_BR, A] },
+      { startsAt: "F", goesTo: "B", points: [F, mid_AR_BR, B] },
+      { startsAt: "F", goesTo: "A", points: [F, mid_AR_BR, A] },
+      // …via the (AL ↔ BL) left‑side midpoint
+      { startsAt: "E", goesTo: "B", points: [E, mid_AL_BL, B] },
+      { startsAt: "E", goesTo: "A", points: [E, mid_AL_BL, A] },
+      { startsAt: "F", goesTo: "B", points: [F, mid_AL_BL, B] },
+      { startsAt: "F", goesTo: "A", points: [F, mid_AL_BL, A] },
+      /*─────────────────────────  Medium (one outer waypoint)  ─────────────────*/
+      // right‑side outer arc
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [E, outerPoints.A_Right, mid_AR_BR, B]
+      },
+      {
+        startsAt: "F",
+        goesTo: "B",
+        points: [F, outerPoints.B_Right, mid_AR_BR, B]
+      },
+      // left‑side outer arc
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [E, outerPoints.B_Left, mid_AL_BL, A]
+      },
+      {
+        startsAt: "F",
+        goesTo: "A",
+        points: [F, outerPoints.A_Left, mid_AL_BL, A]
+      },
+      // criss‑cross outer arc
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [E, outerPoints.A_Left, mid_AL_BL, B]
+      },
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [E, outerPoints.B_Right, mid_AR_BR, A]
+      },
+      /*─────────────────────────  Long (two outer waypoints)  ──────────────────*/
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [E, outerPoints.A_Opp, outerPoints.A_Right, mid_AR_BR, B]
+      },
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [E, outerPoints.B_Opp, outerPoints.B_Left, mid_AL_BL, A]
+      },
+      {
+        startsAt: "F",
+        goesTo: "B",
+        points: [F, outerPoints.A_Opp, outerPoints.A_Left, mid_AL_BL, B]
+      },
+      {
+        startsAt: "F",
+        goesTo: "A",
+        points: [F, outerPoints.B_Opp, outerPoints.B_Right, mid_AR_BR, A]
+      },
+      {
+        startsAt: "F",
+        goesTo: "A",
+        points: [F, outerPoints.B_Opp, outerPoints.B_Left, mid_AL_BL, A]
+      },
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [E, outerPoints.A_Opp, outerPoints.A_Left, mid_AL_BL, B]
+      },
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [E, outerPoints.B_Opp, outerPoints.B_Right, mid_AR_BR, A]
+      },
+      /*─────────────────────────  Longest (three outer waypoints)  ─────────────*/
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [
+          E,
+          outerPoints.A_Left,
+          outerPoints.A_Opp,
+          outerPoints.A_Right,
+          mid_AR_BR,
+          B
+        ]
+      },
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [
+          E,
+          outerPoints.B_Right,
+          outerPoints.B_Opp,
+          outerPoints.B_Left,
+          mid_AL_BL,
+          A
+        ]
+      },
+      {
+        startsAt: "F",
+        goesTo: "B",
+        points: [
+          F,
+          outerPoints.A_Right,
+          outerPoints.A_Opp,
+          outerPoints.A_Left,
+          mid_AL_BL,
+          B
+        ]
+      },
+      {
+        startsAt: "F",
+        goesTo: "A",
+        points: [
+          F,
+          outerPoints.B_Left,
+          outerPoints.B_Opp,
+          outerPoints.B_Right,
+          mid_AR_BR,
+          A
+        ]
+      },
+      {
+        startsAt: "F",
+        goesTo: "A",
+        points: [
+          F,
+          outerPoints.B_Right,
+          outerPoints.B_Opp,
+          outerPoints.B_Left,
+          mid_AL_BL,
+          A
+        ]
+      },
+      {
+        startsAt: "E",
+        goesTo: "B",
+        points: [
+          E,
+          outerPoints.A_Right,
+          outerPoints.A_Opp,
+          outerPoints.A_Left,
+          mid_AL_BL,
+          B
+        ]
+      },
+      {
+        startsAt: "E",
+        goesTo: "A",
+        points: [
+          E,
+          outerPoints.B_Left,
+          outerPoints.B_Opp,
+          outerPoints.B_Right,
+          mid_AR_BR,
+          A
+        ]
+      }
+    ].map((l, index) => ({ ...l, index }));
+  };
+  const subdivideJLinePath = (jLine, oppositePoint, r, m, numSubdivisions) => {
+    const path = jLine.points;
+    if (path.length < 2) return path;
+    const minDistThreshold = r + m;
+    const result = [path[0]];
+    for (let i = 0; i < path.length - 1; i++) {
+      const segment = { start: path[i], end: path[i + 1] };
+      const distToOpposite = pointToSegmentDistance(
+        oppositePoint,
+        segment.start,
+        segment.end
+      );
+      if (distToOpposite < minDistThreshold) {
+        const closestPt = closestPointOnSegment(segment, oppositePoint);
+        const dirX = closestPt.x - oppositePoint.x;
+        const dirY = closestPt.y - oppositePoint.y;
+        const norm = Math.sqrt(dirX * dirX + dirY * dirY);
+        let adjustedPoint = null;
+        if (norm > 1e-6) {
+          adjustedPoint = {
+            x: oppositePoint.x + minDistThreshold * dirX / norm,
+            y: oppositePoint.y + minDistThreshold * dirY / norm
+            // We might need 't' if combining with regular subdivisions,
+            // but for now, just the adjusted point is needed.
+            // t: closestPt.t
+          };
+        } else {
+          const segDirX = segment.end.x - segment.start.x;
+          const segDirY = segment.end.y - segment.start.y;
+          const segNorm = Math.sqrt(segDirX * segDirX + segDirY * segDirY);
+          if (segNorm > 1e-6) {
+            adjustedPoint = {
+              x: oppositePoint.x + minDistThreshold * segDirX / segNorm,
+              y: oppositePoint.y + minDistThreshold * segDirY / segNorm
+            };
+          } else {
+          }
+        }
+        if (adjustedPoint) {
+          if (distance(segment.start, adjustedPoint) > radius / 10) {
+            result.push(adjustedPoint);
+          }
+        }
+      }
+      const lastPointInResult = result[result.length - 1];
+      if (distance(lastPointInResult, segment.end) > radius / 10) {
+        result.push(segment.end);
+      }
+    }
+    if (result.length > 1) {
+      const filteredResult = [result[0]];
+      for (let i = 1; i < result.length; i++) {
+        if (distance(filteredResult[filteredResult.length - 1], result[i]) > radius / 10) {
+          filteredResult.push(result[i]);
+        }
+      }
+      return filteredResult;
+    }
+    return result;
+  };
+  const findOptimalPath = () => {
+    const paths = getPaths();
+    const validPaths = [];
+    for (let i = 0; i < paths.length; i++) {
+      const path2 = paths[i];
+      const firstSeg = { start: path2[0], end: path2[1] };
+      const lastSeg = {
+        start: path2[path2.length - 2],
+        end: path2[path2.length - 1]
+      };
+      const midSeg = { start: path2[3], end: path2[4] };
+      if (!intersect(firstSeg, lastSeg) && !intersect(firstSeg, midSeg) && !intersect(lastSeg, midSeg)) {
+        validPaths.push({
+          index: i + 1,
+          path: path2,
+          length: pathLength(path2)
+        });
+      }
+    }
+    if (validPaths.length === 0) {
+      return { index: 0, path: [] };
+    }
+    const optimalPath2 = validPaths.sort((a, b) => a.length - b.length)[0];
+    const path = [...optimalPath2.path];
+    const firstPoint = path[0];
+    const dist3 = distance(firstPoint, path[2]);
+    const dist4 = distance(firstPoint, path[3]);
+    const closerIdx = dist3 < dist4 ? 2 : 3;
+    if (dist3 < distance(firstPoint, path[1]) || dist4 < distance(firstPoint, path[1])) {
+      path.splice(1, closerIdx - 1);
+    }
+    const lastPoint = path[path.length - 1];
+    const distM3 = distance(lastPoint, path[path.length - 3]);
+    const distM4 = distance(lastPoint, path[path.length - 4]);
+    const closerLastIdx = distM3 < distM4 ? path.length - 3 : path.length - 4;
+    if (distM3 < distance(lastPoint, path[path.length - 2]) || distM4 < distance(lastPoint, path[path.length - 2])) {
+      path.splice(closerLastIdx + 1, path.length - closerLastIdx - 2);
+    }
+    return {
+      index: optimalPath2.index,
+      path,
+      startsAt: path[0] === C ? "C" : "D",
+      goesTo: path[path.length - 1] === C ? "C" : "D"
+    };
+  };
+  const optimalPath = findOptimalPath();
+  const subdivided = subdivisions > 0 ? subdivideOptimalPath(optimalPath.path, subdivisions) : optimalPath.path;
+  const findJPair = () => {
+    if (optimalPath.path.length === 0) return null;
+    const jLines = getJLines();
+    const minDistFromAB = radius + margin / 2;
+    const eLines = jLines.filter((line) => line.startsAt === "E");
+    const fLines = jLines.filter((line) => line.startsAt === "F");
+    const nonIntersectingELines = [];
+    const nonIntersectingFLines = [];
+    for (const jLine of eLines) {
+      if (doPathsIntersect(jLine.points, optimalPath.path)) continue;
+      nonIntersectingELines.push(jLine);
+      break;
+    }
+    for (const jLine of fLines) {
+      if (doPathsIntersect(jLine.points, optimalPath.path)) continue;
+      nonIntersectingFLines.push(jLine);
+      break;
+    }
+    if (nonIntersectingELines.length === 0 || nonIntersectingFLines.length === 0) {
+      return null;
+    }
+    return {
+      line1: nonIntersectingELines[0],
+      line2: nonIntersectingFLines[0]
+    };
+  };
+  let jPair = findJPair();
+  if (jPair) {
+    const oppositePoint1 = jPair.line1.goesTo === "A" ? B : A;
+    const oppositePoint2 = jPair.line2.goesTo === "A" ? B : A;
+    const subdividedPoints1 = subdivideJLinePath(
+      jPair.line1,
+      oppositePoint1,
+      radius,
+      margin,
+      subdivisions
+      // Use same subdivision count for consistency? Or 0? Let's use 0 for now.
+    );
+    const subdividedPoints2 = subdivideJLinePath(
+      jPair.line2,
+      oppositePoint2,
+      radius,
+      margin,
+      subdivisions
+      // Use same subdivision count for consistency? Or 0? Let's use 0 for now.
+    );
+    jPair = {
+      line1: { ...jPair.line1, points: subdividedPoints1 },
+      line2: { ...jPair.line2, points: subdividedPoints2 }
+    };
+  }
+  return {
+    jPair,
+    optimalPath: {
+      startsAt: optimalPath.startsAt,
+      goesTo: optimalPath.goesTo,
+      points: subdivided
+    }
+  };
+}
+
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/TwoCrossingRoutesHighDensitySolver.ts
 var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
   // Input parameters
@@ -3147,6 +3792,7 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
   obstacleMargin;
   layerCount = 2;
   debugViaPositions;
+  escapeLayer = 1;
   // Solution state
   solvedRoutes = [];
   // Bounds
@@ -3181,6 +3827,11 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
       this.failed = true;
       return;
     }
+    if (routeA.startPort.z === 0) {
+      this.escapeLayer = 1;
+    } else {
+      this.escapeLayer = 0;
+    }
   }
   /**
    * Extract routes that need to be connected from the node data
@@ -3350,78 +4001,168 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
       via2
     };
   }
-  /**
-   * Create a route with properly placed vias
-   */
-  createRoute(start, end, via1, via2, connectionName) {
-    const middleZ = start.z === 0 ? 1 : 0;
-    const route = [
-      { x: start.x, y: start.y, z: start.z ?? 0 },
-      { x: via1.x, y: via1.y, z: start.z ?? 0 },
-      { x: via1.x, y: via1.y, z: middleZ },
-      // Via transition to layer 1
-      { x: via2.x, y: via2.y, z: middleZ },
-      // Stay on layer 1
-      { x: via2.x, y: via2.y, z: end.z ?? 0 },
-      // Via transition back
-      { x: end.x, y: end.y, z: end.z ?? 0 }
-    ];
-    return {
-      connectionName,
-      route,
-      traceThickness: this.traceThickness,
-      viaDiameter: this.viaDiameter,
-      vias: [via1, via2]
-    };
-  }
   /**
    * Try to solve with routeA going over and routeB staying on layer 0
    */
-  trySolveAOverB(routeA, routeB) {
-    const viaPositions = this.calculateViaPositions(routeA, routeB);
+  trySolveAOverB(routeA, routeB, swapVias = false) {
+    const viaPositions = swapVias ? this.calculateViaPositions(routeA, routeB) : this.calculateViaPositions(routeB, routeA);
     if (viaPositions) {
       this.debugViaPositions.push(viaPositions);
     } else {
       return false;
     }
-    const { via1, via2 } = this.optimizeViaPositions(viaPositions);
-    const routeASolution = this.createRoute(
-      routeA.startPort,
-      routeA.endPort,
-      via1,
-      via2,
-      routeA.connectionName
-    );
-    const midSegmentStart = { x: via1.x, y: via1.y, z: 1 };
-    const midSegmentEnd = { x: via2.x, y: via2.y, z: 1 };
-    const orthogonalPoints = this.calculateShortestOrthogonalRoutePoints(
-      routeB.startPort,
-      routeB.endPort,
-      midSegmentStart,
-      midSegmentEnd,
-      routeA.startPort,
-      routeA.endPort
-    ) ?? this.calculateConservativeOrthogonalRoutePoints(
-      routeB.startPort,
-      routeB.endPort,
-      midSegmentStart,
-      midSegmentEnd,
-      routeA.startPort,
-      routeA.endPort
+    const { via1, via2 } = this.pushViasFromEndpoints(
+      this.moveViasAsCloseAsPossible(viaPositions)
     );
+    this.debugViaPositions.push({ via1, via2 });
+    const NOT_CIRCULAR_PENALTY_TC = 1.5;
+    const { jPair, optimalPath } = computeDumbbellPaths({
+      A: via1,
+      B: via2,
+      C: routeA.startPort,
+      D: routeA.endPort,
+      E: routeB.startPort,
+      F: routeB.endPort,
+      // NOTE: Should be traceThickness /2, but we don't currently subdivide
+      // enough to make a round enough circle, so we have to add additional margin
+      radius: this.viaDiameter / 2 + this.obstacleMargin + this.traceThickness / 2 * NOT_CIRCULAR_PENALTY_TC,
+      margin: this.obstacleMargin * 2 + this.traceThickness / 2 * NOT_CIRCULAR_PENALTY_TC,
+      subdivisions: 1
+    });
+    if (!jPair) return false;
+    const routeASolution = {
+      connectionName: routeA.connectionName,
+      route: optimalPath.points.map((p) => ({
+        x: p.x,
+        y: p.y,
+        z: routeA.startPort.z ?? 0
+      })),
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
+    };
+    jPair.line2.points.reverse();
     const routeBSolution = {
       connectionName: routeB.connectionName,
-      route: orthogonalPoints,
+      route: [
+        ...jPair.line1.points.map((p) => ({
+          x: p.x,
+          y: p.y,
+          z: routeB.startPort.z ?? 0
+        })),
+        {
+          ...jPair.line1.points[jPair.line1.points.length - 1],
+          z: this.escapeLayer
+        },
+        { ...jPair.line2.points[0], z: this.escapeLayer },
+        ...jPair.line2.points.map((p) => ({
+          x: p.x,
+          y: p.y,
+          z: routeB.startPort.z ?? 0
+        }))
+      ],
       traceThickness: this.traceThickness,
       viaDiameter: this.viaDiameter,
-      vias: []
+      vias: [via1, via2]
     };
     this.solvedRoutes.push(routeASolution, routeBSolution);
     return true;
   }
-  optimizeViaPositions(viaPositions) {
+  pushViasFromEndpoints(viaPositions) {
+    const currentVia1 = { ...viaPositions.via1 };
+    const currentVia2 = { ...viaPositions.via2 };
+    const endpoints = [
+      this.routes[0].startPort,
+      this.routes[0].endPort,
+      this.routes[1].startPort,
+      this.routes[1].endPort
+    ];
+    const optimalDistBtwViaCenters = this.getMinDistanceBetweenViaCenters();
+    const minDistanceBtwViaAndEndpoint = this.viaDiameter / 2 + this.traceThickness * 2 + this.obstacleMargin * 2;
+    const MAX_ITERS = 10;
+    const PUSH_DECAY = 0.9;
+    for (let iter = 0; iter < MAX_ITERS; iter++) {
+      let via1Moved = false;
+      let via2Moved = false;
+      const pushDecayFactor = PUSH_DECAY ** iter;
+      for (const endpoint of endpoints) {
+        const dist1 = distance(currentVia1, endpoint);
+        if (dist1 < minDistanceBtwViaAndEndpoint) {
+          const overlap = minDistanceBtwViaAndEndpoint - dist1;
+          const pushAmount = overlap * pushDecayFactor;
+          const dx = currentVia1.x - endpoint.x;
+          const dy = currentVia1.y - endpoint.y;
+          const norm = Math.sqrt(dx * dx + dy * dy);
+          if (norm > 1e-6) {
+            currentVia1.x += dx / norm * pushAmount;
+            currentVia1.y += dy / norm * pushAmount;
+            via1Moved = true;
+          }
+        }
+        const dist2 = distance(currentVia2, endpoint);
+        if (dist2 < minDistanceBtwViaAndEndpoint) {
+          const overlap = minDistanceBtwViaAndEndpoint - dist2;
+          const pushAmount = overlap * pushDecayFactor;
+          const dx = currentVia2.x - endpoint.x;
+          const dy = currentVia2.y - endpoint.y;
+          const norm = Math.sqrt(dx * dx + dy * dy);
+          if (norm > 1e-6) {
+            currentVia2.x += dx / norm * pushAmount;
+            currentVia2.y += dy / norm * pushAmount;
+            via2Moved = true;
+          }
+        }
+      }
+      const distBetweenVias = distance(currentVia1, currentVia2);
+      if (distBetweenVias < optimalDistBtwViaCenters) {
+        const overlap = optimalDistBtwViaCenters - distBetweenVias;
+        const pushAmount = overlap / 2;
+        const dx = currentVia2.x - currentVia1.x;
+        const dy = currentVia2.y - currentVia1.y;
+        const norm = Math.sqrt(dx * dx + dy * dy);
+        if (norm > 1e-6) {
+          currentVia1.x -= dx / norm * pushAmount;
+          currentVia1.y -= dy / norm * pushAmount;
+          currentVia2.x += dx / norm * pushAmount;
+          currentVia2.y += dy / norm * pushAmount;
+          via1Moved = true;
+          via2Moved = true;
+        } else {
+          currentVia1.x -= pushAmount;
+          currentVia2.x += pushAmount;
+          via1Moved = true;
+          via2Moved = true;
+        }
+      }
+      if (!via1Moved && !via2Moved) {
+        break;
+      }
+    }
+    const finalDist = distance(currentVia1, currentVia2);
+    if (finalDist < optimalDistBtwViaCenters) {
+      const overlap = optimalDistBtwViaCenters - finalDist;
+      const pushAmount = overlap / 2;
+      const dx = currentVia2.x - currentVia1.x;
+      const dy = currentVia2.y - currentVia1.y;
+      const norm = Math.sqrt(dx * dx + dy * dy);
+      if (norm > 1e-6) {
+        currentVia1.x -= dx / norm * pushAmount;
+        currentVia1.y -= dy / norm * pushAmount;
+        currentVia2.x += dx / norm * pushAmount;
+        currentVia2.y += dy / norm * pushAmount;
+      } else {
+        currentVia1.x -= pushAmount;
+        currentVia2.x += pushAmount;
+      }
+    }
+    return { via1: currentVia1, via2: currentVia2 };
+  }
+  getMinDistanceBetweenViaCenters() {
+    return this.viaDiameter + this.traceThickness + this.obstacleMargin * 2;
+  }
+  moveViasAsCloseAsPossible(viaPositions) {
     const { via1, via2 } = viaPositions;
-    const minRequiredDistance = (this.viaDiameter + this.traceThickness + this.obstacleMargin) * 2;
+    const minRequiredDistance = this.getMinDistanceBetweenViaCenters();
     const currentDistance = distance(via1, via2);
     if (currentDistance <= minRequiredDistance) {
       return viaPositions;
@@ -3447,129 +4188,47 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
       via2: newVia2
     };
   }
-  /**
-   * Calculate the orthogonal route points for the second route
-   */
-  calculateConservativeOrthogonalRoutePoints(start, end, via1, via2, otherRouteStart, otherRouteEnd) {
-    const outerBox = {
-      width: this.bounds.maxX - this.bounds.minX,
-      height: this.bounds.maxY - this.bounds.minY,
-      x: this.bounds.minX,
-      y: this.bounds.minY
-    };
-    const innerEdgeBox = {
-      width: outerBox.width - 2 * this.obstacleMargin - this.traceThickness,
-      height: outerBox.height - 2 * this.obstacleMargin - this.traceThickness,
-      x: outerBox.x + this.obstacleMargin + this.traceThickness / 2,
-      y: outerBox.y + this.obstacleMargin + this.traceThickness / 2
-    };
-    const midSegmentDX = via2.x - via1.x;
-    const midSegmentDY = via2.y - via1.y;
-    const orthDX = -midSegmentDY;
-    const orthDY = midSegmentDX;
-    const orthLength = Math.sqrt(orthDX * orthDX + orthDY * orthDY);
-    const normOrthDX = orthDX / orthLength;
-    const normOrthDY = orthDY / orthLength;
-    const midpointX = (via1.x + via2.x) / 2;
-    const midpointY = (via1.y + via2.y) / 2;
-    const calculateIntersections = () => {
-      const intersections2 = [];
-      const leftT = (innerEdgeBox.x - midpointX) / normOrthDX;
-      const leftY = midpointY + leftT * normOrthDY;
-      if (leftY >= innerEdgeBox.y && leftY <= innerEdgeBox.y + innerEdgeBox.height) {
-        intersections2.push({ x: innerEdgeBox.x, y: leftY });
-      }
-      const rightT = (innerEdgeBox.x + innerEdgeBox.width - midpointX) / normOrthDX;
-      const rightY = midpointY + rightT * normOrthDY;
-      if (rightY >= innerEdgeBox.y && rightY <= innerEdgeBox.y + innerEdgeBox.height) {
-        intersections2.push({
-          x: innerEdgeBox.x + innerEdgeBox.width,
-          y: rightY
-        });
-      }
-      const topT = (innerEdgeBox.y - midpointY) / normOrthDY;
-      const topX = midpointX + topT * normOrthDX;
-      if (topX >= innerEdgeBox.x && topX <= innerEdgeBox.x + innerEdgeBox.width) {
-        intersections2.push({ x: topX, y: innerEdgeBox.y });
-      }
-      const bottomT = (innerEdgeBox.y + innerEdgeBox.height - midpointY) / normOrthDY;
-      const bottomX = midpointX + bottomT * normOrthDX;
-      if (bottomX >= innerEdgeBox.x && bottomX <= innerEdgeBox.x + innerEdgeBox.width) {
-        intersections2.push({
-          x: bottomX,
-          y: innerEdgeBox.y + innerEdgeBox.height
-        });
-      }
-      return intersections2;
+  handleRoutesDontCross() {
+    const [routeA, routeB] = this.routes;
+    const routeASolution = {
+      connectionName: routeA.connectionName,
+      route: [
+        {
+          x: routeA.startPort.x,
+          y: routeA.startPort.y,
+          z: routeA.startPort.z ?? 0
+        },
+        {
+          x: routeA.endPort.x,
+          y: routeA.endPort.y,
+          z: routeA.endPort.z ?? 0
+        }
+      ],
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
     };
-    const intersections = calculateIntersections();
-    if (intersections.length < 2) {
-      return [
-        { x: start.x, y: start.y, z: start.z ?? 0 },
-        { x: end.x, y: end.y, z: end.z ?? 0 }
-      ];
-    }
-    const sortedIntersections = [...intersections].sort((a, b) => {
-      const distA = distance(a, start);
-      const distB = distance(b, start);
-      return distA - distB;
-    });
-    let middlePoint1 = sortedIntersections[0];
-    let middlePoint2 = sortedIntersections[intersections.length - 1];
-    if (doSegmentsIntersect(start, middlePoint1, otherRouteStart, via1) || doSegmentsIntersect(end, middlePoint2, otherRouteEnd, via2)) {
-      ;
-      [middlePoint1, middlePoint2] = [middlePoint2, middlePoint1];
-    }
-    return [
-      { x: start.x, y: start.y, z: start.z ?? 0 },
-      { x: middlePoint1.x, y: middlePoint1.y, z: start.z ?? 0 },
-      { x: middlePoint2.x, y: middlePoint2.y, z: start.z ?? 0 },
-      { x: end.x, y: end.y, z: end.z ?? 0 }
-    ];
-  }
-  calculateShortestOrthogonalRoutePoints(start, end, via1, via2, otherRouteStart, otherRouteEnd) {
-    const midSegmentCenter = {
-      x: (via1.x + via2.x) / 2,
-      y: (via1.y + via2.y) / 2
+    const routeBSolution = {
+      connectionName: routeB.connectionName,
+      route: [
+        {
+          x: routeB.startPort.x,
+          y: routeB.startPort.y,
+          z: routeB.startPort.z ?? 0
+        },
+        {
+          x: routeB.endPort.x,
+          y: routeB.endPort.y,
+          z: routeB.endPort.z ?? 0
+        }
+      ],
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
     };
-    const midSegmentDirection = {
-      x: via2.x - via1.x,
-      y: via2.y - via1.y
-    };
-    const midSegmentLength = distance(via1, via2);
-    const normOrthDX = midSegmentDirection.y / midSegmentLength;
-    const normOrthDY = midSegmentDirection.x / midSegmentLength;
-    let orthogonalPoint1 = {
-      x: midSegmentCenter.x + midSegmentLength / 2 * normOrthDY,
-      y: midSegmentCenter.y - midSegmentLength / 2 * normOrthDX
-    };
-    let orthogonalPoint2 = {
-      x: midSegmentCenter.x - midSegmentLength / 2 * normOrthDY,
-      y: midSegmentCenter.y + midSegmentLength / 2 * normOrthDX
-    };
-    if (distance(orthogonalPoint2, start) < distance(orthogonalPoint1, start)) {
-      ;
-      [orthogonalPoint1, orthogonalPoint2] = [
-        orthogonalPoint2,
-        orthogonalPoint1
-      ];
-    }
-    if (doSegmentsIntersect(start, orthogonalPoint1, otherRouteStart, via1) || doSegmentsIntersect(end, orthogonalPoint2, otherRouteEnd, via2)) {
-      ;
-      [orthogonalPoint1, orthogonalPoint2] = [
-        orthogonalPoint2,
-        orthogonalPoint1
-      ];
-    }
-    if (doSegmentsIntersect(start, orthogonalPoint2, otherRouteStart, via1) || doSegmentsIntersect(end, orthogonalPoint1, otherRouteEnd, via2)) {
-      return null;
-    }
-    return [
-      { x: start.x, y: start.y, z: start.z ?? 0 },
-      { x: orthogonalPoint1.x, y: orthogonalPoint1.y, z: start.z ?? 0 },
-      { x: orthogonalPoint2.x, y: orthogonalPoint2.y, z: start.z ?? 0 },
-      { x: end.x, y: end.y, z: end.z ?? 0 }
-    ];
+    this.solvedRoutes.push(routeASolution, routeBSolution);
+    this.solved = true;
+    return;
   }
   /**
    * Main step method that attempts to solve the two crossing routes
@@ -3581,44 +4240,7 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
     }
     const [routeA, routeB] = this.routes;
     if (!this.doRoutesCross(routeA, routeB)) {
-      const routeASolution = {
-        connectionName: routeA.connectionName,
-        route: [
-          {
-            x: routeA.startPort.x,
-            y: routeA.startPort.y,
-            z: routeA.startPort.z ?? 0
-          },
-          {
-            x: routeA.endPort.x,
-            y: routeA.endPort.y,
-            z: routeA.endPort.z ?? 0
-          }
-        ],
-        traceThickness: this.traceThickness,
-        viaDiameter: this.viaDiameter,
-        vias: []
-      };
-      const routeBSolution = {
-        connectionName: routeB.connectionName,
-        route: [
-          {
-            x: routeB.startPort.x,
-            y: routeB.startPort.y,
-            z: routeB.startPort.z ?? 0
-          },
-          {
-            x: routeB.endPort.x,
-            y: routeB.endPort.y,
-            z: routeB.endPort.z ?? 0
-          }
-        ],
-        traceThickness: this.traceThickness,
-        viaDiameter: this.viaDiameter,
-        vias: []
-      };
-      this.solvedRoutes.push(routeASolution, routeBSolution);
-      this.solved = true;
+      this.handleRoutesDontCross();
       return;
     }
     if (this.trySolveAOverB(routeA, routeB)) {
@@ -3629,6 +4251,14 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
+    if (this.trySolveAOverB(routeA, routeB, true)) {
+      this.solved = true;
+      return;
+    }
+    if (this.trySolveAOverB(routeB, routeA, true)) {
+      this.solved = true;
+      return;
+    }
     this.failed = true;
   }
   /**
@@ -3649,44 +4279,49 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
       width: this.bounds.maxX - this.bounds.minX,
       height: this.bounds.maxY - this.bounds.minY,
       stroke: "rgba(0, 0, 0, 0.5)",
-      fill: "rgba(240, 240, 240, 0.1)",
-      label: "PCB Bounds"
+      fill: "rgba(240, 240, 240, 0.1)"
     });
-    for (const route of this.routes) {
+    for (const [routeName, route] of [
+      ["Route A", this.routes[0]],
+      ["Route B", this.routes[1]]
+    ]) {
       graphics.points.push({
         x: route.startPort.x,
         y: route.startPort.y,
-        label: `${route.connectionName} start`,
+        label: `${routeName}
+${route.connectionName} start`,
         color: "orange"
       });
       graphics.points.push({
         x: route.endPort.x,
         y: route.endPort.y,
-        label: `${route.connectionName} end`,
+        label: `${routeName}
+${route.connectionName} end`,
         color: "orange"
       });
       graphics.lines.push({
         points: [route.startPort, route.endPort],
         strokeColor: "rgba(255, 0, 0, 0.5)",
-        label: `${route.connectionName} direct`
+        label: `${routeName}
+${route.connectionName} direct`
       });
     }
     for (let i = 0; i < this.debugViaPositions.length; i++) {
       const { via1, via2 } = this.debugViaPositions[i];
-      const colors = ["rgba(255, 165, 0, 0.7)", "rgba(128, 0, 128, 0.7)"];
+      const colors = ["rgba(255, 165, 0, 0.3)", "rgba(128, 0, 128, 0.3)"];
       const color = colors[i % colors.length];
       graphics.circles.push({
         center: via1,
         radius: this.viaDiameter / 2,
         fill: color,
-        stroke: "rgba(0, 0, 0, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.3)",
         label: `Computed Via A (attempt ${i + 1})`
       });
       graphics.circles.push({
         center: via2,
         radius: this.viaDiameter / 2,
         fill: color,
-        stroke: "rgba(0, 0, 0, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.3)",
         label: `Computed Via B (attempt ${i + 1})`
       });
       const safetyMargin = this.viaDiameter / 2 + this.obstacleMargin;
@@ -3695,14 +4330,14 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
         radius: safetyMargin,
         stroke: color,
         fill: "rgba(0, 0, 0, 0)",
-        label: "Safety Margin"
+        label: `Debug Via 1 Safety Margin (attempt ${i + 1})`
       });
       graphics.circles.push({
         center: via2,
         radius: safetyMargin,
         stroke: color,
         fill: "rgba(0, 0, 0, 0)",
-        label: "Safety Margin"
+        label: `Debug Via 2 Safety Margin (attempt ${i + 1})`
       });
       graphics.lines.push({
         points: [
@@ -3729,6 +4364,13 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
           strokeWidth: route.traceThickness,
           label: `${route.connectionName} z=${pointA.z}`
         });
+        if (pointA._label) {
+          graphics.points.push({
+            x: pointA.x,
+            y: pointA.y,
+            label: pointA._label
+          });
+        }
       }
       for (const via of route.vias) {
         graphics.circles.push({
@@ -3743,7 +4385,7 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
           radius: this.viaDiameter / 2 + this.obstacleMargin,
           fill: "rgba(0, 0, 255, 0.3)",
           stroke: "black",
-          label: "Via Margin"
+          label: "Solved Via Margin"
         });
       }
     }
@@ -4030,20 +4672,17 @@ function distance2(p1, p2) {
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
 var EPSILON2 = 1e-9;
-function calculateSegmentTraversal(startPoint, endPoint, bounds) {
+function calculateSegmentTraversal(startPoint, endPoint, bounds, turnDirection = "cw") {
   const startAngle = pointToAngle(startPoint, bounds);
-  let endAngle = pointToAngle(endPoint, bounds);
-  if (endAngle < startAngle) {
-    endAngle += 2 * Math.PI;
-  }
+  const endAngle = pointToAngle(endPoint, bounds);
   if (Math.abs(endAngle - startAngle) < EPSILON2) {
     return { left: 0, top: 0, right: 0, bottom: 0 };
   }
-  return calculateSidePercentages(startAngle, endAngle, bounds);
+  return calculateSidePercentages(startAngle, endAngle, bounds, turnDirection);
 }
-function calculateTraversalPercentages(A, B, C, bounds) {
-  const percentagesAB = calculateSegmentTraversal(A, B, bounds);
-  const percentagesBC = calculateSegmentTraversal(B, C, bounds);
+function calculateTraversalPercentages(A, B, C, bounds, turnDirection) {
+  const percentagesAB = calculateSegmentTraversal(A, B, bounds, turnDirection);
+  const percentagesBC = calculateSegmentTraversal(B, C, bounds, turnDirection);
   const totalPercentages = {
     left: Math.min(1, percentagesAB.left + percentagesBC.left),
     top: Math.min(1, percentagesAB.top + percentagesBC.top),
@@ -4080,7 +4719,7 @@ function pointToAngle(point, bounds) {
   distance6 = Math.max(0, Math.min(perimeter, distance6));
   return perimeter > EPSILON2 ? distance6 / perimeter * (2 * Math.PI) : 0;
 }
-function calculateSidePercentages(startAngle, endAngle, bounds) {
+function calculateSidePercentages(startAngle, endAngle, bounds, turnDirection) {
   const width = bounds.maxX - bounds.minX;
   const height = bounds.maxY - bounds.minY;
   if (width < EPSILON2 && height < EPSILON2)
@@ -4104,17 +4743,54 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
     // Ends at 2PI
   ];
   const result = { left: 0, top: 0, right: 0, bottom: 0 };
-  const totalAngleTraversal = endAngle - startAngle;
-  if (totalAngleTraversal < EPSILON2) return result;
+  const calculateTraversalOverlap = (sStart, sEnd, tStart, tEnd, wrapsAround) => {
+    const effectiveSEnd = sEnd > 2 * Math.PI - EPSILON2 ? 2 * Math.PI : sEnd;
+    if (effectiveSEnd <= sStart + EPSILON2) return 0;
+    if (!wrapsAround) {
+      const overlapStart = Math.max(sStart, tStart);
+      const overlapEnd = Math.min(effectiveSEnd, tEnd);
+      return Math.max(0, overlapEnd - overlapStart);
+    } else {
+      const overlap1Start = Math.max(sStart, tStart);
+      const overlap1End = Math.min(effectiveSEnd, 2 * Math.PI);
+      const overlap1 = Math.max(0, overlap1End - overlap1Start);
+      const overlap2Start = Math.max(sStart, 0);
+      const overlap2End = Math.min(effectiveSEnd, tEnd);
+      const overlap2 = Math.max(0, overlap2End - overlap2Start);
+      return overlap1 + overlap2;
+    }
+  };
   for (const side of sides) {
     const sideAngleRange = side.end - side.start;
     if (sideAngleRange < EPSILON2 || side.length < EPSILON2) continue;
-    const overlapStart = Math.max(startAngle, side.start);
-    const overlapEnd = Math.min(endAngle, side.end);
-    if (overlapStart < overlapEnd - EPSILON2) {
-      const traversedAngleOnSide = overlapEnd - overlapStart;
+    let traversedAngleOnSide = 0;
+    if (turnDirection === "cw") {
+      const wraps = startAngle > endAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        startAngle,
+        endAngle,
+        wraps
+      );
+    } else {
+      const wraps = endAngle > startAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        endAngle,
+        // Start of equivalent CW traversal
+        startAngle,
+        // End of equivalent CW traversal
+        wraps
+      );
+    }
+    if (traversedAngleOnSide > EPSILON2) {
       const percentage = traversedAngleOnSide / sideAngleRange;
-      result[side.name] += Math.max(0, percentage);
+      result[side.name] += Math.max(
+        0,
+        Number.isFinite(percentage) ? percentage : 0
+      );
     }
   }
   for (const key in result) {
@@ -4126,6 +4802,28 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
   return result;
 }
 
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/computeTurnDirection.ts
+function triangleDirection({
+  angleA,
+  angleB,
+  angleC
+}) {
+  const Ax = Math.cos(angleA);
+  const Ay = Math.sin(angleA);
+  const Bx = Math.cos(angleB);
+  const By = Math.sin(angleB);
+  const Cx = Math.cos(angleC);
+  const Cy = Math.sin(angleC);
+  const signedArea = (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax);
+  return signedArea < 0 ? "ccw" : "cw";
+}
+function computeTurnDirection(A, B, C, bounds) {
+  const angleA = pointToAngle(A, bounds);
+  const angleB = pointToAngle(B, bounds);
+  const angleC = pointToAngle(C, bounds);
+  return triangleDirection({ angleA, angleB, angleC });
+}
+
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
 var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
   // Input parameters
@@ -4213,7 +4911,14 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
     const A = flatRoute.A;
     const B = ntrP1;
     const C = flatRoute.B;
-    const sideTraversal = calculateTraversalPercentages(A, B, C, this.bounds);
+    const turnDirection = computeTurnDirection(A, B, C, this.bounds);
+    const sideTraversal = calculateTraversalPercentages(
+      A,
+      B,
+      C,
+      this.bounds,
+      turnDirection
+    );
     const viaBounds = {
       minX: this.bounds.minX + (sideTraversal.left > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
       minY: this.bounds.minY + (sideTraversal.bottom > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
@@ -4291,23 +4996,29 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
       otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd,
       this.traceThickness
     );
-    const p1 = findPointToGetAroundCircle(flatStart, p2, {
-      center: { x: via.x, y: via.y },
-      radius: minDistFromViaToTrace
-    }).E;
-    const p3 = findPointToGetAroundCircle(p2, flatEnd, {
+    const viaCircle = {
       center: { x: via.x, y: via.y },
       radius: minDistFromViaToTrace
-    }).E;
-    const p1IsNeeded = pointToSegmentDistance(via, flatStart, p2) < minDistFromViaToTrace;
-    const p3IsNeeded = pointToSegmentDistance(via, p2, flatEnd) < minDistFromViaToTrace;
+    };
+    const p1 = findPointToGetAroundCircle(flatStart, p2, viaCircle).E;
+    const p3 = findPointToGetAroundCircle(p2, flatEnd, viaCircle).E;
+    const p0_5 = findPointToGetAroundCircle(flatStart, p1, viaCircle).E;
+    const p1_5 = findPointToGetAroundCircle(p1, p2, viaCircle).E;
+    const p2_5 = findPointToGetAroundCircle(p2, p3, viaCircle).E;
+    const p3_5 = findPointToGetAroundCircle(p3, flatEnd, viaCircle).E;
+    const p2_better = findPointToGetAroundCircle(p1_5, p2_5, viaCircle).E;
     return {
       connectionName: flatRouteConnectionName,
       route: [
         { x: flatStart.x, y: flatStart.y, z: flatStart.z ?? 0 },
-        ...p1IsNeeded ? [{ x: p1.x, y: p1.y, z: flatStart.z ?? 0 }] : [],
-        { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
-        ...p3IsNeeded ? [{ x: p3.x, y: p3.y, z: flatStart.z ?? 0 }] : [],
+        { x: p0_5.x, y: p0_5.y, z: flatStart.z ?? 0 },
+        { x: p1.x, y: p1.y, z: flatStart.z ?? 0 },
+        { x: p1_5.x, y: p1_5.y, z: flatStart.z ?? 0 },
+        // { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
+        { x: p2_better.x, y: p2_better.y, z: flatStart.z ?? 0 },
+        { x: p2_5.x, y: p2_5.y, z: flatStart.z ?? 0 },
+        { x: p3.x, y: p3.y, z: flatStart.z ?? 0 },
+        { x: p3_5.x, y: p3_5.y, z: flatStart.z ?? 0 },
         { x: flatEnd.x, y: flatEnd.y, z: flatEnd.z ?? 0 }
       ],
       traceThickness: this.traceThickness,
@@ -5213,24 +5924,40 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
   remainingHdRoutes;
   start;
   end;
+  colorMap;
   constructor(opts) {
     super();
     this.remainingHdRoutes = [...opts.hdRoutes];
+    this.colorMap = opts.colorMap ?? {};
+    const firstRoute = this.remainingHdRoutes[0];
+    const firstRouteToStartDist = Math.min(
+      distance(firstRoute.route[0], opts.start),
+      distance(firstRoute.route[firstRoute.route.length - 1], opts.start)
+    );
+    const firstRouteToEndDist = Math.min(
+      distance(firstRoute.route[0], opts.end),
+      distance(firstRoute.route[firstRoute.route.length - 1], opts.end)
+    );
+    if (firstRouteToStartDist < firstRouteToEndDist) {
+      this.start = opts.start;
+      this.end = opts.end;
+    } else {
+      this.start = opts.end;
+      this.end = opts.start;
+    }
     this.mergedHdRoute = {
-      connectionName: opts.connectionName ?? opts.hdRoutes[0].connectionName,
+      connectionName: opts.connectionName ?? firstRoute.connectionName,
       route: [
         {
-          x: opts.start.x,
-          y: opts.start.y,
-          z: opts.start.z
+          x: this.start.x,
+          y: this.start.y,
+          z: this.start.z
         }
       ],
       vias: [],
       viaDiameter: opts.hdRoutes?.[0]?.viaDiameter ?? 0.6,
       traceThickness: opts.hdRoutes?.[0]?.traceThickness ?? 0.15
     };
-    this.start = opts.start;
-    this.end = opts.end;
   }
   _step() {
     if (this.remainingHdRoutes.length === 0) {
@@ -5316,31 +6043,29 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
         });
       }
     }
-    const colorList = Array.from(
-      { length: this.remainingHdRoutes.length },
-      (_, i) => `hsl(${i * 360 / this.remainingHdRoutes.length}, 100%, 50%)`
-    );
     for (const [i, hdRoute] of this.remainingHdRoutes.entries()) {
+      const routeColor = this.colorMap[hdRoute.connectionName] ?? "gray";
       if (hdRoute.route.length > 1) {
         graphics.lines?.push({
           points: hdRoute.route.map((point) => ({ x: point.x, y: point.y })),
-          strokeColor: colorList[i]
+          strokeColor: routeColor
         });
       }
       for (let pi = 0; pi < hdRoute.route.length; pi++) {
         const point = hdRoute.route[pi];
         graphics.points?.push({
           x: point.x + (i % 2 - 0.5) / 500 + (pi % 8 - 4) / 1e3,
+          // Keep slight offset for visibility
           y: point.y + (i % 2 - 0.5) / 500 + (pi % 8 - 4) / 1e3,
-          color: colorList[i],
-          label: `Route ${i} ${point === hdRoute.route[0] ? "First" : point === hdRoute.route[hdRoute.route.length - 1] ? "Last" : ""}`
+          color: routeColor,
+          label: `Route ${hdRoute.connectionName} ${point === hdRoute.route[0] ? "First" : point === hdRoute.route[hdRoute.route.length - 1] ? "Last" : ""}`
         });
       }
       for (const via of hdRoute.vias) {
         graphics.circles?.push({
           center: { x: via.x, y: via.y },
           radius: hdRoute.viaDiameter / 2,
-          fill: colorList[i]
+          fill: routeColor
         });
       }
     }
@@ -5353,8 +6078,10 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
   unsolvedRoutes;
   activeSolver = null;
   mergedHdRoutes = [];
+  colorMap = {};
   constructor(opts) {
     super();
+    this.colorMap = opts.colorMap ?? {};
     this.unsolvedRoutes = opts.connections.map((c) => ({
       connectionName: c.name,
       hdRoutes: opts.hdRoutes.filter((r) => r.connectionName === c.name),
@@ -5390,7 +6117,8 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
       connectionName: unsolvedRoute.connectionName,
       hdRoutes: unsolvedRoute.hdRoutes,
       start: unsolvedRoute.start,
-      end: unsolvedRoute.end
+      end: unsolvedRoute.end,
+      colorMap: this.colorMap
     });
   }
   visualize() {
@@ -5416,22 +6144,26 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
       }
     }
     for (const [i, mergedRoute] of this.mergedHdRoutes.entries()) {
-      const solvedColor = `hsl(120, 100%, ${40 + i * 10 % 40}%)`;
-      if (mergedRoute.route.length > 1) {
+      const solvedColor = this.colorMap[mergedRoute.connectionName] ?? `hsl(120, 100%, ${40 + i * 10 % 40}%)`;
+      for (let j = 0; j < mergedRoute.route.length - 1; j++) {
+        const p1 = mergedRoute.route[j];
+        const p2 = mergedRoute.route[j + 1];
+        const segmentColor = p1.z !== 0 ? safeTransparentize(solvedColor, 0.5) : solvedColor;
         graphics.lines?.push({
-          points: mergedRoute.route.map((point) => ({
-            x: point.x,
-            y: point.y
-          })),
-          strokeColor: solvedColor,
+          points: [
+            { x: p1.x, y: p1.y },
+            { x: p2.x, y: p2.y }
+          ],
+          strokeColor: segmentColor,
           strokeWidth: mergedRoute.traceThickness
         });
       }
       for (const point of mergedRoute.route) {
+        const pointColor = point.z !== 0 ? safeTransparentize(solvedColor, 0.5) : solvedColor;
         graphics.points?.push({
           x: point.x,
           y: point.y,
-          color: solvedColor
+          color: pointColor
         });
       }
       for (const via of mergedRoute.vias) {
@@ -5439,25 +6171,23 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
           center: { x: via.x, y: via.y },
           radius: mergedRoute.viaDiameter / 2,
           fill: solvedColor
+          // Keep vias solid color for visibility
         });
       }
     }
-    const colorList = Array.from(
-      { length: this.unsolvedRoutes.length },
-      (_, i) => `hsl(${i * 360 / this.unsolvedRoutes.length}, 100%, 50%)`
-    );
-    for (const [i, unsolvedRoute] of this.unsolvedRoutes.entries()) {
+    for (const unsolvedRoute of this.unsolvedRoutes) {
+      const routeColor = this.colorMap[unsolvedRoute.connectionName] ?? "gray";
       graphics.points?.push(
         {
           x: unsolvedRoute.start.x,
           y: unsolvedRoute.start.y,
-          color: colorList[i],
+          color: routeColor,
           label: `${unsolvedRoute.connectionName} Start`
         },
         {
           x: unsolvedRoute.end.x,
           y: unsolvedRoute.end.y,
-          color: colorList[i],
+          color: routeColor,
           label: `${unsolvedRoute.connectionName} End`
         }
       );
@@ -5466,14 +6196,15 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
           { x: unsolvedRoute.start.x, y: unsolvedRoute.start.y },
           { x: unsolvedRoute.end.x, y: unsolvedRoute.end.y }
         ],
-        strokeColor: colorList[i],
+        strokeColor: routeColor,
         strokeDash: "2 2"
       });
       for (const hdRoute of unsolvedRoute.hdRoutes) {
         if (hdRoute.route.length > 1) {
           graphics.lines?.push({
             points: hdRoute.route.map((point) => ({ x: point.x, y: point.y })),
-            strokeColor: safeTransparentize(colorList[i], 0.5),
+            strokeColor: safeTransparentize(routeColor, 0.5),
+            // Use routeColor
             strokeDash: "10 5"
           });
         }
@@ -5481,7 +6212,8 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
           graphics.circles?.push({
             center: { x: via.x, y: via.y },
             radius: hdRoute.viaDiameter / 2,
-            fill: colorList[i]
+            fill: routeColor
+            // Use routeColor
           });
         }
       }
@@ -6783,853 +7515,467 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
   }
 };
 
-// lib/utils/createRectFromCapacityNode.ts
-var createRectFromCapacityNode = (node, opts = {}) => {
-  const lowestZ = Math.min(...node.availableZ);
-  return {
-    center: !opts.rectMargin || opts.zOffset ? {
-      x: node.center.x + lowestZ * node.width * (opts.zOffset ?? 0.05),
-      y: node.center.y - lowestZ * node.width * (opts.zOffset ?? 0.05)
-    } : node.center,
-    width: opts.rectMargin ? node.width - opts.rectMargin * 2 : Math.max(node.width - 0.5, node.width * 0.8),
-    height: opts.rectMargin ? node.height - opts.rectMargin * 2 : Math.max(node.height - 0.5, node.height * 0.8),
-    fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
-      "0,1": "rgba(0,0,0,0.1)",
-      "0": "rgba(0,200,200, 0.1)",
-      "1": "rgba(0,0,200, 0.1)"
-    }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
-    layer: `z${node.availableZ.join(",")}`,
-    label: [
-      node.capacityMeshNodeId,
-      `availableZ: ${node.availableZ.join(",")}`,
-      `${node._containsTarget ? "containsTarget" : ""}`,
-      `${node._containsObstacle ? "containsObstacle" : ""}`
-    ].filter(Boolean).join("\n")
-  };
-};
-
-// lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts
-var CapacityPathingSolver = class extends BaseSolver {
-  connectionsWithNodes;
-  usedNodeCapacityMap;
-  simpleRouteJson;
-  nodes;
-  edges;
-  GREEDY_MULTIPLIER = 1.1;
-  nodeMap;
-  nodeEdgeMap;
-  connectionNameToGoalNodeIds;
-  colorMap;
-  maxDepthOfNodes;
-  activeCandidateStraightLineDistance;
-  debug_lastNodeCostMap;
-  hyperParameters;
-  constructor({
-    simpleRouteJson,
-    nodes,
-    edges,
-    colorMap,
-    MAX_ITERATIONS = 1e6,
-    hyperParameters = {}
-  }) {
+// lib/solvers/StrawSolver/StrawSolver.ts
+var StrawSolver = class extends BaseSolver {
+  multiLayerNodes;
+  strawNodes;
+  skippedNodes;
+  unprocessedNodes;
+  strawSize;
+  nodeIdCounter;
+  constructor(params) {
     super();
-    this.MAX_ITERATIONS = MAX_ITERATIONS;
-    this.simpleRouteJson = simpleRouteJson;
-    this.nodes = nodes;
-    this.edges = edges;
-    this.colorMap = colorMap ?? {};
-    const { connectionsWithNodes, connectionNameToGoalNodeIds } = this.getConnectionsWithNodes();
-    this.connectionsWithNodes = connectionsWithNodes;
-    this.connectionNameToGoalNodeIds = connectionNameToGoalNodeIds;
-    this.hyperParameters = hyperParameters;
-    this.usedNodeCapacityMap = new Map(
-      this.nodes.map((node) => [node.capacityMeshNodeId, 0])
-    );
-    this.nodeMap = new Map(
-      this.nodes.map((node) => [node.capacityMeshNodeId, node])
-    );
-    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.maxDepthOfNodes = Math.max(
-      ...this.nodes.map((node) => node._depth ?? 0)
-    );
-    this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
-  }
-  getTotalCapacity(node) {
-    const depth = node._depth ?? 0;
-    return (this.maxDepthOfNodes - depth + 1) ** 2;
-  }
-  getConnectionsWithNodes() {
-    const connectionsWithNodes = [];
-    const nodesWithTargets = this.nodes.filter((node) => node._containsTarget);
-    const connectionNameToGoalNodeIds = /* @__PURE__ */ new Map();
-    for (const connection of this.simpleRouteJson.connections) {
-      const nodesForConnection = [];
-      for (const point of connection.pointsToConnect) {
-        let closestNode = this.nodes[0];
-        let minDistance = Number.MAX_VALUE;
-        for (const node of nodesWithTargets) {
-          const distance6 = Math.sqrt(
-            (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
-          );
-          if (distance6 < minDistance) {
-            minDistance = distance6;
-            closestNode = node;
-          }
-        }
-        nodesForConnection.push(closestNode);
-      }
-      if (nodesForConnection.length < 2) {
-        throw new Error(
-          `Not enough nodes for connection "${connection.name}", only ${nodesForConnection.length} found`
-        );
+    this.MAX_ITERATIONS = 1e5;
+    this.strawSize = params.strawSize ?? 0.5;
+    this.multiLayerNodes = [];
+    this.strawNodes = [];
+    this.skippedNodes = [];
+    this.nodeIdCounter = 0;
+    this.unprocessedNodes = [];
+    for (const node of params.nodes) {
+      if (node.availableZ.length === 1) {
+        this.unprocessedNodes.push(node);
+      } else {
+        this.multiLayerNodes.push(node);
       }
-      connectionNameToGoalNodeIds.set(
-        connection.name,
-        nodesForConnection.map((n) => n.capacityMeshNodeId)
-      );
-      connectionsWithNodes.push({
-        connection,
-        nodes: nodesForConnection,
-        pathFound: false,
-        straightLineDistance: distance(
-          nodesForConnection[0].center,
-          nodesForConnection[nodesForConnection.length - 1].center
-        )
-      });
     }
-    connectionsWithNodes.sort(
-      (a, b) => a.straightLineDistance - b.straightLineDistance
-    );
-    return { connectionsWithNodes, connectionNameToGoalNodeIds };
-  }
-  currentConnectionIndex = 0;
-  candidates;
-  visitedNodes;
-  computeG(prevCandidate, node, endGoal) {
-    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node);
-  }
-  computeH(prevCandidate, node, endGoal) {
-    return this.getDistanceBetweenNodes(node, endGoal);
   }
-  getBacktrackedPath(candidate) {
-    const path = [];
-    let currentCandidate = candidate;
-    while (currentCandidate) {
-      path.push(currentCandidate.node);
-      currentCandidate = currentCandidate.prevCandidate;
+  getCapacityOfMultiLayerNodesWithinBounds(bounds) {
+    let totalCapacity = 0;
+    for (const node of this.multiLayerNodes) {
+      const nodeMinX = node.center.x - node.width / 2;
+      const nodeMaxX = node.center.x + node.width / 2;
+      const nodeMinY = node.center.y - node.height / 2;
+      const nodeMaxY = node.center.y + node.height / 2;
+      const overlapMinX = Math.max(bounds.minX, nodeMinX);
+      const overlapMaxX = Math.min(bounds.maxX, nodeMaxX);
+      const overlapMinY = Math.max(bounds.minY, nodeMinY);
+      const overlapMaxY = Math.min(bounds.maxY, nodeMaxY);
+      if (overlapMinX < overlapMaxX && overlapMinY < overlapMaxY) {
+        const overlapWidth = overlapMaxX - overlapMinX;
+        const overlapHeight = overlapMaxY - overlapMinY;
+        const overlapArea = overlapWidth * overlapHeight;
+        const nodeArea = node.width * node.height;
+        const proportion = overlapArea / nodeArea;
+        totalCapacity += getTunedTotalCapacity1(node) * proportion;
+      }
     }
-    return path;
-  }
-  getNeighboringNodes(node) {
-    return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap(
-      (edge) => edge.nodeIds.filter((n) => n !== node.capacityMeshNodeId)
-    ).map((n) => this.nodeMap.get(n));
+    return totalCapacity;
   }
-  getCapacityPaths() {
-    const capacityPaths = [];
-    for (const connection of this.connectionsWithNodes) {
-      const path = connection.path;
-      if (path) {
-        capacityPaths.push({
-          capacityPathId: connection.connection.name,
-          connectionName: connection.connection.name,
-          nodeIds: path.map((node) => node.capacityMeshNodeId)
+  getSurroundingCapacities(node) {
+    const searchDistance = Math.min(node.width, node.height);
+    const leftSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2 - searchDistance,
+      maxX: node.center.x - node.width / 2,
+      minY: node.center.y - node.height / 2,
+      maxY: node.center.y + node.height / 2
+    });
+    const rightSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x + node.width / 2,
+      maxX: node.center.x + node.width / 2 + searchDistance,
+      minY: node.center.y - node.height / 2,
+      maxY: node.center.y + node.height / 2
+    });
+    const topSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2,
+      maxX: node.center.x + node.width / 2,
+      minY: node.center.y - node.height / 2 - searchDistance,
+      maxY: node.center.y - node.height / 2
+    });
+    const bottomSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2,
+      maxX: node.center.x + node.width / 2,
+      minY: node.center.y + node.height / 2,
+      maxY: node.center.y + node.height / 2 + searchDistance
+    });
+    return {
+      leftSurroundingCapacity,
+      rightSurroundingCapacity,
+      topSurroundingCapacity,
+      bottomSurroundingCapacity
+    };
+  }
+  /**
+   * Creates straw nodes from a single-layer node based on surrounding capacities
+   */
+  createStrawsForNode(node) {
+    const result = [];
+    const {
+      leftSurroundingCapacity,
+      rightSurroundingCapacity,
+      topSurroundingCapacity,
+      bottomSurroundingCapacity
+    } = this.getSurroundingCapacities(node);
+    const horizontalCapacity = leftSurroundingCapacity + rightSurroundingCapacity;
+    const verticalCapacity = topSurroundingCapacity + bottomSurroundingCapacity;
+    const layerPrefersFactor = 1;
+    const effectiveHorizontalCapacity = horizontalCapacity * layerPrefersFactor;
+    if (effectiveHorizontalCapacity > verticalCapacity) {
+      const numStraws = Math.floor(node.height / this.strawSize);
+      const strawHeight = node.height / numStraws;
+      for (let i = 0; i < numStraws; i++) {
+        const strawCenterY = node.center.y - node.height / 2 + i * strawHeight + strawHeight / 2;
+        result.push({
+          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
+          center: { x: node.center.x, y: strawCenterY },
+          width: node.width,
+          height: strawHeight,
+          layer: node.layer,
+          availableZ: [...node.availableZ],
+          _depth: node._depth,
+          _strawNode: true,
+          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
+        });
+      }
+    } else {
+      const numStraws = Math.floor(node.width / this.strawSize);
+      const strawWidth = node.width / numStraws;
+      for (let i = 0; i < numStraws; i++) {
+        const strawCenterX = node.center.x - node.width / 2 + i * strawWidth + strawWidth / 2;
+        result.push({
+          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
+          center: { x: strawCenterX, y: node.center.y },
+          width: strawWidth,
+          height: node.height,
+          layer: node.layer,
+          availableZ: [...node.availableZ],
+          _depth: node._depth,
+          _strawNode: true,
+          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
         });
       }
     }
-    return capacityPaths;
-  }
-  doesNodeHaveCapacityForTrace(node, prevNode) {
-    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
-    const totalCapacity = this.getTotalCapacity(node);
-    if (node.availableZ.length === 1 && !node._containsTarget && usedCapacity > 0)
-      return false;
-    let additionalCapacityRequirement = 0;
-    if (node.availableZ.length > 1 && prevNode.availableZ.length === 1) {
-      additionalCapacityRequirement += 0.5;
-    }
-    return usedCapacity + additionalCapacityRequirement < totalCapacity;
-  }
-  canTravelThroughObstacle(node, connectionName) {
-    const goalNodeIds = this.connectionNameToGoalNodeIds.get(connectionName);
-    return goalNodeIds?.includes(node.capacityMeshNodeId) ?? false;
-  }
-  getDistanceBetweenNodes(A, B) {
-    return Math.sqrt(
-      (A.center.x - B.center.x) ** 2 + (A.center.y - B.center.y) ** 2
-    );
-  }
-  reduceCapacityAlongPath(nextConnection) {
-    for (const node of nextConnection.path ?? []) {
-      this.usedNodeCapacityMap.set(
-        node.capacityMeshNodeId,
-        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) + 1
-      );
-    }
+    return result;
   }
-  isConnectedToEndGoal(node, endGoal) {
-    return this.nodeEdgeMap.get(node.capacityMeshNodeId).some((edge) => edge.nodeIds.includes(endGoal.capacityMeshNodeId));
+  getResultNodes() {
+    return [...this.multiLayerNodes, ...this.strawNodes, ...this.skippedNodes];
   }
   _step() {
-    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
-    if (!nextConnection) {
+    const rootNode = this.unprocessedNodes.pop();
+    if (!rootNode) {
       this.solved = true;
       return;
     }
-    const [start, end] = nextConnection.nodes;
-    if (!this.candidates) {
-      this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }];
-      this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
-      this.visitedNodes = /* @__PURE__ */ new Set([start.capacityMeshNodeId]);
-      this.activeCandidateStraightLineDistance = distance(
-        start.center,
-        end.center
-      );
-    }
-    this.candidates.sort((a, b) => a.f - b.f);
-    const currentCandidate = this.candidates.shift();
-    if (!currentCandidate) {
-      console.error(
-        `Ran out of candidates on connection ${nextConnection.connection.name}`
-      );
-      this.currentConnectionIndex++;
-      this.candidates = null;
-      this.visitedNodes = null;
-      this.failed = true;
+    if (rootNode.width < this.strawSize && rootNode.height < this.strawSize) {
+      this.skippedNodes.push(rootNode);
       return;
     }
-    if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
-      nextConnection.path = this.getBacktrackedPath({
-        prevCandidate: currentCandidate,
-        node: end,
-        f: 0,
-        g: 0,
-        h: 0
-      });
-      this.reduceCapacityAlongPath(nextConnection);
-      this.currentConnectionIndex++;
-      this.candidates = null;
-      this.visitedNodes = null;
+    if (rootNode._containsTarget) {
+      this.skippedNodes.push(rootNode);
       return;
     }
-    const neighborNodes = this.getNeighboringNodes(currentCandidate.node);
-    for (const neighborNode of neighborNodes) {
-      if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
-        continue;
-      }
-      if (!this.doesNodeHaveCapacityForTrace(neighborNode, currentCandidate.node)) {
-        continue;
-      }
-      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
-      if (neighborNode._containsObstacle && !this.canTravelThroughObstacle(neighborNode, connectionName)) {
-        continue;
-      }
-      const g = this.computeG(currentCandidate, neighborNode, end);
-      const h = this.computeH(currentCandidate, neighborNode, end);
-      const f = g + h * this.GREEDY_MULTIPLIER;
-      this.debug_lastNodeCostMap.set(neighborNode.capacityMeshNodeId, {
-        f,
-        g,
-        h
-      });
-      const newCandidate = {
-        prevCandidate: currentCandidate,
-        node: neighborNode,
-        f,
-        g,
-        h
-      };
-      this.candidates.push(newCandidate);
-    }
-    this.visitedNodes.add(currentCandidate.node.capacityMeshNodeId);
+    const strawNodes = this.createStrawsForNode(rootNode);
+    this.strawNodes.push(...strawNodes);
   }
   visualize() {
     const graphics = {
+      rects: [],
       lines: [],
       points: [],
-      rects: [],
-      circles: []
+      circles: [],
+      title: "Straw Solver"
     };
-    if (this.connectionsWithNodes) {
-      for (let i = 0; i < this.connectionsWithNodes.length; i++) {
-        const conn = this.connectionsWithNodes[i];
-        if (conn.path && conn.path.length > 0) {
-          const pathPoints = conn.path.map(
-            ({ center: { x, y }, width, availableZ }) => ({
-              // slight offset to allow viewing overlapping paths
-              x: x + (i % 10 + i % 19) * (5e-3 * width),
-              y: y + (i % 10 + i % 19) * (5e-3 * width),
-              availableZ
-            })
-          );
-          graphics.lines.push({
-            points: pathPoints,
-            strokeColor: this.colorMap[conn.connection.name]
-          });
-          for (let u = 0; u < pathPoints.length; u++) {
-            const point = pathPoints[u];
-            graphics.points.push({
-              x: point.x,
-              y: point.y,
-              label: [
-                `conn: ${conn.connection.name}`,
-                `node: ${conn.path[u].capacityMeshNodeId}`,
-                `z: ${point.availableZ.join(",")}`
-              ].join("\n")
-            });
-          }
-        }
-      }
-    }
-    for (const node of this.nodes) {
-      const nodeCosts = this.debug_lastNodeCostMap.get(node.capacityMeshNodeId);
+    for (const node of this.unprocessedNodes) {
       graphics.rects.push({
-        ...createRectFromCapacityNode(node, {
-          rectMargin: 0.025,
-          zOffset: 0.01
-        }),
-        label: [
-          `${node.capacityMeshNodeId}`,
-          `${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}`,
-          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
-          `g: ${nodeCosts?.g !== void 0 ? nodeCosts.g.toFixed(2) : "?"}`,
-          `h: ${nodeCosts?.h !== void 0 ? nodeCosts.h.toFixed(2) : "?"}`,
-          `f: ${nodeCosts?.f !== void 0 ? nodeCosts.f.toFixed(2) : "?"}`,
-          `z: ${node.availableZ.join(", ")}`
-        ].join("\n")
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        fill: "rgba(200, 200, 200, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `${node.capacityMeshNodeId}
+Unprocessed
+${node.width}x${node.height}`
       });
     }
-    if (this.connectionsWithNodes) {
-      for (const conn of this.connectionsWithNodes) {
-        if (conn.connection?.pointsToConnect) {
-          for (const point of conn.connection.pointsToConnect) {
-            graphics.points.push({
-              x: point.x,
-              y: point.y,
-              label: [`pointsToConnect ${conn.connection.name}`].join("\n")
-            });
-          }
-        }
-      }
-    }
-    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
-    if (nextConnection) {
-      const [start, end] = nextConnection.connection.pointsToConnect;
-      graphics.lines.push({
-        points: [
-          { x: start.x, y: start.y },
-          { x: end.x, y: end.y }
-        ],
-        strokeColor: "red",
-        strokeDash: "10 5"
+    for (const node of this.strawNodes) {
+      const color = node.availableZ[0] === 0 ? "rgba(0, 150, 255, 0.5)" : "rgba(255, 100, 0, 0.5)";
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        fill: color,
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `${node.capacityMeshNodeId}
+Layer: ${node.availableZ[0]}
+${node.width}x${node.height}`,
+        layer: `z${node.availableZ.join(",")}`
       });
     }
-    if (this.candidates) {
-      const topCandidates = this.candidates.slice(0, 5);
-      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
-      topCandidates.forEach((candidate, index) => {
-        const opacity = 0.5 * (1 - index / 5);
-        const backtrackedPath = this.getBacktrackedPath(candidate);
-        graphics.lines.push({
-          points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
-          strokeColor: safeTransparentize(
-            this.colorMap[connectionName] ?? "red",
-            1 - opacity
-          )
-        });
+    for (const node of this.multiLayerNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width * 0.9,
+        height: node.height * 0.9,
+        fill: "rgba(100, 255, 100, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: `${node.capacityMeshNodeId}
+Layers: ${node.availableZ.join(",")}
+${node.width}x${node.height}`
       });
     }
     return graphics;
   }
 };
 
-// lib/solvers/CapacityPathingSolver/CapacityPathingSolver5.ts
-var CapacityPathingSolver5 = class extends CapacityPathingSolver {
-  NEGATIVE_CAPACITY_PENALTY_FACTOR = 1;
-  REDUCED_CAPACITY_PENALTY_FACTOR = 1;
-  constructor(...args) {
-    super(...args);
-    this.GREEDY_MULTIPLIER = 2.5;
-  }
-  get maxCapacityFactor() {
-    return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1;
-  }
-  getTotalCapacity(node) {
-    return getTunedTotalCapacity1(node, this.maxCapacityFactor);
-  }
-  /**
-   * Penalty you pay for using this node
-   */
-  getNodeCapacityPenalty(node) {
-    const MAX_PENALTY = node.width + node.height;
-    const MIN_PENALTY = 0.05;
-    const START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW = 2;
-    const totalCapacity = this.getTotalCapacity(node);
-    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
-    const remainingCapacity = totalCapacity - usedCapacity;
-    if (remainingCapacity > START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW) {
-      return MIN_PENALTY;
+// lib/utils/areNodesBordering.ts
+function areNodesBordering(node1, node2) {
+  const n1Left = node1.center.x - node1.width / 2;
+  const n1Right = node1.center.x + node1.width / 2;
+  const n1Top = node1.center.y - node1.height / 2;
+  const n1Bottom = node1.center.y + node1.height / 2;
+  const n2Left = node2.center.x - node2.width / 2;
+  const n2Right = node2.center.x + node2.width / 2;
+  const n2Top = node2.center.y - node2.height / 2;
+  const n2Bottom = node2.center.y + node2.height / 2;
+  const epsilon = 1e-3;
+  const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
+  const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
+  return shareVerticalBorder || shareHorizontalBorder;
+}
+
+// lib/utils/createRectFromCapacityNode.ts
+var createRectFromCapacityNode = (node, opts = {}) => {
+  const lowestZ = Math.min(...node.availableZ);
+  return {
+    center: !opts.rectMargin || opts.zOffset ? {
+      x: node.center.x + lowestZ * node.width * (opts.zOffset ?? 0.05),
+      y: node.center.y - lowestZ * node.width * (opts.zOffset ?? 0.05)
+    } : node.center,
+    width: opts.rectMargin ? node.width - opts.rectMargin * 2 : Math.max(node.width - 0.5, node.width * 0.8),
+    height: opts.rectMargin ? node.height - opts.rectMargin * 2 : Math.max(node.height - 0.5, node.height * 0.8),
+    fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
+      "0,1": "rgba(0,0,0,0.1)",
+      "0": "rgba(0,200,200, 0.1)",
+      "1": "rgba(0,0,200, 0.1)"
+    }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+    layer: `z${node.availableZ.join(",")}`,
+    label: [
+      node.capacityMeshNodeId,
+      `availableZ: ${node.availableZ.join(",")}`,
+      `${node._containsTarget ? "containsTarget" : ""}`,
+      `${node._containsObstacle ? "containsObstacle" : ""}`
+    ].filter(Boolean).join("\n")
+  };
+};
+
+// lib/data-structures/CapacityNodeTree.ts
+var CapacityNodeTree = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+    this.buckets = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const nodeMinX = node.center.x - node.width / 2;
+      const nodeMinY = node.center.y - node.height / 2;
+      const nodeMaxX = node.center.x + node.width / 2;
+      const nodeMaxY = node.center.y + node.height / 2;
+      for (let x = nodeMinX; x <= nodeMaxX; x += this.CELL_SIZE) {
+        for (let y = nodeMinY; y <= nodeMaxY; y += this.CELL_SIZE) {
+          const bucketKey = this.getBucketKey(x, y);
+          const bucket = this.buckets.get(bucketKey);
+          if (!bucket) {
+            this.buckets.set(bucketKey, [node]);
+          } else {
+            bucket.push(node);
+          }
+        }
+      }
     }
-    const penalty = (MAX_PENALTY - MIN_PENALTY) * Math.max(
-      1,
-      (START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW - remainingCapacity) / (MAX_PENALTY - MIN_PENALTY)
-    ) + MIN_PENALTY;
-    return penalty;
-  }
-  /**
-   * We're rewarding travel into big nodes.
-   *
-   * To minimize shortest path, you'd want to comment this out.
-   */
-  getDistanceBetweenNodes(A, B) {
-    const dx = A.center.x - B.center.x;
-    const dy = A.center.y - B.center.y;
-    return Math.sqrt(dx ** 2 + dy ** 2);
   }
-  computeG(prevCandidate, node, endGoal) {
-    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
+  buckets;
+  CELL_SIZE = 0.4;
+  getBucketKey(x, y) {
+    return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
   }
-  computeH(prevCandidate, node, endGoal) {
-    return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
+  getNodesInArea(centerX, centerY, width, height) {
+    const nodes = [];
+    const alreadyAddedNodes = /* @__PURE__ */ new Set();
+    const minX = centerX - width / 2;
+    const minY = centerY - height / 2;
+    const maxX = centerX + width / 2;
+    const maxY = centerY + height / 2;
+    for (let x = minX; x <= maxX; x += this.CELL_SIZE) {
+      for (let y = minY; y <= maxY; y += this.CELL_SIZE) {
+        const bucketKey = this.getBucketKey(x, y);
+        const bucket = this.buckets.get(bucketKey) || [];
+        for (const node of bucket) {
+          if (alreadyAddedNodes.has(node.capacityMeshNodeId)) continue;
+          alreadyAddedNodes.add(node.capacityMeshNodeId);
+          nodes.push(node);
+        }
+      }
+    }
+    return nodes;
   }
 };
 
-// lib/solvers/StrawSolver/StrawSolver.ts
-var StrawSolver = class extends BaseSolver {
-  multiLayerNodes;
-  strawNodes;
-  skippedNodes;
-  unprocessedNodes;
-  strawSize;
-  nodeIdCounter;
-  constructor(params) {
+// lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
+var EPSILON3 = 5e-3;
+var SingleLayerNodeMergerSolver = class extends BaseSolver {
+  nodeMap;
+  currentBatchNodeIds;
+  absorbedNodeIds;
+  nextBatchNodeIds;
+  batchHadModifications;
+  hasComputedAdjacentNodeIds = false;
+  newNodes;
+  constructor(nodes) {
     super();
+    this.nodeMap = /* @__PURE__ */ new Map();
     this.MAX_ITERATIONS = 1e5;
-    this.strawSize = params.strawSize ?? 0.5;
-    this.multiLayerNodes = [];
-    this.strawNodes = [];
-    this.skippedNodes = [];
-    this.nodeIdCounter = 0;
-    this.unprocessedNodes = [];
-    for (const node of params.nodes) {
-      if (node.availableZ.length === 1) {
-        this.unprocessedNodes.push(node);
+    for (const node of nodes) {
+      this.nodeMap.set(node.capacityMeshNodeId, node);
+    }
+    this.newNodes = [];
+    this.absorbedNodeIds = /* @__PURE__ */ new Set();
+    const unprocessedNodesWithArea = [];
+    for (const node of nodes) {
+      if (node.availableZ.length > 1) {
+        this.newNodes.push(node);
+        this.absorbedNodeIds.add(node.capacityMeshNodeId);
       } else {
-        this.multiLayerNodes.push(node);
+        unprocessedNodesWithArea.push([node, node.width * node.height]);
       }
     }
-  }
-  getCapacityOfMultiLayerNodesWithinBounds(bounds) {
-    let totalCapacity = 0;
-    for (const node of this.multiLayerNodes) {
-      const nodeMinX = node.center.x - node.width / 2;
-      const nodeMaxX = node.center.x + node.width / 2;
-      const nodeMinY = node.center.y - node.height / 2;
-      const nodeMaxY = node.center.y + node.height / 2;
-      const overlapMinX = Math.max(bounds.minX, nodeMinX);
-      const overlapMaxX = Math.min(bounds.maxX, nodeMaxX);
-      const overlapMinY = Math.max(bounds.minY, nodeMinY);
-      const overlapMaxY = Math.min(bounds.maxY, nodeMaxY);
-      if (overlapMinX < overlapMaxX && overlapMinY < overlapMaxY) {
-        const overlapWidth = overlapMaxX - overlapMinX;
-        const overlapHeight = overlapMaxY - overlapMinY;
-        const overlapArea = overlapWidth * overlapHeight;
-        const nodeArea = node.width * node.height;
-        const proportion = overlapArea / nodeArea;
-        totalCapacity += getTunedTotalCapacity1(node) * proportion;
-      }
+    unprocessedNodesWithArea.sort((a, b) => a[1] - b[1]);
+    for (const [node, area] of unprocessedNodesWithArea) {
+      const unprocessedNode = {
+        ...node,
+        center: { ...node.center }
+      };
+      this.nodeMap.set(node.capacityMeshNodeId, unprocessedNode);
     }
-    return totalCapacity;
-  }
-  getSurroundingCapacities(node) {
-    const searchDistance = Math.min(node.width, node.height);
-    const leftSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
-      minX: node.center.x - node.width / 2 - searchDistance,
-      maxX: node.center.x - node.width / 2,
-      minY: node.center.y - node.height / 2,
-      maxY: node.center.y + node.height / 2
-    });
-    const rightSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
-      minX: node.center.x + node.width / 2,
-      maxX: node.center.x + node.width / 2 + searchDistance,
-      minY: node.center.y - node.height / 2,
-      maxY: node.center.y + node.height / 2
-    });
-    const topSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
-      minX: node.center.x - node.width / 2,
-      maxX: node.center.x + node.width / 2,
-      minY: node.center.y - node.height / 2 - searchDistance,
-      maxY: node.center.y - node.height / 2
-    });
-    const bottomSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
-      minX: node.center.x - node.width / 2,
-      maxX: node.center.x + node.width / 2,
-      minY: node.center.y + node.height / 2,
-      maxY: node.center.y + node.height / 2 + searchDistance
-    });
-    return {
-      leftSurroundingCapacity,
-      rightSurroundingCapacity,
-      topSurroundingCapacity,
-      bottomSurroundingCapacity
-    };
+    this.currentBatchNodeIds = unprocessedNodesWithArea.map(
+      ([node]) => node.capacityMeshNodeId
+    );
+    this.nextBatchNodeIds = [];
+    this.batchHadModifications = false;
   }
-  /**
-   * Creates straw nodes from a single-layer node based on surrounding capacities
-   */
-  createStrawsForNode(node) {
-    const result = [];
-    const {
-      leftSurroundingCapacity,
-      rightSurroundingCapacity,
-      topSurroundingCapacity,
-      bottomSurroundingCapacity
-    } = this.getSurroundingCapacities(node);
-    const horizontalCapacity = leftSurroundingCapacity + rightSurroundingCapacity;
-    const verticalCapacity = topSurroundingCapacity + bottomSurroundingCapacity;
-    const layerPrefersFactor = 1;
-    const effectiveHorizontalCapacity = horizontalCapacity * layerPrefersFactor;
-    if (effectiveHorizontalCapacity > verticalCapacity) {
-      const numStraws = Math.floor(node.height / this.strawSize);
-      const strawHeight = node.height / numStraws;
-      for (let i = 0; i < numStraws; i++) {
-        const strawCenterY = node.center.y - node.height / 2 + i * strawHeight + strawHeight / 2;
-        result.push({
-          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
-          center: { x: node.center.x, y: strawCenterY },
-          width: node.width,
-          height: strawHeight,
-          layer: node.layer,
-          availableZ: [...node.availableZ],
-          _depth: node._depth,
-          _strawNode: true,
-          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
-        });
-      }
-    } else {
-      const numStraws = Math.floor(node.width / this.strawSize);
-      const strawWidth = node.width / numStraws;
-      for (let i = 0; i < numStraws; i++) {
-        const strawCenterX = node.center.x - node.width / 2 + i * strawWidth + strawWidth / 2;
-        result.push({
-          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
-          center: { x: strawCenterX, y: node.center.y },
-          width: strawWidth,
-          height: node.height,
-          layer: node.layer,
-          availableZ: [...node.availableZ],
-          _depth: node._depth,
-          _strawNode: true,
-          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
-        });
+  computeAdjacentNodeIdsForFirstBatch(nodes) {
+    const nodeTrees = [
+      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 0)),
+      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 1))
+    ];
+    for (const node of nodes) {
+      const adjacentNodes = [];
+      const z = node.availableZ[0];
+      const nodesInArea = nodeTrees[z].getNodesInArea(
+        node.center.x,
+        node.center.y,
+        node.width * 4,
+        node.height * 4
+      );
+      for (const unprocessedNode of nodesInArea) {
+        if (unprocessedNode._containsTarget && unprocessedNode._targetConnectionName !== node._targetConnectionName)
+          continue;
+        if (unprocessedNode.capacityMeshNodeId === node.capacityMeshNodeId)
+          continue;
+        if (!areNodesBordering(node, unprocessedNode)) continue;
+        adjacentNodes.push(unprocessedNode);
       }
+      node._adjacentNodeIds = adjacentNodes.map((n) => n.capacityMeshNodeId);
     }
-    return result;
   }
-  getResultNodes() {
-    return [...this.multiLayerNodes, ...this.strawNodes, ...this.skippedNodes];
+  // getAdjacentSameLayerUnprocessedNodes1(rootNode: CapacityMeshNode) {
+  //   const adjacentNodes: CapacityMeshNode[] = []
+  //   for (const unprocessedNodeId of this.currentBatchNodeIds) {
+  //     const unprocessedNode = this.nodeMap.get(unprocessedNodeId)!
+  //     if (!areNodesBordering(rootNode, unprocessedNode)) continue
+  //     if (unprocessedNode.availableZ[0] !== rootNode.availableZ[0]) continue
+  //     if (
+  //       unprocessedNode._containsTarget &&
+  //       unprocessedNode._targetConnectionName !== rootNode._targetConnectionName
+  //     )
+  //       continue
+  //     if (this.absorbedNodeIds.has(unprocessedNodeId)) continue
+  //     adjacentNodes.push(unprocessedNode)
+  //   }
+  //   return adjacentNodes
+  // }
+  getAdjacentSameLayerUnprocessedNodes(rootNode) {
+    return this.getAdjacentSameLayerUnprocessedNodes2(rootNode);
+  }
+  getAdjacentSameLayerUnprocessedNodes2(rootNode) {
+    const adjacentNodes = [];
+    const unprocessedAdjNodes = Array.from(
+      new Set(
+        (rootNode._adjacentNodeIds ?? []).map((a) => this.nodeMap.get(a))
+      )
+    );
+    unprocessedAdjNodes.sort((a, b) => a.width * a.height - b.width * b.height);
+    for (const unprocessedNode of unprocessedAdjNodes) {
+      if (this.absorbedNodeIds.has(unprocessedNode.capacityMeshNodeId)) continue;
+      adjacentNodes.push(unprocessedNode);
+    }
+    return adjacentNodes;
   }
   _step() {
-    const rootNode = this.unprocessedNodes.pop();
-    if (!rootNode) {
-      this.solved = true;
-      return;
+    if (!this.hasComputedAdjacentNodeIds) {
+      this.computeAdjacentNodeIdsForFirstBatch(
+        this.currentBatchNodeIds.map((id) => this.nodeMap.get(id))
+      );
+      this.hasComputedAdjacentNodeIds = true;
     }
-    if (rootNode.width < this.strawSize && rootNode.height < this.strawSize) {
-      this.skippedNodes.push(rootNode);
+    let rootNodeId = this.currentBatchNodeIds.pop();
+    while (rootNodeId && this.absorbedNodeIds.has(rootNodeId)) {
+      rootNodeId = this.currentBatchNodeIds.pop();
+    }
+    if (!rootNodeId) {
+      if (this.batchHadModifications) {
+        this.currentBatchNodeIds = this.nextBatchNodeIds.sort((a, b) => {
+          const A = this.nodeMap.get(a);
+          const B = this.nodeMap.get(b);
+          return A.width * A.height - B.width * B.height;
+        });
+        this.nextBatchNodeIds = [];
+        this.batchHadModifications = false;
+        return;
+      }
+      this.solved = true;
+      this.newNodes.push(
+        ...this.nextBatchNodeIds.map((id) => this.nodeMap.get(id))
+      );
       return;
     }
-    if (rootNode._containsTarget) {
-      this.skippedNodes.push(rootNode);
+    const rootNode = this.nodeMap.get(rootNodeId);
+    let rootNodeHasGrown = false;
+    const adjacentNodes = this.getAdjacentSameLayerUnprocessedNodes(rootNode);
+    if (adjacentNodes.length === 0) {
+      this.nextBatchNodeIds.push(rootNodeId);
       return;
     }
-    const strawNodes = this.createStrawsForNode(rootNode);
-    this.strawNodes.push(...strawNodes);
-  }
-  visualize() {
-    const graphics = {
-      rects: [],
-      lines: [],
-      points: [],
-      circles: [],
-      title: "Straw Solver"
+    const absorbAdjacentNodeIds = (nodesToAbsorb) => {
+      for (const adjNode of nodesToAbsorb) {
+        this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
+      }
+      rootNode._adjacentNodeIds = Array.from(
+        new Set(
+          [
+            ...rootNode._adjacentNodeIds ?? [],
+            ...nodesToAbsorb.flatMap((n) => n._adjacentNodeIds ?? [])
+          ].filter((id) => !this.absorbedNodeIds.has(id))
+        )
+      );
     };
-    for (const node of this.unprocessedNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        fill: "rgba(200, 200, 200, 0.5)",
-        stroke: "rgba(0, 0, 0, 0.5)",
-        label: `${node.capacityMeshNodeId}
-Unprocessed
-${node.width}x${node.height}`
-      });
-    }
-    for (const node of this.strawNodes) {
-      const color = node.availableZ[0] === 0 ? "rgba(0, 150, 255, 0.5)" : "rgba(255, 100, 0, 0.5)";
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        fill: color,
-        stroke: "rgba(0, 0, 0, 0.5)",
-        label: `${node.capacityMeshNodeId}
-Layer: ${node.availableZ[0]}
-${node.width}x${node.height}`,
-        layer: `z${node.availableZ.join(",")}`
-      });
-    }
-    for (const node of this.multiLayerNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width * 0.9,
-        height: node.height * 0.9,
-        fill: "rgba(100, 255, 100, 0.5)",
-        stroke: "rgba(0, 0, 0, 0.5)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: `${node.capacityMeshNodeId}
-Layers: ${node.availableZ.join(",")}
-${node.width}x${node.height}`
-      });
-    }
-    return graphics;
-  }
-};
-
-// lib/utils/areNodesBordering.ts
-function areNodesBordering(node1, node2) {
-  const n1Left = node1.center.x - node1.width / 2;
-  const n1Right = node1.center.x + node1.width / 2;
-  const n1Top = node1.center.y - node1.height / 2;
-  const n1Bottom = node1.center.y + node1.height / 2;
-  const n2Left = node2.center.x - node2.width / 2;
-  const n2Right = node2.center.x + node2.width / 2;
-  const n2Top = node2.center.y - node2.height / 2;
-  const n2Bottom = node2.center.y + node2.height / 2;
-  const epsilon = 1e-3;
-  const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
-  const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
-  return shareVerticalBorder || shareHorizontalBorder;
-}
-
-// lib/data-structures/CapacityNodeTree.ts
-var CapacityNodeTree = class {
-  constructor(nodes) {
-    this.nodes = nodes;
-    this.buckets = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      const nodeMinX = node.center.x - node.width / 2;
-      const nodeMinY = node.center.y - node.height / 2;
-      const nodeMaxX = node.center.x + node.width / 2;
-      const nodeMaxY = node.center.y + node.height / 2;
-      for (let x = nodeMinX; x <= nodeMaxX; x += this.CELL_SIZE) {
-        for (let y = nodeMinY; y <= nodeMaxY; y += this.CELL_SIZE) {
-          const bucketKey = this.getBucketKey(x, y);
-          const bucket = this.buckets.get(bucketKey);
-          if (!bucket) {
-            this.buckets.set(bucketKey, [node]);
-          } else {
-            bucket.push(node);
-          }
-        }
-      }
-    }
-  }
-  buckets;
-  CELL_SIZE = 0.4;
-  getBucketKey(x, y) {
-    return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
-  }
-  getNodesInArea(centerX, centerY, width, height) {
-    const nodes = [];
-    const alreadyAddedNodes = /* @__PURE__ */ new Set();
-    const minX = centerX - width / 2;
-    const minY = centerY - height / 2;
-    const maxX = centerX + width / 2;
-    const maxY = centerY + height / 2;
-    for (let x = minX; x <= maxX; x += this.CELL_SIZE) {
-      for (let y = minY; y <= maxY; y += this.CELL_SIZE) {
-        const bucketKey = this.getBucketKey(x, y);
-        const bucket = this.buckets.get(bucketKey) || [];
-        for (const node of bucket) {
-          if (alreadyAddedNodes.has(node.capacityMeshNodeId)) continue;
-          alreadyAddedNodes.add(node.capacityMeshNodeId);
-          nodes.push(node);
-        }
-      }
-    }
-    return nodes;
-  }
-};
-
-// lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
-var EPSILON3 = 5e-3;
-var SingleLayerNodeMergerSolver = class extends BaseSolver {
-  nodeMap;
-  currentBatchNodeIds;
-  absorbedNodeIds;
-  nextBatchNodeIds;
-  batchHadModifications;
-  hasComputedAdjacentNodeIds = false;
-  newNodes;
-  constructor(nodes) {
-    super();
-    this.nodeMap = /* @__PURE__ */ new Map();
-    this.MAX_ITERATIONS = 1e5;
-    for (const node of nodes) {
-      this.nodeMap.set(node.capacityMeshNodeId, node);
-    }
-    this.newNodes = [];
-    this.absorbedNodeIds = /* @__PURE__ */ new Set();
-    const unprocessedNodesWithArea = [];
-    for (const node of nodes) {
-      if (node.availableZ.length > 1) {
-        this.newNodes.push(node);
-        this.absorbedNodeIds.add(node.capacityMeshNodeId);
-      } else {
-        unprocessedNodesWithArea.push([node, node.width * node.height]);
-      }
-    }
-    unprocessedNodesWithArea.sort((a, b) => a[1] - b[1]);
-    for (const [node, area] of unprocessedNodesWithArea) {
-      const unprocessedNode = {
-        ...node,
-        center: { ...node.center }
-      };
-      this.nodeMap.set(node.capacityMeshNodeId, unprocessedNode);
-    }
-    this.currentBatchNodeIds = unprocessedNodesWithArea.map(
-      ([node]) => node.capacityMeshNodeId
-    );
-    this.nextBatchNodeIds = [];
-    this.batchHadModifications = false;
-  }
-  computeAdjacentNodeIdsForFirstBatch(nodes) {
-    const nodeTrees = [
-      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 0)),
-      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 1))
-    ];
-    for (const node of nodes) {
-      const adjacentNodes = [];
-      const z = node.availableZ[0];
-      const nodesInArea = nodeTrees[z].getNodesInArea(
-        node.center.x,
-        node.center.y,
-        node.width * 4,
-        node.height * 4
-      );
-      for (const unprocessedNode of nodesInArea) {
-        if (unprocessedNode._containsTarget && unprocessedNode._targetConnectionName !== node._targetConnectionName)
-          continue;
-        if (unprocessedNode.capacityMeshNodeId === node.capacityMeshNodeId)
-          continue;
-        if (!areNodesBordering(node, unprocessedNode)) continue;
-        adjacentNodes.push(unprocessedNode);
-      }
-      node._adjacentNodeIds = adjacentNodes.map((n) => n.capacityMeshNodeId);
-    }
-  }
-  // getAdjacentSameLayerUnprocessedNodes1(rootNode: CapacityMeshNode) {
-  //   const adjacentNodes: CapacityMeshNode[] = []
-  //   for (const unprocessedNodeId of this.currentBatchNodeIds) {
-  //     const unprocessedNode = this.nodeMap.get(unprocessedNodeId)!
-  //     if (!areNodesBordering(rootNode, unprocessedNode)) continue
-  //     if (unprocessedNode.availableZ[0] !== rootNode.availableZ[0]) continue
-  //     if (
-  //       unprocessedNode._containsTarget &&
-  //       unprocessedNode._targetConnectionName !== rootNode._targetConnectionName
-  //     )
-  //       continue
-  //     if (this.absorbedNodeIds.has(unprocessedNodeId)) continue
-  //     adjacentNodes.push(unprocessedNode)
-  //   }
-  //   return adjacentNodes
-  // }
-  getAdjacentSameLayerUnprocessedNodes(rootNode) {
-    return this.getAdjacentSameLayerUnprocessedNodes2(rootNode);
-  }
-  getAdjacentSameLayerUnprocessedNodes2(rootNode) {
-    const adjacentNodes = [];
-    const unprocessedAdjNodes = Array.from(
-      new Set(
-        (rootNode._adjacentNodeIds ?? []).map((a) => this.nodeMap.get(a))
-      )
-    );
-    unprocessedAdjNodes.sort((a, b) => a.width * a.height - b.width * b.height);
-    for (const unprocessedNode of unprocessedAdjNodes) {
-      if (this.absorbedNodeIds.has(unprocessedNode.capacityMeshNodeId)) continue;
-      adjacentNodes.push(unprocessedNode);
-    }
-    return adjacentNodes;
-  }
-  _step() {
-    if (!this.hasComputedAdjacentNodeIds) {
-      this.computeAdjacentNodeIdsForFirstBatch(
-        this.currentBatchNodeIds.map((id) => this.nodeMap.get(id))
-      );
-      this.hasComputedAdjacentNodeIds = true;
-    }
-    let rootNodeId = this.currentBatchNodeIds.pop();
-    while (rootNodeId && this.absorbedNodeIds.has(rootNodeId)) {
-      rootNodeId = this.currentBatchNodeIds.pop();
-    }
-    if (!rootNodeId) {
-      if (this.batchHadModifications) {
-        this.currentBatchNodeIds = this.nextBatchNodeIds.sort((a, b) => {
-          const A = this.nodeMap.get(a);
-          const B = this.nodeMap.get(b);
-          return A.width * A.height - B.width * B.height;
-        });
-        this.nextBatchNodeIds = [];
-        this.batchHadModifications = false;
-        return;
-      }
-      this.solved = true;
-      this.newNodes.push(
-        ...this.nextBatchNodeIds.map((id) => this.nodeMap.get(id))
-      );
-      return;
-    }
-    const rootNode = this.nodeMap.get(rootNodeId);
-    let rootNodeHasGrown = false;
-    const adjacentNodes = this.getAdjacentSameLayerUnprocessedNodes(rootNode);
-    if (adjacentNodes.length === 0) {
-      this.nextBatchNodeIds.push(rootNodeId);
-      return;
-    }
-    const absorbAdjacentNodeIds = (nodesToAbsorb) => {
-      for (const adjNode of nodesToAbsorb) {
-        this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
-      }
-      rootNode._adjacentNodeIds = Array.from(
-        new Set(
-          [
-            ...rootNode._adjacentNodeIds ?? [],
-            ...nodesToAbsorb.flatMap((n) => n._adjacentNodeIds ?? [])
-          ].filter((id) => !this.absorbedNodeIds.has(id))
-        )
-      );
-    };
-    const adjacentNodesToLeft = adjacentNodes.filter(
-      (adjNode) => adjNode.center.x < rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
-    );
-    if (adjacentNodesToLeft.length > 0) {
-      const { width: leftAdjNodeWidth, height: leftAdjNodeHeight } = adjacentNodesToLeft[0];
-      const leftAdjNodesAreAllSameSize = adjacentNodesToLeft.every(
-        (adjNode) => adjNode.width === leftAdjNodeWidth && adjNode.height === leftAdjNodeHeight
-      );
-      const leftAdjNodesTakeUpEntireHeight = Math.abs(
-        adjacentNodesToLeft.reduce((acc, adjNode) => {
-          return acc + adjNode.height;
-        }, 0) - rootNode.height
-      ) < EPSILON3;
-      if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
-        rootNode.width += leftAdjNodeWidth;
-        rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
-        absorbAdjacentNodeIds(adjacentNodesToLeft);
-        rootNodeHasGrown = true;
-      }
+    const adjacentNodesToLeft = adjacentNodes.filter(
+      (adjNode) => adjNode.center.x < rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
+    );
+    if (adjacentNodesToLeft.length > 0) {
+      const { width: leftAdjNodeWidth, height: leftAdjNodeHeight } = adjacentNodesToLeft[0];
+      const leftAdjNodesAreAllSameSize = adjacentNodesToLeft.every(
+        (adjNode) => adjNode.width === leftAdjNodeWidth && adjNode.height === leftAdjNodeHeight
+      );
+      const leftAdjNodesTakeUpEntireHeight = Math.abs(
+        adjacentNodesToLeft.reduce((acc, adjNode) => {
+          return acc + adjNode.height;
+        }, 0) - rootNode.height
+      ) < EPSILON3;
+      if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
+        rootNode.width += leftAdjNodeWidth;
+        rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
+        absorbAdjacentNodeIds(adjacentNodesToLeft);
+        rootNodeHasGrown = true;
+      }
     }
     const adjacentNodesToRight = adjacentNodes.filter(
       (adjNode) => adjNode.center.x > rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
@@ -7926,13 +8272,13 @@ function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
   if (segmentsIntersect(A1, A2, B1, B2)) {
     return 0;
   }
-  const distA1 = pointToSegmentDistance4(A1, B1, B2);
-  const distA2 = pointToSegmentDistance4(A2, B1, B2);
-  const distB1 = pointToSegmentDistance4(B1, A1, A2);
-  const distB2 = pointToSegmentDistance4(B2, A1, A2);
+  const distA1 = pointToSegmentDistance5(A1, B1, B2);
+  const distA2 = pointToSegmentDistance5(A2, B1, B2);
+  const distB1 = pointToSegmentDistance5(B1, A1, A2);
+  const distB2 = pointToSegmentDistance5(B2, A1, A2);
   return Math.min(distA1, distA2, distB1, distB2);
 }
-function pointToSegmentDistance4(P, Q1, Q2) {
+function pointToSegmentDistance5(P, Q1, Q2) {
   const v = { x: Q2.x - Q1.x, y: Q2.y - Q1.y };
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);
@@ -9110,247 +9456,665 @@ var HighDensityRouteSpatialIndex = class {
         distance: Math.sqrt(data.minDistSq)
       });
     }
-    return results;
+    return results;
+  }
+};
+
+// lib/solvers/UselessViaRemovalSolver/SingleRouteUselessViaRemovalSolver.ts
+var SingleRouteUselessViaRemovalSolver = class extends BaseSolver {
+  obstacleSHI;
+  hdRouteSHI;
+  unsimplifiedRoute;
+  routeSections;
+  currentSectionIndex;
+  TRACE_THICKNESS = 0.15;
+  OBSTACLE_MARGIN = 0.1;
+  constructor(params) {
+    super();
+    this.currentSectionIndex = 1;
+    this.obstacleSHI = params.obstacleSHI;
+    this.hdRouteSHI = params.hdRouteSHI;
+    this.unsimplifiedRoute = params.unsimplifiedRoute;
+    this.routeSections = this.breakRouteIntoSections(this.unsimplifiedRoute);
+  }
+  breakRouteIntoSections(route) {
+    const routeSections = [];
+    const routePoints = route.route;
+    if (routePoints.length === 0) return [];
+    let currentSection = {
+      startIndex: 0,
+      endIndex: -1,
+      z: routePoints[0].z,
+      points: [routePoints[0]]
+    };
+    for (let i = 1; i < routePoints.length; i++) {
+      if (routePoints[i].z === currentSection.z) {
+        currentSection.points.push(routePoints[i]);
+      } else {
+        currentSection.endIndex = i - 1;
+        routeSections.push(currentSection);
+        currentSection = {
+          startIndex: i,
+          endIndex: -1,
+          z: routePoints[i].z,
+          points: [routePoints[i]]
+        };
+      }
+    }
+    currentSection.endIndex = routePoints.length - 1;
+    routeSections.push(currentSection);
+    return routeSections;
+  }
+  _step() {
+    if (this.currentSectionIndex >= this.routeSections.length - 1) {
+      this.solved = true;
+      return;
+    }
+    const prevSection = this.routeSections[this.currentSectionIndex - 1];
+    const currentSection = this.routeSections[this.currentSectionIndex];
+    const nextSection = this.routeSections[this.currentSectionIndex + 1];
+    if (prevSection.z !== nextSection.z) {
+      this.currentSectionIndex++;
+      return;
+    }
+    const targetZ = prevSection.z;
+    if (this.canSectionMoveToLayer({ currentSection, targetZ })) {
+      currentSection.z = targetZ;
+      currentSection.points = currentSection.points.map((p) => ({
+        ...p,
+        z: targetZ
+      }));
+      this.currentSectionIndex += 2;
+      return;
+    }
+    this.currentSectionIndex++;
+    return;
+  }
+  canSectionMoveToLayer({
+    currentSection,
+    targetZ
+  }) {
+    for (let i = 0; i < currentSection.points.length - 1; i++) {
+      const A = { ...currentSection.points[i], z: targetZ };
+      const B = { ...currentSection.points[i + 1], z: targetZ };
+      const conflictingRoutes = this.hdRouteSHI.getConflictingRoutesForSegment(
+        A,
+        B,
+        this.TRACE_THICKNESS
+      );
+      for (const { conflictingRoute, distance: distance6 } of conflictingRoutes) {
+        if (conflictingRoute.connectionName === this.unsimplifiedRoute.connectionName)
+          continue;
+        if (distance6 < this.TRACE_THICKNESS + conflictingRoute.traceThickness) {
+          return false;
+        }
+      }
+      const segmentBox = {
+        centerX: (A.x + B.x) / 2,
+        centerY: (A.y + B.y) / 2,
+        width: Math.abs(A.x - B.x),
+        height: Math.abs(A.y - B.y)
+      };
+      const obstacles = this.obstacleSHI.getNodesInArea(
+        segmentBox.centerX,
+        segmentBox.centerY,
+        segmentBox.width + (this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) * 2,
+        // Expand search width
+        segmentBox.height + (this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) * 2
+        // Expand search height
+      );
+      for (const obstacle of obstacles) {
+        const distToObstacle = segmentToBoxMinDistance(A, B, obstacle);
+        if (distToObstacle < this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  getConstructorParams() {
+    return {
+      obstacleSHI: this.obstacleSHI,
+      hdRouteSHI: this.hdRouteSHI,
+      unsimplifiedRoute: this.unsimplifiedRoute
+    };
+  }
+  getOptimizedHdRoute() {
+    const route = this.routeSections.flatMap((section) => section.points);
+    const vias = [];
+    for (let i = 0; i < route.length - 1; i++) {
+      if (route[i].z !== route[i + 1].z) {
+        vias.push({
+          x: route[i].x,
+          y: route[i].y
+        });
+      }
+    }
+    return {
+      connectionName: this.unsimplifiedRoute.connectionName,
+      route,
+      traceThickness: this.unsimplifiedRoute.traceThickness,
+      vias,
+      viaDiameter: this.unsimplifiedRoute.viaDiameter
+    };
+  }
+  visualize() {
+    const graphics = {
+      circles: [],
+      lines: [],
+      points: [],
+      rects: [],
+      coordinateSystem: "cartesian",
+      title: "Single Route Useless Via Removal Solver"
+    };
+    for (let i = 0; i < this.routeSections.length; i++) {
+      const section = this.routeSections[i];
+      graphics.lines.push({
+        points: section.points,
+        strokeWidth: this.TRACE_THICKNESS,
+        strokeColor: i === this.currentSectionIndex ? "orange" : section.z === 0 ? "red" : "blue"
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/UselessViaRemovalSolver/UselessViaRemovalSolver.ts
+var UselessViaRemovalSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.unsimplifiedHdRoutes = input.unsimplifiedHdRoutes;
+    this.optimizedHdRoutes = [];
+    this.unprocessedRoutes = [...input.unsimplifiedHdRoutes];
+    this.obstacleSHI = new ObstacleSpatialHashIndex(input.obstacles);
+    this.hdRouteSHI = new HighDensityRouteSpatialIndex(
+      this.unsimplifiedHdRoutes
+    );
+  }
+  unsimplifiedHdRoutes;
+  optimizedHdRoutes;
+  unprocessedRoutes;
+  activeSubSolver = null;
+  obstacleSHI = null;
+  hdRouteSHI = null;
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        this.optimizedHdRoutes.push(this.activeSubSolver.getOptimizedHdRoute());
+        this.activeSubSolver = null;
+      } else if (this.activeSubSolver.failed || this.activeSubSolver.error) {
+        this.error = this.activeSubSolver.error;
+        this.failed = true;
+      }
+      return;
+    }
+    const unprocessedRoute = this.unprocessedRoutes.shift();
+    if (!unprocessedRoute) {
+      this.solved = true;
+      return;
+    }
+    this.activeSubSolver = new SingleRouteUselessViaRemovalSolver({
+      hdRouteSHI: this.hdRouteSHI,
+      obstacleSHI: this.obstacleSHI,
+      unsimplifiedRoute: unprocessedRoute
+    });
+  }
+  getOptimizedHdRoutes() {
+    return this.optimizedHdRoutes;
+  }
+  visualize() {
+    const visualization = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Useless Via Removal Solver"
+    };
+    for (const obstacle of this.input.obstacles) {
+      let fillColor = "rgba(128, 128, 128, 0.2)";
+      const strokeColor = "rgba(128, 128, 128, 0.5)";
+      const isOnLayer0 = obstacle.zLayers?.includes(0);
+      const isOnLayer1 = obstacle.zLayers?.includes(1);
+      if (isOnLayer0 && isOnLayer1) {
+        fillColor = "rgba(128, 0, 128, 0.2)";
+      } else if (isOnLayer0) {
+        fillColor = "rgba(255, 0, 0, 0.2)";
+      } else if (isOnLayer1) {
+        fillColor = "rgba(0, 0, 255, 0.2)";
+      }
+      visualization.rects.push({
+        center: obstacle.center,
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: fillColor,
+        label: `Obstacle (Z: ${obstacle.zLayers?.join(", ")})`
+      });
+    }
+    for (const route of this.optimizedHdRoutes) {
+      if (route.route.length === 0) continue;
+      const color = this.input.colorMap[route.connectionName] || "#888888";
+      for (let i = 0; i < route.route.length - 1; i++) {
+        const current = route.route[i];
+        const next = route.route[i + 1];
+        if (current.z === next.z) {
+          visualization.lines.push({
+            points: [
+              { x: current.x, y: current.y },
+              { x: next.x, y: next.y }
+            ],
+            strokeColor: current.z === 0 ? "red" : "blue",
+            strokeWidth: route.traceThickness,
+            label: `${route.connectionName} (z=${current.z})`
+          });
+        }
+      }
+      for (const via of route.vias) {
+        visualization.circles.push({
+          center: { x: via.x, y: via.y },
+          radius: route.viaDiameter / 2,
+          fill: "rgba(255, 0, 255, 0.5)",
+          label: `${route.connectionName} via`
+        });
+      }
+    }
+    if (this.activeSubSolver) {
+      visualization.lines.push(
+        ...this.activeSubSolver.visualize().lines ?? []
+      );
+    }
+    return visualization;
+  }
+};
+
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts
+var CapacityPathingSolver = class extends BaseSolver {
+  connectionsWithNodes;
+  usedNodeCapacityMap;
+  simpleRouteJson;
+  nodes;
+  edges;
+  GREEDY_MULTIPLIER = 1.1;
+  nodeMap;
+  nodeEdgeMap;
+  connectionNameToGoalNodeIds;
+  colorMap;
+  maxDepthOfNodes;
+  activeCandidateStraightLineDistance;
+  debug_lastNodeCostMap;
+  hyperParameters;
+  constructor({
+    simpleRouteJson,
+    nodes,
+    edges,
+    colorMap,
+    MAX_ITERATIONS = 1e6,
+    hyperParameters = {}
+  }) {
+    super();
+    this.MAX_ITERATIONS = MAX_ITERATIONS;
+    this.simpleRouteJson = simpleRouteJson;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.colorMap = colorMap ?? {};
+    const { connectionsWithNodes, connectionNameToGoalNodeIds } = this.getConnectionsWithNodes();
+    this.connectionsWithNodes = connectionsWithNodes;
+    this.connectionNameToGoalNodeIds = connectionNameToGoalNodeIds;
+    this.hyperParameters = hyperParameters;
+    this.usedNodeCapacityMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, 0])
+    );
+    this.nodeMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, node])
+    );
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
+    this.maxDepthOfNodes = Math.max(
+      ...this.nodes.map((node) => node._depth ?? 0)
+    );
+    this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
+  }
+  getTotalCapacity(node) {
+    const depth = node._depth ?? 0;
+    return (this.maxDepthOfNodes - depth + 1) ** 2;
+  }
+  getConnectionsWithNodes() {
+    const connectionsWithNodes = [];
+    const nodesWithTargets = this.nodes.filter((node) => node._containsTarget);
+    const connectionNameToGoalNodeIds = /* @__PURE__ */ new Map();
+    for (const connection of this.simpleRouteJson.connections) {
+      const nodesForConnection = [];
+      for (const point of connection.pointsToConnect) {
+        let closestNode = this.nodes[0];
+        let minDistance = Number.MAX_VALUE;
+        for (const node of nodesWithTargets) {
+          const distance6 = Math.sqrt(
+            (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
+          );
+          if (distance6 < minDistance) {
+            minDistance = distance6;
+            closestNode = node;
+          }
+        }
+        nodesForConnection.push(closestNode);
+      }
+      if (nodesForConnection.length < 2) {
+        throw new Error(
+          `Not enough nodes for connection "${connection.name}", only ${nodesForConnection.length} found`
+        );
+      }
+      connectionNameToGoalNodeIds.set(
+        connection.name,
+        nodesForConnection.map((n) => n.capacityMeshNodeId)
+      );
+      connectionsWithNodes.push({
+        connection,
+        nodes: nodesForConnection,
+        pathFound: false,
+        straightLineDistance: distance(
+          nodesForConnection[0].center,
+          nodesForConnection[nodesForConnection.length - 1].center
+        )
+      });
+    }
+    connectionsWithNodes.sort(
+      (a, b) => a.straightLineDistance - b.straightLineDistance
+    );
+    return { connectionsWithNodes, connectionNameToGoalNodeIds };
   }
-};
-
-// lib/solvers/UselessViaRemovalSolver/SingleRouteUselessViaRemovalSolver.ts
-var SingleRouteUselessViaRemovalSolver = class extends BaseSolver {
-  obstacleSHI;
-  hdRouteSHI;
-  unsimplifiedRoute;
-  routeSections;
-  currentSectionIndex;
-  TRACE_THICKNESS = 0.15;
-  OBSTACLE_MARGIN = 0.1;
-  constructor(params) {
-    super();
-    this.currentSectionIndex = 1;
-    this.obstacleSHI = params.obstacleSHI;
-    this.hdRouteSHI = params.hdRouteSHI;
-    this.unsimplifiedRoute = params.unsimplifiedRoute;
-    this.routeSections = this.breakRouteIntoSections(this.unsimplifiedRoute);
+  currentConnectionIndex = 0;
+  candidates;
+  visitedNodes;
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node);
   }
-  breakRouteIntoSections(route) {
-    const routeSections = [];
-    const routePoints = route.route;
-    if (routePoints.length === 0) return [];
-    let currentSection = {
-      startIndex: 0,
-      endIndex: -1,
-      z: routePoints[0].z,
-      points: [routePoints[0]]
-    };
-    for (let i = 1; i < routePoints.length; i++) {
-      if (routePoints[i].z === currentSection.z) {
-        currentSection.points.push(routePoints[i]);
-      } else {
-        currentSection.endIndex = i - 1;
-        routeSections.push(currentSection);
-        currentSection = {
-          startIndex: i,
-          endIndex: -1,
-          z: routePoints[i].z,
-          points: [routePoints[i]]
-        };
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal);
+  }
+  getBacktrackedPath(candidate) {
+    const path = [];
+    let currentCandidate = candidate;
+    while (currentCandidate) {
+      path.push(currentCandidate.node);
+      currentCandidate = currentCandidate.prevCandidate;
+    }
+    return path;
+  }
+  getNeighboringNodes(node) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap(
+      (edge) => edge.nodeIds.filter((n) => n !== node.capacityMeshNodeId)
+    ).map((n) => this.nodeMap.get(n));
+  }
+  getCapacityPaths() {
+    const capacityPaths = [];
+    for (const connection of this.connectionsWithNodes) {
+      const path = connection.path;
+      if (path) {
+        capacityPaths.push({
+          capacityPathId: connection.connection.name,
+          connectionName: connection.connection.name,
+          nodeIds: path.map((node) => node.capacityMeshNodeId)
+        });
       }
     }
-    currentSection.endIndex = routePoints.length - 1;
-    routeSections.push(currentSection);
-    return routeSections;
+    return capacityPaths;
+  }
+  doesNodeHaveCapacityForTrace(node, prevNode) {
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const totalCapacity = this.getTotalCapacity(node);
+    if (node.availableZ.length === 1 && !node._containsTarget && usedCapacity > 0)
+      return false;
+    let additionalCapacityRequirement = 0;
+    if (node.availableZ.length > 1 && prevNode.availableZ.length === 1) {
+      additionalCapacityRequirement += 0.5;
+    }
+    return usedCapacity + additionalCapacityRequirement < totalCapacity;
+  }
+  canTravelThroughObstacle(node, connectionName) {
+    const goalNodeIds = this.connectionNameToGoalNodeIds.get(connectionName);
+    return goalNodeIds?.includes(node.capacityMeshNodeId) ?? false;
+  }
+  getDistanceBetweenNodes(A, B) {
+    return Math.sqrt(
+      (A.center.x - B.center.x) ** 2 + (A.center.y - B.center.y) ** 2
+    );
+  }
+  reduceCapacityAlongPath(nextConnection) {
+    for (const node of nextConnection.path ?? []) {
+      this.usedNodeCapacityMap.set(
+        node.capacityMeshNodeId,
+        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) + 1
+      );
+    }
+  }
+  isConnectedToEndGoal(node, endGoal) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).some((edge) => edge.nodeIds.includes(endGoal.capacityMeshNodeId));
   }
   _step() {
-    if (this.currentSectionIndex >= this.routeSections.length - 1) {
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (!nextConnection) {
       this.solved = true;
       return;
     }
-    const prevSection = this.routeSections[this.currentSectionIndex - 1];
-    const currentSection = this.routeSections[this.currentSectionIndex];
-    const nextSection = this.routeSections[this.currentSectionIndex + 1];
-    if (prevSection.z !== nextSection.z) {
-      this.currentSectionIndex++;
+    const [start, end] = nextConnection.nodes;
+    if (!this.candidates) {
+      this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }];
+      this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
+      this.visitedNodes = /* @__PURE__ */ new Set([start.capacityMeshNodeId]);
+      this.activeCandidateStraightLineDistance = distance(
+        start.center,
+        end.center
+      );
+    }
+    this.candidates.sort((a, b) => a.f - b.f);
+    const currentCandidate = this.candidates.shift();
+    if (!currentCandidate) {
+      console.error(
+        `Ran out of candidates on connection ${nextConnection.connection.name}`
+      );
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
+      this.failed = true;
       return;
     }
-    const targetZ = prevSection.z;
-    if (this.canSectionMoveToLayer({ currentSection, targetZ })) {
-      currentSection.z = targetZ;
-      currentSection.points = currentSection.points.map((p) => ({
-        ...p,
-        z: targetZ
-      }));
-      this.currentSectionIndex += 2;
+    if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
+      nextConnection.path = this.getBacktrackedPath({
+        prevCandidate: currentCandidate,
+        node: end,
+        f: 0,
+        g: 0,
+        h: 0
+      });
+      this.reduceCapacityAlongPath(nextConnection);
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
       return;
     }
-    this.currentSectionIndex++;
-    return;
-  }
-  canSectionMoveToLayer({
-    currentSection,
-    targetZ
-  }) {
-    for (let i = 0; i < currentSection.points.length - 1; i++) {
-      const A = { ...currentSection.points[i], z: targetZ };
-      const B = { ...currentSection.points[i + 1], z: targetZ };
-      const conflictingRoutes = this.hdRouteSHI.getConflictingRoutesForSegment(
-        A,
-        B,
-        this.TRACE_THICKNESS
-      );
-      for (const { conflictingRoute, distance: distance6 } of conflictingRoutes) {
-        if (conflictingRoute.connectionName === this.unsimplifiedRoute.connectionName)
-          continue;
-        if (distance6 < this.TRACE_THICKNESS + conflictingRoute.traceThickness) {
-          return false;
-        }
+    const neighborNodes = this.getNeighboringNodes(currentCandidate.node);
+    for (const neighborNode of neighborNodes) {
+      if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
+        continue;
       }
-      const segmentBox = {
-        centerX: (A.x + B.x) / 2,
-        centerY: (A.y + B.y) / 2,
-        width: Math.abs(A.x - B.x),
-        height: Math.abs(A.y - B.y)
-      };
-      const obstacles = this.obstacleSHI.getNodesInArea(
-        segmentBox.centerX,
-        segmentBox.centerY,
-        segmentBox.width,
-        segmentBox.height
-      );
-      for (const obstacle of obstacles) {
-        const distToObstacle = segmentToBoxMinDistance(A, B, obstacle);
-        if (distToObstacle < this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) {
-          return false;
-        }
+      if (!this.doesNodeHaveCapacityForTrace(neighborNode, currentCandidate.node)) {
+        continue;
       }
-    }
-    return true;
-  }
-  getOptimizedHdRoute() {
-    const route = this.routeSections.flatMap((section) => section.points);
-    const vias = [];
-    for (let i = 0; i < route.length - 1; i++) {
-      if (route[i].z !== route[i + 1].z) {
-        vias.push({
-          x: route[i].x,
-          y: route[i].y
-        });
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      if (neighborNode._containsObstacle && !this.canTravelThroughObstacle(neighborNode, connectionName)) {
+        continue;
       }
+      const g = this.computeG(currentCandidate, neighborNode, end);
+      const h = this.computeH(currentCandidate, neighborNode, end);
+      const f = g + h * this.GREEDY_MULTIPLIER;
+      this.debug_lastNodeCostMap.set(neighborNode.capacityMeshNodeId, {
+        f,
+        g,
+        h
+      });
+      const newCandidate = {
+        prevCandidate: currentCandidate,
+        node: neighborNode,
+        f,
+        g,
+        h
+      };
+      this.candidates.push(newCandidate);
     }
-    return {
-      connectionName: this.unsimplifiedRoute.connectionName,
-      route,
-      traceThickness: this.unsimplifiedRoute.traceThickness,
-      vias,
-      viaDiameter: this.unsimplifiedRoute.viaDiameter
-    };
+    this.visitedNodes.add(currentCandidate.node.capacityMeshNodeId);
   }
   visualize() {
     const graphics = {
-      circles: [],
       lines: [],
       points: [],
       rects: [],
-      coordinateSystem: "cartesian",
-      title: "Single Route Useless Via Removal Solver"
+      circles: []
     };
-    for (let i = 0; i < this.routeSections.length; i++) {
-      const section = this.routeSections[i];
+    if (this.connectionsWithNodes) {
+      for (let i = 0; i < this.connectionsWithNodes.length; i++) {
+        const conn = this.connectionsWithNodes[i];
+        if (conn.path && conn.path.length > 0) {
+          const pathPoints = conn.path.map(
+            ({ center: { x, y }, width, availableZ }) => ({
+              // slight offset to allow viewing overlapping paths
+              x: x + (i % 10 + i % 19) * (5e-3 * width),
+              y: y + (i % 10 + i % 19) * (5e-3 * width),
+              availableZ
+            })
+          );
+          graphics.lines.push({
+            points: pathPoints,
+            strokeColor: this.colorMap[conn.connection.name]
+          });
+          for (let u = 0; u < pathPoints.length; u++) {
+            const point = pathPoints[u];
+            graphics.points.push({
+              x: point.x,
+              y: point.y,
+              label: [
+                `conn: ${conn.connection.name}`,
+                `node: ${conn.path[u].capacityMeshNodeId}`,
+                `z: ${point.availableZ.join(",")}`
+              ].join("\n")
+            });
+          }
+        }
+      }
+    }
+    for (const node of this.nodes) {
+      const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+      const totalCapacity = this.getTotalCapacity(node);
+      const nodeCosts = this.debug_lastNodeCostMap.get(node.capacityMeshNodeId);
+      graphics.rects.push({
+        ...createRectFromCapacityNode(node, {
+          rectMargin: 0.025,
+          zOffset: 0.01
+        }),
+        label: [
+          `${node.capacityMeshNodeId}`,
+          `${usedCapacity}/${totalCapacity}`,
+          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+          `g: ${nodeCosts?.g !== void 0 ? nodeCosts.g.toFixed(2) : "?"}`,
+          `h: ${nodeCosts?.h !== void 0 ? nodeCosts.h.toFixed(2) : "?"}`,
+          `f: ${nodeCosts?.f !== void 0 ? nodeCosts.f.toFixed(2) : "?"}`,
+          `z: ${node.availableZ.join(", ")}`
+        ].join("\n"),
+        stroke: usedCapacity > totalCapacity + 0.5 ? "red" : void 0
+      });
+    }
+    if (this.connectionsWithNodes) {
+      for (const conn of this.connectionsWithNodes) {
+        if (conn.connection?.pointsToConnect) {
+          for (const point of conn.connection.pointsToConnect) {
+            graphics.points.push({
+              x: point.x,
+              y: point.y,
+              label: [`pointsToConnect ${conn.connection.name}`].join("\n")
+            });
+          }
+        }
+      }
+    }
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (nextConnection) {
+      const [start, end] = nextConnection.connection.pointsToConnect;
       graphics.lines.push({
-        points: section.points,
-        strokeWidth: this.TRACE_THICKNESS,
-        strokeColor: i === this.currentSectionIndex ? "orange" : section.z === 0 ? "red" : "blue"
+        points: [
+          { x: start.x, y: start.y },
+          { x: end.x, y: end.y }
+        ],
+        strokeColor: "red",
+        strokeDash: "10 5"
+      });
+    }
+    if (this.candidates) {
+      const topCandidates = this.candidates.slice(0, 5);
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      topCandidates.forEach((candidate, index) => {
+        const opacity = 0.5 * (1 - index / 5);
+        const backtrackedPath = this.getBacktrackedPath(candidate);
+        graphics.lines.push({
+          points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
+          strokeColor: safeTransparentize(
+            this.colorMap[connectionName] ?? "red",
+            1 - opacity
+          )
+        });
       });
     }
     return graphics;
   }
 };
 
-// lib/solvers/UselessViaRemovalSolver/UselessViaRemovalSolver.ts
-var UselessViaRemovalSolver = class extends BaseSolver {
-  constructor(input) {
-    super();
-    this.input = input;
-    this.unsimplifiedHdRoutes = input.unsimplifiedHdRoutes;
-    this.optimizedHdRoutes = [];
-    this.unprocessedRoutes = [...input.unsimplifiedHdRoutes];
-    this.obstacleSHI = new ObstacleSpatialHashIndex(input.obstacles);
-    this.hdRouteSHI = new HighDensityRouteSpatialIndex(
-      this.unsimplifiedHdRoutes
-    );
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver5.ts
+var CapacityPathingSolver5 = class extends CapacityPathingSolver {
+  NEGATIVE_CAPACITY_PENALTY_FACTOR = 1;
+  REDUCED_CAPACITY_PENALTY_FACTOR = 1;
+  constructor(...args) {
+    super(...args);
+    this.GREEDY_MULTIPLIER = 2.5;
   }
-  unsimplifiedHdRoutes;
-  optimizedHdRoutes;
-  unprocessedRoutes;
-  activeSubSolver = null;
-  obstacleSHI = null;
-  hdRouteSHI = null;
-  _step() {
-    if (this.activeSubSolver) {
-      this.activeSubSolver.step();
-      if (this.activeSubSolver.solved) {
-        this.optimizedHdRoutes.push(this.activeSubSolver.getOptimizedHdRoute());
-        this.activeSubSolver = null;
-      } else if (this.activeSubSolver.failed || this.activeSubSolver.error) {
-        this.error = this.activeSubSolver.error;
-        this.failed = true;
-      }
-      return;
-    }
-    const unprocessedRoute = this.unprocessedRoutes.shift();
-    if (!unprocessedRoute) {
-      this.solved = true;
-      return;
-    }
-    this.activeSubSolver = new SingleRouteUselessViaRemovalSolver({
-      hdRouteSHI: this.hdRouteSHI,
-      obstacleSHI: this.obstacleSHI,
-      unsimplifiedRoute: unprocessedRoute
-    });
+  get maxCapacityFactor() {
+    return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1;
   }
-  getOptimizedHdRoutes() {
-    return this.optimizedHdRoutes;
+  getTotalCapacity(node) {
+    return getTunedTotalCapacity1(node, this.maxCapacityFactor);
   }
-  visualize() {
-    const visualization = {
-      lines: [],
-      points: [],
-      rects: [],
-      circles: [],
-      coordinateSystem: "cartesian",
-      title: "Useless Via Removal Solver"
-    };
-    for (const route of this.optimizedHdRoutes) {
-      if (route.route.length === 0) continue;
-      const color = this.input.colorMap[route.connectionName] || "#888888";
-      for (let i = 0; i < route.route.length - 1; i++) {
-        const current = route.route[i];
-        const next = route.route[i + 1];
-        if (current.z === next.z) {
-          visualization.lines.push({
-            points: [
-              { x: current.x, y: current.y },
-              { x: next.x, y: next.y }
-            ],
-            strokeColor: current.z === 0 ? "red" : "blue",
-            strokeWidth: route.traceThickness,
-            label: `${route.connectionName} (z=${current.z})`
-          });
-        }
-      }
-      for (const via of route.vias) {
-        visualization.circles.push({
-          center: { x: via.x, y: via.y },
-          radius: route.viaDiameter / 2,
-          fill: "rgba(255, 0, 255, 0.5)",
-          label: `${route.connectionName} via`
-        });
-      }
-    }
-    if (this.activeSubSolver) {
-      visualization.lines.push(
-        ...this.activeSubSolver.visualize().lines ?? []
-      );
+  /**
+   * Penalty you pay for using this node
+   */
+  getNodeCapacityPenalty(node) {
+    const MAX_PENALTY = node.width + node.height;
+    const MIN_PENALTY = 0.05;
+    const START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW = 2;
+    const totalCapacity = this.getTotalCapacity(node);
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const remainingCapacity = totalCapacity - usedCapacity;
+    if (remainingCapacity > START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW) {
+      return MIN_PENALTY;
     }
-    return visualization;
+    const penalty = (MAX_PENALTY - MIN_PENALTY) * Math.max(
+      1,
+      (START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW - remainingCapacity) / (MAX_PENALTY - MIN_PENALTY)
+    ) + MIN_PENALTY;
+    return penalty;
+  }
+  /**
+   * We're rewarding travel into big nodes.
+   *
+   * To minimize shortest path, you'd want to comment this out.
+   */
+  getDistanceBetweenNodes(A, B) {
+    const dx = A.center.x - B.center.x;
+    const dy = A.center.y - B.center.y;
+    return Math.sqrt(dx ** 2 + dy ** 2);
+  }
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
+  }
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
   }
 };
 
@@ -9390,6 +10154,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   nodeTargetMerger;
   edgeSolver;
   pathingSolver;
+  // Updated type
   edgeToPortSegmentSolver;
   colorMap;
   segmentToPointSolver;
@@ -9399,8 +10164,10 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   highDensityStitchSolver;
   singleLayerNodeMerger;
   strawSolver;
-  uselessViaRemovalSolver;
-  multiSimplifiedPathSolver;
+  uselessViaRemovalSolver1;
+  uselessViaRemovalSolver2;
+  multiSimplifiedPathSolver1;
+  multiSimplifiedPathSolver2;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -9473,17 +10240,23 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       CapacityMeshEdgeSolver2_NodeTreeOptimization,
       (cms) => [cms.capacityNodes]
     ),
-    definePipelineStep("pathingSolver", CapacityPathingSolver5, (cms) => [
-      {
-        simpleRouteJson: cms.srjWithPointPairs,
-        nodes: cms.capacityNodes,
-        edges: cms.edgeSolver?.edges || [],
-        colorMap: cms.colorMap,
-        hyperParameters: {
-          MAX_CAPACITY_FACTOR: 1
+    definePipelineStep(
+      "pathingSolver",
+      CapacityPathingSolver5,
+      // CapacityPathingMultiSectionSolver,
+      (cms) => [
+        // Replaced solver class
+        {
+          simpleRouteJson: cms.srjWithPointPairs,
+          nodes: cms.capacityNodes,
+          edges: cms.edgeSolver?.edges || [],
+          colorMap: cms.colorMap,
+          hyperParameters: {
+            MAX_CAPACITY_FACTOR: 1
+          }
         }
-      }
-    ]),
+      ]
+    ),
     definePipelineStep(
       "edgeToPortSegmentSolver",
       CapacityEdgeToPortSegmentSolver,
@@ -9551,12 +10324,13 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         {
           connections: cms.srjWithPointPairs.connections,
           hdRoutes: cms.highDensityRouteSolver.routes,
+          colorMap: cms.colorMap,
           layerCount: cms.srj.layerCount
         }
       ]
     ),
     definePipelineStep(
-      "uselessViaRemovalSolver",
+      "uselessViaRemovalSolver1",
       UselessViaRemovalSolver,
       (cms) => [
         {
@@ -9568,11 +10342,35 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       ]
     ),
     definePipelineStep(
-      "multiSimplifiedPathSolver",
+      "multiSimplifiedPathSolver1",
+      MultiSimplifiedPathSolver,
+      (cms) => [
+        {
+          unsimplifiedHdRoutes: cms.uselessViaRemovalSolver1?.getOptimizedHdRoutes() || cms.highDensityStitchSolver.mergedHdRoutes,
+          obstacles: cms.srj.obstacles,
+          connMap: cms.connMap,
+          colorMap: cms.colorMap
+        }
+      ]
+    ),
+    definePipelineStep(
+      "uselessViaRemovalSolver2",
+      UselessViaRemovalSolver,
+      (cms) => [
+        {
+          unsimplifiedHdRoutes: cms.multiSimplifiedPathSolver1.simplifiedHdRoutes,
+          obstacles: cms.srj.obstacles,
+          colorMap: cms.colorMap,
+          layerCount: cms.srj.layerCount
+        }
+      ]
+    ),
+    definePipelineStep(
+      "multiSimplifiedPathSolver2",
       MultiSimplifiedPathSolver,
       (cms) => [
         {
-          unsimplifiedHdRoutes: cms.uselessViaRemovalSolver?.getOptimizedHdRoutes() || cms.highDensityStitchSolver.mergedHdRoutes,
+          unsimplifiedHdRoutes: cms.uselessViaRemovalSolver2?.getOptimizedHdRoutes(),
           obstacles: cms.srj.obstacles,
           connMap: cms.connMap,
           colorMap: cms.colorMap
@@ -9631,8 +10429,10 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     const segmentOptimizationViz = this.unravelMultiSectionSolver?.visualize() ?? this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
     const highDensityStitchViz = this.highDensityStitchSolver?.visualize();
-    const uselessViaRemovalViz = this.uselessViaRemovalSolver?.visualize();
-    const simplifiedPathSolverViz = this.multiSimplifiedPathSolver?.visualize();
+    const uselessViaRemovalViz1 = this.uselessViaRemovalSolver1?.visualize();
+    const uselessViaRemovalViz2 = this.uselessViaRemovalSolver2?.visualize();
+    const simplifiedPathSolverViz1 = this.multiSimplifiedPathSolver1?.visualize();
+    const simplifiedPathSolverViz2 = this.multiSimplifiedPathSolver2?.visualize();
     const problemViz = {
       points: [
         ...this.srj.connections.flatMap(
@@ -9684,8 +10484,10 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       segmentOptimizationViz,
       highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null,
       highDensityStitchViz,
-      uselessViaRemovalViz,
-      simplifiedPathSolverViz,
+      uselessViaRemovalViz1,
+      simplifiedPathSolverViz1,
+      uselessViaRemovalViz2,
+      simplifiedPathSolverViz2,
       this.solved ? combineVisualizations(
         problemViz,
         convertSrjToGraphicsObject(this.getOutputSimpleRouteJson())
@@ -9747,7 +10549,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     return match ? match[1] : mstConnectionName;
   }
   _getOutputHdRoutes() {
-    return this.multiSimplifiedPathSolver?.simplifiedHdRoutes ?? this.uselessViaRemovalSolver?.getOptimizedHdRoutes() ?? this.highDensityStitchSolver.mergedHdRoutes;
+    return this.multiSimplifiedPathSolver2?.simplifiedHdRoutes ?? this.uselessViaRemovalSolver2?.getOptimizedHdRoutes() ?? this.multiSimplifiedPathSolver1?.simplifiedHdRoutes ?? this.uselessViaRemovalSolver1?.getOptimizedHdRoutes() ?? this.highDensityStitchSolver.mergedHdRoutes;
   }
   /**
    * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
@@ -9759,9 +10561,9 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     const traces = [];
     const allHdRoutes = this._getOutputHdRoutes();
     for (const connection of this.netToPointPairsSolver?.newConnections ?? []) {
-      const netConnection = this.srj.connections.find(
-        (c) => c.name === connection.netConnectionName
-      );
+      const netConnectionName = this.srj.connections.find(
+        (c) => c.name === connection.name
+      )?.netConnectionName;
       const hdRoutes = allHdRoutes.filter(
         (r) => r.connectionName === connection.name
       );
@@ -9770,7 +10572,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         const simplifiedPcbTrace = {
           type: "pcb_trace",
           pcb_trace_id: `${connection.name}_${i}`,
-          connection_name: this.getOriginalConnectionName(connection.name),
+          connection_name: netConnectionName ?? this.getOriginalConnectionName(connection.name),
           route: convertHdRouteToSimplifiedRoute(hdRoute, this.srj.layerCount)
         };
         traces.push(simplifiedPcbTrace);