@tscircuit/capacity-autorouter 0.0.27 → 0.0.29

package/dist/index.js

@@ -156,7 +156,8 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     this.edges = [];
     for (let i = 0; i < this.nodes.length; i++) {
       for (let j = i + 1; j < this.nodes.length; j++) {
-        if (!(this.nodes[i]._strawNode && this.nodes[j]._strawNode) && areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
+        const strawNodesWithSameParent = this.nodes[i]._strawNode && this.nodes[j]._strawNode && this.nodes[i]._strawParentCapacityMeshNodeId === this.nodes[j]._strawParentCapacityMeshNodeId;
+        if (!strawNodesWithSameParent && areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
           this.edges.push({
             capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
             nodeIds: [
@@ -1113,6 +1114,29 @@ var mapLayerNameToZ = (layerName, layerCount) => {
   return parseInt(layerName.slice(5));
 };
 
+// lib/utils/getTunedTotalCapacity1.ts
+var getTunedTotalCapacity1 = (nodeOrWidth, maxCapacityFactor = 1) => {
+  const VIA_DIAMETER = 0.6;
+  const TRACE_WIDTH = 0.15;
+  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;
+};
+var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxDepth = 16) => {
+  let depth = 0;
+  let width = initialWidth;
+  while (depth < maxDepth) {
+    const capacity = getTunedTotalCapacity1({ width });
+    if (capacity <= targetMinCapacity) {
+      break;
+    }
+    width /= 2;
+    depth++;
+  }
+  return Math.max(1, depth);
+};
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver1.ts
 var CapacityMeshNodeSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
@@ -1407,7 +1431,9 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
           node.capacityMeshNodeId,
           `availableZ: ${node.availableZ.join(",")}`,
           `target? ${node._containsTarget ?? false}`,
-          `obs? ${node._containsObstacle ?? false}`
+          `obs? ${node._containsObstacle ?? false}`,
+          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+          `capacity: ${getTunedTotalCapacity1(node).toFixed(2)}`
         ].join("\n")
       });
     }
@@ -1434,6 +1460,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 +1565,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) {
@@ -2057,7 +2084,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     return false;
   }
   isNodeTooCloseToEdge(node, isVia) {
-    const margin = isVia ? this.viaDiameter / 2 : this.obstacleMargin;
+    const margin = isVia ? this.viaDiameter / 2 + this.obstacleMargin / 2 : this.obstacleMargin / 2;
     const tooClose = node.x < this.bounds.minX + margin || node.x > this.bounds.maxX - margin || node.y < this.bounds.minY + margin || node.y > this.bounds.maxY - margin;
     if (tooClose && !isVia) {
       if (distance(node, this.B) < margin * 2 || distance(node, this.A) < margin * 2) {
@@ -3127,30 +3154,10 @@ var getConnectivityMapFromSimpleRouteJson = (srj) => {
       }
     }
   }
-  return connMap;
-};
-
-// lib/utils/getTunedTotalCapacity1.ts
-var getTunedTotalCapacity1 = (nodeOrWidth, maxCapacityFactor = 1) => {
-  const VIA_DIAMETER = 0.6;
-  const TRACE_WIDTH = 0.15;
-  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;
-};
-var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxDepth = 16) => {
-  let depth = 0;
-  let width = initialWidth;
-  while (depth < maxDepth) {
-    const capacity = getTunedTotalCapacity1({ width });
-    if (capacity <= targetMinCapacity) {
-      break;
-    }
-    width /= 2;
-    depth++;
+  for (const obstacle of srj.obstacles) {
+    connMap.addConnections([obstacle.connectedTo]);
   }
-  return Math.max(1, depth);
+  return connMap;
 };
 
 // lib/solvers/NetToPointPairsSolver/buildMinimumSpanningTree.ts
@@ -3332,13 +3339,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
       });
     }
   }
@@ -5025,9 +5032,9 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
 var createRectFromCapacityNode = (node, opts = {}) => {
   const lowestZ = Math.min(...node.availableZ);
   return {
-    center: !opts.rectMargin ? {
-      x: node.center.x + lowestZ * node.width * 0.05,
-      y: node.center.y - lowestZ * node.width * 0.05
+    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),
@@ -5105,11 +5112,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;
           }
         }
@@ -5169,12 +5176,16 @@ var CapacityPathingSolver = class extends BaseSolver {
     }
     return capacityPaths;
   }
-  doesNodeHaveCapacityForTrace(node) {
+  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;
-    return usedCapacity < totalCapacity;
+    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);
@@ -5242,7 +5253,7 @@ var CapacityPathingSolver = class extends BaseSolver {
       if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
         continue;
       }
-      if (!this.doesNodeHaveCapacityForTrace(neighborNode)) {
+      if (!this.doesNodeHaveCapacityForTrace(neighborNode, currentCandidate.node)) {
         continue;
       }
       const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
@@ -5281,27 +5292,42 @@ var CapacityPathingSolver = class extends BaseSolver {
         if (conn.path && conn.path.length > 0) {
           const pathPoints = conn.path.map(({ center: { x, y }, width }) => ({
             // slight offset to allow viewing overlapping paths
-            x: x + (i % 10 + i % 19) * (0.01 * width),
-            y: y + (i % 10 + i % 19) * (0.01 * width)
+            x: x + (i % 10 + i % 19) * (5e-3 * width),
+            y: y + (i % 10 + i % 19) * (5e-3 * width)
           }));
           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}`
+              ].join("\n")
+            });
+          }
         }
       }
     }
     for (const node of this.nodes) {
       const nodeCosts = this.debug_lastNodeCostMap.get(node.capacityMeshNodeId);
       graphics.rects.push({
-        ...createRectFromCapacityNode(node),
+        ...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) : "?"}`
+          `f: ${nodeCosts?.f !== void 0 ? nodeCosts.f.toFixed(2) : "?"}`,
+          `z: ${node.availableZ.join(", ")}`
         ].join("\n")
       });
     }
@@ -5311,7 +5337,8 @@ var CapacityPathingSolver = class extends BaseSolver {
           for (const point of conn.connection.pointsToConnect) {
             graphics.points.push({
               x: point.x,
-              y: point.y
+              y: point.y,
+              label: [`pointsToConnect ${conn.connection.name}`].join("\n")
             });
           }
         }
@@ -5367,18 +5394,6 @@ var CapacityPathingSolver5 = class extends CapacityPathingSolver {
    */
   getNodeCapacityPenalty(node) {
     return 0.05;
-    if (node.availableZ.length === 1) {
-      return 0;
-    }
-    const totalCapacity = this.getTotalCapacity(node);
-    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
-    const remainingCapacity = totalCapacity - usedCapacity;
-    const dist = this.activeCandidateStraightLineDistance;
-    if (remainingCapacity <= 0) {
-      const penalty = (-remainingCapacity + 1) / totalCapacity * dist * (this.NEGATIVE_CAPACITY_PENALTY_FACTOR / 4);
-      return penalty ** 2;
-    }
-    return 1 / remainingCapacity * dist * this.REDUCED_CAPACITY_PENALTY_FACTOR / 8;
   }
   /**
    * We're rewarding travel into big nodes.
@@ -5505,7 +5520,8 @@ var StrawSolver = class extends BaseSolver {
           layer: node.layer,
           availableZ: [...node.availableZ],
           _depth: node._depth,
-          _strawNode: true
+          _strawNode: true,
+          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
         });
       }
     } else {
@@ -5521,7 +5537,8 @@ var StrawSolver = class extends BaseSolver {
           layer: node.layer,
           availableZ: [...node.availableZ],
           _depth: node._depth,
-          _strawNode: true
+          _strawNode: true,
+          _strawParentCapacityMeshNodeId: node.capacityMeshNodeId
         });
       }
     }
@@ -5577,7 +5594,8 @@ ${node.width}x${node.height}`
         stroke: "rgba(0, 0, 0, 0.5)",
         label: `${node.capacityMeshNodeId}
 Layer: ${node.availableZ[0]}
-${node.width}x${node.height}`
+${node.width}x${node.height}`,
+        layer: `z${node.availableZ.join(",")}`
       });
     }
     for (const node of this.multiLayerNodes) {
@@ -5625,6 +5643,13 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       }
     }
     nodeWithArea.sort((a, b) => a[1] - b[1]);
+    for (const [nodeId, area] of nodeWithArea) {
+      const node = this.nodeMap.get(nodeId);
+      this.nodeMap.set(nodeId, {
+        ...node,
+        center: { ...node.center }
+      });
+    }
     this.currentBatchNodeIds = nodeWithArea.map((n) => n[0]);
     this.nextBatchNodeIds = [];
     this.batchHadModifications = false;
@@ -5827,6 +5852,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: `z${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: `z${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: `z${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: `z${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: `z${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 {
@@ -5872,6 +6585,7 @@ var CapacityMeshSolver = class extends BaseSolver {
   highDensityStitchSolver;
   singleLayerNodeMerger;
   strawSolver;
+  multiSimplifiedPathSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -5894,17 +6608,18 @@ var CapacityMeshSolver = class extends BaseSolver {
         }
       }
     ),
-    // definePipelineStep("nodeSolver", CapacityMeshNodeSolver, (cms) => [
-    //   cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
-    //   cms.opts,
-    // ]),
     definePipelineStep(
       "nodeSolver",
       CapacityMeshNodeSolver2_NodeUnderObstacle,
       (cms) => [
         cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
         cms.opts
-      ]
+      ],
+      {
+        onSolved: (cms) => {
+          cms.capacityNodes = cms.nodeSolver?.finishedNodes;
+        }
+      }
     ),
     // definePipelineStep("nodeTargetMerger", CapacityNodeTargetMerger, (cms) => [
     //   cms.nodeSolver?.finishedNodes || [],
@@ -5921,7 +6636,12 @@ var CapacityMeshSolver = class extends BaseSolver {
     definePipelineStep(
       "singleLayerNodeMerger",
       SingleLayerNodeMergerSolver,
-      (cms) => [cms.nodeSolver?.finishedNodes]
+      (cms) => [cms.nodeSolver?.finishedNodes],
+      {
+        onSolved: (cms) => {
+          cms.capacityNodes = cms.singleLayerNodeMerger?.newNodes;
+        }
+      }
     ),
     definePipelineStep(
       "strawSolver",
@@ -6017,6 +6737,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;
@@ -6065,12 +6797,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: [
@@ -6108,6 +6849,7 @@ var CapacityMeshSolver = class extends BaseSolver {
       segmentOptimizationViz,
       highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null,
       highDensityStitchViz,
+      simplifiedPathSolverViz,
       this.solved ? combineVisualizations(
         problemViz,
         convertSrjToGraphicsObject(this.getOutputSimpleRouteJson())
@@ -6124,6 +6866,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
    */
@@ -6132,11 +6877,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++) {