@tscircuit/capacity-autorouter 0.0.19 → 0.0.21

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 {
@@ -135,7 +140,7 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     this.edges = [];
     for (let i = 0; i < this.nodes.length; i++) {
       for (let j = i + 1; j < this.nodes.length; j++) {
-        if (this.areNodesBordering(this.nodes[i], this.nodes[j])) {
+        if (this.areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
           this.edges.push({
             capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
             nodeIds: [
@@ -189,16 +194,35 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
     return shareVerticalBorder || shareHorizontalBorder;
   }
+  doNodesHaveSharedLayer(node1, node2) {
+    return node1.availableZ.some((z) => node2.availableZ.includes(z));
+  }
   visualize() {
     const graphics = {
       lines: [],
       points: [],
-      rects: this.nodes.map((node) => ({
-        width: Math.max(node.width - 2, node.width * 0.8),
-        height: Math.max(node.height - 2, node.height * 0.8),
-        center: node.center,
-        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : node._containsTarget ? "rgba(0,255,0,0.2)" : "rgba(0,0,0,0.1)"
-      })),
+      rects: this.nodes.map((node) => {
+        const lowestZ = Math.min(...node.availableZ);
+        return {
+          width: Math.max(node.width - 2, node.width * 0.8),
+          height: Math.max(node.height - 2, node.height * 0.8),
+          center: {
+            x: node.center.x + lowestZ * node.width * 0.05,
+            y: node.center.y - lowestZ * node.width * 0.05
+          },
+          fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
+            "0,1": "rgba(0,0,0,0.1)",
+            "0": "rgba(0,200,200, 0.1)",
+            "1": "rgba(0,0,200, 0.1)"
+          }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+          label: [
+            node.capacityMeshNodeId,
+            `availableZ: ${node.availableZ.join(",")}`,
+            `target? ${node._containsTarget ?? false}`,
+            `obs? ${node._containsObstacle ?? false}`
+          ].join("\n")
+        };
+      }),
       circles: []
     };
     for (const edge of this.edges) {
@@ -1069,7 +1093,14 @@ function doRectsOverlap(rect1, rect2) {
   return rect1Left <= rect2Right && rect1Right >= rect2Left && rect1Top <= rect2Bottom && rect1Bottom >= rect2Top;
 }
 
-// lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver.ts
+// 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/CapacityMeshSolver/CapacityMeshNodeSolver1.ts
 var CapacityMeshNodeSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
     super();
@@ -1077,6 +1108,16 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     this.opts = opts;
     this.MAX_DEPTH = opts?.capacityDepth ?? this.MAX_DEPTH;
     this.MAX_ITERATIONS = 1e5;
+    this.layerCount = srj.layerCount ?? 2;
+    for (const obstacle of srj.obstacles) {
+      if (!obstacle.zLayers) {
+        const zLayers = [];
+        for (const layer of obstacle.layers) {
+          zLayers.push(mapLayerNameToZ(layer, srj.layerCount));
+        }
+        obstacle.zLayers = zLayers;
+      }
+    }
     const boundsCenter = {
       x: (srj.bounds.minX + srj.bounds.maxX) / 2,
       y: (srj.bounds.minY + srj.bounds.maxY) / 2
@@ -1101,7 +1142,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       }
     ];
     this.finishedNodes = [];
-    this.nodeToOverlappingObstaclesMap = /* @__PURE__ */ new Map();
+    this.nodeToXYOverlappingObstaclesMap = /* @__PURE__ */ new Map();
     this.targets = this.srj.connections.flatMap(
       (c) => c.pointsToConnect.map((p) => ({
         ...p,
@@ -1112,7 +1153,8 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   }
   unfinishedNodes;
   finishedNodes;
-  nodeToOverlappingObstaclesMap;
+  nodeToXYOverlappingObstaclesMap;
+  layerCount;
   // targetObstacleMap: Record<string, { obstacle: Obstacle, node: CapacityMeshNode }>
   MAX_DEPTH = 4;
   targets;
@@ -1124,7 +1166,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     return (this.MAX_DEPTH - depth + 1) ** 2;
   }
   getTargetIfNodeContainsTarget(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYOverlappingObstacles(node);
     for (const target of this.targets) {
       const targetObstacle = overlappingObstacles.find(
         (o) => isPointInRect(target, o)
@@ -1140,8 +1182,8 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     }
     return null;
   }
-  getOverlappingObstacles(node) {
-    const cachedObstacles = this.nodeToOverlappingObstaclesMap.get(
+  getXYOverlappingObstacles(node) {
+    const cachedObstacles = this.nodeToXYOverlappingObstaclesMap.get(
       node.capacityMeshNodeId
     );
     if (cachedObstacles) {
@@ -1152,7 +1194,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     const nodeRight = node.center.x + node.width / 2;
     const nodeTop = node.center.y - node.height / 2;
     const nodeBottom = node.center.y + node.height / 2;
-    const obstacles = node._parent ? this.getOverlappingObstacles(node._parent) : this.srj.obstacles;
+    const obstacles = node._parent ? this.getXYOverlappingObstacles(node._parent) : this.srj.obstacles;
     for (const obstacle of obstacles) {
       const obsLeft = obstacle.center.x - obstacle.width / 2;
       const obsRight = obstacle.center.x + obstacle.width / 2;
@@ -1160,20 +1202,38 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       const obsBottom = obstacle.center.y + obstacle.height / 2;
       if (nodeRight >= obsLeft && nodeLeft <= obsRight && nodeBottom >= obsTop && nodeTop <= obsBottom) {
         overlappingObstacles.push(obstacle);
+        continue;
+      }
+      if (nodeLeft >= obsLeft && nodeRight <= obsRight && nodeTop >= obsTop && nodeBottom <= obsBottom) {
+        overlappingObstacles.push(obstacle);
+        continue;
+      }
+      if (obsLeft >= nodeLeft && obsRight <= nodeRight && obsTop >= nodeTop && obsBottom <= nodeBottom) {
+        overlappingObstacles.push(obstacle);
       }
     }
-    this.nodeToOverlappingObstaclesMap.set(
+    this.nodeToXYOverlappingObstaclesMap.set(
       node.capacityMeshNodeId,
       overlappingObstacles
     );
     return overlappingObstacles;
   }
+  getXYZOverlappingObstacles(node) {
+    const xyOverlappingObstacles = this.getXYOverlappingObstacles(node);
+    const xyzOverlappingObstacles = [];
+    for (const obstacle of xyOverlappingObstacles) {
+      if (node.availableZ.some((z) => obstacle.zLayers.includes(z))) {
+        xyzOverlappingObstacles.push(obstacle);
+      }
+    }
+    return xyzOverlappingObstacles;
+  }
   /**
    * Checks if the given mesh node overlaps with any obstacle.
    * We treat both obstacles and nodes as axis‐aligned rectangles.
    */
   doesNodeOverlapObstacle(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYZOverlappingObstacles(node);
     if (overlappingObstacles.length > 0) {
       return true;
     }
@@ -1190,7 +1250,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
    * Checks if the entire node is contained within any obstacle.
    */
   isNodeCompletelyInsideObstacle(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYZOverlappingObstacles(node);
     const nodeLeft = node.center.x - node.width / 2;
     const nodeRight = node.center.x + node.width / 2;
     const nodeTop = node.center.y - node.height / 2;
@@ -1258,7 +1318,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     }
     return childNodes;
   }
-  shouldNodeBeSubdivided(node) {
+  shouldNodeBeXYSubdivided(node) {
     if (node._depth >= this.MAX_DEPTH) return false;
     if (node._containsTarget) return true;
     if (node._containsObstacle && !node._completelyInsideObstacle) return true;
@@ -1274,7 +1334,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     const finishedNewNodes = [];
     const unfinishedNewNodes = [];
     for (const newNode of newNodes) {
-      const shouldBeSubdivided = this.shouldNodeBeSubdivided(newNode);
+      const shouldBeSubdivided = this.shouldNodeBeXYSubdivided(newNode);
       if (shouldBeSubdivided) {
         unfinishedNewNodes.push(newNode);
       } else if (!shouldBeSubdivided && !newNode._containsObstacle) {
@@ -1312,20 +1372,33 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         height: obstacle.height,
         fill: "rgba(255,0,0,0.3)",
         stroke: "red",
-        label: "obstacle"
+        label: ["obstacle", obstacle.zLayers.join(",")].join("\n")
       });
     }
     const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
     for (const node of allNodes) {
+      const lowestZ = Math.min(...node.availableZ);
       graphics.rects.push({
-        center: node.center,
+        center: {
+          x: node.center.x + lowestZ * node.width * 0.05,
+          y: node.center.y - lowestZ * node.width * 0.05
+        },
         width: Math.max(node.width - 2, node.width * 0.8),
         height: Math.max(node.height - 2, node.height * 0.8),
-        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
-        label: `${node.capacityMeshNodeId}
-availableZ: ${node.availableZ.join(",")}`
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
+          "0,1": "rgba(0,0,0,0.1)",
+          "0": "rgba(0,200,200, 0.1)",
+          "1": "rgba(0,0,200, 0.1)"
+        }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+        label: [
+          node.capacityMeshNodeId,
+          `availableZ: ${node.availableZ.join(",")}`,
+          `target? ${node._containsTarget ?? false}`,
+          `obs? ${node._containsObstacle ?? false}`
+        ].join("\n")
       });
     }
+    graphics.rects.sort((a, b) => a.center.y - b.center.y);
     this.srj.connections.forEach((connection, index) => {
       const color = COLORS[index % COLORS.length];
       for (const pt of connection.pointsToConnect) {
@@ -3347,788 +3420,102 @@ 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 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);
-      }
-    }
-    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);
-      }
-    }
-    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
+    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) {
@@ -4398,13 +3785,6 @@ var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
   return result;
 };
 
-// lib/utils/mapLayerNameToZ.ts
-var mapLayerNameToZ = (layerName, layerCount) => {
-  if (layerName === "top") return 0;
-  if (layerName === "bottom") return layerCount - 1;
-  return parseInt(layerName.slice(5));
-};
-
 // lib/solvers/RouteStitchingSolver/SingleHighDensityRouteStitchSolver.ts
 var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
   mergedHdRoute;
@@ -4759,7 +4139,1126 @@ var convertSrjToGraphicsObject = (srj) => {
   };
 };
 
-// lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
+// 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);
+      }
+    }
+  }
+  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/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
+        });
+      }
+    }
+  }
+  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
+        });
+      }
+    }
+    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
+            });
+          }
+        }
+      }
+    }
+  }
+  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
+      );
+    }
+  }
+};
+
+// 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/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.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);
+        }
+      }
+    }
+    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
+    };
+  }
+  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() {
+    const candidate = this.candidates.shift();
+    if (!candidate) {
+      this.solved = true;
+      return;
+    }
+    this.lastProcessedCandidate = candidate;
+    if (candidate.f < (this.bestCandidate?.f ?? Infinity)) {
+      this.bestCandidate = candidate;
+    }
+    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: [],
+      coordinateSystem: "cartesian",
+      title: "Unravel Section Solver"
+    };
+    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];
+      }
+    } 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 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 [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"
+          });
+        }
+      }
+    }
+    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 (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 (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 {
+    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.iterations >= this.MAX_ITERATIONS - 1) {
+      this.solved = true;
+      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;
+    }
+  }
+  visualize() {
+    if (this.activeSolver) {
+      return this.activeSolver.visualize();
+    }
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Unravel Multi Section Solver"
+    };
+    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 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, []);
+      }
+      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 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;
+        }
+        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;
+  }
+  getNodesWithPortPoints() {
+    if (!this.solved) {
+      throw new Error(
+        "CapacitySegmentToPointSolver not solved, can't give port points yet"
+      );
+    }
+    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
+          });
+        }
+      }
+    }
+    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());
+  }
+};
+
+// lib/solvers/AutoroutingPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,
@@ -4798,6 +5297,7 @@ var CapacityMeshSolver = class extends BaseSolver {
   edgeToPortSegmentSolver;
   colorMap;
   segmentToPointSolver;
+  unravelMultiSectionSolver;
   segmentToPointOptimizer;
   highDensityRouteSolver;
   highDensityStitchSolver;
@@ -4880,9 +5380,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 +5404,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 +5462,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 = {