@tscircuit/capacity-autorouter 0.0.26 → 0.0.28

package/dist/index.js

@@ -1434,6 +1434,7 @@ var CapacityMeshNodeSolver2_NodeUnderObstacle = class extends CapacityMeshNodeSo
     this.srj = srj;
     this.opts = opts;
   }
+  VIA_DIAMETER = 0.6;
   isNodeCompletelyOutsideBounds(node) {
     return node.center.x + node.width / 2 < this.srj.bounds.minX || node.center.x - node.width / 2 > this.srj.bounds.maxX || node.center.y + node.height / 2 < this.srj.bounds.minY || node.center.y - node.height / 2 > this.srj.bounds.maxY;
   }
@@ -1538,10 +1539,10 @@ var CapacityMeshNodeSolver2_NodeUnderObstacle = class extends CapacityMeshNodeSo
     const unfinishedNewNodes = [];
     for (const childNode of childNodes) {
       const shouldBeXYSubdivided = this.shouldNodeBeXYSubdivided(childNode);
-      const shouldBeZSubdivided = childNode.availableZ.length > 1 && !shouldBeXYSubdivided && childNode._containsObstacle;
+      const shouldBeZSubdivided = childNode.availableZ.length > 1 && !shouldBeXYSubdivided && (childNode._containsObstacle || childNode.width < this.VIA_DIAMETER);
       if (shouldBeXYSubdivided) {
         unfinishedNewNodes.push(childNode);
-      } else if (!shouldBeXYSubdivided && !childNode._containsObstacle) {
+      } else if (!shouldBeXYSubdivided && !childNode._containsObstacle && !shouldBeZSubdivided) {
         finishedNewNodes.push(childNode);
       } else if (!shouldBeXYSubdivided && childNode._containsTarget) {
         if (shouldBeZSubdivided) {
@@ -2503,7 +2504,6 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         { x, y, z: z ?? 0 }
       ]);
     }
-    console.log({ unsolvedConnectionsMap });
     this.unsolvedConnections = Array.from(
       unsolvedConnectionsMap.entries().map(([connectionName, points]) => ({
         connectionName,
@@ -3128,6 +3128,9 @@ var getConnectivityMapFromSimpleRouteJson = (srj) => {
       }
     }
   }
+  for (const obstacle of srj.obstacles) {
+    connMap.addConnections([obstacle.connectedTo]);
+  }
   return connMap;
 };
 
@@ -3333,13 +3336,13 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance3 = Math.sqrt(
+      const distance4 = Math.sqrt(
         (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
       );
       edges.push({
         from: point,
         to: neighbor,
-        weight: distance3
+        weight: distance4
       });
     }
   }
@@ -5106,11 +5109,11 @@ var CapacityPathingSolver = class extends BaseSolver {
         let closestNode = this.nodes[0];
         let minDistance = Number.MAX_VALUE;
         for (const node of nodesWithTargets) {
-          const distance3 = Math.sqrt(
+          const distance4 = Math.sqrt(
             (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
           );
-          if (distance3 < minDistance) {
-            minDistance = distance3;
+          if (distance4 < minDistance) {
+            minDistance = distance4;
             closestNode = node;
           }
         }
@@ -5828,6 +5831,694 @@ ${node.width}x${node.height}
   }
 };
 
+// lib/solvers/SimplifiedPathSolver/SingleSimplifiedPathSolver.ts
+var SingleSimplifiedPathSolver = class extends BaseSolver {
+  newRoute;
+  newVias;
+  headIndex = 0;
+  tailIndex = 0;
+  inputRoute;
+  otherHdRoutes;
+  obstacles;
+  connMap;
+  colorMap;
+  constructor(params) {
+    super();
+    this.inputRoute = params.inputRoute;
+    this.otherHdRoutes = params.otherHdRoutes;
+    this.obstacles = params.obstacles;
+    this.connMap = params.connMap;
+    this.colorMap = params.colorMap;
+    this.newRoute = [];
+    this.newVias = [];
+  }
+  get simplifiedRoute() {
+    return {
+      connectionName: this.inputRoute.connectionName,
+      traceThickness: this.inputRoute.traceThickness,
+      viaDiameter: this.inputRoute.viaDiameter,
+      route: this.newRoute,
+      vias: this.newVias
+    };
+  }
+  isValidPath(pointsInRoute) {
+    throw new Error("Not implemented");
+  }
+  _step() {
+    throw new Error("Not implemented");
+  }
+  getVisualsForNewRouteAndObstacles() {
+    const graphics = {
+      lines: [],
+      points: [],
+      circles: [],
+      rects: [],
+      coordinateSystem: "cartesian",
+      title: "Simplified Path Solver"
+    };
+    for (let i = 0; i < this.inputRoute.route.length - 1; i++) {
+      graphics.lines.push({
+        points: [
+          { x: this.inputRoute.route[i].x, y: this.inputRoute.route[i].y },
+          {
+            x: this.inputRoute.route[i + 1].x,
+            y: this.inputRoute.route[i + 1].y
+          }
+        ],
+        strokeColor: "rgba(255, 0, 0, 0.8)",
+        strokeDash: this.inputRoute.route[i].z === 1 ? "5, 5" : void 0,
+        layer: this.inputRoute.route[i].z.toString()
+      });
+    }
+    for (let i = 0; i < this.newRoute.length; i++) {
+      if (i < this.newRoute.length - 1) {
+        graphics.lines.push({
+          points: [
+            { x: this.newRoute[i].x, y: this.newRoute[i].y },
+            { x: this.newRoute[i + 1].x, y: this.newRoute[i + 1].y }
+          ],
+          strokeWidth: 0.15,
+          strokeColor: "rgba(0, 255, 0, 0.8)",
+          strokeDash: this.newRoute[i].z === 1 ? [0.4, 0.4] : void 0,
+          layer: this.newRoute[i].z.toString()
+        });
+      }
+      graphics.points.push({
+        x: this.newRoute[i].x,
+        y: this.newRoute[i].y,
+        color: "rgba(0, 255, 0, 0.8)",
+        label: `z: ${this.newRoute[i].z}`,
+        layer: this.newRoute[i].z.toString()
+      });
+    }
+    for (const via of this.newVias) {
+      graphics.circles.push({
+        center: via,
+        radius: this.inputRoute.viaDiameter / 2,
+        fill: "rgba(0, 0, 255, 0.5)"
+      });
+    }
+    for (const obstacle of this.obstacles) {
+      graphics.rects.push({
+        center: obstacle.center,
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: obstacle.layers?.includes("top") ? "rgba(255, 0, 0, 0.3)" : obstacle.layers?.includes("bottom") ? "rgba(0, 0, 255, 0.3)" : "rgba(128, 128, 128, 0.3)"
+      });
+    }
+    for (const route of this.otherHdRoutes) {
+      for (let i = 0; i < route.route.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: route.route[i].x, y: route.route[i].y },
+            { x: route.route[i + 1].x, y: route.route[i + 1].y }
+          ],
+          strokeWidth: 0.15,
+          strokeColor: route.route[i].z === 0 ? "rgba(255, 0, 255, 0.5)" : route.route[i].z === 1 ? "rgba(128, 0, 128, 0.5)" : "rgba(0, 0, 255, 0.5)",
+          // bottom layer (blue)
+          layer: route.route[i].z.toString()
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/utils/calculate45DegreePaths.ts
+var calculate45DegreePaths = (pointA, pointB) => {
+  const result = [];
+  const dx = Math.abs(pointB.x - pointA.x);
+  const dy = Math.abs(pointB.y - pointA.y);
+  const signX = pointB.x > pointA.x ? 1 : -1;
+  const signY = pointB.y > pointA.y ? 1 : -1;
+  const midPoint1 = {
+    x: pointB.x - signX * Math.abs(pointB.y - pointA.y),
+    y: pointA.y
+  };
+  if ((midPoint1.x - pointA.x) * signX >= 0 && (midPoint1.x - pointB.x) * signX <= 0) {
+    result.push([pointA, midPoint1, pointB]);
+  }
+  const midPoint2 = {
+    x: pointA.x,
+    y: pointB.y - signY * Math.abs(pointB.x - pointA.x)
+  };
+  if ((midPoint2.y - pointA.y) * signY >= 0 && (midPoint2.y - pointB.y) * signY <= 0) {
+    result.push([pointA, midPoint2, pointB]);
+  }
+  const minDist = Math.min(dx, dy);
+  const midPoint3 = {
+    x: pointA.x + signX * minDist,
+    y: pointA.y + signY * minDist
+  };
+  if ((midPoint3.x - pointA.x) * signX >= 0 && (midPoint3.x - pointB.x) * signX <= 0 && (midPoint3.y - pointA.y) * signY >= 0 && (midPoint3.y - pointB.y) * signY <= 0) {
+    result.push([pointA, midPoint3, pointB]);
+  }
+  return result;
+};
+
+// lib/utils/minimumDistanceBetweenSegments.ts
+function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
+  if (segmentsIntersect(A1, A2, B1, B2)) {
+    return 0;
+  }
+  const distA1 = pointToSegmentDistance3(A1, B1, B2);
+  const distA2 = pointToSegmentDistance3(A2, B1, B2);
+  const distB1 = pointToSegmentDistance3(B1, A1, A2);
+  const distB2 = pointToSegmentDistance3(B2, A1, A2);
+  return Math.min(distA1, distA2, distB1, distB2);
+}
+function pointToSegmentDistance3(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);
+  if (c1 <= 0) {
+    return distance3(P, Q1);
+  }
+  const c2 = dotProduct(v, v);
+  if (c2 <= c1) {
+    return distance3(P, Q2);
+  }
+  const b = c1 / c2;
+  const Pb = {
+    x: Q1.x + b * v.x,
+    y: Q1.y + b * v.y
+  };
+  return distance3(P, Pb);
+}
+function dotProduct(v1, v2) {
+  return v1.x * v2.x + v1.y * v2.y;
+}
+function distance3(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function orientation3(p, q, r) {
+  const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  if (val === 0) return 0;
+  return val > 0 ? 1 : 2;
+}
+function onSegment3(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function segmentsIntersect(A1, A2, B1, B2) {
+  const o1 = orientation3(A1, A2, B1);
+  const o2 = orientation3(A1, A2, B2);
+  const o3 = orientation3(B1, B2, A1);
+  const o4 = orientation3(B1, B2, A2);
+  if (o1 !== o2 && o3 !== o4) return true;
+  if (o1 === 0 && onSegment3(A1, B1, A2)) return true;
+  if (o2 === 0 && onSegment3(A1, B2, A2)) return true;
+  if (o3 === 0 && onSegment3(B1, A1, B2)) return true;
+  if (o4 === 0 && onSegment3(B1, A2, B2)) return true;
+  return false;
+}
+
+// lib/solvers/SimplifiedPathSolver/SingleSimplifiedPathSolver5_Deg45.ts
+var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
+  pathSegments = [];
+  totalPathLength = 0;
+  headDistanceAlongPath = 0;
+  tailDistanceAlongPath = 0;
+  stepSize = 0.25;
+  // Default step size, can be adjusted
+  lastValidPath = null;
+  // Store the current valid path
+  lastValidPathHeadDistance = 0;
+  filteredObstacles = [];
+  OBSTACLE_MARGIN = 0.15;
+  TAIL_JUMP_RATIO = 0.8;
+  constructor(params) {
+    super(params);
+    if (this.inputRoute.route.length <= 1) {
+      this.newRoute = [...this.inputRoute.route];
+      this.solved = true;
+      return;
+    }
+    this.filteredObstacles = this.obstacles.filter(
+      (obstacle) => !obstacle.connectedTo.some(
+        (id) => this.connMap.areIdsConnected(this.inputRoute.connectionName, id)
+      )
+    );
+    this.computePathSegments();
+  }
+  // Compute the path segments and their distances
+  computePathSegments() {
+    let cumulativeDistance = 0;
+    for (let i = 0; i < this.inputRoute.route.length - 1; i++) {
+      const start = this.inputRoute.route[i];
+      const end = this.inputRoute.route[i + 1];
+      const length = Math.sqrt((end.x - start.x) ** 2 + (end.y - start.y) ** 2) + i / 1e4;
+      this.pathSegments.push({
+        start,
+        end,
+        length,
+        startDistance: cumulativeDistance,
+        endDistance: cumulativeDistance + length
+      });
+      cumulativeDistance += length;
+    }
+    this.totalPathLength = cumulativeDistance;
+  }
+  // Helper to check if two points are the same
+  arePointsEqual(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
+  }
+  // Get point at a specific distance along the path
+  getPointAtDistance(distance4) {
+    distance4 = Math.max(0, Math.min(distance4, this.totalPathLength));
+    const segment = this.pathSegments.find(
+      (seg) => distance4 >= seg.startDistance && distance4 <= seg.endDistance
+    );
+    if (!segment) {
+      return this.inputRoute.route[this.inputRoute.route.length - 1];
+    }
+    const factor = (distance4 - segment.startDistance) / segment.length;
+    return {
+      x: segment.start.x + factor * (segment.end.x - segment.start.x),
+      y: segment.start.y + factor * (segment.end.y - segment.start.y),
+      z: segment.start.z
+      // Z doesn't interpolate - use the segment's start z value
+    };
+  }
+  // Find nearest index in the original route for a given distance
+  getNearestIndexForDistance(distance4) {
+    if (distance4 <= 0) return 0;
+    if (distance4 >= this.totalPathLength)
+      return this.inputRoute.route.length - 1;
+    const segmentIndex = this.pathSegments.findIndex(
+      (seg) => distance4 >= seg.startDistance && distance4 <= seg.endDistance
+    );
+    if (segmentIndex === -1) return 0;
+    const segment = this.pathSegments[segmentIndex];
+    const midDistance = (segment.startDistance + segment.endDistance) / 2;
+    return distance4 > midDistance ? segmentIndex + 1 : segmentIndex;
+  }
+  // Check if a path segment is valid
+  isValidPathSegment(start, end) {
+    for (const obstacle of this.filteredObstacles) {
+      if (!obstacle.zLayers?.includes(start.z)) {
+        continue;
+      }
+      const obstacleLeft = obstacle.center.x - obstacle.width / 2 - this.OBSTACLE_MARGIN;
+      const obstacleRight = obstacle.center.x + obstacle.width / 2 + this.OBSTACLE_MARGIN;
+      const obstacleTop = obstacle.center.y - obstacle.height / 2 - this.OBSTACLE_MARGIN;
+      const obstacleBottom = obstacle.center.y + obstacle.height / 2 + this.OBSTACLE_MARGIN;
+      if (doSegmentsIntersect(
+        { x: start.x, y: start.y },
+        { x: end.x, y: end.y },
+        { x: obstacleLeft, y: obstacleTop },
+        { x: obstacleRight, y: obstacleTop }
+      ) || doSegmentsIntersect(
+        { x: start.x, y: start.y },
+        { x: end.x, y: end.y },
+        { x: obstacleRight, y: obstacleTop },
+        { x: obstacleRight, y: obstacleBottom }
+      ) || doSegmentsIntersect(
+        { x: start.x, y: start.y },
+        { x: end.x, y: end.y },
+        { x: obstacleRight, y: obstacleBottom },
+        { x: obstacleLeft, y: obstacleBottom }
+      ) || doSegmentsIntersect(
+        { x: start.x, y: start.y },
+        { x: end.x, y: end.y },
+        { x: obstacleLeft, y: obstacleBottom },
+        { x: obstacleLeft, y: obstacleTop }
+      )) {
+        return false;
+      }
+    }
+    for (const route of this.otherHdRoutes) {
+      if (this.connMap.areIdsConnected(
+        this.inputRoute.connectionName,
+        route.connectionName
+      )) {
+        continue;
+      }
+      for (let j = 0; j < route.route.length - 1; j++) {
+        const routeStart = route.route[j];
+        const routeEnd = route.route[j + 1];
+        if (routeStart.z === start.z && routeEnd.z === start.z) {
+          if (minimumDistanceBetweenSegments(
+            { x: start.x, y: start.y },
+            { x: end.x, y: end.y },
+            { x: routeStart.x, y: routeStart.y },
+            { x: routeEnd.x, y: routeEnd.y }
+          ) < this.OBSTACLE_MARGIN) {
+            return false;
+          }
+        }
+      }
+      for (const via of route.vias) {
+        if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + route.viaDiameter / 2) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  // Check if a path with multiple points is valid
+  isValidPath(pointsInRoute) {
+    if (pointsInRoute.length < 2) return true;
+    for (let i = 0; i < pointsInRoute.length - 1; i++) {
+      if (pointsInRoute[i].z !== pointsInRoute[i + 1].z) {
+        return false;
+      }
+    }
+    for (let i = 0; i < pointsInRoute.length - 1; i++) {
+      if (!this.isValidPathSegment(pointsInRoute[i], pointsInRoute[i + 1])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Find a valid 45-degree path between two points
+  find45DegreePath(start, end) {
+    if (this.arePointsEqual(start, end)) {
+      return [start];
+    }
+    if (start.z !== end.z) {
+      return null;
+    }
+    const possiblePaths = calculate45DegreePaths(
+      { x: start.x, y: start.y },
+      { x: end.x, y: end.y }
+    );
+    for (const path of possiblePaths) {
+      const fullPath = path.map((p) => ({ x: p.x, y: p.y, z: start.z }));
+      if (this.isValidPath(fullPath)) {
+        return fullPath;
+      }
+    }
+    return null;
+  }
+  // Add a path to the result, skipping the first point if it's already added
+  addPathToResult(path) {
+    if (path.length === 0) return;
+    for (let i = 0; i < path.length; i++) {
+      if (i === 0 && this.newRoute.length > 0 && this.arePointsEqual(this.newRoute[this.newRoute.length - 1], path[i])) {
+        continue;
+      }
+      this.newRoute.push(path[i]);
+    }
+  }
+  _step() {
+    const tailHasReachedEnd = this.tailDistanceAlongPath >= this.totalPathLength;
+    const headHasReachedEnd = this.headDistanceAlongPath >= this.totalPathLength;
+    if (tailHasReachedEnd) {
+      const lastPoint = this.inputRoute.route[this.inputRoute.route.length - 1];
+      if (this.newRoute.length === 0 || !this.arePointsEqual(this.newRoute[this.newRoute.length - 1], lastPoint)) {
+        this.newRoute.push(lastPoint);
+      }
+      this.solved = true;
+      return;
+    }
+    if (headHasReachedEnd) {
+      const tailPoint2 = this.getPointAtDistance(this.tailDistanceAlongPath);
+      const endPoint = this.inputRoute.route[this.inputRoute.route.length - 1];
+      const path452 = this.find45DegreePath(tailPoint2, endPoint);
+      if (path452) {
+        this.addPathToResult(path452);
+        this.solved = true;
+        return;
+      } else {
+        if (this.lastValidPath) {
+          this.addPathToResult(this.lastValidPath);
+          this.lastValidPath = null;
+          this.tailDistanceAlongPath = this.lastValidPathHeadDistance;
+        } else {
+          this.newRoute.push(endPoint);
+          this.solved = true;
+        }
+      }
+    }
+    this.headDistanceAlongPath = Math.min(
+      this.headDistanceAlongPath + this.stepSize,
+      this.totalPathLength
+    );
+    const tailPoint = this.getPointAtDistance(this.tailDistanceAlongPath);
+    const headPoint = this.getPointAtDistance(this.headDistanceAlongPath);
+    const tailIndex = this.getNearestIndexForDistance(
+      this.tailDistanceAlongPath
+    );
+    const headIndex = this.getNearestIndexForDistance(
+      this.headDistanceAlongPath
+    );
+    let layerChangeBtwHeadAndTail = false;
+    let layerChangeAtDistance = -1;
+    for (let i = tailIndex; i < headIndex; i++) {
+      if (i + 1 < this.inputRoute.route.length && this.inputRoute.route[i].z !== this.inputRoute.route[i + 1].z) {
+        layerChangeBtwHeadAndTail = true;
+        const changeSegmentIndex = i;
+        layerChangeAtDistance = this.pathSegments[changeSegmentIndex].startDistance;
+        break;
+      }
+    }
+    if (layerChangeBtwHeadAndTail && layerChangeAtDistance > 0) {
+      if (this.lastValidPath) {
+        this.addPathToResult(this.lastValidPath);
+        this.lastValidPath = null;
+      }
+      const pointBeforeChange = this.getPointAtDistance(layerChangeAtDistance);
+      const pointAfterChange = this.inputRoute.route[this.getNearestIndexForDistance(layerChangeAtDistance) + 1];
+      this.newVias.push({
+        x: pointAfterChange.x,
+        y: pointAfterChange.y
+      });
+      this.newRoute.push(pointAfterChange);
+      const nextTailIndex = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
+      if (this.pathSegments[nextTailIndex]) {
+        this.tailDistanceAlongPath = this.pathSegments[nextTailIndex].startDistance;
+        this.headDistanceAlongPath = this.tailDistanceAlongPath;
+      } else {
+        console.error("Creating via at end, this is probably not right");
+        this.solved = true;
+        return;
+      }
+      return;
+    }
+    const path45 = this.find45DegreePath(tailPoint, headPoint);
+    if (!path45 && !this.lastValidPath) {
+      this.tailDistanceAlongPath += this.stepSize;
+      this.headDistanceAlongPath += this.stepSize;
+      return;
+    }
+    if (path45) {
+      this.lastValidPath = path45;
+      this.lastValidPathHeadDistance = this.headDistanceAlongPath;
+      return;
+    }
+    if (this.lastValidPath) {
+      this.addPathToResult(this.lastValidPath);
+      this.lastValidPath = null;
+      this.tailDistanceAlongPath = this.lastValidPathHeadDistance;
+    }
+    this.headDistanceAlongPath = Math.min(
+      this.headDistanceAlongPath + this.stepSize,
+      this.totalPathLength
+    );
+  }
+  visualize() {
+    const graphics = this.getVisualsForNewRouteAndObstacles();
+    const tailPoint = this.getPointAtDistance(this.tailDistanceAlongPath);
+    const headPoint = this.getPointAtDistance(this.headDistanceAlongPath);
+    graphics.points.push({
+      x: tailPoint.x,
+      y: tailPoint.y,
+      color: "yellow",
+      label: ["Tail", `z: ${tailPoint.z}`].join("\n")
+    });
+    graphics.points.push({
+      x: headPoint.x,
+      y: headPoint.y,
+      color: "orange",
+      label: ["Head", `z: ${headPoint.z}`].join("\n")
+    });
+    let distance4 = 0;
+    while (distance4 < this.totalPathLength) {
+      const point = this.getPointAtDistance(distance4);
+      graphics.circles.push({
+        center: {
+          x: point.x,
+          y: point.y
+        },
+        radius: 0.05,
+        fill: "rgba(100, 100, 100, 0.5)"
+      });
+      distance4 += this.totalPathLength / 20;
+    }
+    if (this.lastValidPath && this.lastValidPath.length > 1) {
+      for (let i = 0; i < this.lastValidPath.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: this.lastValidPath[i].x, y: this.lastValidPath[i].y },
+            {
+              x: this.lastValidPath[i + 1].x,
+              y: this.lastValidPath[i + 1].y
+            }
+          ],
+          strokeColor: "rgba(0, 255, 255, 0.9)",
+          // Bright cyan
+          strokeDash: "3, 3"
+          // Dashed line to indicate it's a prospective path
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/SimplifiedPathSolver/MultiSimplifiedPathSolver.ts
+var MultiSimplifiedPathSolver = class extends BaseSolver {
+  simplifiedHdRoutes;
+  currentUnsimplifiedHdRouteIndex = 0;
+  activeSubSolver = null;
+  unsimplifiedHdRoutes;
+  obstacles;
+  connMap;
+  colorMap;
+  constructor(params) {
+    super();
+    this.MAX_ITERATIONS = 1e8;
+    this.unsimplifiedHdRoutes = params.unsimplifiedHdRoutes;
+    this.obstacles = params.obstacles;
+    this.connMap = params.connMap || new ConnectivityMap({});
+    this.colorMap = params.colorMap || {};
+    this.simplifiedHdRoutes = [];
+  }
+  _step() {
+    const hdRoute = this.unsimplifiedHdRoutes[this.currentUnsimplifiedHdRouteIndex];
+    if (!this.activeSubSolver) {
+      if (!hdRoute) {
+        this.solved = true;
+        return;
+      }
+      this.activeSubSolver = new SingleSimplifiedPathSolver5({
+        inputRoute: hdRoute,
+        otherHdRoutes: this.unsimplifiedHdRoutes.slice(this.currentUnsimplifiedHdRouteIndex + 1).concat(this.simplifiedHdRoutes),
+        obstacles: this.obstacles,
+        connMap: this.connMap,
+        colorMap: this.colorMap
+      });
+      this.currentUnsimplifiedHdRouteIndex++;
+      return;
+    }
+    this.activeSubSolver.step();
+    if (this.activeSubSolver.solved) {
+      this.simplifiedHdRoutes.push(this.activeSubSolver.simplifiedRoute);
+      this.activeSubSolver = null;
+    }
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    const graphics = {
+      lines: [],
+      points: [],
+      circles: [],
+      rects: [],
+      coordinateSystem: "cartesian",
+      title: "Multi Simplified Path Solver"
+    };
+    for (const route of this.unsimplifiedHdRoutes) {
+      if (this.simplifiedHdRoutes.some(
+        (r) => r.connectionName === route.connectionName
+      )) {
+        continue;
+      }
+      for (let i = 0; i < route.route.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: route.route[i].x, y: route.route[i].y },
+            { x: route.route[i + 1].x, y: route.route[i + 1].y }
+          ],
+          strokeColor: route.route[i].z === 1 ? "rgba(0, 0, 255, 0.4)" : "rgba(255, 0, 0, 0.4)",
+          strokeWidth: 0.15,
+          strokeDash: route.route[i].z === 1 ? [0.5, 0.5] : void 0
+        });
+      }
+      for (const via of route.vias || []) {
+        graphics.circles.push({
+          center: via,
+          radius: route.viaDiameter / 2 || 0.3,
+          // Default radius if viaDiameter not specified
+          fill: "rgba(0, 0, 255, 0.4)"
+        });
+      }
+    }
+    for (const route of this.simplifiedHdRoutes) {
+      const routeColor = this.colorMap?.[route.connectionName] || "rgba(128, 128, 128, 0.8)";
+      for (let i = 0; i < route.route.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: route.route[i].x, y: route.route[i].y },
+            { x: route.route[i + 1].x, y: route.route[i + 1].y }
+          ],
+          strokeWidth: 0.15,
+          strokeColor: routeColor,
+          strokeDash: route.route[i].z === 1 ? [0.5, 0.5] : void 0,
+          step: 1
+        });
+      }
+      for (const via of route.vias || []) {
+        graphics.circles.push({
+          center: via,
+          radius: route.viaDiameter / 2,
+          fill: "rgba(0, 0, 255, 0.5)",
+          step: 1
+        });
+      }
+    }
+    for (const route of this.unsimplifiedHdRoutes) {
+      for (let i = 0; i < route.route.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: route.route[i].x, y: route.route[i].y },
+            { x: route.route[i + 1].x, y: route.route[i + 1].y }
+          ],
+          strokeWidth: 0.15,
+          strokeColor: "rgba(255, 0, 0, 0.2)",
+          strokeDash: [0.5, 0.5],
+          step: 0,
+          layer: route.route[i].z.toString()
+        });
+      }
+      for (const point of route.vias) {
+        graphics.circles.push({
+          center: { x: point.x, y: point.y },
+          radius: route.viaDiameter / 2,
+          fill: "rgba(255, 0, 0, 0.2)",
+          step: 0
+        });
+      }
+    }
+    for (const obstacle of this.obstacles) {
+      graphics.rects.push({
+        center: obstacle.center,
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: obstacle.layers?.includes("top") ? "rgba(255, 0, 0, 0.3)" : obstacle.layers?.includes("bottom") ? "rgba(0, 0, 255, 0.3)" : "rgba(128, 128, 128, 0.3)"
+      });
+    }
+    if (this.currentUnsimplifiedHdRouteIndex < this.unsimplifiedHdRoutes.length) {
+      const currentRoute = this.unsimplifiedHdRoutes[this.currentUnsimplifiedHdRouteIndex];
+      if (currentRoute.route.length > 0) {
+        graphics.circles.push({
+          center: {
+            x: currentRoute.route[0].x,
+            y: currentRoute.route[0].y
+          },
+          radius: 0.2,
+          fill: "yellow",
+          label: "Current"
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/AutoroutingPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -5873,6 +6564,7 @@ var CapacityMeshSolver = class extends BaseSolver {
   highDensityStitchSolver;
   singleLayerNodeMerger;
   strawSolver;
+  multiSimplifiedPathSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -6018,6 +6710,18 @@ var CapacityMeshSolver = class extends BaseSolver {
           layerCount: cms.srj.layerCount
         }
       ]
+    ),
+    definePipelineStep(
+      "multiSimplifiedPathSolver",
+      MultiSimplifiedPathSolver,
+      (cms) => [
+        {
+          unsimplifiedHdRoutes: cms.highDensityStitchSolver.mergedHdRoutes,
+          obstacles: cms.srj.obstacles,
+          connMap: cms.connMap,
+          colorMap: cms.colorMap
+        }
+      ]
     )
   ];
   currentPipelineStepIndex = 0;
@@ -6066,12 +6770,21 @@ var CapacityMeshSolver = class extends BaseSolver {
     const segmentOptimizationViz = this.unravelMultiSectionSolver?.visualize() ?? this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
     const highDensityStitchViz = this.highDensityStitchSolver?.visualize();
+    const simplifiedPathSolverViz = this.multiSimplifiedPathSolver?.visualize();
     const problemViz = {
-      points: [...this.srj.connections.flatMap((c) => c.pointsToConnect)],
+      points: [
+        ...this.srj.connections.flatMap(
+          (c) => c.pointsToConnect.map((p) => ({
+            ...p,
+            label: `${c.name} ${p.pcb_port_id ?? ""}`
+          }))
+        )
+      ],
       rects: [
         ...(this.srj.obstacles ?? []).map((o) => ({
           ...o,
-          fill: o.layers?.includes("top") ? "rgba(255,0,0,0.25)" : o.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)"
+          fill: o.layers?.includes("top") ? "rgba(255,0,0,0.25)" : o.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)",
+          label: o.layers?.join(", ")
         }))
       ],
       lines: [
@@ -6109,6 +6822,7 @@ var CapacityMeshSolver = class extends BaseSolver {
       segmentOptimizationViz,
       highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null,
       highDensityStitchViz,
+      simplifiedPathSolverViz,
       this.solved ? combineVisualizations(
         problemViz,
         convertSrjToGraphicsObject(this.getOutputSimpleRouteJson())
@@ -6125,6 +6839,9 @@ var CapacityMeshSolver = class extends BaseSolver {
     const match = mstConnectionName.match(/^(.+?)_mst\d+$/);
     return match ? match[1] : mstConnectionName;
   }
+  _getOutputHdRoutes() {
+    return this.multiSimplifiedPathSolver?.simplifiedHdRoutes ?? this.highDensityStitchSolver.mergedHdRoutes;
+  }
   /**
    * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
    */
@@ -6133,11 +6850,12 @@ var CapacityMeshSolver = class extends BaseSolver {
       throw new Error("Cannot get output before solving is complete");
     }
     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 hdRoutes = this.highDensityStitchSolver.mergedHdRoutes.filter(
+      const hdRoutes = allHdRoutes.filter(
         (r) => r.connectionName === connection.name
       );
       for (let i = 0; i < hdRoutes.length; i++) {