@tscircuit/capacity-autorouter 0.0.48 → 0.0.50

package/dist/index.js

@@ -965,7 +965,7 @@ var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxD
 };
 
 // lib/data-structures/ObstacleTree.ts
-var ObstacleTree = class {
+var ObstacleSpatialHashIndex = class {
   constructor(obstacles) {
     this.obstacles = obstacles;
     this.buckets = /* @__PURE__ */ new Map();
@@ -1109,7 +1109,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     ];
     this.finishedNodes = [];
     this.nodeToXYOverlappingObstaclesMap = /* @__PURE__ */ new Map();
-    this.obstacleTree = new ObstacleTree(this.srj.obstacles);
+    this.obstacleTree = new ObstacleSpatialHashIndex(this.srj.obstacles);
     this.targets = this.computeTargets();
     this.targetTree = new TargetTree(this.targets);
   }
@@ -8358,26 +8358,59 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       return;
     }
     if (layerChangeBtwHeadAndTail && layerChangeAtDistance > 0) {
-      const pointBeforeChange = this.getPointAtDistance(layerChangeAtDistance);
+      const indexAfterLayerChange = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
+      const pointAfterChange = this.inputRoute.route[indexAfterLayerChange];
+      const viaLocation = { x: pointAfterChange.x, y: pointAfterChange.y };
       if (this.lastValidPath) {
         this.addPathToResult(this.lastValidPath);
         this.lastValidPath = null;
       }
-      const indexAfterLayerChange = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
-      const pointAfterChange = this.inputRoute.route[indexAfterLayerChange];
-      this.newVias.push({
-        x: pointAfterChange.x,
-        y: pointAfterChange.y
+      const lastPointInNewRoute = this.newRoute[this.newRoute.length - 1];
+      if (lastPointInNewRoute.x !== viaLocation.x || lastPointInNewRoute.y !== viaLocation.y) {
+        this.newRoute.push({
+          x: viaLocation.x,
+          y: viaLocation.y,
+          z: lastPointInNewRoute.z
+          // Use the Z of the layer we are leaving
+        });
+      }
+      this.newVias.push(viaLocation);
+      this.newRoute.push({
+        x: viaLocation.x,
+        y: viaLocation.y,
+        z: pointAfterChange.z
+        // Use the Z of the layer we are entering
       });
-      this.newRoute.push(pointAfterChange);
       this.currentStepSize = this.maxStepSize;
-      if (this.pathSegments[indexAfterLayerChange]) {
-        this.tailDistanceAlongPath = this.pathSegments[indexAfterLayerChange].startDistance;
+      const segmentIndexAfterChange = this.pathSegments.findIndex(
+        (seg) => seg.start === pointAfterChange
+      );
+      if (segmentIndexAfterChange !== -1) {
+        this.tailDistanceAlongPath = this.pathSegments[segmentIndexAfterChange].startDistance;
         this.headDistanceAlongPath = this.tailDistanceAlongPath;
+        this.lastValidPath = null;
+        this.lastValidPathHeadDistance = this.tailDistanceAlongPath;
+      } else if (indexAfterLayerChange < this.inputRoute.route.length) {
+        console.warn(
+          "Fallback used for tailDistanceAlongPath after layer change"
+        );
+        const segment = this.pathSegments.find(
+          (seg) => seg.start === this.inputRoute.route[indexAfterLayerChange]
+        );
+        if (segment) {
+          this.tailDistanceAlongPath = segment.startDistance;
+          this.headDistanceAlongPath = this.tailDistanceAlongPath;
+          this.lastValidPath = null;
+          this.lastValidPathHeadDistance = this.tailDistanceAlongPath;
+        } else {
+          console.error(
+            "Could not find segment start after layer change, path might be incomplete."
+          );
+          this.solved = true;
+        }
       } else {
-        console.error("Creating via at end, this is probably not right");
+        console.warn("Layer change occurred at the end of the path.");
         this.solved = true;
-        return;
       }
       return;
     }
@@ -8773,6 +8806,537 @@ var CapacityMeshEdgeSolver2_NodeTreeOptimization = class extends CapacityMeshEdg
   }
 };
 
+// lib/data-structures/HighDensityRouteSpatialIndex.ts
+var getSegmentBounds2 = (segment) => {
+  return {
+    minX: Math.min(segment[0].x, segment[1].x),
+    maxX: Math.max(segment[0].x, segment[1].x),
+    minY: Math.min(segment[0].y, segment[1].y),
+    maxY: Math.max(segment[0].y, segment[1].y)
+  };
+};
+function computeDistSq(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return dx * dx + dy * dy;
+}
+function pointToSegmentDistanceSq(p, a, b) {
+  const l2 = computeDistSq(a, b);
+  if (l2 === 0) return computeDistSq(p, a);
+  let t = ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / l2;
+  t = Math.max(0, Math.min(1, t));
+  const projection = {
+    x: a.x + t * (b.x - a.x),
+    y: a.y + t * (b.y - a.y)
+  };
+  return computeDistSq(p, projection);
+}
+function segmentToSegmentDistanceSq(a, b, c, d) {
+  if (doSegmentsIntersect(a, b, c, d)) {
+    return 0;
+  }
+  const pA = { x: a.x, y: a.y };
+  const pB = { x: b.x, y: b.y };
+  const pC = { x: c.x, y: c.y };
+  const pD = { x: d.x, y: d.y };
+  return Math.min(
+    pointToSegmentDistanceSq(pA, pC, pD),
+    pointToSegmentDistanceSq(pB, pC, pD),
+    pointToSegmentDistanceSq(pC, pA, pB),
+    pointToSegmentDistanceSq(pD, pA, pB)
+  );
+}
+var HighDensityRouteSpatialIndex = class {
+  segmentBuckets;
+  viaBuckets;
+  // New: Store vias
+  routes;
+  CELL_SIZE;
+  constructor(routes, cellSize = 1) {
+    this.segmentBuckets = /* @__PURE__ */ new Map();
+    this.viaBuckets = /* @__PURE__ */ new Map();
+    this.routes = /* @__PURE__ */ new Map();
+    this.CELL_SIZE = cellSize;
+    const epsilon = 1e-9;
+    for (const route of routes) {
+      if (!route || !route.connectionName) {
+        console.warn("Skipping route with missing data:", route);
+        continue;
+      }
+      if (this.routes.has(route.connectionName)) {
+        console.warn(
+          `Skipping duplicate route connectionName: ${route.connectionName}`
+        );
+        continue;
+      }
+      this.routes.set(route.connectionName, route);
+      if (route.route && route.route.length >= 2) {
+        for (let i = 0; i < route.route.length - 1; i++) {
+          const p1 = route.route[i];
+          const p2 = route.route[i + 1];
+          if (p1.x === p2.x && p1.y === p2.y) continue;
+          const segment = [p1, p2];
+          const bounds = getSegmentBounds2(segment);
+          const segmentInfo = {
+            segmentId: `${route.connectionName}-seg-${i}`,
+            segment,
+            parentRoute: route
+          };
+          const minIndexX = Math.floor(bounds.minX / this.CELL_SIZE);
+          const maxIndexX = Math.floor((bounds.maxX + epsilon) / this.CELL_SIZE);
+          const minIndexY = Math.floor(bounds.minY / this.CELL_SIZE);
+          const maxIndexY = Math.floor((bounds.maxY + epsilon) / this.CELL_SIZE);
+          for (let ix = minIndexX; ix <= maxIndexX; ix++) {
+            for (let iy = minIndexY; iy <= maxIndexY; iy++) {
+              const bucketKey = `${ix}x${iy}`;
+              let bucketList = this.segmentBuckets.get(bucketKey);
+              if (!bucketList) {
+                bucketList = [];
+                this.segmentBuckets.set(bucketKey, bucketList);
+              }
+              bucketList.push(segmentInfo);
+            }
+          }
+        }
+      }
+      if (route.vias && route.vias.length > 0) {
+        for (let i = 0; i < route.vias.length; i++) {
+          const via = route.vias[i];
+          if (via === void 0 || via === null) continue;
+          const storedVia = {
+            viaId: `${route.connectionName}-via-${i}`,
+            x: via.x,
+            y: via.y,
+            parentRoute: route
+          };
+          const ix = Math.floor(via.x / this.CELL_SIZE);
+          const iy = Math.floor(via.y / this.CELL_SIZE);
+          const bucketKey = `${ix}x${iy}`;
+          let bucketList = this.viaBuckets.get(bucketKey);
+          if (!bucketList) {
+            bucketList = [];
+            this.viaBuckets.set(bucketKey, bucketList);
+          }
+          bucketList.push(storedVia);
+        }
+      }
+    }
+  }
+  /**
+   * Finds routes that potentially conflict with a given line segment within a margin.
+   * Checks both segments and vias.
+   * @param segmentStart Start point of the query segment.
+   * @param segmentEnd End point of the query segment.
+   * @param margin The minimum required clearance distance from the query segment's centerline.
+   * @returns An array of conflicting routes and their minimum distance to the segment.
+   */
+  getConflictingRoutesForSegment(segmentStart, segmentEnd, margin) {
+    const querySegment = [segmentStart, segmentEnd];
+    const bounds = getSegmentBounds2(querySegment);
+    const searchMinX = bounds.minX - margin;
+    const searchMinY = bounds.minY - margin;
+    const searchMaxX = bounds.maxX + margin;
+    const searchMaxY = bounds.maxY + margin;
+    const epsilon = 1e-9;
+    const minIndexX = Math.floor(searchMinX / this.CELL_SIZE);
+    const maxIndexX = Math.floor((searchMaxX + epsilon) / this.CELL_SIZE);
+    const minIndexY = Math.floor(searchMinY / this.CELL_SIZE);
+    const maxIndexY = Math.floor((searchMaxY + epsilon) / this.CELL_SIZE);
+    const conflictingRouteData = /* @__PURE__ */ new Map();
+    const checkedSegments = /* @__PURE__ */ new Set();
+    const checkedVias = /* @__PURE__ */ new Set();
+    const queryP1 = { x: segmentStart.x, y: segmentStart.y };
+    const queryP2 = { x: segmentEnd.x, y: segmentEnd.y };
+    for (let ix = minIndexX; ix <= maxIndexX; ix++) {
+      for (let iy = minIndexY; iy <= maxIndexY; iy++) {
+        const bucketKey = `${ix}x${iy}`;
+        const segmentBucketList = this.segmentBuckets.get(bucketKey);
+        if (segmentBucketList) {
+          for (const segmentInfo of segmentBucketList) {
+            if (checkedSegments.has(segmentInfo.segmentId)) continue;
+            checkedSegments.add(segmentInfo.segmentId);
+            const route = segmentInfo.parentRoute;
+            const [p1, p2] = segmentInfo.segment;
+            const requiredSeparation = margin + route.traceThickness / 2;
+            const requiredSeparationSq = requiredSeparation * requiredSeparation;
+            const distSq = segmentToSegmentDistanceSq(
+              segmentStart,
+              segmentEnd,
+              p1,
+              p2
+            );
+            if (distSq < requiredSeparationSq) {
+              const routeName = route.connectionName;
+              const existing = conflictingRouteData.get(routeName);
+              if (!existing || distSq < existing.minDistSq) {
+                conflictingRouteData.set(routeName, {
+                  route,
+                  minDistSq: distSq
+                });
+              }
+            }
+          }
+        }
+        const viaBucketList = this.viaBuckets.get(bucketKey);
+        if (viaBucketList) {
+          for (const viaInfo of viaBucketList) {
+            if (checkedVias.has(viaInfo.viaId)) continue;
+            checkedVias.add(viaInfo.viaId);
+            const route = viaInfo.parentRoute;
+            const viaPoint = { x: viaInfo.x, y: viaInfo.y };
+            const requiredSeparation = margin + route.viaDiameter / 2;
+            const requiredSeparationSq = requiredSeparation * requiredSeparation;
+            const distSq = pointToSegmentDistanceSq(viaPoint, queryP1, queryP2);
+            if (distSq < requiredSeparationSq) {
+              const routeName = route.connectionName;
+              const existing = conflictingRouteData.get(routeName);
+              if (!existing || distSq < existing.minDistSq) {
+                conflictingRouteData.set(routeName, {
+                  route,
+                  minDistSq: distSq
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    const results = [];
+    for (const data of conflictingRouteData.values()) {
+      results.push({
+        conflictingRoute: data.route,
+        distance: Math.sqrt(data.minDistSq)
+      });
+    }
+    return results;
+  }
+  /**
+   * Finds routes that pass near a given point within a margin.
+   * Checks both segments and vias.
+   * @param point The query point {x, y}. Z is ignored.
+   * @param margin The minimum required clearance distance from the query point.
+   * @returns An array of conflicting routes and their minimum distance to the point.
+   */
+  getConflictingRoutesNearPoint(point, margin) {
+    const searchMinX = point.x - margin;
+    const searchMinY = point.y - margin;
+    const searchMaxX = point.x + margin;
+    const searchMaxY = point.y + margin;
+    const epsilon = 1e-9;
+    const minIndexX = Math.floor(searchMinX / this.CELL_SIZE);
+    const maxIndexX = Math.floor((searchMaxX + epsilon) / this.CELL_SIZE);
+    const minIndexY = Math.floor(searchMinY / this.CELL_SIZE);
+    const maxIndexY = Math.floor((searchMaxY + epsilon) / this.CELL_SIZE);
+    const conflictingRouteData = /* @__PURE__ */ new Map();
+    const checkedSegments = /* @__PURE__ */ new Set();
+    const checkedVias = /* @__PURE__ */ new Set();
+    for (let ix = minIndexX; ix <= maxIndexX; ix++) {
+      for (let iy = minIndexY; iy <= maxIndexY; iy++) {
+        const bucketKey = `${ix}x${iy}`;
+        const segmentBucketList = this.segmentBuckets.get(bucketKey);
+        if (segmentBucketList) {
+          for (const segmentInfo of segmentBucketList) {
+            if (checkedSegments.has(segmentInfo.segmentId)) continue;
+            checkedSegments.add(segmentInfo.segmentId);
+            const route = segmentInfo.parentRoute;
+            const p1 = {
+              x: segmentInfo.segment[0].x,
+              y: segmentInfo.segment[0].y
+            };
+            const p2 = {
+              x: segmentInfo.segment[1].x,
+              y: segmentInfo.segment[1].y
+            };
+            const requiredSeparation = margin + route.traceThickness / 2;
+            const requiredSeparationSq = requiredSeparation * requiredSeparation;
+            const distSq = pointToSegmentDistanceSq(point, p1, p2);
+            if (distSq < requiredSeparationSq) {
+              const routeName = route.connectionName;
+              const existing = conflictingRouteData.get(routeName);
+              if (!existing || distSq < existing.minDistSq) {
+                conflictingRouteData.set(routeName, {
+                  route,
+                  minDistSq: distSq
+                });
+              }
+            }
+          }
+        }
+        const viaBucketList = this.viaBuckets.get(bucketKey);
+        if (viaBucketList) {
+          for (const viaInfo of viaBucketList) {
+            if (checkedVias.has(viaInfo.viaId)) continue;
+            checkedVias.add(viaInfo.viaId);
+            const route = viaInfo.parentRoute;
+            const viaPoint = { x: viaInfo.x, y: viaInfo.y };
+            const requiredSeparation = margin + route.viaDiameter / 2;
+            const requiredSeparationSq = requiredSeparation * requiredSeparation;
+            const distSq = computeDistSq(point, viaPoint);
+            if (distSq < requiredSeparationSq) {
+              const routeName = route.connectionName;
+              const existing = conflictingRouteData.get(routeName);
+              if (!existing || distSq < existing.minDistSq) {
+                conflictingRouteData.set(routeName, {
+                  route,
+                  minDistSq: distSq
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    const results = [];
+    for (const data of conflictingRouteData.values()) {
+      results.push({
+        conflictingRoute: data.route,
+        distance: Math.sqrt(data.minDistSq)
+      });
+    }
+    return results;
+  }
+};
+
+// lib/solvers/UselessViaRemovalSolver/SingleRouteUselessViaRemovalSolver.ts
+var SingleRouteUselessViaRemovalSolver = class extends BaseSolver {
+  obstacleSHI;
+  hdRouteSHI;
+  unsimplifiedRoute;
+  routeSections;
+  currentSectionIndex;
+  TRACE_THICKNESS = 0.15;
+  OBSTACLE_MARGIN = 0.1;
+  constructor(params) {
+    super();
+    this.currentSectionIndex = 1;
+    this.obstacleSHI = params.obstacleSHI;
+    this.hdRouteSHI = params.hdRouteSHI;
+    this.unsimplifiedRoute = params.unsimplifiedRoute;
+    this.routeSections = this.breakRouteIntoSections(this.unsimplifiedRoute);
+  }
+  breakRouteIntoSections(route) {
+    const routeSections = [];
+    const routePoints = route.route;
+    if (routePoints.length === 0) return [];
+    let currentSection = {
+      startIndex: 0,
+      endIndex: -1,
+      z: routePoints[0].z,
+      points: [routePoints[0]]
+    };
+    for (let i = 1; i < routePoints.length; i++) {
+      if (routePoints[i].z === currentSection.z) {
+        currentSection.points.push(routePoints[i]);
+      } else {
+        currentSection.endIndex = i - 1;
+        routeSections.push(currentSection);
+        currentSection = {
+          startIndex: i,
+          endIndex: -1,
+          z: routePoints[i].z,
+          points: [routePoints[i]]
+        };
+      }
+    }
+    currentSection.endIndex = routePoints.length - 1;
+    routeSections.push(currentSection);
+    return routeSections;
+  }
+  _step() {
+    if (this.currentSectionIndex >= this.routeSections.length - 1) {
+      this.solved = true;
+      return;
+    }
+    const prevSection = this.routeSections[this.currentSectionIndex - 1];
+    const currentSection = this.routeSections[this.currentSectionIndex];
+    const nextSection = this.routeSections[this.currentSectionIndex + 1];
+    if (prevSection.z !== nextSection.z) {
+      this.currentSectionIndex++;
+      return;
+    }
+    const targetZ = prevSection.z;
+    if (this.canSectionMoveToLayer({ currentSection, targetZ })) {
+      currentSection.z = targetZ;
+      currentSection.points = currentSection.points.map((p) => ({
+        ...p,
+        z: targetZ
+      }));
+      this.currentSectionIndex += 2;
+      return;
+    }
+    this.currentSectionIndex++;
+    return;
+  }
+  canSectionMoveToLayer({
+    currentSection,
+    targetZ
+  }) {
+    for (let i = 0; i < currentSection.points.length - 1; i++) {
+      const A = { ...currentSection.points[i], z: targetZ };
+      const B = { ...currentSection.points[i + 1], z: targetZ };
+      const conflictingRoutes = this.hdRouteSHI.getConflictingRoutesForSegment(
+        A,
+        B,
+        this.TRACE_THICKNESS
+      );
+      for (const { conflictingRoute, distance: distance6 } of conflictingRoutes) {
+        if (conflictingRoute.connectionName === this.unsimplifiedRoute.connectionName)
+          continue;
+        if (distance6 < this.TRACE_THICKNESS + conflictingRoute.traceThickness) {
+          return false;
+        }
+      }
+      const segmentBox = {
+        centerX: (A.x + B.x) / 2,
+        centerY: (A.y + B.y) / 2,
+        width: Math.abs(A.x - B.x),
+        height: Math.abs(A.y - B.y)
+      };
+      const obstacles = this.obstacleSHI.getNodesInArea(
+        segmentBox.centerX,
+        segmentBox.centerY,
+        segmentBox.width,
+        segmentBox.height
+      );
+      for (const obstacle of obstacles) {
+        const distToObstacle = segmentToBoxMinDistance(A, B, obstacle);
+        if (distToObstacle < this.TRACE_THICKNESS + this.OBSTACLE_MARGIN) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  getOptimizedHdRoute() {
+    const route = this.routeSections.flatMap((section) => section.points);
+    const vias = [];
+    for (let i = 0; i < route.length - 1; i++) {
+      if (route[i].z !== route[i + 1].z) {
+        vias.push({
+          x: route[i].x,
+          y: route[i].y
+        });
+      }
+    }
+    return {
+      connectionName: this.unsimplifiedRoute.connectionName,
+      route,
+      traceThickness: this.unsimplifiedRoute.traceThickness,
+      vias,
+      viaDiameter: this.unsimplifiedRoute.viaDiameter
+    };
+  }
+  visualize() {
+    const graphics = {
+      circles: [],
+      lines: [],
+      points: [],
+      rects: [],
+      coordinateSystem: "cartesian",
+      title: "Single Route Useless Via Removal Solver"
+    };
+    for (let i = 0; i < this.routeSections.length; i++) {
+      const section = this.routeSections[i];
+      graphics.lines.push({
+        points: section.points,
+        strokeWidth: this.TRACE_THICKNESS,
+        strokeColor: i === this.currentSectionIndex ? "orange" : section.z === 0 ? "red" : "blue"
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/UselessViaRemovalSolver/UselessViaRemovalSolver.ts
+var UselessViaRemovalSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.unsimplifiedHdRoutes = input.unsimplifiedHdRoutes;
+    this.optimizedHdRoutes = [];
+    this.unprocessedRoutes = [...input.unsimplifiedHdRoutes];
+    this.obstacleSHI = new ObstacleSpatialHashIndex(input.obstacles);
+    this.hdRouteSHI = new HighDensityRouteSpatialIndex(
+      this.unsimplifiedHdRoutes
+    );
+  }
+  unsimplifiedHdRoutes;
+  optimizedHdRoutes;
+  unprocessedRoutes;
+  activeSubSolver = null;
+  obstacleSHI = null;
+  hdRouteSHI = null;
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        this.optimizedHdRoutes.push(this.activeSubSolver.getOptimizedHdRoute());
+        this.activeSubSolver = null;
+      } else if (this.activeSubSolver.failed || this.activeSubSolver.error) {
+        this.error = this.activeSubSolver.error;
+        this.failed = true;
+      }
+      return;
+    }
+    const unprocessedRoute = this.unprocessedRoutes.shift();
+    if (!unprocessedRoute) {
+      this.solved = true;
+      return;
+    }
+    this.activeSubSolver = new SingleRouteUselessViaRemovalSolver({
+      hdRouteSHI: this.hdRouteSHI,
+      obstacleSHI: this.obstacleSHI,
+      unsimplifiedRoute: unprocessedRoute
+    });
+  }
+  getOptimizedHdRoutes() {
+    return this.optimizedHdRoutes;
+  }
+  visualize() {
+    const visualization = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Useless Via Removal Solver"
+    };
+    for (const route of this.optimizedHdRoutes) {
+      if (route.route.length === 0) continue;
+      const color = this.input.colorMap[route.connectionName] || "#888888";
+      for (let i = 0; i < route.route.length - 1; i++) {
+        const current = route.route[i];
+        const next = route.route[i + 1];
+        if (current.z === next.z) {
+          visualization.lines.push({
+            points: [
+              { x: current.x, y: current.y },
+              { x: next.x, y: next.y }
+            ],
+            strokeColor: current.z === 0 ? "red" : "blue",
+            strokeWidth: route.traceThickness,
+            label: `${route.connectionName} (z=${current.z})`
+          });
+        }
+      }
+      for (const via of route.vias) {
+        visualization.circles.push({
+          center: { x: via.x, y: via.y },
+          radius: route.viaDiameter / 2,
+          fill: "rgba(255, 0, 255, 0.5)",
+          label: `${route.connectionName} via`
+        });
+      }
+    }
+    if (this.activeSubSolver) {
+      visualization.lines.push(
+        ...this.activeSubSolver.visualize().lines ?? []
+      );
+    }
+    return visualization;
+  }
+};
+
 // lib/solvers/AutoroutingPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -8818,6 +9382,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   highDensityStitchSolver;
   singleLayerNodeMerger;
   strawSolver;
+  uselessViaRemovalSolver;
   multiSimplifiedPathSolver;
   startTimeOfPhase;
   endTimeOfPhase;
@@ -8973,12 +9538,24 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         }
       ]
     ),
+    definePipelineStep(
+      "uselessViaRemovalSolver",
+      UselessViaRemovalSolver,
+      (cms) => [
+        {
+          unsimplifiedHdRoutes: cms.highDensityStitchSolver.mergedHdRoutes,
+          obstacles: cms.srj.obstacles,
+          colorMap: cms.colorMap,
+          layerCount: cms.srj.layerCount
+        }
+      ]
+    ),
     definePipelineStep(
       "multiSimplifiedPathSolver",
       MultiSimplifiedPathSolver,
       (cms) => [
         {
-          unsimplifiedHdRoutes: cms.highDensityStitchSolver.mergedHdRoutes,
+          unsimplifiedHdRoutes: cms.uselessViaRemovalSolver?.getOptimizedHdRoutes() || cms.highDensityStitchSolver.mergedHdRoutes,
           obstacles: cms.srj.obstacles,
           connMap: cms.connMap,
           colorMap: cms.colorMap
@@ -9037,6 +9614,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     const segmentOptimizationViz = this.unravelMultiSectionSolver?.visualize() ?? this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
     const highDensityStitchViz = this.highDensityStitchSolver?.visualize();
+    const uselessViaRemovalViz = this.uselessViaRemovalSolver?.visualize();
     const simplifiedPathSolverViz = this.multiSimplifiedPathSolver?.visualize();
     const problemViz = {
       points: [
@@ -9089,6 +9667,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       segmentOptimizationViz,
       highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null,
       highDensityStitchViz,
+      uselessViaRemovalViz,
       simplifiedPathSolverViz,
       this.solved ? combineVisualizations(
         problemViz,
@@ -9151,7 +9730,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     return match ? match[1] : mstConnectionName;
   }
   _getOutputHdRoutes() {
-    return this.multiSimplifiedPathSolver?.simplifiedHdRoutes ?? this.highDensityStitchSolver.mergedHdRoutes;
+    return this.multiSimplifiedPathSolver?.simplifiedHdRoutes ?? this.uselessViaRemovalSolver?.getOptimizedHdRoutes() ?? this.highDensityStitchSolver.mergedHdRoutes;
   }
   /**
    * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces