@tscircuit/capacity-autorouter 0.0.19 → 0.0.20

package/dist/index.js

@@ -43,7 +43,9 @@ var BaseSolver = class {
   iterations = 0;
   progress = 0;
   error = null;
+  activeSubSolver;
   failedSubSolvers;
+  timeToSolve;
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -66,9 +68,12 @@ var BaseSolver = class {
   _step() {
   }
   solve() {
+    const startTime = Date.now();
     while (!this.solved && !this.failed) {
       this.step();
     }
+    const endTime = Date.now();
+    this.timeToSolve = endTime - startTime;
   }
   visualize() {
     return {
@@ -3347,817 +3352,131 @@ var CapacityNodeTargetMerger = class extends BaseSolver {
   }
 };
 
-// lib/utils/getIntraNodeCrossingsFromSegments.ts
-var getIntraNodeCrossingsFromSegments = (segments) => {
-  let numSameLayerCrossings = 0;
-  const pointPairs = [];
-  const transitionPairPoints = [];
-  let numEntryExitLayerChanges = 0;
-  const portPoints = segments.flatMap((seg) => seg.assignedPoints);
-  for (const { connectionName: aConnName, point: A } of portPoints) {
-    if (pointPairs.some((p) => p.connectionName === aConnName)) {
-      continue;
-    }
-    if (transitionPairPoints.some((p) => p.connectionName === aConnName)) {
-      continue;
-    }
-    const pointPair = {
-      connectionName: aConnName,
-      z: A.z,
-      points: [A]
-    };
-    for (const { connectionName: bConnName, point: B } of portPoints) {
-      if (aConnName !== bConnName) continue;
-      if (A === B) continue;
-      pointPair.points.push(B);
-    }
-    if (pointPair.points.some((p) => p.z !== pointPair.z)) {
-      numEntryExitLayerChanges++;
-      transitionPairPoints.push(pointPair);
-      continue;
-    }
-    pointPairs.push(pointPair);
+// lib/solvers/NetToPointPairsSolver/buildMinimumSpanningTree.ts
+var KDNode = class {
+  point;
+  left = null;
+  right = null;
+  constructor(point) {
+    this.point = point;
   }
-  for (let i = 0; i < pointPairs.length; i++) {
-    for (let j = i + 1; j < pointPairs.length; j++) {
-      const pair1 = pointPairs[i];
-      const pair2 = pointPairs[j];
-      if (pair1.z === pair2.z && doSegmentsIntersect(
-        pair1.points[0],
-        pair1.points[1],
-        pair2.points[0],
-        pair2.points[1]
-      )) {
-        numSameLayerCrossings++;
-      }
+};
+var KDTree = class {
+  root = null;
+  constructor(points) {
+    if (points.length > 0) {
+      this.root = this.buildTree(points, 0);
     }
   }
-  let numTransitionCrossings = 0;
-  for (let i = 0; i < transitionPairPoints.length; i++) {
-    for (let j = i + 1; j < transitionPairPoints.length; j++) {
-      const pair1 = transitionPairPoints[i];
-      const pair2 = transitionPairPoints[j];
-      if (doSegmentsIntersect(
-        pair1.points[0],
-        pair1.points[1],
-        pair2.points[0],
-        pair2.points[1]
-      )) {
-        numTransitionCrossings++;
-      }
+  buildTree(points, depth) {
+    const axis = depth % 2 === 0 ? "x" : "y";
+    points.sort((a, b) => a[axis] - b[axis]);
+    const medianIndex = Math.floor(points.length / 2);
+    const node = new KDNode(points[medianIndex]);
+    if (medianIndex > 0) {
+      node.left = this.buildTree(points.slice(0, medianIndex), depth + 1);
     }
-  }
-  for (let i = 0; i < transitionPairPoints.length; i++) {
-    for (let j = 0; j < pointPairs.length; j++) {
-      const pair1 = transitionPairPoints[i];
-      const pair2 = pointPairs[j];
-      if (doSegmentsIntersect(
-        pair1.points[0],
-        pair1.points[1],
-        pair2.points[0],
-        pair2.points[1]
-      )) {
-        numTransitionCrossings++;
-      }
+    if (medianIndex < points.length - 1) {
+      node.right = this.buildTree(points.slice(medianIndex + 1), depth + 1);
     }
+    return node;
   }
-  return {
-    numSameLayerCrossings,
-    numEntryExitLayerChanges,
-    numTransitionCrossings
-  };
-};
-
-// lib/solvers/CapacitySegmentPointOptimizer/CapacitySegmentPointOptimizer.ts
-var CapacitySegmentPointOptimizer = class extends BaseSolver {
-  assignedSegments;
-  colorMap;
-  nodeMap;
-  nodeIdToSegmentIds;
-  segmentIdToNodeIds;
-  currentMutatedSegments;
-  allSegmentIds;
-  lastAppliedOperation = null;
-  lastCreatedOperation = null;
-  currentNodeCosts;
-  lastAcceptedIteration = 0;
-  currentCost;
-  randomSeed;
-  numNodes;
-  probabilityOfFailure;
-  nodesThatCantFitVias;
-  mutableSegments;
-  VIA_DIAMETER = 0.6;
-  OBSTACLE_MARGIN = 0.15;
-  MAX_OPERATIONS_PER_MUTATION = 5;
-  MAX_NODE_CHAIN_PER_MUTATION = 2;
-  NOOP_ITERATIONS_BEFORE_EARLY_STOP = 2e4;
-  // We use an extra property on segments to remember assigned points.
-  // Each segment will get an added property "assignedPoints" which is an array of:
-  // { connectionName: string, point: {x: number, y: number } }
-  // This is a temporary extension used by the solver.
-  constructor({
-    assignedSegments,
-    colorMap,
-    nodes
-  }) {
-    super();
-    this.MAX_ITERATIONS = 5e5;
-    this.assignedSegments = assignedSegments;
-    const dedupedSegments = [];
-    const dedupedSegPointMap = /* @__PURE__ */ new Map();
-    let highestSegmentId = -1;
-    for (const seg of this.assignedSegments) {
-      const segKey = `${seg.start.x}-${seg.start.y}-${seg.end.x}-${seg.end.y}`;
-      const existingSeg = dedupedSegPointMap.get(segKey);
-      if (!existingSeg) {
-        highestSegmentId++;
-        seg.nodePortSegmentId = `SEG${highestSegmentId}`;
-        dedupedSegPointMap.set(segKey, seg);
-        dedupedSegments.push(seg);
-        continue;
-      }
-      seg.nodePortSegmentId = existingSeg.nodePortSegmentId;
-    }
-    this.currentMutatedSegments = /* @__PURE__ */ new Map();
-    for (const seg of dedupedSegments) {
-      this.currentMutatedSegments.set(seg.nodePortSegmentId, {
-        ...seg,
-        assignedPoints: seg.assignedPoints?.map((p) => ({
-          ...p,
-          point: { x: p.point.x, y: p.point.y, z: p.point.z }
-        }))
-      });
-    }
-    this.nodeIdToSegmentIds = /* @__PURE__ */ new Map();
-    this.segmentIdToNodeIds = /* @__PURE__ */ new Map();
-    for (const segment of this.assignedSegments) {
-      this.segmentIdToNodeIds.set(segment.nodePortSegmentId, [
-        ...this.segmentIdToNodeIds.get(segment.nodePortSegmentId) ?? [],
-        segment.capacityMeshNodeId
-      ]);
-      this.nodeIdToSegmentIds.set(segment.capacityMeshNodeId, [
-        ...this.nodeIdToSegmentIds.get(segment.capacityMeshNodeId) ?? [],
-        segment.nodePortSegmentId
-      ]);
+  // Find the nearest neighbor to a query point
+  findNearestNeighbor(queryPoint) {
+    if (!this.root) {
+      throw new Error("Tree is empty");
     }
-    this.colorMap = colorMap ?? {};
-    this.nodeMap = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      this.nodeMap.set(node.capacityMeshNodeId, node);
+    const best = this.root.point;
+    const bestDistance = this.distance(queryPoint, best);
+    this.nearestNeighborSearch(this.root, queryPoint, 0, best, bestDistance);
+    return best;
+  }
+  nearestNeighborSearch(node, queryPoint, depth, best, bestDistance) {
+    if (!node) {
+      return best;
     }
-    this.numNodes = this.segmentIdToNodeIds.size;
-    const { cost, nodeCosts, probabilityOfFailure } = this.computeCurrentCost();
-    this.currentCost = cost;
-    this.currentNodeCosts = nodeCosts;
-    this.probabilityOfFailure = probabilityOfFailure;
-    this.randomSeed = 1;
-    this.allSegmentIds = Array.from(this.currentMutatedSegments.keys());
-    this.nodesThatCantFitVias = /* @__PURE__ */ new Set();
-    for (const nodeId of this.nodeIdToSegmentIds.keys()) {
-      const node = this.nodeMap.get(nodeId);
-      if (node.width < this.VIA_DIAMETER + this.OBSTACLE_MARGIN) {
-        this.nodesThatCantFitVias.add(nodeId);
-      }
+    const axis = depth % 2 ? "x" : "y";
+    const currentDistance = this.distance(queryPoint, node.point);
+    if (currentDistance < bestDistance) {
+      best = node.point;
+      bestDistance = currentDistance;
     }
-    this.mutableSegments = this.getMutableSegments();
-  }
-  random() {
-    this.randomSeed = this.randomSeed * 16807 % 2147483647;
-    return (this.randomSeed - 1) / 2147483646;
-  }
-  /**
-   * The cost is the "probability of failure" of the node.
-   */
-  computeNodeCost(nodeId) {
-    const node = this.nodeMap.get(nodeId);
-    if (node?._containsTarget) return 0;
-    const totalCapacity = getTunedTotalCapacity1(node);
-    const usedViaCapacity = this.getUsedViaCapacity(nodeId);
-    const usedTraceCapacity = this.getUsedTraceCapacity(nodeId);
-    const approxProb = usedViaCapacity * usedTraceCapacity / totalCapacity ** 2;
-    const K = -2.3;
-    return 1 - Math.exp(approxProb * K);
-  }
-  /**
-   * Number of traces that can go through this node if they are completely
-   * straight without crossings
-   */
-  getUsedTraceCapacity(nodeId) {
-    const segmentIds = this.nodeIdToSegmentIds.get(nodeId);
-    const segments = segmentIds.map(
-      (segmentId) => this.currentMutatedSegments.get(segmentId)
-    );
-    const points = segments.flatMap((s) => s.assignedPoints);
-    const numTracesThroughNode = points.length / 2;
-    const numLayers = 2;
-    return numTracesThroughNode / numLayers;
-  }
-  /**
-   * Granular via capacity is a consideration of capacity that includes...
-   * - The number of traces
-   * - The number of trace crossings (0-2 vias per trace crossing)
-   *   - Empirically, each crossing typically results in 0.82 vias
-   *   - e.g. 17 traces would typically have 51 crossings & 42 vias
-   * - The number of layer changes (at least 1 via per layer change)
-   *   - We don't know how a entry/exit being on separated layers effects
-   *     the capacity/number of vias yet
-   *
-   * - Generally minimizing the number of crossings is pretty good, if there
-   *   is no trace crossing you basically don't have any used capacity
-   * - If the entry/exit layer is different, you're guaranteed to have at least
-   *   one via
-   *
-   * - Total capacity is computed by estimating the number of vias that could
-   *   be created using the formula (viaFitAcross / 2) ** 1.1
-   */
-  getUsedViaCapacity(nodeId) {
-    const segmentIds = this.nodeIdToSegmentIds.get(nodeId);
-    const segments = segmentIds.map(
-      (segmentId) => this.currentMutatedSegments.get(segmentId)
+    const axisDiff = queryPoint[axis] - node.point[axis];
+    const firstBranch = axisDiff <= 0 ? node.left : node.right;
+    const secondBranch = axisDiff <= 0 ? node.right : node.left;
+    best = this.nearestNeighborSearch(
+      firstBranch,
+      queryPoint,
+      depth + 1,
+      best,
+      bestDistance
     );
-    const {
-      numEntryExitLayerChanges,
-      numSameLayerCrossings,
-      numTransitionCrossings
-    } = getIntraNodeCrossingsFromSegments(segments);
-    const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
-    const estUsedCapacity = (estNumVias / 2) ** 1.1;
-    return estUsedCapacity;
-  }
-  getRandomWeightedNodeId() {
-    const nodeIdsWithCosts = [...this.currentNodeCosts.entries()].filter(([nodeId, cost]) => cost > 1e-5).filter(([nodeId]) => !this.nodeMap.get(nodeId)?._containsTarget);
-    if (nodeIdsWithCosts.length === 0) {
-      console.error(
-        "No nodes with cost > 0.00001 (why are you even running this solver)"
-      );
-      return this.currentNodeCosts.keys().next().value;
-    }
-    const totalCost = nodeIdsWithCosts.reduce((acc, [, cost]) => acc + cost, 0);
-    const randomValue = this.random() * totalCost;
-    let cumulativeCost = 0;
-    for (let i = 0; i < nodeIdsWithCosts.length; i++) {
-      const [nodeId, cost] = nodeIdsWithCosts[i];
-      cumulativeCost += cost;
-      if (cumulativeCost >= randomValue) {
-        return nodeId;
-      }
-    }
-    throw new Error("RANDOM SELECTION FAILURE FOR NODES (this is a bug)");
-  }
-  getRandomWeightedSegmentId() {
-    const nodeId = this.getRandomWeightedNodeId();
-    const segmentsIds = this.nodeIdToSegmentIds.get(nodeId).filter((s) => this.isSegmentMutable(s));
-    return segmentsIds[Math.floor(this.random() * segmentsIds.length)];
-  }
-  getMutableSegments() {
-    const mutableSegments = /* @__PURE__ */ new Set();
-    for (const segmentId of this.currentMutatedSegments.keys()) {
-      const segment = this.currentMutatedSegments.get(segmentId);
-      const nodes = this.segmentIdToNodeIds.get(segmentId);
-      const isMutable = nodes.every(
-        (nodeId) => !this.nodeMap.get(nodeId)?._containsTarget
+    bestDistance = this.distance(queryPoint, best);
+    if (Math.abs(axisDiff) < bestDistance) {
+      best = this.nearestNeighborSearch(
+        secondBranch,
+        queryPoint,
+        depth + 1,
+        best,
+        bestDistance
       );
-      if (isMutable) {
-        mutableSegments.add(segmentId);
-      }
     }
-    return mutableSegments;
-  }
-  isSegmentMutable(segmentId) {
-    return this.mutableSegments.has(segmentId);
+    return best;
   }
-  getRandomOperationForSegment(randomSegmentId) {
-    const segment = this.currentMutatedSegments.get(randomSegmentId);
-    let operationType = this.random() < 0.5 ? "switch" : "changeLayer";
-    if (segment.assignedPoints.length <= 1) {
-      operationType = "changeLayer";
-    }
-    if (operationType === "switch") {
-      const randomPointIndex1 = Math.floor(
-        this.random() * segment.assignedPoints.length
-      );
-      let randomPointIndex2 = randomPointIndex1;
-      while (randomPointIndex1 === randomPointIndex2) {
-        randomPointIndex2 = Math.floor(
-          this.random() * segment.assignedPoints.length
-        );
-      }
-      return {
-        op: "switch",
-        segmentId: randomSegmentId,
-        point1Index: randomPointIndex1,
-        point2Index: randomPointIndex2
-      };
+  // Find k nearest neighbors
+  findKNearestNeighbors(queryPoint, k) {
+    if (!this.root) {
+      return [];
     }
-    const randomPointIndex = Math.floor(
-      this.random() * segment.assignedPoints.length
-    );
-    const point = segment.assignedPoints[randomPointIndex];
-    return {
-      op: "changeLayer",
-      segmentId: randomSegmentId,
-      pointIndex: randomPointIndex,
-      newLayer: point.point.z === 0 ? 1 : 0
-    };
+    const neighbors = [];
+    this.kNearestNeighborSearch(this.root, queryPoint, 0, neighbors, k);
+    return neighbors.sort((a, b) => a.distance - b.distance).slice(0, k).map((n) => n.point);
   }
-  getNodesNearNode(nodeId, hops = 1) {
-    if (hops === 0) return [nodeId];
-    const segments = this.nodeIdToSegmentIds.get(nodeId);
-    const nodes = /* @__PURE__ */ new Set();
-    for (const segmentId of segments) {
-      const adjacentNodeIds = this.segmentIdToNodeIds.get(segmentId);
-      for (const adjacentNodeId of adjacentNodeIds) {
-        const ancestors = this.getNodesNearNode(adjacentNodeId, hops - 1);
-        for (const ancestor of ancestors) {
-          nodes.add(ancestor);
-        }
-      }
+  kNearestNeighborSearch(node, queryPoint, depth, neighbors, k) {
+    if (!node) {
+      return;
     }
-    return Array.from(nodes);
-  }
-  getRandomCombinedOperationNearNode(nodeId) {
-    const adjacentNodeIds = this.getNodesNearNode(
-      nodeId,
-      this.MAX_NODE_CHAIN_PER_MUTATION
+    const axis = depth % 2 ? "x" : "y";
+    const currentDistance = this.distance(queryPoint, node.point);
+    neighbors.push({ point: node.point, distance: currentDistance });
+    const axisDiff = queryPoint[axis] - node.point[axis];
+    const firstBranch = axisDiff <= 0 ? node.left : node.right;
+    const secondBranch = axisDiff <= 0 ? node.right : node.left;
+    this.kNearestNeighborSearch(
+      firstBranch,
+      queryPoint,
+      depth + 1,
+      neighbors,
+      k
     );
-    const subOperations = [];
-    const adjacentSegments = adjacentNodeIds.flatMap((nodeId2) => this.nodeIdToSegmentIds.get(nodeId2)).filter((s) => this.isSegmentMutable(s));
-    const numOperations = Math.floor(this.random() * this.MAX_OPERATIONS_PER_MUTATION) + 1;
-    for (let i = 0; i < numOperations; i++) {
-      const randomSegmentId = adjacentSegments[Math.floor(this.random() * adjacentSegments.length)];
-      const newOp = this.getRandomOperationForSegment(randomSegmentId);
-      if (newOp) {
-        subOperations.push(newOp);
-      }
+    let kthDistance = Infinity;
+    if (neighbors.length >= k) {
+      neighbors.sort((a, b) => a.distance - b.distance);
+      kthDistance = neighbors[k - 1]?.distance || Infinity;
     }
-    return {
-      op: "combined",
-      subOperations
-    };
-  }
-  /**
-   * A combined operation can perform multiple operations on a single node, this
-   * allows it to reach outcomes that may not be beneficial with since
-   * operations
-   */
-  getRandomCombinedOperationOnSingleNode(max = 7) {
-    const numSubOperations = max === 1 ? 1 : Math.floor(this.random() * max) + 1;
-    const subOperations = [];
-    const nodeId = this.getRandomWeightedNodeId();
-    const segmentsIds = this.nodeIdToSegmentIds.get(nodeId).filter((s) => this.isSegmentMutable(s));
-    for (let i = 0; i < numSubOperations; i++) {
-      const randomSegmentId = segmentsIds[Math.floor(this.random() * segmentsIds.length)];
-      const newOp = this.getRandomOperationForSegment(randomSegmentId);
-      if (newOp) {
-        subOperations.push(newOp);
-      }
+    if (Math.abs(axisDiff) < kthDistance || neighbors.length < k) {
+      this.kNearestNeighborSearch(
+        secondBranch,
+        queryPoint,
+        depth + 1,
+        neighbors,
+        k
+      );
     }
-    return {
-      op: "combined",
-      subOperations
-    };
   }
-  getRandomOperation() {
-    const randomSegmentId = this.getRandomWeightedSegmentId();
-    const newOp = this.getRandomOperationForSegment(randomSegmentId);
-    if (newOp) {
-      return newOp;
-    }
-    return this.getRandomOperation();
-  }
-  /**
-   * We compute "overall probability of failure" as our overall cost, then
-   * linearize it to make it easier to work with
-   */
-  computeCurrentCost() {
-    let logProbabilityOfSuccess = 0;
-    let costSum = 0;
-    const nodeCosts = /* @__PURE__ */ new Map();
-    for (const nodeId of this.nodeIdToSegmentIds.keys()) {
-      const nodeProbOfFailure = this.computeNodeCost(nodeId);
-      nodeCosts.set(nodeId, nodeProbOfFailure);
-      costSum += nodeProbOfFailure;
-      if (nodeProbOfFailure < 1) {
-        logProbabilityOfSuccess += Math.log(1 - nodeProbOfFailure);
-      } else {
-        logProbabilityOfSuccess = -Infinity;
-      }
-    }
-    const probabilityOfSuccess = Math.exp(logProbabilityOfSuccess);
-    const probabilityOfFailure = 1 - probabilityOfSuccess;
-    const numNodes = this.nodeIdToSegmentIds.size;
-    const linearizedCost = numNodes > 0 ? -logProbabilityOfSuccess / numNodes : 0;
-    return {
-      cost: linearizedCost,
-      // Replace cost with linearized version
-      nodeCosts,
-      probabilityOfFailure,
-      linearizedCost
-      // Also return as separate value if you need original cost sum
-    };
-  }
-  applyOperation(op) {
-    if (op.op === "combined") {
-      for (const subOp of op.subOperations) {
-        this.applyOperation(subOp);
-      }
-      return;
-    }
-    const segment = this.currentMutatedSegments.get(op.segmentId);
-    if (!segment || !segment.assignedPoints) return;
-    if (op.op === "changeLayer") {
-      op.oldLayer = segment.assignedPoints[op.pointIndex].point.z;
-      segment.assignedPoints[op.pointIndex].point.z = op.newLayer;
-    } else if (op.op === "switch") {
-      const point1 = segment.assignedPoints[op.point1Index].point;
-      const point2 = segment.assignedPoints[op.point2Index].point;
-      const tempX = point1.x;
-      const tempY = point1.y;
-      const tempZ = point1.z;
-      point1.x = point2.x;
-      point1.y = point2.y;
-      point1.z = point2.z;
-      point2.x = tempX;
-      point2.y = tempY;
-      point2.z = tempZ;
-    }
-  }
-  reverseOperation(op) {
-    if (op.op === "combined") {
-      for (const subOp of [...op.subOperations].reverse()) {
-        this.reverseOperation(subOp);
-      }
-      return;
-    }
-    const segment = this.currentMutatedSegments.get(op.segmentId);
-    if (!segment || !segment.assignedPoints) return;
-    if (op.op === "changeLayer") {
-      const oldLayer = op.oldLayer;
-      if (oldLayer === void 0) return;
-      segment.assignedPoints[op.pointIndex].point.z = oldLayer;
-    } else if (op.op === "switch") {
-      const point1 = segment.assignedPoints[op.point1Index].point;
-      const point2 = segment.assignedPoints[op.point2Index].point;
-      const tempX = point1.x;
-      const tempY = point1.y;
-      const tempZ = point1.z;
-      point1.x = point2.x;
-      point1.y = point2.y;
-      point1.z = point2.z;
-      point2.x = tempX;
-      point2.y = tempY;
-      point2.z = tempZ;
-    }
-  }
-  isNewCostAcceptable(oldPf, newPf) {
-    if (newPf < oldPf) return true;
-    return false;
-  }
-  /**
-   * FOR OUTPUT: Return the assigned points for each segment.
-   */
-  getNodesWithPortPoints() {
-    if (!this.solved) {
-      throw new Error(
-        "CapacitySegmentToPointSolver not solved, can't give port points yet"
-      );
-    }
-    const map = /* @__PURE__ */ new Map();
-    for (const segId of this.allSegmentIds) {
-      for (const nodeId of this.segmentIdToNodeIds.get(segId)) {
-        const node = this.nodeMap.get(nodeId);
-        if (!map.has(nodeId)) {
-          map.set(nodeId, {
-            capacityMeshNodeId: nodeId,
-            portPoints: [],
-            center: node.center,
-            width: node.width,
-            height: node.height
-          });
-        }
-        map.get(nodeId).portPoints.push(
-          ...this.currentMutatedSegments.get(segId).assignedPoints.map((ap) => ({
-            ...ap.point,
-            connectionName: ap.connectionName
-          }))
-        );
-      }
-    }
-    return Array.from(map.values());
-  }
-  _step() {
-    if (this.iterations === this.MAX_ITERATIONS - 1) {
-      this.solved = true;
-      return;
-    }
-    if (this.currentCost < 1e-3) {
-      this.solved = true;
-      return;
-    }
-    const op = this.getRandomCombinedOperationOnSingleNode();
-    this.lastCreatedOperation = op;
-    this.applyOperation(op);
-    const {
-      cost: newCost,
-      nodeCosts: newNodeCosts,
-      probabilityOfFailure: newProbabilityOfFailure
-    } = this.computeCurrentCost();
-    op.cost = newCost;
-    const keepChange = this.isNewCostAcceptable(this.currentCost, newCost);
-    if (!keepChange) {
-      this.reverseOperation(op);
-      if (this.iterations - this.lastAcceptedIteration > this.NOOP_ITERATIONS_BEFORE_EARLY_STOP) {
-        this.solved = true;
-      }
-      return;
-    }
-    this.lastAcceptedIteration = this.iterations;
-    this.currentCost = newCost;
-    this.currentNodeCosts = newNodeCosts;
-    this.lastAppliedOperation = op;
-    this.probabilityOfFailure = newProbabilityOfFailure;
-  }
-  visualize() {
-    const immutableSegments = new Set(
-      [...this.currentMutatedSegments.values()].filter(
-        (seg) => !this.isSegmentMutable(seg.nodePortSegmentId)
-      )
-    );
-    const graphics = {
-      points: [...this.currentMutatedSegments.values()].flatMap(
-        (seg, i) => seg.assignedPoints.map((ap) => ({
-          x: ap.point.x,
-          y: ap.point.y,
-          label: `${seg.nodePortSegmentId}
-layer: ${ap.point.z}
-${ap.connectionName}
-${immutableSegments.has(seg) ? "(IMMUTABLE)" : ""}`,
-          color: this.colorMap[ap.connectionName]
-        }))
-      ),
-      lines: [...this.currentMutatedSegments.values()].map((seg) => ({
-        points: [seg.start, seg.end]
-      })),
-      rects: [
-        ...[...this.nodeMap.values()].map((node) => {
-          const segmentIds = this.nodeIdToSegmentIds.get(
-            node.capacityMeshNodeId
-          );
-          if (!segmentIds) return null;
-          const segments = segmentIds.map(
-            (segmentId) => this.currentMutatedSegments.get(segmentId)
-          );
-          let label;
-          if (node._containsTarget) {
-            label = `${node.capacityMeshNodeId}
-${node.width.toFixed(2)}x${node.height.toFixed(2)}`;
-          } else {
-            const intraNodeCrossings = getIntraNodeCrossingsFromSegments(segments);
-            label = `${node.capacityMeshNodeId}
-${this.computeNodeCost(node.capacityMeshNodeId).toFixed(2)}/${getTunedTotalCapacity1(node).toFixed(2)}
-Trace Capacity: ${this.getUsedTraceCapacity(node.capacityMeshNodeId).toFixed(2)}
-X'ings: ${intraNodeCrossings.numSameLayerCrossings}
-Ent/Ex LC: ${intraNodeCrossings.numEntryExitLayerChanges}
-T X'ings: ${intraNodeCrossings.numTransitionCrossings}
-${node.width.toFixed(2)}x${node.height.toFixed(2)}`;
-          }
-          return {
-            center: node.center,
-            label,
-            color: "red",
-            width: node.width / 8,
-            height: node.height / 8
-          };
-        }).filter((r) => r !== null)
-      ],
-      circles: [],
-      coordinateSystem: "cartesian",
-      title: "Capacity Segment Point Optimizer"
-    };
-    const dashedLines = [];
-    const nodeConnections = {};
-    for (const seg of this.currentMutatedSegments.values()) {
-      const nodeIds = this.segmentIdToNodeIds.get(seg.nodePortSegmentId);
-      for (const nodeId of nodeIds) {
-        if (!nodeConnections[nodeId]) {
-          nodeConnections[nodeId] = {};
-        }
-        for (const ap of seg.assignedPoints) {
-          if (!nodeConnections[nodeId][ap.connectionName]) {
-            nodeConnections[nodeId][ap.connectionName] = [];
-          }
-          nodeConnections[nodeId][ap.connectionName].push(ap.point);
-        }
-      }
-    }
-    for (const nodeId in nodeConnections) {
-      for (const conn in nodeConnections[nodeId]) {
-        const points = nodeConnections[nodeId][conn];
-        if (points.length <= 1) continue;
-        const sameLayer = points[0].z === points[1].z;
-        const commonLayer = points[0].z;
-        const type = sameLayer ? commonLayer === 0 ? "top" : "bottom" : "transition";
-        dashedLines.push({
-          points,
-          strokeDash: type === "top" ? void 0 : type === "bottom" ? "10 5" : "3 3 10",
-          strokeColor: this.colorMap[conn] || "#000"
-        });
-      }
-    }
-    graphics.lines.push(...dashedLines);
-    const operationsToShow = [];
-    if (this.lastCreatedOperation?.op === "combined") {
-      operationsToShow.push(...this.lastCreatedOperation.subOperations);
-    } else if (this.lastCreatedOperation) {
-      operationsToShow.push(this.lastCreatedOperation);
-    }
-    for (const op of operationsToShow) {
-      const segment = this.currentMutatedSegments.get(op.segmentId);
-      const node = this.nodeMap.get(segment.capacityMeshNodeId);
-      graphics.circles.push({
-        center: { x: node.center.x, y: node.center.y },
-        radius: node.width / 4,
-        stroke: "#0000ff",
-        fill: "rgba(0, 0, 255, 0.2)",
-        label: `LAST OPERATION: ${op.op}
-Cost: ${op.cost?.toString()}
-${node.capacityMeshNodeId}
-${this.currentNodeCosts.get(node.capacityMeshNodeId)}/${getTunedTotalCapacity1(node)}
-${node.width.toFixed(2)}x${node.height.toFixed(2)}`
-      });
-      if (op.op === "changeLayer") {
-        const point = segment.assignedPoints[op.pointIndex];
-        graphics.circles.push({
-          center: { x: point.point.x, y: point.point.y },
-          radius: this.nodeMap.get(segment.capacityMeshNodeId).width / 8,
-          stroke: "#ff0000",
-          fill: "rgba(255, 0, 0, 0.2)",
-          label: `Layer Changed
-oldLayer: ${op.oldLayer}
-newLayer: ${op.newLayer}`
-        });
-      } else if (op.op === "switch") {
-        const point1 = segment.assignedPoints[op.point1Index];
-        const point2 = segment.assignedPoints[op.point2Index];
-        graphics.circles.push(
-          {
-            center: { x: point1.point.x, y: point1.point.y },
-            radius: node.width / 16,
-            stroke: "#00ff00",
-            fill: "rgba(0, 255, 0, 0.2)",
-            label: `Swapped 1
-${segment.nodePortSegmentId}`
-          },
-          {
-            center: { x: point2.point.x, y: point2.point.y },
-            radius: node.width / 16,
-            stroke: "#00ff00",
-            fill: "rgba(0, 255, 0, 0.2)",
-            label: `Swapped 2
-${segment.nodePortSegmentId}`
-          }
-        );
-        graphics.lines.push({
-          points: [
-            { x: point1.point.x, y: point1.point.y },
-            { x: point2.point.x, y: point2.point.y }
-          ],
-          strokeColor: "#00ff00",
-          strokeDash: "3 3",
-          strokeWidth: node.width / 32
-        });
-      }
-    }
-    return graphics;
-  }
-};
-
-// lib/solvers/NetToPointPairsSolver/buildMinimumSpanningTree.ts
-var KDNode = class {
-  point;
-  left = null;
-  right = null;
-  constructor(point) {
-    this.point = point;
-  }
-};
-var KDTree = class {
-  root = null;
-  constructor(points) {
-    if (points.length > 0) {
-      this.root = this.buildTree(points, 0);
-    }
-  }
-  buildTree(points, depth) {
-    const axis = depth % 2 === 0 ? "x" : "y";
-    points.sort((a, b) => a[axis] - b[axis]);
-    const medianIndex = Math.floor(points.length / 2);
-    const node = new KDNode(points[medianIndex]);
-    if (medianIndex > 0) {
-      node.left = this.buildTree(points.slice(0, medianIndex), depth + 1);
-    }
-    if (medianIndex < points.length - 1) {
-      node.right = this.buildTree(points.slice(medianIndex + 1), depth + 1);
-    }
-    return node;
-  }
-  // Find the nearest neighbor to a query point
-  findNearestNeighbor(queryPoint) {
-    if (!this.root) {
-      throw new Error("Tree is empty");
-    }
-    const best = this.root.point;
-    const bestDistance = this.distance(queryPoint, best);
-    this.nearestNeighborSearch(this.root, queryPoint, 0, best, bestDistance);
-    return best;
-  }
-  nearestNeighborSearch(node, queryPoint, depth, best, bestDistance) {
-    if (!node) {
-      return best;
-    }
-    const axis = depth % 2 ? "x" : "y";
-    const currentDistance = this.distance(queryPoint, node.point);
-    if (currentDistance < bestDistance) {
-      best = node.point;
-      bestDistance = currentDistance;
-    }
-    const axisDiff = queryPoint[axis] - node.point[axis];
-    const firstBranch = axisDiff <= 0 ? node.left : node.right;
-    const secondBranch = axisDiff <= 0 ? node.right : node.left;
-    best = this.nearestNeighborSearch(
-      firstBranch,
-      queryPoint,
-      depth + 1,
-      best,
-      bestDistance
-    );
-    bestDistance = this.distance(queryPoint, best);
-    if (Math.abs(axisDiff) < bestDistance) {
-      best = this.nearestNeighborSearch(
-        secondBranch,
-        queryPoint,
-        depth + 1,
-        best,
-        bestDistance
-      );
-    }
-    return best;
-  }
-  // Find k nearest neighbors
-  findKNearestNeighbors(queryPoint, k) {
-    if (!this.root) {
-      return [];
-    }
-    const neighbors = [];
-    this.kNearestNeighborSearch(this.root, queryPoint, 0, neighbors, k);
-    return neighbors.sort((a, b) => a.distance - b.distance).slice(0, k).map((n) => n.point);
-  }
-  kNearestNeighborSearch(node, queryPoint, depth, neighbors, k) {
-    if (!node) {
-      return;
-    }
-    const axis = depth % 2 ? "x" : "y";
-    const currentDistance = this.distance(queryPoint, node.point);
-    neighbors.push({ point: node.point, distance: currentDistance });
-    const axisDiff = queryPoint[axis] - node.point[axis];
-    const firstBranch = axisDiff <= 0 ? node.left : node.right;
-    const secondBranch = axisDiff <= 0 ? node.right : node.left;
-    this.kNearestNeighborSearch(
-      firstBranch,
-      queryPoint,
-      depth + 1,
-      neighbors,
-      k
-    );
-    let kthDistance = Infinity;
-    if (neighbors.length >= k) {
-      neighbors.sort((a, b) => a.distance - b.distance);
-      kthDistance = neighbors[k - 1]?.distance || Infinity;
-    }
-    if (Math.abs(axisDiff) < kthDistance || neighbors.length < k) {
-      this.kNearestNeighborSearch(
-        secondBranch,
-        queryPoint,
-        depth + 1,
-        neighbors,
-        k
-      );
-    }
-  }
-  // Calculate Euclidean distance between two points
-  distance(a, b) {
-    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
-  }
-};
-var DisjointSet = class {
-  parent = /* @__PURE__ */ new Map();
-  rank = /* @__PURE__ */ new Map();
-  constructor(points) {
-    for (const point of points) {
-      const key = this.pointToKey(point);
-      this.parent.set(key, key);
-      this.rank.set(key, 0);
+  // Calculate Euclidean distance between two points
+  distance(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
+  }
+};
+var DisjointSet = class {
+  parent = /* @__PURE__ */ new Map();
+  rank = /* @__PURE__ */ new Map();
+  constructor(points) {
+    for (const point of points) {
+      const key = this.pointToKey(point);
+      this.parent.set(key, key);
+      this.rank.set(key, 0);
     }
   }
   pointToKey(point) {
@@ -4212,551 +3531,1670 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance3 = Math.sqrt(
-        (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
-      );
-      edges.push({
-        from: point,
-        to: neighbor,
-        weight: distance3
+      const distance3 = Math.sqrt(
+        (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
+      );
+      edges.push({
+        from: point,
+        to: neighbor,
+        weight: distance3
+      });
+    }
+  }
+  edges.sort((a, b) => a.weight - b.weight);
+  const disjointSet = new DisjointSet(points);
+  const mstEdges = [];
+  for (const edge of edges) {
+    if (disjointSet.union(edge.from, edge.to)) {
+      mstEdges.push(edge);
+      if (mstEdges.length === points.length - 1) {
+        break;
+      }
+    }
+  }
+  return mstEdges;
+}
+
+// lib/solvers/NetToPointPairsSolver/NetToPointPairsSolver.ts
+var NetToPointPairsSolver = class extends BaseSolver {
+  constructor(ogSrj, colorMap = {}) {
+    super();
+    this.ogSrj = ogSrj;
+    this.colorMap = colorMap;
+    this.unprocessedConnections = [...ogSrj.connections];
+    this.newConnections = [];
+  }
+  unprocessedConnections;
+  newConnections;
+  _step() {
+    if (this.unprocessedConnections.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const connection = this.unprocessedConnections.pop();
+    if (connection.pointsToConnect.length === 2) {
+      this.newConnections.push(connection);
+      return;
+    }
+    const edges = buildMinimumSpanningTree(connection.pointsToConnect);
+    for (let i = 0; i < edges.length; i++) {
+      const edge = edges[i];
+      this.newConnections.push({
+        pointsToConnect: [edge.from, edge.to],
+        name: `${connection.name}_mst${i}`
+      });
+    }
+  }
+  getNewSimpleRouteJson() {
+    return {
+      ...this.ogSrj,
+      connections: this.newConnections
+    };
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Net To Point Pairs Visualization"
+    };
+    this.unprocessedConnections.forEach((connection) => {
+      connection.pointsToConnect.forEach((point) => {
+        graphics.points.push({
+          x: point.x,
+          y: point.y,
+          color: "red",
+          label: connection.name
+        });
+      });
+      const fullyConnectedEdgeCount = connection.pointsToConnect.length ** 2;
+      const random = seededRandom(0);
+      const alreadyPlacedEdges = /* @__PURE__ */ new Set();
+      for (let i = 0; i < Math.max(
+        fullyConnectedEdgeCount,
+        connection.pointsToConnect.length * 2
+      ); i++) {
+        const a = Math.floor(random() * connection.pointsToConnect.length);
+        const b = Math.floor(random() * connection.pointsToConnect.length);
+        if (alreadyPlacedEdges.has(`${a}-${b}`)) continue;
+        alreadyPlacedEdges.add(`${a}-${b}`);
+        graphics.lines.push({
+          points: [
+            connection.pointsToConnect[a],
+            connection.pointsToConnect[b]
+          ],
+          strokeColor: "rgba(255,0,0,0.25)"
+        });
+      }
+    });
+    this.newConnections.forEach((connection) => {
+      const color = this.colorMap?.[connection.name] || "blue";
+      connection.pointsToConnect.forEach((point) => {
+        graphics.points.push({
+          x: point.x,
+          y: point.y,
+          color,
+          label: connection.name
+        });
+      });
+      for (let i = 0; i < connection.pointsToConnect.length - 1; i++) {
+        for (let j = i + 1; j < connection.pointsToConnect.length; j++) {
+          graphics.lines.push({
+            points: [
+              connection.pointsToConnect[i],
+              connection.pointsToConnect[j]
+            ],
+            strokeColor: color
+          });
+        }
+      }
+    });
+    return graphics;
+  }
+};
+
+// 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;
+  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, layerCount);
+      for (const layerPoint of currentLayerPoints) {
+        result.push({
+          route_type: "wire",
+          x: layerPoint.x,
+          y: layerPoint.y,
+          width: hdRoute.traceThickness,
+          layer: layerName2
+        });
+      }
+      const viaExists = hdRoute.vias.some(
+        (via) => Math.abs(via.x - point.x) < 1e-3 && Math.abs(via.y - point.y) < 1e-3
+      );
+      if (viaExists) {
+        const fromLayer = mapZToLayerName(currentZ, layerCount);
+        const toLayer = mapZToLayerName(point.z, layerCount);
+        result.push({
+          route_type: "via",
+          x: point.x,
+          y: point.y,
+          from_layer: fromLayer,
+          to_layer: toLayer
+        });
+      }
+      currentLayerPoints = [point];
+      currentZ = point.z;
+    } else {
+      currentLayerPoints.push(point);
+    }
+  }
+  const layerName = mapZToLayerName(currentZ, layerCount);
+  for (const layerPoint of currentLayerPoints) {
+    result.push({
+      route_type: "wire",
+      x: layerPoint.x,
+      y: layerPoint.y,
+      width: hdRoute.traceThickness,
+      layer: layerName
+    });
+  }
+  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"
+        });
+      }
     }
-  }
-  edges.sort((a, b) => a.weight - b.weight);
-  const disjointSet = new DisjointSet(points);
-  const mstEdges = [];
-  for (const edge of edges) {
-    if (disjointSet.union(edge.from, edge.to)) {
-      mstEdges.push(edge);
-      if (mstEdges.length === points.length - 1) {
-        break;
+    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;
   }
-  return mstEdges;
-}
+};
 
-// lib/solvers/NetToPointPairsSolver/NetToPointPairsSolver.ts
-var NetToPointPairsSolver = class extends BaseSolver {
-  constructor(ogSrj, colorMap = {}) {
+// lib/solvers/RouteStitchingSolver/MultipleHighDensityRouteStitchSolver.ts
+var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
+  unsolvedRoutes;
+  activeSolver = null;
+  mergedHdRoutes = [];
+  constructor(opts) {
     super();
-    this.ogSrj = ogSrj;
-    this.colorMap = colorMap;
-    this.unprocessedConnections = [...ogSrj.connections];
-    this.newConnections = [];
+    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)
+      }
+    }));
   }
-  unprocessedConnections;
-  newConnections;
   _step() {
-    if (this.unprocessedConnections.length === 0) {
-      this.solved = true;
+    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 connection = this.unprocessedConnections.pop();
-    if (connection.pointsToConnect.length === 2) {
-      this.newConnections.push(connection);
+    const unsolvedRoute = this.unsolvedRoutes.pop();
+    if (!unsolvedRoute) {
+      this.solved = true;
       return;
     }
-    const edges = buildMinimumSpanningTree(connection.pointsToConnect);
-    for (let i = 0; i < edges.length; i++) {
-      const edge = edges[i];
-      this.newConnections.push({
-        pointsToConnect: [edge.from, edge.to],
-        name: `${connection.name}_mst${i}`
-      });
+    if (unsolvedRoute.hdRoutes.length === 0) {
+      console.warn(`No routes to stitch for ${unsolvedRoute.connectionName}`);
+      return;
     }
-  }
-  getNewSimpleRouteJson() {
-    return {
-      ...this.ogSrj,
-      connections: this.newConnections
-    };
+    this.activeSolver = new SingleHighDensityRouteStitchSolver({
+      hdRoutes: unsolvedRoute.hdRoutes,
+      start: unsolvedRoute.start,
+      end: unsolvedRoute.end
+    });
   }
   visualize() {
     const graphics = {
-      lines: [],
       points: [],
-      rects: [],
+      lines: [],
       circles: [],
-      coordinateSystem: "cartesian",
-      title: "Net To Point Pairs Visualization"
+      title: "Multiple High Density Route Stitch Solver"
     };
-    this.unprocessedConnections.forEach((connection) => {
-      connection.pointsToConnect.forEach((point) => {
-        graphics.points.push({
+    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: "red",
-          label: connection.name
+          color: solvedColor
         });
-      });
-      const fullyConnectedEdgeCount = connection.pointsToConnect.length ** 2;
-      const random = seededRandom(0);
-      const alreadyPlacedEdges = /* @__PURE__ */ new Set();
-      for (let i = 0; i < Math.max(
-        fullyConnectedEdgeCount,
-        connection.pointsToConnect.length * 2
-      ); i++) {
-        const a = Math.floor(random() * connection.pointsToConnect.length);
-        const b = Math.floor(random() * connection.pointsToConnect.length);
-        if (alreadyPlacedEdges.has(`${a}-${b}`)) continue;
-        alreadyPlacedEdges.add(`${a}-${b}`);
-        graphics.lines.push({
-          points: [
-            connection.pointsToConnect[a],
-            connection.pointsToConnect[b]
-          ],
-          strokeColor: "rgba(255,0,0,0.25)"
+      }
+      for (const via of mergedRoute.vias) {
+        graphics.circles?.push({
+          center: { x: via.x, y: via.y },
+          radius: mergedRoute.viaDiameter / 2,
+          fill: solvedColor
         });
       }
-    });
-    this.newConnections.forEach((connection) => {
-      const color = this.colorMap?.[connection.name] || "blue";
-      connection.pointsToConnect.forEach((point) => {
-        graphics.points.push({
+    }
+    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,
-          label: connection.name
+          color: colorMap[connection.name],
+          label: `${connection.name} (${point.layer})`
         });
-      });
-      for (let i = 0; i < connection.pointsToConnect.length - 1; i++) {
-        for (let j = i + 1; j < connection.pointsToConnect.length; j++) {
-          graphics.lines.push({
+      }
+    }
+  }
+  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: [
-              connection.pointsToConnect[i],
-              connection.pointsToConnect[j]
+              { x: routePoint.x, y: routePoint.y },
+              { x: nextRoutePoint.x, y: nextRoutePoint.y }
             ],
-            strokeColor: color
+            strokeWidth: 0.15,
+            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 graphics;
+    }
   }
+  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/utils/mapZToLayerName.ts
-var mapZToLayerName = (z, layerCount) => {
-  if (z < 0 || z >= layerCount) {
-    throw new Error(`Invalid z "${z}" for layer count: ${layerCount}`);
+// lib/solvers/UnravelSolver/getNodesNearNode.ts
+function getNodesNearNode(params) {
+  const { nodeId, nodeIdToSegmentIds, segmentIdToNodeIds, hops } = params;
+  if (hops === 0) return [nodeId];
+  const segments = nodeIdToSegmentIds.get(nodeId);
+  const nodes = /* @__PURE__ */ new Set();
+  for (const segmentId of segments) {
+    const adjacentNodeIds = segmentIdToNodeIds.get(segmentId);
+    for (const adjacentNodeId of adjacentNodeIds) {
+      const ancestors = getNodesNearNode({
+        nodeId: adjacentNodeId,
+        nodeIdToSegmentIds,
+        segmentIdToNodeIds,
+        hops: hops - 1
+      });
+      for (const ancestor of ancestors) {
+        nodes.add(ancestor);
+      }
+    }
   }
-  if (z === 0) return "top";
-  if (z === layerCount - 1) return "bottom";
-  return `inner${z}`;
+  return Array.from(nodes);
+}
+
+// lib/solvers/UnravelSolver/createPointModificationsHash.ts
+var createPointModificationsHash = (pointModifications) => {
+  return Array.from(pointModifications.entries()).map(
+    ([id, { x, y, z }]) => `${id}(${x?.toFixed(3) ?? ""},${y?.toFixed(3) ?? ""},${z ?? ""})`
+  ).sort().join("&");
 };
 
-// lib/utils/convertHdRouteToSimplifiedRoute.ts
-var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
-  const result = [];
-  if (hdRoute.route.length === 0) return result;
-  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, layerCount);
-      for (const layerPoint of currentLayerPoints) {
-        result.push({
-          route_type: "wire",
-          x: layerPoint.x,
-          y: layerPoint.y,
-          width: hdRoute.traceThickness,
-          layer: layerName2
+// lib/solvers/UnravelSolver/hasZRangeOverlap.ts
+var hasZRangeOverlap = (A_z1, A_z2, B_z1, B_z2) => {
+  const Amin = Math.min(A_z1, A_z2);
+  const Amax = Math.max(A_z1, A_z2);
+  const Bmin = Math.min(B_z1, B_z2);
+  const Bmax = Math.max(B_z1, B_z2);
+  return Amin <= Bmax && Amax >= Bmin;
+};
+
+// lib/solvers/UnravelSolver/getIssuesInSection.ts
+var getIssuesInSection = (section, nodeMap, pointModifications, connMap) => {
+  const issues = [];
+  const points = /* @__PURE__ */ new Map();
+  for (const nodeId of section.allNodeIds) {
+    for (const segmentPointId of section.segmentPointsInNode.get(nodeId)) {
+      if (!points.has(segmentPointId)) {
+        const ogPoint = section.segmentPointMap.get(segmentPointId);
+        const modPoint = pointModifications.get(segmentPointId);
+        points.set(segmentPointId, {
+          x: modPoint?.x ?? ogPoint.x,
+          y: modPoint?.y ?? ogPoint.y,
+          z: modPoint?.z ?? ogPoint.z
         });
       }
-      const viaExists = hdRoute.vias.some(
-        (via) => Math.abs(via.x - point.x) < 1e-3 && Math.abs(via.y - point.y) < 1e-3
-      );
-      if (viaExists) {
-        const fromLayer = mapZToLayerName(currentZ, layerCount);
-        const toLayer = mapZToLayerName(point.z, layerCount);
-        result.push({
-          route_type: "via",
-          x: point.x,
-          y: point.y,
-          from_layer: fromLayer,
-          to_layer: toLayer
+    }
+  }
+  for (const nodeId of section.allNodeIds) {
+    const node = nodeMap.get(nodeId);
+    if (!node) continue;
+    const nodeSegmentPairs = section.segmentPairsInNode.get(nodeId);
+    for (const pair of nodeSegmentPairs) {
+      const A = points.get(pair[0]);
+      const B = points.get(pair[1]);
+      if (A.z !== B.z) {
+        issues.push({
+          type: "transition_via",
+          segmentPoints: pair,
+          capacityMeshNodeId: nodeId,
+          probabilityOfFailure: 0
         });
       }
-      currentLayerPoints = [point];
-      currentZ = point.z;
-    } else {
-      currentLayerPoints.push(point);
+    }
+    for (let i = 0; i < nodeSegmentPairs.length; i++) {
+      for (let j = i + 1; j < nodeSegmentPairs.length; j++) {
+        if (connMap?.areIdsConnected(
+          nodeSegmentPairs[i][0],
+          nodeSegmentPairs[i][1]
+        )) {
+          continue;
+        }
+        const pair1 = nodeSegmentPairs[i];
+        const pair2 = nodeSegmentPairs[j];
+        const A = points.get(pair1[0]);
+        const B = points.get(pair1[1]);
+        const C = points.get(pair2[0]);
+        const D = points.get(pair2[1]);
+        if (!hasZRangeOverlap(A.z, B.z, C.z, D.z)) continue;
+        const areCrossing = doSegmentsIntersect(A, B, C, D);
+        const isSameLayer = A.z === B.z && C.z === D.z && A.z === C.z;
+        if (areCrossing) {
+          if (isSameLayer) {
+            issues.push({
+              type: "same_layer_crossing",
+              segmentPoints: [pair1, pair2],
+              capacityMeshNodeId: nodeId,
+              crossingLine1: pair1,
+              crossingLine2: pair2,
+              probabilityOfFailure: 0
+            });
+          } else if (A.z === B.z && C.z !== D.z) {
+            issues.push({
+              type: "single_transition_crossing",
+              segmentPoints: [pair1, pair2],
+              capacityMeshNodeId: nodeId,
+              sameLayerCrossingLine: pair1,
+              transitionCrossingLine: pair2,
+              probabilityOfFailure: 0
+            });
+          } else if (A.z !== B.z && C.z === D.z) {
+            issues.push({
+              type: "single_transition_crossing",
+              segmentPoints: [pair1, pair2],
+              capacityMeshNodeId: nodeId,
+              sameLayerCrossingLine: pair2,
+              transitionCrossingLine: pair1,
+              probabilityOfFailure: 0
+            });
+          } else if (A.z !== B.z && C.z !== D.z) {
+            issues.push({
+              type: "double_transition_crossing",
+              segmentPoints: [pair1, pair2],
+              capacityMeshNodeId: nodeId,
+              crossingLine1: pair1,
+              crossingLine2: pair2,
+              probabilityOfFailure: 0
+            });
+          }
+        }
+      }
     }
   }
-  const layerName = mapZToLayerName(currentZ, layerCount);
-  for (const layerPoint of currentLayerPoints) {
-    result.push({
-      route_type: "wire",
-      x: layerPoint.x,
-      y: layerPoint.y,
-      width: hdRoute.traceThickness,
-      layer: layerName
+  return issues;
+};
+
+// lib/solvers/UnravelSolver/getLogProbability.ts
+var getLogProbability = (probability) => {
+  const K = -2.3;
+  return 1 - Math.exp(probability * K);
+};
+
+// lib/solvers/UnravelSolver/applyOperationToPointModifications.ts
+var applyOperationToPointModifications = (pointModifications, operation, getPointInCandidate) => {
+  if (operation.type === "change_layer") {
+    for (const segmentPointId of operation.segmentPointIds) {
+      const existingMods = pointModifications.get(segmentPointId) || {};
+      pointModifications.set(segmentPointId, {
+        ...existingMods,
+        z: operation.newZ
+      });
+    }
+  } else if (operation.type === "swap_position_on_segment") {
+    const [ASpId, BSpId] = operation.segmentPointIds;
+    const A = getPointInCandidate(ASpId);
+    const B = getPointInCandidate(BSpId);
+    const existingModsA = pointModifications.get(ASpId) || {};
+    const existingModsB = pointModifications.get(BSpId) || {};
+    pointModifications.set(ASpId, {
+      ...existingModsA,
+      x: B.x,
+      y: B.y
+    });
+    pointModifications.set(BSpId, {
+      ...existingModsB,
+      x: A.x,
+      y: A.y
     });
+  } else if (operation.type === "combined") {
+    for (const subOperation of operation.operations) {
+      applyOperationToPointModifications(
+        pointModifications,
+        subOperation,
+        getPointInCandidate
+      );
+    }
   }
-  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/UnravelSolver/createSegmentPointMap.ts
+var createSegmentPointMap = (dedupedSegments, segmentIdToNodeIds) => {
+  const segmentPoints = [];
+  let highestSegmentPointId = 0;
+  for (const segment of dedupedSegments) {
+    for (const point of segment.assignedPoints) {
+      segmentPoints.push({
+        segmentPointId: `SP${highestSegmentPointId++}`,
+        segmentId: segment.nodePortSegmentId,
+        capacityMeshNodeIds: segmentIdToNodeIds.get(
+          segment.nodePortSegmentId
+        ),
+        connectionName: point.connectionName,
+        x: point.point.x,
+        y: point.point.y,
+        z: point.point.z,
+        directlyConnectedSegmentPointIds: []
+      });
+    }
+  }
+  const segmentPointMap = /* @__PURE__ */ new Map();
+  for (const segmentPoint of segmentPoints) {
+    segmentPointMap.set(segmentPoint.segmentPointId, segmentPoint);
+  }
+  return segmentPointMap;
 };
 
-// lib/solvers/RouteStitchingSolver/SingleHighDensityRouteStitchSolver.ts
-var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
-  mergedHdRoute;
-  remainingHdRoutes;
-  start;
-  end;
-  constructor(opts) {
+// lib/solvers/UnravelSolver/UnravelSectionSolver.ts
+var UnravelSectionSolver = class extends BaseSolver {
+  nodeMap;
+  dedupedSegments;
+  MUTABLE_HOPS = 1;
+  unravelSection;
+  candidates = [];
+  lastProcessedCandidate = null;
+  bestCandidate = null;
+  originalCandidate;
+  rootNodeId;
+  nodeIdToSegmentIds;
+  segmentIdToNodeIds;
+  colorMap;
+  tunedNodeCapacityMap;
+  MAX_CANDIDATES = 500;
+  selectedCandidateIndex = null;
+  queuedOrExploredCandidatePointModificationHashes = /* @__PURE__ */ new Set();
+  constructor(params) {
     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
+    this.MUTABLE_HOPS = params.MUTABLE_HOPS ?? this.MUTABLE_HOPS;
+    this.nodeMap = params.nodeMap;
+    this.dedupedSegments = params.dedupedSegments;
+    this.nodeIdToSegmentIds = params.nodeIdToSegmentIds;
+    this.segmentIdToNodeIds = params.segmentIdToNodeIds;
+    this.rootNodeId = params.rootNodeId;
+    this.colorMap = params.colorMap ?? {};
+    this.unravelSection = this.createUnravelSection(params.segmentPointMap);
+    this.tunedNodeCapacityMap = /* @__PURE__ */ new Map();
+    for (const nodeId of this.unravelSection.allNodeIds) {
+      this.tunedNodeCapacityMap.set(
+        nodeId,
+        getTunedTotalCapacity1(this.nodeMap.get(nodeId))
+      );
+    }
+    this.originalCandidate = this.createInitialCandidate();
+    this.candidates = [this.originalCandidate];
+  }
+  createUnravelSection(segmentPointMap) {
+    const mutableNodeIds = getNodesNearNode({
+      nodeId: this.rootNodeId,
+      nodeIdToSegmentIds: this.nodeIdToSegmentIds,
+      segmentIdToNodeIds: this.segmentIdToNodeIds,
+      hops: this.MUTABLE_HOPS
+    });
+    const allNodeIds = getNodesNearNode({
+      nodeId: this.rootNodeId,
+      nodeIdToSegmentIds: this.nodeIdToSegmentIds,
+      segmentIdToNodeIds: this.segmentIdToNodeIds,
+      hops: this.MUTABLE_HOPS + 1
+    });
+    const immutableNodeIds = Array.from(
+      new Set(allNodeIds).difference(new Set(mutableNodeIds))
+    );
+    if (!segmentPointMap) {
+      segmentPointMap = createSegmentPointMap(
+        this.dedupedSegments,
+        this.segmentIdToNodeIds
+      );
+    }
+    const segmentPoints = Array.from(segmentPointMap.values());
+    const segmentPointsInNode = /* @__PURE__ */ new Map();
+    for (const segmentPoint of segmentPoints) {
+      for (const nodeId of segmentPoint.capacityMeshNodeIds) {
+        segmentPointsInNode.set(nodeId, [
+          ...segmentPointsInNode.get(nodeId) ?? [],
+          segmentPoint.segmentPointId
+        ]);
+      }
+    }
+    const segmentPointsInSegment = /* @__PURE__ */ new Map();
+    for (const segmentPoint of segmentPoints) {
+      segmentPointsInSegment.set(segmentPoint.segmentId, [
+        ...segmentPointsInSegment.get(segmentPoint.segmentId) ?? [],
+        segmentPoint.segmentPointId
+      ]);
+    }
+    for (let i = 0; i < segmentPoints.length; i++) {
+      const A = segmentPoints[i];
+      for (let j = i + 1; j < segmentPoints.length; j++) {
+        const B = segmentPoints[j];
+        if (B.segmentPointId === A.segmentPointId) continue;
+        if (B.segmentId === A.segmentId) continue;
+        if (B.connectionName !== A.connectionName) continue;
+        if (A.capacityMeshNodeIds.some(
+          (nId) => B.capacityMeshNodeIds.includes(nId)
+        )) {
+          A.directlyConnectedSegmentPointIds.push(B.segmentPointId);
+          B.directlyConnectedSegmentPointIds.push(A.segmentPointId);
         }
-      ],
-      vias: [],
-      viaDiameter: opts.hdRoutes[0].viaDiameter,
-      traceThickness: opts.hdRoutes[0].traceThickness
+      }
+    }
+    const segmentPairsInNode = /* @__PURE__ */ new Map();
+    for (const nodeId of allNodeIds) {
+      segmentPairsInNode.set(nodeId, []);
+    }
+    for (const A of segmentPoints) {
+      for (const nodeId of A.capacityMeshNodeIds) {
+        const otherSegmentPoints = segmentPointsInNode.get(nodeId).map((spId) => segmentPointMap.get(spId));
+        const segmentPairs = segmentPairsInNode.get(nodeId);
+        if (!segmentPairs) continue;
+        for (const BId of A.directlyConnectedSegmentPointIds) {
+          const B = segmentPointMap.get(BId);
+          if (B.segmentPointId === A.segmentPointId) continue;
+          if (!B.capacityMeshNodeIds.some((nId) => nId === nodeId)) continue;
+          if (!segmentPairs.some(
+            ([a, b]) => a === A.segmentPointId && b === B.segmentPointId || a === B.segmentPointId && b === A.segmentPointId
+          )) {
+            segmentPairs.push([A.segmentPointId, B.segmentPointId]);
+          }
+        }
+      }
+    }
+    const mutableSegmentIds = /* @__PURE__ */ new Set();
+    for (const nodeId of mutableNodeIds) {
+      for (const segmentId of this.nodeIdToSegmentIds.get(nodeId)) {
+        const allNodeIdsWithSegment = this.segmentIdToNodeIds.get(segmentId);
+        if (allNodeIdsWithSegment.every(
+          (nodeId2) => !this.nodeMap.get(nodeId2)._containsTarget
+        )) {
+          mutableSegmentIds.add(segmentId);
+        }
+      }
+    }
+    return {
+      allNodeIds,
+      mutableNodeIds,
+      immutableNodeIds,
+      mutableSegmentIds,
+      segmentPairsInNode,
+      segmentPointMap,
+      segmentPointsInNode,
+      segmentPointsInSegment
+    };
+  }
+  createInitialCandidate() {
+    const pointModifications = /* @__PURE__ */ new Map();
+    const issues = getIssuesInSection(
+      this.unravelSection,
+      this.nodeMap,
+      pointModifications
+    );
+    const g = this.computeG({
+      issues,
+      originalCandidate: {},
+      operationsPerformed: 0,
+      operation: {}
+    });
+    return {
+      pointModifications,
+      issues,
+      g,
+      h: 0,
+      f: g,
+      operationsPerformed: 0,
+      candidateHash: createPointModificationsHash(pointModifications)
+      // candidateFullHash: createFullPointModificationsHash(
+      //   this.unravelSection.segmentPointMap,
+      //   pointModifications,
+      // ),
+    };
+  }
+  get nextCandidate() {
+    return this.candidates[0] ?? null;
+  }
+  getPointInCandidate(candidate, segmentPointId) {
+    const originalPoint = this.unravelSection.segmentPointMap.get(segmentPointId);
+    const modifications = candidate.pointModifications.get(segmentPointId);
+    return {
+      x: modifications?.x ?? originalPoint.x,
+      y: modifications?.y ?? originalPoint.y,
+      z: modifications?.z ?? originalPoint.z,
+      segmentId: originalPoint.segmentId
+    };
+  }
+  getOperationsForIssue(candidate, issue) {
+    const operations = [];
+    if (issue.type === "transition_via") {
+      const [APointId, BPointId] = issue.segmentPoints;
+      const pointA = this.getPointInCandidate(candidate, APointId);
+      const pointB = this.getPointInCandidate(candidate, BPointId);
+      if (this.unravelSection.mutableSegmentIds.has(pointA.segmentId)) {
+        operations.push({
+          type: "change_layer",
+          newZ: pointB.z,
+          segmentPointIds: [APointId]
+        });
+      }
+      if (this.unravelSection.mutableSegmentIds.has(pointB.segmentId)) {
+        operations.push({
+          type: "change_layer",
+          newZ: pointA.z,
+          segmentPointIds: [BPointId]
+        });
+      }
+    }
+    if (issue.type === "same_layer_crossing") {
+      const [APointId, BPointId] = issue.crossingLine1;
+      const [CPointId, DPointId] = issue.crossingLine2;
+      const sharedSegments = [];
+      const A = this.unravelSection.segmentPointMap.get(APointId);
+      const B = this.unravelSection.segmentPointMap.get(BPointId);
+      const C = this.unravelSection.segmentPointMap.get(CPointId);
+      const D = this.unravelSection.segmentPointMap.get(DPointId);
+      if (A.segmentId === C.segmentId) {
+        sharedSegments.push([APointId, CPointId]);
+      }
+      if (A.segmentId === D.segmentId) {
+        sharedSegments.push([APointId, DPointId]);
+      }
+      if (B.segmentId === C.segmentId) {
+        sharedSegments.push([BPointId, CPointId]);
+      }
+      if (B.segmentId === D.segmentId) {
+        sharedSegments.push([BPointId, DPointId]);
+      }
+      for (const [EPointId, FPointId] of sharedSegments) {
+        operations.push({
+          type: "swap_position_on_segment",
+          segmentPointIds: [EPointId, FPointId]
+        });
+      }
+      const Amutable = this.unravelSection.mutableSegmentIds.has(A.segmentId);
+      const Bmutable = this.unravelSection.mutableSegmentIds.has(B.segmentId);
+      const Cmutable = this.unravelSection.mutableSegmentIds.has(C.segmentId);
+      const Dmutable = this.unravelSection.mutableSegmentIds.has(D.segmentId);
+      if (Amutable && Bmutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: A.z === 0 ? 1 : 0,
+          segmentPointIds: [APointId, BPointId]
+        });
+      }
+      if (Cmutable && Dmutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: C.z === 0 ? 1 : 0,
+          segmentPointIds: [CPointId, DPointId]
+        });
+      }
+      if (Amutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: A.z === 0 ? 1 : 0,
+          segmentPointIds: [APointId]
+        });
+      }
+      if (Bmutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: B.z === 0 ? 1 : 0,
+          segmentPointIds: [BPointId]
+        });
+      }
+      if (Cmutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: C.z === 0 ? 1 : 0,
+          segmentPointIds: [CPointId]
+        });
+      }
+      if (Dmutable) {
+        operations.push({
+          type: "change_layer",
+          newZ: D.z === 0 ? 1 : 0,
+          segmentPointIds: [DPointId]
+        });
+      }
+    }
+    return operations;
+  }
+  computeG(params) {
+    const { issues, originalCandidate, operationsPerformed, operation } = params;
+    const nodeProblemCounts = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      if (!nodeProblemCounts.has(issue.capacityMeshNodeId)) {
+        nodeProblemCounts.set(issue.capacityMeshNodeId, {
+          numTransitionCrossings: 0,
+          numSameLayerCrossings: 0,
+          numEntryExitLayerChanges: 0
+        });
+      }
+      const nodeProblemCount = nodeProblemCounts.get(issue.capacityMeshNodeId);
+      if (issue.type === "transition_via") {
+        nodeProblemCount.numTransitionCrossings++;
+      } else if (issue.type === "same_layer_crossing") {
+        nodeProblemCount.numSameLayerCrossings++;
+      } else if (issue.type === "double_transition_crossing" || issue.type === "single_transition_crossing") {
+        nodeProblemCount.numEntryExitLayerChanges++;
+      } else if (issue.type === "same_layer_trace_imbalance_with_low_capacity") {
+      }
+    }
+    let cost = 0;
+    for (const [
+      nodeId,
+      {
+        numEntryExitLayerChanges,
+        numSameLayerCrossings,
+        numTransitionCrossings
+      }
+    ] of nodeProblemCounts) {
+      const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
+      const estUsedCapacity = (estNumVias / 2) ** 1.1;
+      const totalCapacity = this.tunedNodeCapacityMap.get(nodeId);
+      const estPf = estUsedCapacity / totalCapacity;
+      cost += getLogProbability(estPf);
+    }
+    return cost;
+  }
+  getNeighborByApplyingOperation(currentCandidate, operation) {
+    const pointModifications = new Map(currentCandidate.pointModifications);
+    applyOperationToPointModifications(
+      pointModifications,
+      operation,
+      (segmentPointId) => this.getPointInCandidate(currentCandidate, segmentPointId)
+    );
+    const issues = getIssuesInSection(
+      this.unravelSection,
+      this.nodeMap,
+      pointModifications
+    );
+    const operationsPerformed = currentCandidate.operationsPerformed + 1;
+    const g = this.computeG({
+      issues,
+      originalCandidate: currentCandidate,
+      operationsPerformed,
+      operation
+    });
+    return {
+      issues,
+      g,
+      h: 0,
+      f: g,
+      pointModifications,
+      candidateHash: createPointModificationsHash(pointModifications),
+      // TODO PERFORMANCE allow disabling this
+      // candidateFullHash: createFullPointModificationsHash(
+      //   this.unravelSection.segmentPointMap,
+      //   pointModifications,
+      // ),
+      operationsPerformed
     };
-    this.start = opts.start;
-    this.end = opts.end;
+  }
+  getNeighborOperationsForCandidate(candidate) {
+    return candidate.issues.flatMap(
+      (issue) => this.getOperationsForIssue(candidate, issue)
+    );
+  }
+  getNeighbors(candidate) {
+    const neighbors = [];
+    const operations = this.getNeighborOperationsForCandidate(candidate);
+    for (const operation of operations) {
+      const neighbor = this.getNeighborByApplyingOperation(candidate, operation);
+      neighbors.push(neighbor);
+    }
+    return neighbors;
   }
   _step() {
-    if (this.remainingHdRoutes.length === 0) {
-      this.mergedHdRoute.route.push({
-        x: this.end.x,
-        y: this.end.y,
-        z: this.end.z
-      });
+    const candidate = this.candidates.shift();
+    if (!candidate) {
       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.lastProcessedCandidate = candidate;
+    if (candidate.f < (this.bestCandidate?.f ?? Infinity)) {
+      this.bestCandidate = candidate;
     }
-    this.mergedHdRoute.vias.push(...hdRouteToMerge.vias);
+    this.getNeighbors(candidate).forEach((neighbor) => {
+      const isPartialHashExplored = this.queuedOrExploredCandidatePointModificationHashes.has(
+        neighbor.candidateHash
+      );
+      if (isPartialHashExplored) return;
+      this.queuedOrExploredCandidatePointModificationHashes.add(
+        neighbor.candidateHash
+      );
+      this.candidates.push(neighbor);
+    });
+    this.candidates.sort((a, b) => a.f - b.f);
+    this.candidates.length = Math.min(
+      this.candidates.length,
+      this.MAX_CANDIDATES
+    );
   }
   visualize() {
     const graphics = {
       points: [],
       lines: [],
+      rects: [],
       circles: [],
-      title: "Single High Density Route Stitch Solver"
+      coordinateSystem: "cartesian",
+      title: "Unravel Section 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"
+    let candidate = null;
+    if (this.selectedCandidateIndex !== null) {
+      if (this.selectedCandidateIndex === "best") {
+        candidate = this.bestCandidate;
+      } else if (this.selectedCandidateIndex === "original") {
+        candidate = this.originalCandidate;
+      } else {
+        candidate = this.candidates[this.selectedCandidateIndex];
       }
-    );
-    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"
+    } else {
+      candidate = this.lastProcessedCandidate || this.candidates[0];
+    }
+    if (!candidate) return graphics;
+    const modifiedSegmentPoints = /* @__PURE__ */ new Map();
+    for (const [segmentPointId, segmentPoint] of this.unravelSection.segmentPointMap) {
+      const modifiedPoint = { ...segmentPoint };
+      const modification = candidate.pointModifications.get(segmentPointId);
+      if (modification) {
+        if (modification.x !== void 0) modifiedPoint.x = modification.x;
+        if (modification.y !== void 0) modifiedPoint.y = modification.y;
+        if (modification.z !== void 0) modifiedPoint.z = modification.z;
+      }
+      modifiedSegmentPoints.set(segmentPointId, modifiedPoint);
+    }
+    for (const [segmentPointId, segmentPoint] of modifiedSegmentPoints) {
+      graphics.points.push({
+        x: segmentPoint.x,
+        y: segmentPoint.y,
+        label: `${segmentPointId}
+Segment: ${segmentPoint.segmentId} ${this.unravelSection.mutableSegmentIds.has(segmentPoint.segmentId) ? "MUTABLE" : "IMMUTABLE"}
+Layer: ${segmentPoint.z}`,
+        color: this.colorMap[segmentPoint.connectionName] || "#000"
       });
-      for (const point of this.mergedHdRoute.route) {
-        graphics.points?.push({
-          x: point.x,
-          y: point.y,
-          color: "green"
+    }
+    for (const nodeId of this.unravelSection.allNodeIds) {
+      const node = this.nodeMap.get(nodeId);
+      const isMutable = this.unravelSection.mutableNodeIds.includes(nodeId);
+      graphics.rects.push({
+        center: node.center,
+        label: `${nodeId}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}
+${isMutable ? "MUTABLE" : "IMMUTABLE"}`,
+        color: isMutable ? "green" : "red",
+        width: node.width / 8,
+        height: node.height / 8
+      });
+    }
+    for (const [segmentId, segmentPointIds] of this.unravelSection.segmentPointsInSegment) {
+      if (segmentPointIds.length <= 1) continue;
+      const points = segmentPointIds.map(
+        (spId) => modifiedSegmentPoints.get(spId)
+      );
+      for (let i = 0; i < points.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: points[i].x, y: points[i].y },
+            { x: points[i + 1].x, y: points[i + 1].y }
+          ],
+          strokeColor: this.colorMap[segmentId] || "#000"
         });
       }
-      for (const via of this.mergedHdRoute.vias) {
-        graphics.circles?.push({
-          center: { x: via.x, y: via.y },
-          radius: this.mergedHdRoute.viaDiameter / 2,
-          fill: "green"
-        });
+    }
+    for (const [segmentPointId, segmentPoint] of modifiedSegmentPoints) {
+      for (const connectedPointId of segmentPoint.directlyConnectedSegmentPointIds) {
+        if (segmentPointId < connectedPointId) {
+          const connectedPoint = modifiedSegmentPoints.get(connectedPointId);
+          const sameLayer = segmentPoint.z === connectedPoint.z;
+          const commonLayer = segmentPoint.z;
+          let strokeDash;
+          if (sameLayer) {
+            strokeDash = commonLayer === 0 ? void 0 : "10 5";
+          } else {
+            strokeDash = "3 3 10";
+          }
+          graphics.lines.push({
+            points: [
+              { x: segmentPoint.x, y: segmentPoint.y },
+              { x: connectedPoint.x, y: connectedPoint.y }
+            ],
+            strokeDash,
+            strokeColor: this.colorMap[segmentPoint.connectionName] || "#000"
+          });
+        }
       }
     }
-    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 (const issue of candidate.issues) {
+      const node = this.nodeMap.get(issue.capacityMeshNodeId);
+      if (issue.type === "transition_via") {
+        for (const segmentPointId of issue.segmentPoints) {
+          const segmentPoint = modifiedSegmentPoints.get(segmentPointId);
+          graphics.circles.push({
+            center: { x: segmentPoint.x, y: segmentPoint.y },
+            radius: node.width / 16,
+            stroke: "#ff0000",
+            fill: "rgba(255, 0, 0, 0.2)",
+            label: `Via Issue
+${segmentPointId}
+Layer: ${segmentPoint.z}`
+          });
+        }
+      } else if (issue.type === "same_layer_crossing") {
+        for (const [sp1Id, sp2Id] of [
+          issue.crossingLine1,
+          issue.crossingLine2
+        ]) {
+          const sp1 = modifiedSegmentPoints.get(sp1Id);
+          const sp2 = modifiedSegmentPoints.get(sp2Id);
+          graphics.lines.push({
+            points: [
+              { x: sp1.x, y: sp1.y },
+              { x: sp2.x, y: sp2.y }
+            ],
+            strokeColor: "rgba(255,0,0,0.2)",
+            strokeWidth: node.width / 32
+          });
+        }
       }
-      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 [segmentPointId, modification] of candidate.pointModifications) {
+      const modifiedPoint = modifiedSegmentPoints.get(segmentPointId);
+      const originalPoint = this.unravelSection.segmentPointMap.get(segmentPointId);
+      graphics.circles.push({
+        center: { x: modifiedPoint.x, y: modifiedPoint.y },
+        radius: 0.05,
+        stroke: "#0000ff",
+        fill: "rgba(0, 0, 255, 0.2)",
+        label: `${segmentPointId}
+Original: (${originalPoint.x.toFixed(2)}, ${originalPoint.y.toFixed(2)}, ${originalPoint.z})
+New: (${modifiedPoint.x.toFixed(2)}, ${modifiedPoint.y.toFixed(2)}, ${modifiedPoint.z})`
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/UnravelSolver/getDedupedSegments.ts
+var getDedupedSegments = (assignedSegments) => {
+  const dedupedSegments = [];
+  const dedupedSegPointMap = /* @__PURE__ */ new Map();
+  let highestSegmentId = -1;
+  for (const seg of assignedSegments) {
+    const segKey = `${seg.start.x}-${seg.start.y}-${seg.end.x}-${seg.end.y}`;
+    const existingSeg = dedupedSegPointMap.get(segKey);
+    if (!existingSeg) {
+      highestSegmentId++;
+      seg.nodePortSegmentId = `SEG${highestSegmentId}`;
+      dedupedSegPointMap.set(segKey, seg);
+      dedupedSegments.push(seg);
+      continue;
+    }
+    seg.nodePortSegmentId = existingSeg.nodePortSegmentId;
+  }
+  return dedupedSegments;
+};
+
+// lib/utils/getIntraNodeCrossingsFromSegments.ts
+var getIntraNodeCrossingsFromSegments = (segments) => {
+  let numSameLayerCrossings = 0;
+  const pointPairs = [];
+  const transitionPairPoints = [];
+  let numEntryExitLayerChanges = 0;
+  const portPoints = segments.flatMap((seg) => seg.assignedPoints);
+  for (const { connectionName: aConnName, point: A } of portPoints) {
+    if (pointPairs.some((p) => p.connectionName === aConnName)) {
+      continue;
+    }
+    if (transitionPairPoints.some((p) => p.connectionName === aConnName)) {
+      continue;
+    }
+    const pointPair = {
+      connectionName: aConnName,
+      z: A.z,
+      points: [A]
+    };
+    for (const { connectionName: bConnName, point: B } of portPoints) {
+      if (aConnName !== bConnName) continue;
+      if (A === B) continue;
+      pointPair.points.push(B);
+      if (pointPair.points.some((p) => p.z !== pointPair.z)) {
+        numEntryExitLayerChanges++;
+        transitionPairPoints.push(pointPair);
+        break;
+      } else {
+        pointPairs.push(pointPair);
+        break;
       }
-      for (const via of hdRoute.vias) {
-        graphics.circles?.push({
-          center: { x: via.x, y: via.y },
-          radius: hdRoute.viaDiameter / 2,
-          fill: colorList[i]
-        });
+    }
+  }
+  for (let i = 0; i < pointPairs.length; i++) {
+    for (let j = i + 1; j < pointPairs.length; j++) {
+      const pair1 = pointPairs[i];
+      const pair2 = pointPairs[j];
+      if (pair1.z === pair2.z && doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numSameLayerCrossings++;
+      }
+    }
+  }
+  let numTransitionCrossings = 0;
+  for (let i = 0; i < transitionPairPoints.length; i++) {
+    for (let j = i + 1; j < transitionPairPoints.length; j++) {
+      const pair1 = transitionPairPoints[i];
+      const pair2 = transitionPairPoints[j];
+      if (doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numTransitionCrossings++;
+      }
+    }
+  }
+  for (let i = 0; i < transitionPairPoints.length; i++) {
+    for (let j = 0; j < pointPairs.length; j++) {
+      const pair1 = transitionPairPoints[i];
+      const pair2 = pointPairs[j];
+      if (doSegmentsIntersect(
+        pair1.points[0],
+        pair1.points[1],
+        pair2.points[0],
+        pair2.points[1]
+      )) {
+        numTransitionCrossings++;
       }
     }
-    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)
-      }
-    }));
+  return {
+    numSameLayerCrossings,
+    numEntryExitLayerChanges,
+    numTransitionCrossings
+  };
+};
+
+// lib/solvers/UnravelSolver/calculateCrossingProbabilityOfFailure.ts
+var calculateNodeProbabilityOfFailure = (node, numSameLayerCrossings, numEntryExitLayerChanges, numTransitionCrossings) => {
+  if (node?._containsTarget) return 0;
+  const totalCapacity = getTunedTotalCapacity1(node);
+  const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
+  const estUsedCapacity = (estNumVias / 2) ** 1.1;
+  const approxProb = estUsedCapacity / totalCapacity;
+  return approxProb;
+};
+
+// lib/solvers/UnravelSolver/UnravelMultiSectionSolver.ts
+var UnravelMultiSectionSolver = class extends BaseSolver {
+  nodeMap;
+  dedupedSegments;
+  nodeIdToSegmentIds;
+  segmentIdToNodeIds;
+  colorMap;
+  tunedNodeCapacityMap;
+  MAX_NODE_ATTEMPTS = 2;
+  MUTABLE_HOPS = 1;
+  ACCEPTABLE_PF = 0.05;
+  /**
+   * Probability of failure for each node
+   */
+  nodePfMap;
+  attemptsToFixNode;
+  activeSolver = null;
+  segmentPointMap;
+  constructor({
+    assignedSegments,
+    colorMap,
+    nodes
+  }) {
+    super();
+    this.MAX_ITERATIONS = 1e5;
+    this.dedupedSegments = getDedupedSegments(assignedSegments);
+    this.nodeMap = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      this.nodeMap.set(node.capacityMeshNodeId, node);
+    }
+    this.nodeIdToSegmentIds = /* @__PURE__ */ new Map();
+    this.segmentIdToNodeIds = /* @__PURE__ */ new Map();
+    this.attemptsToFixNode = /* @__PURE__ */ new Map();
+    for (const segment of assignedSegments) {
+      this.segmentIdToNodeIds.set(segment.nodePortSegmentId, [
+        ...this.segmentIdToNodeIds.get(segment.nodePortSegmentId) ?? [],
+        segment.capacityMeshNodeId
+      ]);
+      this.nodeIdToSegmentIds.set(segment.capacityMeshNodeId, [
+        ...this.nodeIdToSegmentIds.get(segment.capacityMeshNodeId) ?? [],
+        segment.nodePortSegmentId
+      ]);
+    }
+    this.colorMap = colorMap ?? {};
+    this.tunedNodeCapacityMap = /* @__PURE__ */ new Map();
+    for (const [nodeId, node] of this.nodeMap) {
+      this.tunedNodeCapacityMap.set(nodeId, getTunedTotalCapacity1(node));
+    }
+    this.segmentPointMap = createSegmentPointMap(
+      this.dedupedSegments,
+      this.segmentIdToNodeIds
+    );
+    this.nodePfMap = this.computeInitialPfMap();
+  }
+  computeInitialPfMap() {
+    const pfMap = /* @__PURE__ */ new Map();
+    for (const [nodeId, node] of this.nodeMap.entries()) {
+      pfMap.set(nodeId, this.computeNodePf(node));
+    }
+    return pfMap;
+  }
+  computeNodePf(node) {
+    const {
+      numSameLayerCrossings,
+      numEntryExitLayerChanges,
+      numTransitionCrossings
+    } = getIntraNodeCrossingsFromSegments(
+      this.dedupedSegments.filter(
+        (seg) => this.segmentIdToNodeIds.get(seg.nodePortSegmentId).includes(node.capacityMeshNodeId)
+      )
+    );
+    const probabilityOfFailure = calculateNodeProbabilityOfFailure(
+      node,
+      numSameLayerCrossings,
+      numEntryExitLayerChanges,
+      numTransitionCrossings
+    );
+    return probabilityOfFailure;
   }
   _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) {
+    if (this.iterations >= this.MAX_ITERATIONS - 1) {
       this.solved = true;
       return;
     }
-    if (unsolvedRoute.hdRoutes.length === 0) {
-      console.warn(`No routes to stitch for ${unsolvedRoute.connectionName}`);
-      return;
+    if (!this.activeSolver) {
+      let highestPfNodeId = null;
+      let highestPf = 0;
+      for (const [nodeId, pf] of this.nodePfMap.entries()) {
+        const pfReduced = pf * (1 - (this.attemptsToFixNode.get(nodeId) ?? 0) / this.MAX_NODE_ATTEMPTS);
+        if (pfReduced > highestPf) {
+          highestPf = pf;
+          highestPfNodeId = nodeId;
+        }
+      }
+      if (!highestPfNodeId || highestPf < this.ACCEPTABLE_PF) {
+        this.solved = true;
+        return;
+      }
+      this.attemptsToFixNode.set(
+        highestPfNodeId,
+        (this.attemptsToFixNode.get(highestPfNodeId) ?? 0) + 1
+      );
+      this.activeSolver = new UnravelSectionSolver({
+        dedupedSegments: this.dedupedSegments,
+        nodeMap: this.nodeMap,
+        nodeIdToSegmentIds: this.nodeIdToSegmentIds,
+        segmentIdToNodeIds: this.segmentIdToNodeIds,
+        colorMap: this.colorMap,
+        rootNodeId: highestPfNodeId,
+        MUTABLE_HOPS: this.MUTABLE_HOPS,
+        segmentPointMap: this.segmentPointMap
+      });
+    }
+    this.activeSolver.step();
+    const { bestCandidate, originalCandidate, lastProcessedCandidate } = this.activeSolver;
+    const giveUpFactor = 1 + 4 * (1 - Math.min(1, this.activeSolver.iterations / 40));
+    const shouldEarlyStop = lastProcessedCandidate && lastProcessedCandidate.g > bestCandidate.g * giveUpFactor;
+    if (this.activeSolver.solved || shouldEarlyStop) {
+      const foundBetterSolution = bestCandidate && bestCandidate.g < originalCandidate.g;
+      if (foundBetterSolution) {
+        for (const [
+          segmentPointId,
+          pointModification
+        ] of bestCandidate.pointModifications.entries()) {
+          const segmentPoint = this.segmentPointMap.get(segmentPointId);
+          segmentPoint.x = pointModification.x ?? segmentPoint.x;
+          segmentPoint.y = pointModification.y ?? segmentPoint.y;
+          segmentPoint.z = pointModification.z ?? segmentPoint.z;
+        }
+      }
+      for (const nodeId of this.activeSolver.unravelSection.allNodeIds) {
+        this.nodePfMap.set(
+          nodeId,
+          this.computeNodePf(this.nodeMap.get(nodeId))
+        );
+      }
+      this.activeSolver = null;
     }
-    this.activeSolver = new SingleHighDensityRouteStitchSolver({
-      hdRoutes: unsolvedRoute.hdRoutes,
-      start: unsolvedRoute.start,
-      end: unsolvedRoute.end
-    });
   }
   visualize() {
+    if (this.activeSolver) {
+      return this.activeSolver.visualize();
+    }
     const graphics = {
-      points: [],
       lines: [],
+      points: [],
+      rects: [],
       circles: [],
-      title: "Multiple High Density Route Stitch Solver"
+      coordinateSystem: "cartesian",
+      title: "Unravel Multi Section 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 [nodeId, node] of this.nodeMap.entries()) {
+      const probabilityOfFailure = this.nodePfMap.get(nodeId) || 0;
+      const pf = Math.min(probabilityOfFailure, 1);
+      const red = Math.floor(255 * pf);
+      const green = Math.floor(255 * (1 - pf));
+      const color = `rgb(${red}, ${green}, 0)`;
+      graphics.rects.push({
+        center: node.center,
+        label: `${nodeId}
+${node.width.toFixed(2)}x${node.height.toFixed(2)}
+Pf: ${probabilityOfFailure.toFixed(3)}`,
+        color,
+        width: node.width / 8,
+        height: node.height / 8
+      });
     }
-    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 segmentPoint of this.segmentPointMap.values()) {
+      graphics.points.push({
+        x: segmentPoint.x,
+        y: segmentPoint.y,
+        label: `${segmentPoint.segmentPointId}
+Segment: ${segmentPoint.segmentId}
+Layer: ${segmentPoint.z}`,
+        color: this.colorMap[segmentPoint.connectionName] || "#000"
+      });
+    }
+    const pointsBySegment = /* @__PURE__ */ new Map();
+    for (const point of this.segmentPointMap.values()) {
+      if (!pointsBySegment.has(point.segmentId)) {
+        pointsBySegment.set(point.segmentId, []);
       }
-      for (const via of mergedRoute.vias) {
-        graphics.circles?.push({
-          center: { x: via.x, y: via.y },
-          radius: mergedRoute.viaDiameter / 2,
-          fill: solvedColor
+      pointsBySegment.get(point.segmentId).push(point);
+    }
+    for (const [segmentId, points] of pointsBySegment.entries()) {
+      if (points.length < 2) continue;
+      const sortedPoints = [...points].sort(
+        (a, b) => a.x !== b.x ? a.x - b.x : a.y - b.y
+      );
+      for (let i = 0; i < sortedPoints.length - 1; i++) {
+        graphics.lines.push({
+          points: [
+            { x: sortedPoints[i].x, y: sortedPoints[i].y },
+            { x: sortedPoints[i + 1].x, y: sortedPoints[i + 1].y }
+          ],
+          strokeColor: this.colorMap[segmentId] || "#000"
         });
       }
     }
-    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"
-          });
+    const processedConnections = /* @__PURE__ */ new Set();
+    const allPoints = Array.from(this.segmentPointMap.values());
+    for (let i = 0; i < allPoints.length; i++) {
+      const point1 = allPoints[i];
+      for (let j = i + 1; j < allPoints.length; j++) {
+        const point2 = allPoints[j];
+        if (point1.connectionName !== point2.connectionName || point1.segmentId === point2.segmentId) {
+          continue;
         }
-        for (const via of hdRoute.vias) {
-          graphics.circles?.push({
-            center: { x: via.x, y: via.y },
-            radius: hdRoute.viaDiameter / 2,
-            fill: colorList[i]
+        const hasSharedNode = point1.capacityMeshNodeIds.some(
+          (nodeId) => point2.capacityMeshNodeIds.includes(nodeId)
+        );
+        if (hasSharedNode) {
+          const connectionKey = `${point1.segmentPointId}-${point2.segmentPointId}`;
+          if (processedConnections.has(connectionKey)) continue;
+          processedConnections.add(connectionKey);
+          const sameLayer = point1.z === point2.z;
+          const layer = point1.z;
+          let strokeDash;
+          if (sameLayer) {
+            strokeDash = layer === 0 ? void 0 : "10 5";
+          } else {
+            strokeDash = "3 3 10";
+          }
+          graphics.lines.push({
+            points: [
+              { x: point1.x, y: point1.y },
+              { x: point2.x, y: point2.y }
+            ],
+            strokeDash,
+            strokeColor: this.colorMap[point1.connectionName] || "#666"
           });
         }
       }
     }
     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})`
-        });
-      }
+  getNodesWithPortPoints() {
+    if (!this.solved) {
+      throw new Error(
+        "CapacitySegmentToPointSolver not solved, can't give port points yet"
+      );
     }
-  }
-  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"
+    const nodeWithPortPointsMap = /* @__PURE__ */ new Map();
+    for (const segment of this.dedupedSegments) {
+      const segId = segment.nodePortSegmentId;
+      for (const nodeId of this.segmentIdToNodeIds.get(segId)) {
+        const node = this.nodeMap.get(nodeId);
+        if (!nodeWithPortPointsMap.has(nodeId)) {
+          nodeWithPortPointsMap.set(nodeId, {
+            capacityMeshNodeId: nodeId,
+            portPoints: [],
+            center: node.center,
+            width: node.width,
+            height: node.height
           });
-        } 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 }
-            ],
-            strokeWidth: 0.15,
-            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,
+        }
+      }
+    }
+    for (const segmentPoint of this.segmentPointMap.values()) {
+      for (const nodeId of segmentPoint.capacityMeshNodeIds) {
+        const nodeWithPortPoints = nodeWithPortPointsMap.get(nodeId);
+        if (nodeWithPortPoints) {
+          nodeWithPortPoints.portPoints.push({
+            x: segmentPoint.x,
+            y: segmentPoint.y,
+            z: segmentPoint.z,
+            connectionName: segmentPoint.connectionName
           });
         }
       }
     }
+    return Array.from(nodeWithPortPointsMap.values());
   }
-  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
@@ -4798,6 +5236,7 @@ var CapacityMeshSolver = class extends BaseSolver {
   edgeToPortSegmentSolver;
   colorMap;
   segmentToPointSolver;
+  unravelMultiSectionSolver;
   segmentToPointOptimizer;
   highDensityRouteSolver;
   highDensityStitchSolver;
@@ -4880,9 +5319,20 @@ var CapacityMeshSolver = class extends BaseSolver {
         ];
       }
     ),
+    // definePipelineStep(
+    //   "segmentToPointOptimizer",
+    //   CapacitySegmentPointOptimizer,
+    //   (cms) => [
+    //     {
+    //       assignedSegments: cms.segmentToPointSolver?.solvedSegments || [],
+    //       colorMap: cms.colorMap,
+    //       nodes: cms.nodeTargetMerger?.newNodes || [],
+    //     },
+    //   ],
+    // ),
     definePipelineStep(
-      "segmentToPointOptimizer",
-      CapacitySegmentPointOptimizer,
+      "unravelMultiSectionSolver",
+      UnravelMultiSectionSolver,
       (cms) => [
         {
           assignedSegments: cms.segmentToPointSolver?.solvedSegments || [],
@@ -4893,7 +5343,7 @@ var CapacityMeshSolver = class extends BaseSolver {
     ),
     definePipelineStep("highDensityRouteSolver", HighDensitySolver, (cms) => [
       {
-        nodePortPoints: cms.segmentToPointOptimizer?.getNodesWithPortPoints() || [],
+        nodePortPoints: cms.unravelMultiSectionSolver?.getNodesWithPortPoints() ?? cms.segmentToPointOptimizer?.getNodesWithPortPoints() ?? [],
         colorMap: cms.colorMap,
         connMap: cms.connMap
       }
@@ -4951,7 +5401,7 @@ var CapacityMeshSolver = class extends BaseSolver {
     const pathingViz = this.pathingSolver?.visualize();
     const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
     const segmentToPointViz = this.segmentToPointSolver?.visualize();
-    const segmentOptimizationViz = this.segmentToPointOptimizer?.visualize();
+    const segmentOptimizationViz = this.unravelMultiSectionSolver?.visualize() ?? this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
     const highDensityStitchViz = this.highDensityStitchSolver?.visualize();
     const problemViz = {