@tscircuit/capacity-autorouter 0.0.56 → 0.0.58

package/dist/index.js

@@ -2945,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) {
@@ -3057,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 = [];
@@ -6140,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 = {};
@@ -6149,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;
@@ -8277,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;
@@ -8399,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
           }
         ]
       }
@@ -8430,7 +8971,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
       });
     }
     if (hyperParameters.MULTI_HEAD_POLYLINE_SOLVER) {
-      return new MultiHeadPolyLineIntraNodeSolver2({
+      return new MultiHeadPolyLineIntraNodeSolver3({
         nodeWithPortPoints: this.nodeWithPortPoints,
         hyperParameters
       });
@@ -8551,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
         });
@@ -8558,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`
@@ -8573,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",
@@ -11530,7 +12074,7 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     this.nodeMap = new Map(
       this.sectionNodes.map((n) => [n.capacityMeshNodeId, n])
     );
-    this.nodeEdgeMap = getNodeEdgeMap(this.sectionEdges);
+    this.nodeEdgeMap = params.nodeEdgeMap ?? getNodeEdgeMap(this.sectionEdges);
     this.colorMap = params.colorMap ?? {};
     this.usedNodeCapacityMap = new Map(
       this.sectionNodes.map((node) => [node.capacityMeshNodeId, 0])
@@ -11993,21 +12537,27 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   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;
     this.edges = params.edges;
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
     this.colorMap = params.colorMap ?? {};
     this.nodeMap = new Map(
       this.nodes.map((node) => [node.capacityMeshNodeId, node])
     );
     this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.initialSolver = new CapacityPathingGreedySolver({
+    this.initialSolver = params.initialPathingSolver || new CapacityPathingGreedySolver({
       simpleRouteJson: this.simpleRouteJson,
       nodes: this.nodes,
       edges: this.edges,
@@ -12086,7 +12636,8 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         sectionEdges: section.sectionEdges,
         sectionNodes: section.sectionNodes,
         colorMap: this.colorMap,
-        centerNodeId: section.centerNodeId
+        centerNodeId: section.centerNodeId,
+        nodeEdgeMap: this.nodeEdgeMap
       });
       this.activeSubSolver = this.sectionSolver;
       this.nodeOptimizationAttemptCountMap.set(
@@ -12160,9 +12711,11 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         sectionNodeIds
       });
       if (afterScore > beforeScore) {
+        this.stats.successfulOptimizations++;
         this._mergeSolvedSectionPaths(solvedSectionSolver);
         this._recalculateNodeCapacityUsage();
       } else {
+        this.stats.failedOptimizations++;
       }
     }
   }
@@ -13038,13 +13591,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);
@@ -14546,8 +15099,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   nodeSolver;
   nodeTargetMerger;
   edgeSolver;
-  pathingSolver;
-  // Updated type
+  initialPathingSolver;
+  pathingOptimizer;
   edgeToPortSegmentSolver;
   colorMap;
   segmentToPointSolver;
@@ -14634,12 +15187,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 || [],
@@ -14657,7 +15226,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         {
           nodes: cms.capacityNodes,
           edges: cms.edgeSolver?.edges || [],
-          capacityPaths: cms.pathingSolver?.getCapacityPaths() || [],
+          capacityPaths: cms.pathingOptimizer?.getCapacityPaths() || [],
           colorMap: cms.colorMap
         }
       ]
@@ -14816,7 +15385,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();
@@ -14871,7 +15441,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       singleLayerNodeMergerViz,
       strawSolverViz,
       edgeViz,
-      pathingViz,
+      initialPathingViz,
+      pathingOptimizerViz,
       edgeToPortSegmentViz,
       segmentToPointViz,
       segmentOptimizationViz,
@@ -14913,9 +15484,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) => ({