@tscircuit/capacity-autorouter 0.0.55 → 0.0.57

package/dist/index.js

@@ -47,6 +47,7 @@ var BaseSolver = class {
   activeSubSolver;
   failedSubSolvers;
   timeToSolve;
+  stats = {};
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -65,6 +66,9 @@ var BaseSolver = class {
       console.error(this.error);
       this.failed = true;
     }
+    if ("computeProgress" in this) {
+      this.progress = this.computeProgress();
+    }
   }
   _step() {
   }
@@ -2902,7 +2906,7 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
   }
 };
 
-// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
+// node_modules/@tscircuit/math-utils/dist/chunk-3453HRP7.js
 function doSegmentsIntersect(p1, q1, p2, q2) {
   const o1 = orientation(p1, q1, p2);
   const o2 = orientation(p1, q1, q2);
@@ -2941,6 +2945,27 @@ function distance(p1, p2) {
   const dy = p1.y - p2.y;
   return Math.sqrt(dx * dx + dy * dy);
 }
+function getSegmentIntersection(a, b, u, v) {
+  const dx1 = b.x - a.x;
+  const dy1 = b.y - a.y;
+  const dx2 = v.x - u.x;
+  const dy2 = v.y - u.y;
+  const dx3 = a.x - u.x;
+  const dy3 = a.y - u.y;
+  const denominator = dx1 * dy2 - dy1 * dx2;
+  if (Math.abs(denominator) < 1e-10) {
+    return null;
+  }
+  const t = (dy3 * dx2 - dx3 * dy2) / denominator;
+  const s = (dx1 * dy3 - dy1 * dx3) / denominator;
+  const epsilon = 1e-9;
+  if (t >= -epsilon && t <= 1 + epsilon && s >= -epsilon && s <= 1 + epsilon) {
+    const intersectionX = a.x + t * dx1;
+    const intersectionY = a.y + t * dy1;
+    return { x: intersectionX, y: intersectionY };
+  }
+  return null;
+}
 
 // node_modules/@tscircuit/math-utils/dist/chunk-MHHTZHOJ.js
 function getBoundingBox(box) {
@@ -2974,7 +2999,7 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
 
-// node_modules/@tscircuit/math-utils/dist/chunk-RNQKFERU.js
+// node_modules/@tscircuit/math-utils/dist/chunk-FWQGMQBW.js
 function segmentToSegmentMinDistance(a, b, u, v) {
   if (a.x === b.x && a.y === b.y) {
     return pointToSegmentDistance(a, u, v);
@@ -3053,6 +3078,14 @@ function pointToSegmentClosestPoint(p, a, b) {
   return closestPoint;
 }
 
+// node_modules/@tscircuit/math-utils/dist/chunk-SLG2OU3P.js
+function midpoint(p1, p2) {
+  return {
+    x: (p1.x + p2.x) / 2,
+    y: (p1.y + p2.y) / 2
+  };
+}
+
 // lib/data-structures/SingleRouteCandidatePriorityQueue.ts
 var SingleRouteCandidatePriorityQueue = class {
   heap = [];
@@ -4008,12 +4041,15 @@ var HyperParameterSupervisorSolver = class extends BaseSolver {
     }
     return bestSolver;
   }
+  getFailureMessage() {
+    return "All solvers failed in hyper solver.";
+  }
   _step() {
     if (!this.supervisedSolvers) this.initializeSolvers();
     const supervisedSolver = this.getSupervisedSolverWithBestFitness();
     if (!supervisedSolver) {
       this.failed = true;
-      this.error = "All solvers failed";
+      this.error = this.getFailureMessage();
       return;
     }
     for (let i = 0; i < this.MIN_SUBSTEPS; i++) {
@@ -6133,6 +6169,23 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/getPortPairs.ts
+var getPortPairMap = (nodeWithPortPoints) => {
+  const portPairMap = /* @__PURE__ */ new Map();
+  nodeWithPortPoints.portPoints.forEach((portPoint) => {
+    if (!portPairMap.has(portPoint.connectionName)) {
+      portPairMap.set(portPoint.connectionName, {
+        start: portPoint,
+        end: null,
+        connectionName: portPoint.connectionName
+      });
+    } else {
+      portPairMap.get(portPoint.connectionName).end = portPoint;
+    }
+  });
+  return portPairMap;
+};
+
 // lib/utils/generateColorMapFromNodeWithPortPoints.ts
 var generateColorMapFromNodeWithPortPoints = (nodeWithPortPoints, connMap) => {
   const colorMap = {};
@@ -6142,6 +6195,320 @@ var generateColorMapFromNodeWithPortPoints = (nodeWithPortPoints, connMap) => {
   return colorMap;
 };
 
+// lib/solvers/ViaPossibilitiesSolver/ViaPossibilitiesSolver2.ts
+var ViaPossibilitiesSolver2 = class extends BaseSolver {
+  bounds;
+  maxViaCount;
+  portPairMap;
+  colorMap;
+  nodeWidth;
+  availableZ;
+  hyperParameters;
+  VIA_INTERSECTION_BUFFER_DISTANCE = 0.05;
+  PLACEHOLDER_WALL_BUFFER_DISTANCE = 0.1;
+  NEW_HEAD_WALL_BUFFER_DISTANCE = 0.05;
+  unprocessedConnections;
+  completedPaths = /* @__PURE__ */ new Map();
+  placeholderPaths = /* @__PURE__ */ new Map();
+  currentHead;
+  currentConnectionName;
+  currentPath;
+  constructor({
+    nodeWithPortPoints,
+    colorMap,
+    hyperParameters
+  }) {
+    super();
+    this.MAX_ITERATIONS = 1e5;
+    this.colorMap = colorMap ?? generateColorMapFromNodeWithPortPoints(nodeWithPortPoints);
+    this.maxViaCount = 5;
+    this.bounds = getBoundsFromNodeWithPortPoints(nodeWithPortPoints);
+    this.nodeWidth = this.bounds.maxX - this.bounds.minX;
+    this.portPairMap = getPortPairMap(nodeWithPortPoints);
+    this.stats.solutionsFound = 0;
+    this.availableZ = nodeWithPortPoints.availableZ ?? [0, 1];
+    this.hyperParameters = hyperParameters ?? {
+      SHUFFLE_SEED: 0
+    };
+    this.unprocessedConnections = Array.from(this.portPairMap.keys()).sort();
+    if (hyperParameters?.SHUFFLE_SEED) {
+      this.unprocessedConnections = cloneAndShuffleArray(
+        this.unprocessedConnections,
+        hyperParameters.SHUFFLE_SEED
+      );
+    }
+    const nodeCenterX = (this.bounds.minX + this.bounds.maxX) / 2;
+    const nodeCenterY = (this.bounds.minY + this.bounds.maxY) / 2;
+    for (const [connectionName, { start: start2, end }] of this.portPairMap.entries()) {
+      if (start2.z === end.z) {
+        const isVertical = Math.abs(start2.x - end.x) < 1e-9;
+        const isHorizontal = Math.abs(start2.y - end.y) < 1e-9;
+        if (isVertical || isHorizontal) {
+          this.placeholderPaths.set(connectionName, [
+            start2,
+            this._padByPlaceholderWallBuffer(start2),
+            this._padByPlaceholderWallBuffer(end),
+            end
+          ]);
+        } else {
+          this.placeholderPaths.set(connectionName, [start2, end]);
+        }
+      } else {
+        const midX = (start2.x + end.x) / 2;
+        const midY = (start2.y + end.y) / 2;
+        const midStart = this._padByPlaceholderWallBuffer({
+          x: midX,
+          y: midY,
+          z: start2.z
+        });
+        const midEnd = this._padByPlaceholderWallBuffer({
+          x: midX,
+          y: midY,
+          z: end.z
+        });
+        this.placeholderPaths.set(connectionName, [
+          start2,
+          this._padByPlaceholderWallBuffer(start2),
+          midStart,
+          midEnd,
+          this._padByPlaceholderWallBuffer(end),
+          end
+        ]);
+      }
+    }
+    this.currentConnectionName = this.unprocessedConnections.pop();
+    const start = this.portPairMap.get(this.currentConnectionName).start;
+    this.currentHead = this._padByNewHeadWallBuffer(start);
+    this.currentPath = [start, this.currentHead];
+    this.placeholderPaths.delete(this.currentConnectionName);
+  }
+  _padByNewHeadWallBuffer(point) {
+    return {
+      x: clamp(
+        point.x,
+        this.bounds.minX + this.NEW_HEAD_WALL_BUFFER_DISTANCE,
+        this.bounds.maxX - this.NEW_HEAD_WALL_BUFFER_DISTANCE
+      ),
+      y: clamp(
+        point.y,
+        this.bounds.minY + this.NEW_HEAD_WALL_BUFFER_DISTANCE,
+        this.bounds.maxY - this.NEW_HEAD_WALL_BUFFER_DISTANCE
+      ),
+      z: point.z
+    };
+  }
+  _padByPlaceholderWallBuffer(point) {
+    return {
+      x: clamp(
+        point.x,
+        this.bounds.minX + this.PLACEHOLDER_WALL_BUFFER_DISTANCE,
+        this.bounds.maxX - this.PLACEHOLDER_WALL_BUFFER_DISTANCE
+      ),
+      y: clamp(
+        point.y,
+        this.bounds.minY + this.PLACEHOLDER_WALL_BUFFER_DISTANCE,
+        this.bounds.maxY - this.PLACEHOLDER_WALL_BUFFER_DISTANCE
+      ),
+      z: point.z
+    };
+  }
+  _step() {
+    if (this.solved) return;
+    const targetEnd = this.portPairMap.get(this.currentConnectionName).end;
+    const proposedSegment = [this.currentHead, targetEnd];
+    let closestIntersection = null;
+    let intersectedSegmentZ = null;
+    const checkIntersectionsWithPathMap = (pathMap) => {
+      for (const path of pathMap.values()) {
+        for (let i = 0; i < path.length - 1; i++) {
+          const segment = [path[i], path[i + 1]];
+          if (segment[0].x === segment[1].x && segment[0].y === segment[1].y) {
+            continue;
+          }
+          if (segment[0].z !== this.currentHead.z) {
+            continue;
+          }
+          const intersection = getSegmentIntersection(
+            proposedSegment[0],
+            proposedSegment[1],
+            segment[0],
+            segment[1]
+          );
+          if (intersection) {
+            const distToIntersection = distance(this.currentHead, intersection);
+            if (distToIntersection < 1e-6) continue;
+            if (!closestIntersection || distToIntersection < closestIntersection.dist) {
+              closestIntersection = {
+                point: intersection,
+                dist: distToIntersection
+              };
+              intersectedSegmentZ = segment[0].z;
+            }
+          }
+        }
+      }
+    };
+    checkIntersectionsWithPathMap(this.completedPaths);
+    checkIntersectionsWithPathMap(this.placeholderPaths);
+    const needsZChange = this.currentHead.z !== targetEnd.z;
+    if (closestIntersection) {
+      let viaXY;
+      const distToIntersection = closestIntersection.dist;
+      if (distToIntersection < this.VIA_INTERSECTION_BUFFER_DISTANCE) {
+        viaXY = midpoint(this.currentHead, closestIntersection.point);
+      } else {
+        const intersectionPoint = closestIntersection.point;
+        const vectorX = intersectionPoint.x - this.currentHead.x;
+        const vectorY = intersectionPoint.y - this.currentHead.y;
+        const ratio = (distToIntersection - this.VIA_INTERSECTION_BUFFER_DISTANCE) / distToIntersection;
+        viaXY = {
+          x: this.currentHead.x + vectorX * ratio,
+          y: this.currentHead.y + vectorY * ratio
+        };
+      }
+      const nextZ = this.availableZ.find((z) => z !== intersectedSegmentZ);
+      if (nextZ === void 0) {
+        console.error("Could not determine next Z level for via placement!");
+        this.failed = true;
+        return;
+      }
+      const viaPoint1 = { ...viaXY, z: this.currentHead.z };
+      const viaPoint2 = { ...viaXY, z: nextZ };
+      this.currentPath.push(viaPoint1, viaPoint2);
+      this.currentHead = viaPoint2;
+    } else if (needsZChange) {
+      let viaXY;
+      const distToTarget = distance(this.currentHead, targetEnd);
+      if (distToTarget < this.VIA_INTERSECTION_BUFFER_DISTANCE) {
+        viaXY = midpoint(this.currentHead, targetEnd);
+      } else {
+        const vectorX = targetEnd.x - this.currentHead.x;
+        const vectorY = targetEnd.y - this.currentHead.y;
+        const ratio = (distToTarget - this.VIA_INTERSECTION_BUFFER_DISTANCE) / distToTarget;
+        viaXY = {
+          x: this.currentHead.x + vectorX * ratio,
+          y: this.currentHead.y + vectorY * ratio
+        };
+      }
+      const nextZ = targetEnd.z;
+      const viaPoint1 = { ...viaXY, z: this.currentHead.z };
+      const viaPoint2 = { ...viaXY, z: nextZ };
+      this.currentPath.push(viaPoint1, viaPoint2);
+      this.currentHead = viaPoint2;
+    } else {
+      this.currentPath.push(targetEnd);
+      this.completedPaths.set(this.currentConnectionName, this.currentPath);
+      if (this.unprocessedConnections.length === 0) {
+        this.solved = true;
+        this.stats.solutionsFound = 1;
+      } else {
+        this.currentConnectionName = this.unprocessedConnections.pop();
+        const { start } = this.portPairMap.get(this.currentConnectionName);
+        this.currentHead = this._padByNewHeadWallBuffer(start);
+        this.currentPath = [start, this.currentHead];
+        this.placeholderPaths.delete(this.currentConnectionName);
+      }
+    }
+  }
+  visualize() {
+    const graphics = {
+      points: [],
+      lines: [],
+      circles: [],
+      rects: [],
+      title: "Via Possibilities Solver State",
+      coordinateSystem: "cartesian"
+    };
+    const colorMap = this.colorMap;
+    graphics.lines.push({
+      points: [
+        { x: this.bounds.minX, y: this.bounds.minY },
+        { x: this.bounds.maxX, y: this.bounds.minY },
+        { x: this.bounds.maxX, y: this.bounds.maxY },
+        { x: this.bounds.minX, y: this.bounds.maxY },
+        { x: this.bounds.minX, y: this.bounds.minY }
+      ],
+      strokeColor: "gray",
+      strokeWidth: 0.01
+    });
+    for (const [connectionName, { start, end }] of this.portPairMap.entries()) {
+      const color = this.colorMap[connectionName] ?? "black";
+      graphics.points.push({
+        x: start.x,
+        y: start.y,
+        color,
+        label: `Port: ${connectionName} Start (z${start.z})`
+      });
+      graphics.points.push({
+        x: end.x,
+        y: end.y,
+        color,
+        label: `Port: ${connectionName} End (z${end.z})`
+      });
+    }
+    const drawPath = (pathMap, labelPrefix) => {
+      for (const [connectionName, path] of pathMap.entries()) {
+        const color = colorMap[connectionName] ?? "black";
+        for (let i = 0; i < path.length - 1; i++) {
+          const p1 = path[i];
+          const p2 = path[i + 1];
+          if (p1.x === p2.x && p1.y === p2.y && p1.z !== p2.z) {
+            graphics.circles.push({
+              center: { x: p1.x, y: p1.y },
+              radius: 0.3,
+              // Diameter 0.6
+              fill: safeTransparentize(color, 0.5),
+              label: `${labelPrefix}: ${connectionName} Via (z${p1.z}->z${p2.z})`
+            });
+          } else {
+            graphics.lines.push({
+              points: [p1, p2],
+              strokeColor: safeTransparentize(color, 0.5),
+              strokeDash: p1.z === 0 ? void 0 : [0.1, 0.1],
+              strokeWidth: 0.1,
+              label: `${labelPrefix}: ${connectionName} (z${p1.z})`
+            });
+          }
+        }
+      }
+    };
+    drawPath(this.placeholderPaths, "Placeholder");
+    drawPath(this.completedPaths, "Completed");
+    if (this.currentPath && this.currentPath.length > 0) {
+      const color = colorMap[this.currentConnectionName] ?? "orange";
+      for (let i = 0; i < this.currentPath.length - 1; i++) {
+        const p1 = this.currentPath[i];
+        const p2 = this.currentPath[i + 1];
+        if (p1.x === p2.x && p1.y === p2.y && p1.z !== p2.z) {
+          graphics.circles.push({
+            center: { x: p1.x, y: p1.y },
+            radius: 0.3,
+            fill: safeTransparentize(color, 0.5),
+            label: `Current: ${this.currentConnectionName} Via (z${p1.z}->z${p2.z})`
+          });
+        } else {
+          graphics.lines.push({
+            points: [p1, p2],
+            strokeColor: safeTransparentize(color, 0.5),
+            strokeWidth: 0.15,
+            // Thicker
+            strokeDash: "2,2",
+            // Dashed
+            label: `Current: ${this.currentConnectionName} (z${p1.z})`
+          });
+        }
+      }
+      graphics.points.push({
+        x: this.currentHead.x,
+        y: this.currentHead.y,
+        color: "green",
+        label: `Current Head: ${this.currentConnectionName} (z${this.currentHead.z})`
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/utils/getIntraNodeCrossings.ts
 var getIntraNodeCrossings = (node) => {
   let numSameLayerCrossings = 0;
@@ -6262,10 +6629,13 @@ var Vertex = class {
   y;
   out;
   // Outgoing half-edge indices
+  connectionNames;
+  // Names of connections passing through this vertex
   constructor(x, y) {
     this.x = x;
     this.y = y;
     this.out = [];
+    this.connectionNames = /* @__PURE__ */ new Set();
   }
 };
 var HalfEdge = class {
@@ -6349,9 +6719,17 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       return t1 - t2;
     });
     for (let k = 0; k < list.length - 1; ++k) {
-      const v1 = getVertexId(list[k]);
-      const v2 = getVertexId(list[k + 1]);
-      if (v1 !== v2) undirectedEdges.push([v1, v2]);
+      const p1 = list[k];
+      const p2 = list[k + 1];
+      const v1 = getVertexId(p1);
+      const v2 = getVertexId(p2);
+      if (v1 !== v2) {
+        undirectedEdges.push([v1, v2]);
+        if (s.connectionName) {
+          vertices[v1].connectionNames.add(s.connectionName);
+          vertices[v2].connectionNames.add(s.connectionName);
+        }
+      }
     }
   }
   const halfEdges = [];
@@ -6408,8 +6786,11 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       if (c) {
         centroids.push(c);
         faces.push({
-          vertices: poly.map((p) => ({ x: p.x, y: p.y })),
-          // Convert Vertex back to simple Point
+          vertices: poly.map((v) => ({
+            x: v.x,
+            y: v.y,
+            connectionNames: v.connectionNames.size > 0 ? v.connectionNames : void 0
+          })),
           centroid: c
         });
       }
@@ -6995,6 +7376,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
   obstacleMargin = 0.1;
   traceWidth = 0.15;
   availableZ = [];
+  uniqueConnections = 0;
   lastCandidate = null;
   maxViaCount;
   minViaCount;
@@ -7022,6 +7404,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     const uniqueConnections = new Set(
       this.nodeWithPortPoints.portPoints.map((pp) => pp.connectionName)
     ).size;
+    this.uniqueConnections = uniqueConnections;
     const { numSameLayerCrossings, numTransitions } = getIntraNodeCrossings(
       this.nodeWithPortPoints
     );
@@ -7030,11 +7413,6 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
       Math.floor(areaInsideNode / areaPerVia),
       Math.ceil(uniqueConnections * 1.5)
     );
-    if (uniqueConnections > 5) {
-      this.failed = true;
-      this.error = `Limit is currently set to 6 unique connections, ${uniqueConnections} found`;
-      return;
-    }
     if (this.minViaCount > this.SEGMENTS_PER_POLYLINE * (uniqueConnections / 2)) {
       this.failed = true;
       this.error = `Not possible to solve problem with given SEGMENTS_PER_POLYLINE (${this.SEGMENTS_PER_POLYLINE}), atleast ${this.minViaCount} vias are required`;
@@ -7773,7 +8151,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
             strokeColor: segmentColor,
             strokeWidth: this.traceWidth,
             // TODO: Use actual trace thickness from HighDensityRoute?
-            strokeDash: !isLayer0 ? "5,5" : void 0,
+            strokeDash: !isLayer0 ? [0.15, 0.15] : void 0,
             // Dashed for layers > 0
             label: `${polyLine.connectionName} segment (z=${segmentLayer})`
           });
@@ -8259,6 +8637,191 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
   }
 };
 
+// lib/solvers/HighDensitySolver/MultiHeadPolyLineIntraNodeSolver/MultiHeadPolyLineIntraNodeSolver3_ViaPossibilitiesSolverIntegration.ts
+var hashPolyLines = (polyLines) => {
+  return polyLines.flatMap(
+    (pl) => `${pl.connectionName}-${pl.mPoints.map((mp) => `${mp.x.toFixed(2)},${mp.y.toFixed(2)},${mp.z1},${mp.z2}`)}`
+  ).sort().join("|");
+};
+function factorial(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new RangeError("n must be a non-negative integer");
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+var MultiHeadPolyLineIntraNodeSolver3 = class extends MultiHeadPolyLineIntraNodeSolver2 {
+  constructor(params) {
+    super(params);
+    this.MAX_ITERATIONS = 1e3;
+  }
+  createInitialCandidateFromSeed(shuffleSeed) {
+    const viaSolver = new ViaPossibilitiesSolver2({
+      nodeWithPortPoints: this.nodeWithPortPoints,
+      colorMap: this.colorMap,
+      // Pass relevant hyperparameters if needed, e.g., shuffle seed
+      hyperParameters: {
+        SHUFFLE_SEED: shuffleSeed
+      }
+    });
+    viaSolver.solve();
+    if (viaSolver.failed || !viaSolver.solved) {
+      this.failed = true;
+      this.error = viaSolver.error ?? "ViaPossibilitiesSolver2 failed to find a solution.";
+      console.error(this.error);
+      return null;
+    }
+    const polyLines = [];
+    let totalViaCount = 0;
+    for (const [
+      connectionName,
+      pathPoints
+    ] of viaSolver.completedPaths.entries()) {
+      if (pathPoints.length < 2) {
+        console.warn(
+          `Skipping connection "${connectionName}" due to insufficient points (${pathPoints.length}) in ViaPossibilitiesSolver2 path.`
+        );
+        continue;
+      }
+      const startPoint = pathPoints[0];
+      const endPoint = pathPoints[pathPoints.length - 1];
+      const middlePointsRaw = pathPoints.slice(1, -1);
+      const mPoints = [];
+      let currentViaCount = 0;
+      let lastZ = startPoint.z;
+      for (let i = 0; i < middlePointsRaw.length; i++) {
+        const currentRawPoint = middlePointsRaw[i];
+        const nextRawPoint = i + 1 < middlePointsRaw.length ? middlePointsRaw[i + 1] : endPoint;
+        const isViaStart = i + 1 < middlePointsRaw.length && currentRawPoint.x === nextRawPoint.x && currentRawPoint.y === nextRawPoint.y && currentRawPoint.z !== nextRawPoint.z;
+        const z1 = lastZ;
+        const z2 = isViaStart ? nextRawPoint.z : currentRawPoint.z;
+        mPoints.push({
+          x: currentRawPoint.x,
+          y: currentRawPoint.y,
+          z1,
+          z2
+        });
+        if (z1 !== z2) {
+          currentViaCount++;
+          i++;
+          lastZ = z2;
+        } else {
+          lastZ = currentRawPoint.z;
+        }
+      }
+      totalViaCount += currentViaCount;
+      const targetSegmentCount = this.SEGMENTS_PER_POLYLINE;
+      let currentSegments = mPoints.length + 1;
+      while (currentSegments < targetSegmentCount) {
+        let longestSegmentLength = -1;
+        let longestSegmentIndex = -1;
+        let p1 = null;
+        let p2 = null;
+        const fullPathPoints = [
+          {
+            ...startPoint,
+            z1: startPoint.z,
+            z2: startPoint.z,
+            connectionName
+          },
+          ...mPoints,
+          { ...endPoint, z1: endPoint.z, z2: endPoint.z, connectionName }
+        ];
+        for (let k = 0; k < fullPathPoints.length - 1; k++) {
+          const segP1 = fullPathPoints[k];
+          const segP2 = fullPathPoints[k + 1];
+          if (segP1.x === segP2.x && segP1.y === segP2.y) {
+            continue;
+          }
+          const len = distance(segP1, segP2);
+          if (len > longestSegmentLength) {
+            longestSegmentLength = len;
+            longestSegmentIndex = k;
+            p1 = segP1;
+            p2 = segP2;
+          }
+        }
+        if (longestSegmentIndex === -1 || !p1 || !p2) {
+          console.warn(
+            `Could not find longest segment for ${connectionName} while trying to reach ${targetSegmentCount} segments.`
+          );
+          break;
+        }
+        const midX = (p1.x + p2.x) / 2;
+        const midY = (p1.y + p2.y) / 2;
+        const segmentZ = p1.z2;
+        const newMPoint = {
+          x: midX,
+          y: midY,
+          z1: segmentZ,
+          // New point is on the same layer
+          z2: segmentZ
+        };
+        mPoints.splice(longestSegmentIndex, 0, newMPoint);
+        currentSegments++;
+      }
+      polyLines.push({
+        connectionName,
+        start: {
+          // Use original start/end points from ViaSolver
+          ...startPoint,
+          z1: startPoint.z,
+          z2: startPoint.z
+          // Start point is not a via itself
+        },
+        end: {
+          ...endPoint,
+          z1: endPoint.z,
+          // End point uses its own Z as z1
+          z2: endPoint.z
+          // End point is not a via itself
+        },
+        mPoints
+      });
+    }
+    if (polyLines.length === 0) {
+      this.failed = true;
+      this.error = "No valid polylines generated from ViaPossibilitiesSolver2.";
+      console.error(this.error);
+      return null;
+    }
+    const minGaps = this.computeMinGapBtwPolyLines(polyLines);
+    const h = this.computeH({ minGaps, forces: [] });
+    const initialCandidate = {
+      polyLines,
+      g: 0,
+      h,
+      f: 0 + h,
+      // f = g + h
+      viaCount: totalViaCount,
+      minGaps
+    };
+    initialCandidate.g = this.computeG(polyLines, initialCandidate);
+    initialCandidate.f = initialCandidate.g + initialCandidate.h;
+    return initialCandidate;
+  }
+  setupInitialPolyLines() {
+    this.candidates = [];
+    const maxCandidatesToGenerate = Math.min(
+      2e3,
+      factorial(this.uniqueConnections)
+    );
+    const candidatePolylineHashes = /* @__PURE__ */ new Set();
+    for (let i = 0; i < maxCandidatesToGenerate; i++) {
+      const newCandidate = this.createInitialCandidateFromSeed(i);
+      if (!newCandidate) continue;
+      const newCandidatePolylineHash = hashPolyLines(newCandidate.polyLines);
+      if (candidatePolylineHashes.has(newCandidatePolylineHash)) continue;
+      candidatePolylineHashes.add(newCandidatePolylineHash);
+      this.candidates.push(newCandidate);
+    }
+    this.candidates.sort((a, b) => a.f - b.f);
+  }
+};
+
 // lib/solvers/HyperHighDensitySolver/HyperSingleIntraNodeSolver.ts
 var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   constructorParams;
@@ -8381,11 +8944,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         possibleValues: [
           {
             MULTI_HEAD_POLYLINE_SOLVER: true,
-            SEGMENTS_PER_POLYLINE: 3
-          },
-          {
-            MULTI_HEAD_POLYLINE_SOLVER: true,
-            SEGMENTS_PER_POLYLINE: 4
+            SEGMENTS_PER_POLYLINE: 6
           }
         ]
       }
@@ -8412,7 +8971,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
       });
     }
     if (hyperParameters.MULTI_HEAD_POLYLINE_SOLVER) {
-      return new MultiHeadPolyLineIntraNodeSolver2({
+      return new MultiHeadPolyLineIntraNodeSolver3({
         nodeWithPortPoints: this.nodeWithPortPoints,
         hyperParameters
       });
@@ -8502,7 +9061,7 @@ var HighDensitySolver = class extends BaseSolver {
       if (this.failedSolvers.length > 0) {
         this.solved = false;
         this.failed = true;
-        this.error = `Failed to solve ${this.failedSolvers.length} nodes`;
+        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs) => fs.nodeWithPortPoints.capacityMeshNodeId)}`;
         return;
       }
       this.solved = true;
@@ -8533,6 +9092,7 @@ var HighDensitySolver = class extends BaseSolver {
           points: segment.points,
           label: segment.connectionName,
           strokeColor: segment.z === 0 ? segment.color : safeTransparentize(segment.color, 0.75),
+          layer: `z${segment.z}`,
           strokeWidth: route.traceThickness,
           strokeDash: segment.z !== 0 ? "10, 5" : void 0
         });
@@ -8540,6 +9100,7 @@ var HighDensitySolver = class extends BaseSolver {
       for (const via of route.vias) {
         graphics.circles.push({
           center: via,
+          layer: "z0,1",
           radius: route.viaDiameter / 2,
           fill: this.colorMap[route.connectionName],
           label: `${route.connectionName} via`
@@ -8555,6 +9116,7 @@ var HighDensitySolver = class extends BaseSolver {
           x: node.center.x - rectWidth / 2,
           y: node.center.y - rectHeight / 2
         },
+        layer: "did_not_connect",
         width: rectWidth,
         height: rectHeight,
         fill: "red",
@@ -8574,7 +9136,8 @@ var HighDensitySolver = class extends BaseSolver {
           graphics.lines.push({
             points: [start, end],
             strokeColor: "red",
-            strokeDash: "10, 5"
+            strokeDash: "10, 5",
+            layer: "did_not_connect"
           });
         }
       }
@@ -11476,7 +12039,7 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
 }
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionPathingSolver.ts
-var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
+var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   GREEDY_MULTIPLIER = 1.5;
   sectionNodes;
   sectionEdges;
@@ -11488,6 +12051,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   colorMap;
   usedNodeCapacityMap;
   // Tracks capacity usage *within this solver's run*
+  centerNodeId;
   MAX_CANDIDATES_IN_MEMORY = 1e4;
   // A* state
   currentConnectionIndex = 0;
@@ -11501,6 +12065,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   // Default, similar to CapacityPathingSolver5
   constructor(params) {
     super();
+    this.centerNodeId = params.centerNodeId;
     this.sectionNodes = params.sectionNodes;
     this.sectionEdges = params.sectionEdges;
     this.sectionConnectionTerminals = params.sectionConnectionTerminals.map(
@@ -11674,6 +12239,28 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
       candidates.push(newCandidate);
     }
   }
+  computeProgress() {
+    const totalConnections = this.sectionConnectionTerminals.length;
+    if (totalConnections === 0) return 1;
+    const completedConnections = this.currentConnectionIndex;
+    let progress = completedConnections / totalConnections;
+    if (this.currentConnectionIndex < totalConnections && this.candidates && this.candidates.length > 0 && this.activeCandidateStraightLineDistance && this.activeCandidateStraightLineDistance > 0) {
+      const bestCandidate = this.candidates.reduce(
+        (best, current) => current.f < best.f ? current : best
+      );
+      const currentConnectionProgress = Math.max(
+        0,
+        Math.min(
+          1,
+          1 - bestCandidate.h / this.activeCandidateStraightLineDistance
+        )
+      );
+      progress += currentConnectionProgress / totalConnections;
+    } else if (this.solved) {
+      progress = 1;
+    }
+    return Math.min(1, progress);
+  }
   _setupAStar(startNode, endNode) {
     this.candidates = [
       { prevCandidate: null, node: startNode, f: 0, g: 0, h: 0 }
@@ -11778,133 +12365,157 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
     return baseGraphics;
   }
 };
+var CapacityPathingSingleSectionPathingSolver = CapacityPathingSingleSectionSolver;
 
-// lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionSolver.ts
-var CapacityPathingSingleSectionSolver = class extends BaseSolver {
-  centerNodeId;
-  connectionsWithNodes;
-  nodes;
-  nodeMap;
-  edges;
-  nodeEdgeMap;
-  expansionDegrees;
-  colorMap;
-  sectionNodes;
-  sectionEdges;
-  // Added sectionEdges property
-  sectionConnectionTerminals;
-  activeSubSolver = null;
+// lib/solvers/CapacityPathingSectionSolver/HyperCapacityPathingSingleSectionSolver.ts
+var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSupervisorSolver {
+  constructorParams;
+  winningSolver;
   constructor(params) {
     super();
-    this.MAX_ITERATIONS = 1e5;
-    this.colorMap = params.colorMap;
-    this.centerNodeId = params.centerNodeId;
-    this.connectionsWithNodes = params.connectionsWithNodes;
-    this.nodes = params.nodes;
-    this.nodeMap = new Map(this.nodes.map((n) => [n.capacityMeshNodeId, n]));
-    this.edges = params.edges;
-    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.expansionDegrees = params.hyperParameters?.EXPANSION_DEGREES ?? 3;
-    this.sectionNodes = [];
-    this.sectionEdges = [];
-    this.sectionConnectionTerminals = [];
-    this.computeSectionNodesTerminalsAndEdges();
-    this.activeSubSolver = new CapacityPathingSingleSectionPathingSolver({
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      colorMap: this.colorMap,
-      hyperParameters: params.hyperParameters
-    });
+    this.MAX_ITERATIONS = 1e4;
+    this.constructorParams = params;
   }
-  computeSectionNodesTerminalsAndEdges() {
-    const sectionNodeIds = /* @__PURE__ */ new Set();
-    const queue = [
-      { nodeId: this.centerNodeId, depth: 0 }
-    ];
-    sectionNodeIds.add(this.centerNodeId);
-    let head = 0;
-    while (head < queue.length) {
-      const { nodeId, depth } = queue[head++];
-      if (depth >= this.expansionDegrees) continue;
-      const neighbors = this.nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
-      for (const neighborId of neighbors) {
-        if (!sectionNodeIds.has(neighborId)) {
-          sectionNodeIds.add(neighborId);
-          queue.push({ nodeId: neighborId, depth: depth + 1 });
-        }
-      }
-    }
-    this.sectionNodes = Array.from(sectionNodeIds).map(
-      (id) => this.nodeMap.get(id)
-    );
-    this.sectionEdges = this.edges.filter((edge) => {
-      const [nodeIdA, nodeIdB] = edge.nodeIds;
-      return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
-    });
-    this.sectionConnectionTerminals = [];
-    for (const conn of this.connectionsWithNodes) {
-      if (!conn.path) continue;
-      let startNodeId = null;
-      let endNodeId = null;
-      for (const node of conn.path) {
-        if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-          startNodeId = node.capacityMeshNodeId;
-          break;
-        }
-      }
-      for (let i = conn.path.length - 1; i >= 0; i--) {
-        const node = conn.path[i];
-        if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-          endNodeId = node.capacityMeshNodeId;
-          break;
-        }
-      }
-      if (startNodeId && endNodeId) {
-        this.sectionConnectionTerminals.push({
-          connectionName: conn.connection.name,
-          startNodeId,
-          endNodeId
-        });
-      }
-    }
+  computeG(solver) {
+    return solver.iterations / 100;
   }
-  _step() {
-    this.activeSubSolver?.step();
-    if (this.activeSubSolver?.solved) {
-      this.solved = true;
-      return;
-    }
-    if (this.activeSubSolver?.failed) {
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
-      return;
-    }
+  computeH(solver) {
+    return solver.computeProgress();
   }
-  getConstructorParams() {
+  getCombinationDefs() {
+    return [["orderings10"]];
+  }
+  getFailureMessage() {
+    return `All CapacityPathingSingleSection solvers failed for "${this.centerNodeId}"`;
+  }
+  getHyperParameterDefs() {
     return [
       {
-        centerNodeId: this.centerNodeId,
-        connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
-        edges: this.edges,
-        expansionDegrees: this.expansionDegrees
+        name: "orderings10",
+        possibleValues: [
+          {
+            SHUFFLE_SEED: 0
+          },
+          {
+            SHUFFLE_SEED: 1
+          },
+          {
+            SHUFFLE_SEED: 2
+          },
+          {
+            SHUFFLE_SEED: 3
+          },
+          {
+            SHUFFLE_SEED: 4
+          },
+          {
+            SHUFFLE_SEED: 5
+          },
+          {
+            SHUFFLE_SEED: 6
+          },
+          {
+            SHUFFLE_SEED: 7
+          },
+          {
+            SHUFFLE_SEED: 8
+          },
+          {
+            SHUFFLE_SEED: 9
+          }
+        ]
       }
     ];
   }
-  visualize() {
-    return visualizeSection({
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      // Use the computed class property
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      nodeMap: this.nodeMap,
-      colorMap: this.colorMap,
-      centerNodeId: this.centerNodeId,
-      nodeOpacity: 1e-3,
-      title: `Section Solver (Center: ${this.centerNodeId}, Hops: ${this.expansionDegrees})`
+  generateSolver(hyperParameters) {
+    return new CapacityPathingSingleSectionPathingSolver({
+      ...this.constructorParams,
+      hyperParameters: {
+        ...this.constructorParams.hyperParameters,
+        ...hyperParameters
+      }
     });
   }
+  onSolve({
+    solver
+  }) {
+    this.winningSolver = solver;
+  }
+  get centerNodeId() {
+    return this.constructorParams.centerNodeId;
+  }
+  get sectionNodes() {
+    return this.constructorParams.sectionNodes;
+  }
+  get sectionConnectionTerminals() {
+    return this.winningSolver?.sectionConnectionTerminals;
+  }
+};
+
+// lib/solvers/CapacityPathingSectionSolver/computeSectionNodesTerminalsAndEdges.ts
+var computeSectionNodesTerminalsAndEdges = (opts) => {
+  const {
+    centerNodeId,
+    connectionsWithNodes,
+    nodeMap,
+    edges,
+    nodeEdgeMap,
+    expansionDegrees
+  } = opts;
+  const sectionNodeIds = /* @__PURE__ */ new Set();
+  const queue = [
+    { nodeId: centerNodeId, depth: 0 }
+  ];
+  sectionNodeIds.add(centerNodeId);
+  let head = 0;
+  while (head < queue.length) {
+    const { nodeId, depth } = queue[head++];
+    if (depth >= expansionDegrees) continue;
+    const neighbors = nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
+    for (const neighborId of neighbors) {
+      if (!sectionNodeIds.has(neighborId)) {
+        sectionNodeIds.add(neighborId);
+        queue.push({ nodeId: neighborId, depth: depth + 1 });
+      }
+    }
+  }
+  const sectionNodes = Array.from(sectionNodeIds).map((id) => nodeMap.get(id));
+  const sectionEdges = edges.filter((edge) => {
+    const [nodeIdA, nodeIdB] = edge.nodeIds;
+    return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
+  });
+  const sectionConnectionTerminals = [];
+  for (const conn of connectionsWithNodes) {
+    if (!conn.path) continue;
+    let startNodeId = null;
+    let endNodeId = null;
+    for (const node of conn.path) {
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        startNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    for (let i = conn.path.length - 1; i >= 0; i--) {
+      const node = conn.path[i];
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        endNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    if (startNodeId && endNodeId) {
+      sectionConnectionTerminals.push({
+        connectionName: conn.connection.name,
+        startNodeId,
+        endNodeId
+      });
+    }
+  }
+  return {
+    sectionConnectionTerminals,
+    sectionNodes,
+    sectionEdges,
+    centerNodeId
+  };
 };
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingMultiSectionSolver.ts
@@ -11912,6 +12523,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   simpleRouteJson;
   nodes;
   edges;
+  nodeEdgeMap;
   connectionsWithNodes = [];
   // Initialize here
   colorMap;
@@ -11923,12 +12535,18 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   // Added
   nodeCapacityPercentMap = /* @__PURE__ */ new Map();
   nodeOptimizationAttemptCountMap = /* @__PURE__ */ new Map();
+  currentSection = null;
   sectionSolver = null;
-  MAX_ATTEMPTS_PER_NODE = 10;
+  MAX_ATTEMPTS_PER_NODE = 1;
   MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE = 0.05;
-  MAX_EXPANSION_DEGREES = 3;
+  MAX_EXPANSION_DEGREES = 5;
+  stats;
   constructor(params) {
     super();
+    this.stats = {
+      successfulOptimizations: 0,
+      failedOptimizations: 0
+    };
     this.MAX_ITERATIONS = 1e7;
     this.simpleRouteJson = params.simpleRouteJson;
     this.nodes = params.nodes;
@@ -11937,7 +12555,8 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.nodeMap = new Map(
       this.nodes.map((node) => [node.capacityMeshNodeId, node])
     );
-    this.initialSolver = new CapacityPathingGreedySolver({
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
+    this.initialSolver = params.initialPathingSolver || new CapacityPathingGreedySolver({
       simpleRouteJson: this.simpleRouteJson,
       nodes: this.nodes,
       edges: this.edges,
@@ -12002,16 +12621,21 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         this.solved = true;
         return;
       }
-      this.sectionSolver = new CapacityPathingSingleSectionSolver({
+      const section = computeSectionNodesTerminalsAndEdges({
         centerNodeId,
         connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
+        nodeMap: this.nodeMap,
         edges: this.edges,
+        expansionDegrees: this.MAX_EXPANSION_DEGREES,
+        nodeEdgeMap: this.nodeEdgeMap
+      });
+      this.currentSection = section;
+      this.sectionSolver = new HyperCapacityPathingSingleSectionSolver({
+        sectionConnectionTerminals: section.sectionConnectionTerminals,
+        sectionEdges: section.sectionEdges,
+        sectionNodes: section.sectionNodes,
         colorMap: this.colorMap,
-        hyperParameters: {
-          EXPANSION_DEGREES: this.MAX_EXPANSION_DEGREES,
-          SHUFFLE_SEED: this.iterations
-        }
+        centerNodeId: section.centerNodeId
       });
       this.activeSubSolver = this.sectionSolver;
       this.nodeOptimizationAttemptCountMap.set(
@@ -12022,7 +12646,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.sectionSolver.step();
     if (this.sectionSolver.failed) {
       console.warn(
-        `Section solver failed for node ${this.sectionSolver.centerNodeId}. Error: ${this.sectionSolver.error}`
+        `Section solver failed for node ${this.currentSection.centerNodeId}. Error: ${this.sectionSolver.error}`
       );
       this.sectionSolver = null;
       this.activeSubSolver = null;
@@ -12030,12 +12654,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     }
     if (this.sectionSolver.solved) {
       const solvedSectionSolver = this.sectionSolver;
-      const pathingSolver = solvedSectionSolver.activeSubSolver;
+      const pathingSolver = solvedSectionSolver?.activeSubSolver || solvedSectionSolver;
       this.sectionSolver = null;
       this.activeSubSolver = null;
       if (!pathingSolver || !pathingSolver.solved) {
         console.warn(
-          `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Discarding results.`
+          `Pathing sub-solver for section ${this.currentSection.centerNodeId} did not complete successfully. Discarding results.`
         );
         return;
       }
@@ -12085,9 +12709,11 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         sectionNodeIds
       });
       if (afterScore > beforeScore) {
+        this.stats.successfulOptimizations++;
         this._mergeSolvedSectionPaths(solvedSectionSolver);
         this._recalculateNodeCapacityUsage();
       } else {
+        this.stats.failedOptimizations++;
       }
     }
   }
@@ -12096,18 +12722,18 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
    * connectionsWithNodes list.
    */
   _mergeSolvedSectionPaths(solvedSectionSolver) {
-    const pathingSolver = solvedSectionSolver.activeSubSolver;
-    if (!pathingSolver || !pathingSolver.solved) {
+    const centerNodeId = solvedSectionSolver.centerNodeId;
+    if (!solvedSectionSolver || !solvedSectionSolver.solved) {
       console.warn(
-        `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Skipping merge.`
+        `Pathing sub-solver for section ${centerNodeId} did not complete successfully. Skipping merge.`
       );
       return;
     }
-    const solvedTerminals = pathingSolver.sectionConnectionTerminals;
+    const solvedTerminals = solvedSectionSolver.sectionConnectionTerminals;
     for (const solvedTerminal of solvedTerminals) {
       if (!solvedTerminal.path) {
         console.warn(
-          `No path found for connection ${solvedTerminal.connectionName} in section ${solvedSectionSolver.centerNodeId}`
+          `No path found for connection ${solvedTerminal.connectionName} in section ${centerNodeId}`
         );
         continue;
       }
@@ -12963,13 +13589,13 @@ function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
   if (segmentsIntersect(A1, A2, B1, B2)) {
     return 0;
   }
-  const distA1 = pointToSegmentDistance5(A1, B1, B2);
-  const distA2 = pointToSegmentDistance5(A2, B1, B2);
-  const distB1 = pointToSegmentDistance5(B1, A1, A2);
-  const distB2 = pointToSegmentDistance5(B2, A1, A2);
+  const distA1 = pointToSegmentDistance6(A1, B1, B2);
+  const distA2 = pointToSegmentDistance6(A2, B1, B2);
+  const distB1 = pointToSegmentDistance6(B1, A1, A2);
+  const distB2 = pointToSegmentDistance6(B2, A1, A2);
   return Math.min(distA1, distA2, distB1, distB2);
 }
-function pointToSegmentDistance5(P, Q1, Q2) {
+function pointToSegmentDistance6(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);
@@ -14471,8 +15097,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   nodeSolver;
   nodeTargetMerger;
   edgeSolver;
-  pathingSolver;
-  // Updated type
+  initialPathingSolver;
+  pathingOptimizer;
   edgeToPortSegmentSolver;
   colorMap;
   segmentToPointSolver;
@@ -14559,12 +15185,28 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       (cms) => [cms.capacityNodes]
     ),
     definePipelineStep(
-      "pathingSolver",
+      "initialPathingSolver",
+      CapacityPathingGreedySolver,
+      (cms) => [
+        {
+          simpleRouteJson: cms.srjWithPointPairs,
+          nodes: cms.capacityNodes,
+          edges: cms.edgeSolver?.edges || [],
+          colorMap: cms.colorMap,
+          hyperParameters: {
+            MAX_CAPACITY_FACTOR: 1
+          }
+        }
+      ]
+    ),
+    definePipelineStep(
+      "pathingOptimizer",
       // CapacityPathingSolver5,
       CapacityPathingMultiSectionSolver,
       (cms) => [
         // Replaced solver class
         {
+          initialPathingSolver: cms.initialPathingSolver,
           simpleRouteJson: cms.srjWithPointPairs,
           nodes: cms.capacityNodes,
           edges: cms.edgeSolver?.edges || [],
@@ -14582,7 +15224,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         {
           nodes: cms.capacityNodes,
           edges: cms.edgeSolver?.edges || [],
-          capacityPaths: cms.pathingSolver?.getCapacityPaths() || [],
+          capacityPaths: cms.pathingOptimizer?.getCapacityPaths() || [],
           colorMap: cms.colorMap
         }
       ]
@@ -14741,7 +15383,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     const singleLayerNodeMergerViz = this.singleLayerNodeMerger?.visualize();
     const strawSolverViz = this.strawSolver?.visualize();
     const edgeViz = this.edgeSolver?.visualize();
-    const pathingViz = this.pathingSolver?.visualize();
+    const initialPathingViz = this.initialPathingSolver?.visualize();
+    const pathingOptimizerViz = this.pathingOptimizer?.visualize();
     const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
     const segmentToPointViz = this.segmentToPointSolver?.visualize();
     const segmentOptimizationViz = this.unravelMultiSectionSolver?.visualize() ?? this.segmentToPointOptimizer?.visualize();
@@ -14796,7 +15439,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       singleLayerNodeMergerViz,
       strawSolverViz,
       edgeViz,
-      pathingViz,
+      initialPathingViz,
+      pathingOptimizerViz,
       edgeToPortSegmentViz,
       segmentToPointViz,
       segmentOptimizationViz,
@@ -14838,9 +15482,9 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       }
       return { lines };
     }
-    if (this.pathingSolver) {
+    if (this.pathingOptimizer) {
       const lines = [];
-      for (const connection of this.pathingSolver.connectionsWithNodes) {
+      for (const connection of this.pathingOptimizer.connectionsWithNodes) {
         if (!connection.path) continue;
         lines.push({
           points: connection.path.map((n) => ({