@tscircuit/capacity-autorouter 0.0.10 → 0.0.12

package/dist/index.js

@@ -1757,17 +1757,19 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
   }
   handleSimpleCases() {
     this.solved = true;
+    const { A, B } = this;
+    const route = A.z === B.z ? [A, B] : [
+      A,
+      { ...this.boundsCenter, z: this.A.z },
+      {
+        ...this.boundsCenter,
+        z: B.z
+      },
+      B
+    ];
     this.solvedPath = {
       connectionName: this.connectionName,
-      route: [
-        this.A,
-        { ...this.boundsCenter, z: this.A.z },
-        {
-          ...this.boundsCenter,
-          z: this.B.z
-        },
-        this.B
-      ],
+      route,
       traceThickness: this.traceThickness,
       viaDiameter: this.viaDiameter,
       vias: this.A.z === this.B.z ? [] : [this.boundsCenter]
@@ -2210,8 +2212,8 @@ var getMinDistBetweenEnteringPoints = (node) => {
   return minDist === Infinity ? 0 : minDist;
 };
 
-// lib/solvers/HighDensitySolver/SingleIntraNodeRouteSolver.ts
-var SingleIntraNodeRouteSolver = class extends BaseSolver {
+// lib/solvers/HighDensitySolver/IntraNodeSolver.ts
+var IntraNodeRouteSolver = class extends BaseSolver {
   nodeWithPortPoints;
   colorMap;
   unsolvedConnections;
@@ -2303,6 +2305,15 @@ var SingleIntraNodeRouteSolver = class extends BaseSolver {
       this.solved = this.failedSolvers.length === 0;
       return;
     }
+    if (unsolvedConnection.points.length === 1) {
+      return;
+    }
+    if (unsolvedConnection.points.length === 2) {
+      const [A, B] = unsolvedConnection.points;
+      if (A.x === B.x && A.y === B.y && A.z === B.z) {
+        return;
+      }
+    }
     const { connectionName, points } = unsolvedConnection;
     this.activeSolver = new SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost({
       connectionName,
@@ -2598,7 +2609,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
     return 1 - (solver.progress || 0);
   }
   generateSolver(hyperParameters) {
-    return new SingleIntraNodeRouteSolver({
+    return new IntraNodeRouteSolver({
       ...this.constructorParams,
       hyperParameters
     });
@@ -2639,8 +2650,8 @@ function mergeRouteSegments(route, connectionName, color) {
   return segments;
 }
 
-// lib/solvers/HighDensitySolver/HighDensityRouteSolver.ts
-var HighDensityRouteSolver = class extends BaseSolver {
+// lib/solvers/HighDensitySolver/HighDensitySolver.ts
+var HighDensitySolver = class extends BaseSolver {
   unsolvedNodePortPoints;
   routes;
   colorMap;
@@ -4287,24 +4298,26 @@ var NetToPointPairsSolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/mapZToLayerName.ts
+var mapZToLayerName = (z, layerCount) => {
+  if (z < 0 || z >= layerCount) {
+    throw new Error(`Invalid z "${z}" for layer count: ${layerCount}`);
+  }
+  if (z === 0) return "top";
+  if (z === layerCount - 1) return "bottom";
+  return `inner${z}`;
+};
+
 // lib/utils/convertHdRouteToSimplifiedRoute.ts
 var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
   const result = [];
   if (hdRoute.route.length === 0) return result;
-  const mapZToLayerName = (z) => {
-    if (z < 0 || z >= layerCount) {
-      throw new Error(`Invalid z "${z}" for layer count: ${layerCount}`);
-    }
-    if (z === 0) return "top";
-    if (z === layerCount - 1) return "bottom";
-    return `inner${z}`;
-  };
   let currentLayerPoints = [];
   let currentZ = hdRoute.route[0].z;
   for (let i = 0; i < hdRoute.route.length; i++) {
     const point = hdRoute.route[i];
     if (point.z !== currentZ) {
-      const layerName2 = mapZToLayerName(currentZ);
+      const layerName2 = mapZToLayerName(currentZ, layerCount);
       for (const layerPoint of currentLayerPoints) {
         result.push({
           route_type: "wire",
@@ -4318,8 +4331,8 @@ var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
         (via) => Math.abs(via.x - point.x) < 1e-3 && Math.abs(via.y - point.y) < 1e-3
       );
       if (viaExists) {
-        const fromLayer = mapZToLayerName(currentZ);
-        const toLayer = mapZToLayerName(point.z);
+        const fromLayer = mapZToLayerName(currentZ, layerCount);
+        const toLayer = mapZToLayerName(point.z, layerCount);
         result.push({
           route_type: "via",
           x: point.x,
@@ -4334,7 +4347,7 @@ var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
       currentLayerPoints.push(point);
     }
   }
-  const layerName = mapZToLayerName(currentZ);
+  const layerName = mapZToLayerName(currentZ, layerCount);
   for (const layerPoint of currentLayerPoints) {
     result.push({
       route_type: "wire",
@@ -4347,7 +4360,371 @@ var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
   return result;
 };
 
+// lib/utils/mapLayerNameToZ.ts
+var mapLayerNameToZ = (layerName, layerCount) => {
+  if (layerName === "top") return 0;
+  if (layerName === "bottom") return layerCount - 1;
+  return parseInt(layerName.slice(5));
+};
+
+// lib/solvers/RouteStitchingSolver/SingleHighDensityRouteStitchSolver.ts
+var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
+  mergedHdRoute;
+  remainingHdRoutes;
+  start;
+  end;
+  constructor(opts) {
+    super();
+    this.remainingHdRoutes = [...opts.hdRoutes];
+    this.mergedHdRoute = {
+      connectionName: opts.hdRoutes[0].connectionName,
+      route: [
+        {
+          x: opts.start.x,
+          y: opts.start.y,
+          z: opts.start.z
+        }
+      ],
+      vias: [],
+      viaDiameter: opts.hdRoutes[0].viaDiameter,
+      traceThickness: opts.hdRoutes[0].traceThickness
+    };
+    this.start = opts.start;
+    this.end = opts.end;
+  }
+  _step() {
+    if (this.remainingHdRoutes.length === 0) {
+      this.mergedHdRoute.route.push({
+        x: this.end.x,
+        y: this.end.y,
+        z: this.end.z
+      });
+      this.solved = true;
+      return;
+    }
+    const lastMergedPoint = this.mergedHdRoute.route[this.mergedHdRoute.route.length - 1];
+    let closestRouteIndex = 0;
+    let matchedOn = "first";
+    let closestDistance = Infinity;
+    for (let i = 0; i < this.remainingHdRoutes.length; i++) {
+      const hdRoute = this.remainingHdRoutes[i];
+      const lastPointInCandidate = hdRoute.route[hdRoute.route.length - 1];
+      const firstPointInCandidate = hdRoute.route[0];
+      const distToFirst = distance(lastMergedPoint, firstPointInCandidate);
+      const distToLast = distance(lastMergedPoint, lastPointInCandidate);
+      if (distToFirst < closestDistance) {
+        closestDistance = distToFirst;
+        closestRouteIndex = i;
+        matchedOn = "first";
+      }
+      if (distToLast < closestDistance) {
+        closestDistance = distToLast;
+        closestRouteIndex = i;
+        matchedOn = "last";
+      }
+    }
+    const hdRouteToMerge = this.remainingHdRoutes[closestRouteIndex];
+    this.remainingHdRoutes.splice(closestRouteIndex, 1);
+    if (matchedOn === "first") {
+      this.mergedHdRoute.route.push(...hdRouteToMerge.route);
+    } else {
+      this.mergedHdRoute.route.push(...[...hdRouteToMerge.route].reverse());
+    }
+    this.mergedHdRoute.vias.push(...hdRouteToMerge.vias);
+  }
+  visualize() {
+    const graphics = {
+      points: [],
+      lines: [],
+      circles: [],
+      title: "Single High Density Route Stitch Solver"
+    };
+    graphics.points?.push(
+      {
+        x: this.start.x,
+        y: this.start.y,
+        color: "green",
+        label: "Start"
+      },
+      {
+        x: this.end.x,
+        y: this.end.y,
+        color: "red",
+        label: "End"
+      }
+    );
+    if (this.mergedHdRoute && this.mergedHdRoute.route.length > 1) {
+      graphics.lines?.push({
+        points: this.mergedHdRoute.route.map((point) => ({
+          x: point.x,
+          y: point.y
+        })),
+        strokeColor: "green"
+      });
+      for (const point of this.mergedHdRoute.route) {
+        graphics.points?.push({
+          x: point.x,
+          y: point.y,
+          color: "green"
+        });
+      }
+      for (const via of this.mergedHdRoute.vias) {
+        graphics.circles?.push({
+          center: { x: via.x, y: via.y },
+          radius: this.mergedHdRoute.viaDiameter / 2,
+          fill: "green"
+        });
+      }
+    }
+    const colorList = Array.from(
+      { length: this.remainingHdRoutes.length },
+      (_, i) => `hsl(${i * 360 / this.remainingHdRoutes.length}, 100%, 50%)`
+    );
+    for (const [i, hdRoute] of this.remainingHdRoutes.entries()) {
+      if (hdRoute.route.length > 1) {
+        graphics.lines?.push({
+          points: hdRoute.route.map((point) => ({ x: point.x, y: point.y })),
+          strokeColor: colorList[i]
+        });
+      }
+      for (let pi = 0; pi < hdRoute.route.length; pi++) {
+        const point = hdRoute.route[pi];
+        graphics.points?.push({
+          x: point.x + (i % 2 - 0.5) / 500 + (pi % 8 - 4) / 1e3,
+          y: point.y + (i % 2 - 0.5) / 500 + (pi % 8 - 4) / 1e3,
+          color: colorList[i],
+          label: `Route ${i} ${point === hdRoute.route[0] ? "First" : point === hdRoute.route[hdRoute.route.length - 1] ? "Last" : ""}`
+        });
+      }
+      for (const via of hdRoute.vias) {
+        graphics.circles?.push({
+          center: { x: via.x, y: via.y },
+          radius: hdRoute.viaDiameter / 2,
+          fill: colorList[i]
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/RouteStitchingSolver/MultipleHighDensityRouteStitchSolver.ts
+var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
+  unsolvedRoutes;
+  activeSolver = null;
+  mergedHdRoutes = [];
+  constructor(opts) {
+    super();
+    this.unsolvedRoutes = opts.connections.map((c) => ({
+      connectionName: c.name,
+      hdRoutes: opts.hdRoutes.filter((r) => r.connectionName === c.name),
+      start: {
+        ...c.pointsToConnect[0],
+        z: mapLayerNameToZ(c.pointsToConnect[0].layer, opts.layerCount)
+      },
+      end: {
+        ...c.pointsToConnect[1],
+        z: mapLayerNameToZ(c.pointsToConnect[1].layer, opts.layerCount)
+      }
+    }));
+  }
+  _step() {
+    if (this.activeSolver) {
+      this.activeSolver.step();
+      if (this.activeSolver.solved) {
+        this.mergedHdRoutes.push(this.activeSolver.mergedHdRoute);
+        this.activeSolver = null;
+      } else if (this.activeSolver.failed) {
+        this.failed = true;
+        this.error = this.activeSolver.error;
+      }
+      return;
+    }
+    const unsolvedRoute = this.unsolvedRoutes.pop();
+    if (!unsolvedRoute) {
+      this.solved = true;
+      return;
+    }
+    this.activeSolver = new SingleHighDensityRouteStitchSolver({
+      hdRoutes: unsolvedRoute.hdRoutes,
+      start: unsolvedRoute.start,
+      end: unsolvedRoute.end
+    });
+  }
+  visualize() {
+    const graphics = {
+      points: [],
+      lines: [],
+      circles: [],
+      title: "Multiple High Density Route Stitch Solver"
+    };
+    if (this.activeSolver) {
+      const activeSolverGraphics = this.activeSolver.visualize();
+      if (activeSolverGraphics.points?.length) {
+        graphics.points?.push(...activeSolverGraphics.points);
+      }
+      if (activeSolverGraphics.lines?.length) {
+        graphics.lines?.push(...activeSolverGraphics.lines);
+      }
+      if (activeSolverGraphics.circles?.length) {
+        graphics.circles?.push(...activeSolverGraphics.circles);
+      }
+      if (activeSolverGraphics.rects?.length) {
+        graphics.rects = activeSolverGraphics.rects;
+      }
+    }
+    for (const [i, mergedRoute] of this.mergedHdRoutes.entries()) {
+      const solvedColor = `hsl(120, 100%, ${40 + i * 10 % 40}%)`;
+      if (mergedRoute.route.length > 1) {
+        graphics.lines?.push({
+          points: mergedRoute.route.map((point) => ({
+            x: point.x,
+            y: point.y
+          })),
+          strokeColor: solvedColor,
+          strokeWidth: mergedRoute.traceThickness
+        });
+      }
+      for (const point of mergedRoute.route) {
+        graphics.points?.push({
+          x: point.x,
+          y: point.y,
+          color: solvedColor
+        });
+      }
+      for (const via of mergedRoute.vias) {
+        graphics.circles?.push({
+          center: { x: via.x, y: via.y },
+          radius: mergedRoute.viaDiameter / 2,
+          fill: solvedColor
+        });
+      }
+    }
+    const colorList = Array.from(
+      { length: this.unsolvedRoutes.length },
+      (_, i) => `hsl(${i * 360 / this.unsolvedRoutes.length}, 100%, 50%)`
+    );
+    for (const [i, unsolvedRoute] of this.unsolvedRoutes.entries()) {
+      graphics.points?.push(
+        {
+          x: unsolvedRoute.start.x,
+          y: unsolvedRoute.start.y,
+          color: colorList[i],
+          label: `${unsolvedRoute.connectionName} Start`
+        },
+        {
+          x: unsolvedRoute.end.x,
+          y: unsolvedRoute.end.y,
+          color: colorList[i],
+          label: `${unsolvedRoute.connectionName} End`
+        }
+      );
+      graphics.lines?.push({
+        points: [
+          { x: unsolvedRoute.start.x, y: unsolvedRoute.start.y },
+          { x: unsolvedRoute.end.x, y: unsolvedRoute.end.y }
+        ],
+        strokeColor: colorList[i],
+        strokeDash: "2 2"
+      });
+      for (const hdRoute of unsolvedRoute.hdRoutes) {
+        if (hdRoute.route.length > 1) {
+          graphics.lines?.push({
+            points: hdRoute.route.map((point) => ({ x: point.x, y: point.y })),
+            strokeColor: safeTransparentize(colorList[i], 0.5),
+            strokeDash: "10 5"
+          });
+        }
+        for (const via of hdRoute.vias) {
+          graphics.circles?.push({
+            center: { x: via.x, y: via.y },
+            radius: hdRoute.viaDiameter / 2,
+            fill: colorList[i]
+          });
+        }
+      }
+    }
+    return graphics;
+  }
+};
+
+// tests/fixtures/convertSrjToGraphicsObject.ts
+var convertSrjToGraphicsObject = (srj) => {
+  const lines = [];
+  const circles = [];
+  const points = [];
+  const colorMap = getColorMap(srj);
+  if (srj.connections) {
+    for (const connection of srj.connections) {
+      for (const point of connection.pointsToConnect) {
+        points.push({
+          x: point.x,
+          y: point.y,
+          color: colorMap[connection.name],
+          label: `${connection.name} (${point.layer})`
+        });
+      }
+    }
+  }
+  if (srj.traces) {
+    for (const trace of srj.traces) {
+      for (let j = 0; j < trace.route.length - 1; j++) {
+        const routePoint = trace.route[j];
+        const nextRoutePoint = trace.route[j + 1];
+        if (routePoint.route_type === "via") {
+          circles.push({
+            center: { x: routePoint.x, y: routePoint.y },
+            radius: 0.3,
+            // 0.6 via diameter
+            fill: "blue",
+            stroke: "none"
+          });
+        } else if (routePoint.route_type === "wire" && nextRoutePoint.route_type === "wire" && nextRoutePoint.layer === routePoint.layer) {
+          lines.push({
+            points: [
+              { x: routePoint.x, y: routePoint.y },
+              { x: nextRoutePoint.x, y: nextRoutePoint.y }
+            ],
+            strokeColor: safeTransparentize(
+              {
+                top: "red",
+                bottom: "blue",
+                inner1: "green",
+                inner2: "yellow"
+              }[routePoint.layer],
+              0.5
+            )
+            // For some reason this is too small, likely a graphics-debug bug
+            // strokeWidth: 0.15,
+          });
+        }
+      }
+    }
+  }
+  return {
+    rects: srj.obstacles.map(
+      (o) => ({
+        center: o.center,
+        width: o.width,
+        height: o.height,
+        fill: "rgba(255,0,0,0.5)"
+      })
+    ),
+    circles,
+    lines,
+    points
+  };
+};
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
+function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
+  return {
+    solverName,
+    solverClass,
+    getConstructorParams,
+    onSolved: opts.onSolved
+  };
+}
 var CapacityMeshSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
     super();
@@ -4366,6 +4743,9 @@ var CapacityMeshSolver = class extends BaseSolver {
     }
     this.connMap = getConnectivityMapFromSimpleRouteJson(srj);
     this.colorMap = getColorMap(srj, this.connMap);
+    this.startTimeOfPhase = {};
+    this.endTimeOfPhase = {};
+    this.timeSpentOnPhase = {};
   }
   netToPointPairsSolver;
   nodeSolver;
@@ -4377,13 +4757,131 @@ var CapacityMeshSolver = class extends BaseSolver {
   segmentToPointSolver;
   segmentToPointOptimizer;
   highDensityRouteSolver;
+  highDensityStitchSolver;
+  startTimeOfPhase;
+  endTimeOfPhase;
+  timeSpentOnPhase;
   activeSolver = null;
   connMap;
+  srjWithPointPairs;
+  pipelineDef = [
+    definePipelineStep(
+      "netToPointPairsSolver",
+      NetToPointPairsSolver,
+      (cms) => [cms.srj, cms.colorMap],
+      {
+        onSolved: (cms) => {
+          cms.srjWithPointPairs = cms.netToPointPairsSolver?.getNewSimpleRouteJson();
+          cms.colorMap = getColorMap(cms.srjWithPointPairs, this.connMap);
+          cms.connMap = getConnectivityMapFromSimpleRouteJson(
+            cms.srjWithPointPairs
+          );
+        }
+      }
+    ),
+    definePipelineStep("nodeSolver", CapacityMeshNodeSolver, (cms) => [
+      cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
+      cms.opts
+    ]),
+    definePipelineStep("nodeTargetMerger", CapacityNodeTargetMerger, (cms) => [
+      cms.nodeSolver?.finishedNodes || [],
+      cms.srj.obstacles,
+      cms.connMap
+    ]),
+    definePipelineStep("edgeSolver", CapacityMeshEdgeSolver, (cms) => [
+      cms.nodeTargetMerger?.newNodes || []
+    ]),
+    definePipelineStep(
+      "pathingSolver",
+      CapacityPathingSolver4_FlexibleNegativeCapacity,
+      (cms) => [
+        {
+          simpleRouteJson: cms.srjWithPointPairs,
+          nodes: cms.nodeTargetMerger?.newNodes || [],
+          edges: cms.edgeSolver?.edges || [],
+          colorMap: cms.colorMap,
+          hyperParameters: {
+            MAX_CAPACITY_FACTOR: 1
+          }
+        }
+      ]
+    ),
+    definePipelineStep(
+      "edgeToPortSegmentSolver",
+      CapacityEdgeToPortSegmentSolver,
+      (cms) => [
+        {
+          nodes: cms.nodeTargetMerger?.newNodes || [],
+          edges: cms.edgeSolver?.edges || [],
+          capacityPaths: cms.pathingSolver?.getCapacityPaths() || [],
+          colorMap: cms.colorMap
+        }
+      ]
+    ),
+    definePipelineStep(
+      "segmentToPointSolver",
+      CapacitySegmentToPointSolver,
+      (cms) => {
+        const allSegments = [];
+        if (cms.edgeToPortSegmentSolver?.nodePortSegments) {
+          cms.edgeToPortSegmentSolver.nodePortSegments.forEach((segs) => {
+            allSegments.push(...segs);
+          });
+        }
+        return [
+          {
+            segments: allSegments,
+            colorMap: cms.colorMap,
+            nodes: cms.nodeTargetMerger?.newNodes || []
+          }
+        ];
+      }
+    ),
+    definePipelineStep(
+      "segmentToPointOptimizer",
+      CapacitySegmentPointOptimizer,
+      (cms) => [
+        {
+          assignedSegments: cms.segmentToPointSolver?.solvedSegments || [],
+          colorMap: cms.colorMap,
+          nodes: cms.nodeTargetMerger?.newNodes || []
+        }
+      ]
+    ),
+    definePipelineStep("highDensityRouteSolver", HighDensitySolver, (cms) => [
+      {
+        nodePortPoints: cms.segmentToPointOptimizer?.getNodesWithPortPoints() || [],
+        colorMap: cms.colorMap,
+        connMap: cms.connMap
+      }
+    ]),
+    definePipelineStep(
+      "highDensityStitchSolver",
+      MultipleHighDensityRouteStitchSolver,
+      (cms) => [
+        {
+          connections: cms.srjWithPointPairs.connections,
+          hdRoutes: cms.highDensityRouteSolver.routes,
+          layerCount: cms.srj.layerCount
+        }
+      ]
+    )
+  ];
+  currentPipelineStepIndex = 0;
   _step() {
+    const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex];
+    if (!pipelineStepDef) {
+      this.solved = true;
+      return;
+    }
     if (this.activeSolver) {
       this.activeSolver.step();
       if (this.activeSolver.solved) {
+        this.endTimeOfPhase[pipelineStepDef.solverName] = performance.now();
+        this.timeSpentOnPhase[pipelineStepDef.solverName] = this.endTimeOfPhase[pipelineStepDef.solverName] - this.startTimeOfPhase[pipelineStepDef.solverName];
+        pipelineStepDef.onSolved?.(this);
         this.activeSolver = null;
+        this.currentPipelineStepIndex++;
       } else if (this.activeSolver.failed) {
         this.error = this.activeSolver?.error;
         this.failed = true;
@@ -4391,93 +4889,16 @@ var CapacityMeshSolver = class extends BaseSolver {
       }
       return;
     }
-    if (!this.netToPointPairsSolver) {
-      this.netToPointPairsSolver = new NetToPointPairsSolver(
-        this.srj,
-        this.colorMap
-      );
-      this.activeSolver = this.netToPointPairsSolver;
-      return;
-    }
-    if (!this.nodeSolver) {
-      const newSrj = this.netToPointPairsSolver.getNewSimpleRouteJson();
-      this.connMap = getConnectivityMapFromSimpleRouteJson(newSrj);
-      this.colorMap = getColorMap(newSrj, this.connMap);
-      this.nodeSolver = new CapacityMeshNodeSolver(newSrj, this.opts);
-      this.activeSolver = this.nodeSolver;
-      return;
-    }
-    if (!this.nodeTargetMerger) {
-      this.nodeTargetMerger = new CapacityNodeTargetMerger(
-        this.nodeSolver.finishedNodes,
-        this.srj.obstacles,
-        this.connMap
-      );
-      this.activeSolver = this.nodeTargetMerger;
-      return;
-    }
-    const nodes = this.nodeTargetMerger.newNodes;
-    if (!this.edgeSolver) {
-      this.edgeSolver = new CapacityMeshEdgeSolver(nodes);
-      this.activeSolver = this.edgeSolver;
-      return;
-    }
-    if (!this.pathingSolver) {
-      this.pathingSolver = new CapacityPathingSolver4_FlexibleNegativeCapacity({
-        simpleRouteJson: this.netToPointPairsSolver.getNewSimpleRouteJson(),
-        nodes,
-        edges: this.edgeSolver.edges,
-        colorMap: this.colorMap,
-        hyperParameters: {
-          MAX_CAPACITY_FACTOR: 1
-        }
-      });
-      this.activeSolver = this.pathingSolver;
-      return;
-    }
-    if (!this.edgeToPortSegmentSolver) {
-      this.edgeToPortSegmentSolver = new CapacityEdgeToPortSegmentSolver({
-        nodes,
-        edges: this.edgeSolver.edges,
-        capacityPaths: this.pathingSolver.getCapacityPaths(),
-        colorMap: this.colorMap
-      });
-      this.activeSolver = this.edgeToPortSegmentSolver;
-      return;
-    }
-    if (!this.segmentToPointSolver) {
-      const allSegments = [];
-      this.edgeToPortSegmentSolver.nodePortSegments.forEach((segs) => {
-        allSegments.push(...segs);
-      });
-      this.segmentToPointSolver = new CapacitySegmentToPointSolver({
-        segments: allSegments,
-        colorMap: this.colorMap,
-        nodes
-      });
-      this.activeSolver = this.segmentToPointSolver;
-      return;
-    }
-    if (!this.segmentToPointOptimizer) {
-      this.segmentToPointOptimizer = new CapacitySegmentPointOptimizer({
-        assignedSegments: this.segmentToPointSolver.solvedSegments,
-        colorMap: this.colorMap,
-        nodes
-      });
-      this.activeSolver = this.segmentToPointOptimizer;
-      return;
-    }
-    if (!this.highDensityRouteSolver) {
-      const nodesWithPortPoints = this.segmentToPointOptimizer.getNodesWithPortPoints();
-      this.highDensityRouteSolver = new HighDensityRouteSolver({
-        nodePortPoints: nodesWithPortPoints,
-        colorMap: this.colorMap,
-        connMap: this.connMap
-      });
-      this.activeSolver = this.highDensityRouteSolver;
-      return;
-    }
-    this.solved = true;
+    const constructorParams = pipelineStepDef.getConstructorParams(this);
+    this.activeSolver = new pipelineStepDef.solverClass(
+      ...constructorParams
+    );
+    this[pipelineStepDef.solverName] = this.activeSolver;
+    this.timeSpentOnPhase[pipelineStepDef.solverName] = 0;
+    this.startTimeOfPhase[pipelineStepDef.solverName] = performance.now();
+  }
+  getCurrentPhase() {
+    return this.pipelineDef[this.currentPipelineStepIndex]?.solverName ?? "none";
   }
   visualize() {
     if (!this.solved && this.activeSolver) return this.activeSolver.visualize();
@@ -4489,6 +4910,7 @@ var CapacityMeshSolver = class extends BaseSolver {
     const segmentToPointViz = this.segmentToPointSolver?.visualize();
     const segmentOptimizationViz = this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
+    const highDensityStitchViz = this.highDensityStitchSolver?.visualize();
     const problemViz = {
       points: [...this.srj.connections.flatMap((c) => c.pointsToConnect)],
       rects: [
@@ -4507,51 +4929,15 @@ var CapacityMeshSolver = class extends BaseSolver {
       edgeToPortSegmentViz,
       segmentToPointViz,
       segmentOptimizationViz,
-      highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null
+      highDensityViz ? combineVisualizations(problemViz, highDensityViz) : null,
+      highDensityStitchViz,
+      this.solved ? combineVisualizations(
+        problemViz,
+        convertSrjToGraphicsObject(this.getOutputSimpleRouteJson())
+      ) : null
     ].filter(Boolean);
     return combineVisualizations(...visualizations);
   }
-  /**
-   * Simplifies a route by merging consecutive points along the same line
-   */
-  simplifyRoute(points) {
-    if (points.length <= 2) return points;
-    const result = [points[0]];
-    for (let i = 1; i < points.length - 1; i++) {
-      const prev = points[i - 1];
-      const curr = points[i];
-      const next = points[i + 1];
-      if (curr.z === prev.z && curr.z === next.z) {
-        const dx1 = curr.x - prev.x;
-        const dy1 = curr.y - prev.y;
-        const dx2 = next.x - curr.x;
-        const dy2 = next.y - curr.y;
-        const crossProduct = dx1 * dy2 - dy1 * dx2;
-        const dotProduct = dx1 * dx2 + dy1 * dy2;
-        if (Math.abs(crossProduct) < 1e-3 && dotProduct > 0) {
-          continue;
-        }
-      }
-      result.push(curr);
-    }
-    result.push(points[points.length - 1]);
-    return result;
-  }
-  /**
-   * Maps numeric layer to named layer
-   * @param layer Numeric layer (0, 1, etc)
-   * @returns Named layer ("top", "bottom", etc)
-   */
-  mapLayer(layer) {
-    switch (layer) {
-      case "0":
-        return "top";
-      case "1":
-        return "bottom";
-      default:
-        return `layer${layer}`;
-    }
-  }
   /**
    * Get original connection name from connection name with MST suffix
    * @param mstConnectionName The MST-suffixed connection name (e.g. "connection1_mst0")
@@ -4564,24 +4950,38 @@ var CapacityMeshSolver = class extends BaseSolver {
   /**
    * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
    */
-  getOutputSimpleRouteJson() {
+  getOutputSimplifiedPcbTraces() {
     if (!this.solved || !this.highDensityRouteSolver) {
       throw new Error("Cannot get output before solving is complete");
     }
     const traces = [];
-    for (const hdRoute of this.highDensityRouteSolver.routes) {
-      const pointPairConnName = hdRoute.connectionName;
-      const trace = {
+    for (const connection of this.netToPointPairsSolver?.newConnections ?? []) {
+      const netConnection = this.srj.connections.find(
+        (c) => c.name === connection.netConnectionName
+      );
+      const hdRoutes = this.highDensityStitchSolver.mergedHdRoutes.filter(
+        (r) => r.connectionName === connection.name
+      );
+      if (hdRoutes.length > 1) {
+        throw new Error("Multiple hdRoutes found for connection");
+      }
+      const simplifiedPcbTrace = {
         type: "pcb_trace",
-        pcb_trace_id: pointPairConnName,
-        connection_name: this.getOriginalConnectionName(pointPairConnName),
-        route: convertHdRouteToSimplifiedRoute(hdRoute, 2)
+        pcb_trace_id: connection.name,
+        connection_name: this.getOriginalConnectionName(connection.name),
+        route: convertHdRouteToSimplifiedRoute(
+          hdRoutes[0],
+          this.srj.layerCount
+        )
       };
-      traces.push(trace);
+      traces.push(simplifiedPcbTrace);
     }
+    return traces;
+  }
+  getOutputSimpleRouteJson() {
     return {
       ...this.srj,
-      traces
+      traces: this.getOutputSimplifiedPcbTraces()
     };
   }
 };