@tscircuit/capacity-autorouter 0.0.21 → 0.0.23

package/dist/index.js

@@ -125,6 +125,22 @@ function distance(p1, p2) {
   return Math.sqrt(dx * dx + dy * dy);
 }
 
+// lib/utils/areNodesBordering.ts
+function areNodesBordering(node1, node2) {
+  const n1Left = node1.center.x - node1.width / 2;
+  const n1Right = node1.center.x + node1.width / 2;
+  const n1Top = node1.center.y - node1.height / 2;
+  const n1Bottom = node1.center.y + node1.height / 2;
+  const n2Left = node2.center.x - node2.width / 2;
+  const n2Right = node2.center.x + node2.width / 2;
+  const n2Top = node2.center.y - node2.height / 2;
+  const n2Bottom = node2.center.y + node2.height / 2;
+  const epsilon = 1e-3;
+  const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
+  const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
+  return shareVerticalBorder || shareHorizontalBorder;
+}
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshEdgeSolver.ts
 var CapacityMeshEdgeSolver = class extends BaseSolver {
   constructor(nodes) {
@@ -140,7 +156,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]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
+        if (!(this.nodes[i]._strawNode && this.nodes[j]._strawNode) && areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
           this.edges.push({
             capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
             nodeIds: [
@@ -180,20 +196,6 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     }
     this.solved = true;
   }
-  areNodesBordering(node1, node2) {
-    const n1Left = node1.center.x - node1.width / 2;
-    const n1Right = node1.center.x + node1.width / 2;
-    const n1Top = node1.center.y - node1.height / 2;
-    const n1Bottom = node1.center.y + node1.height / 2;
-    const n2Left = node2.center.x - node2.width / 2;
-    const n2Right = node2.center.x + node2.width / 2;
-    const n2Top = node2.center.y - node2.height / 2;
-    const n2Bottom = node2.center.y + node2.height / 2;
-    const epsilon = 1e-3;
-    const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
-    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));
   }
@@ -233,8 +235,19 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
         (node) => node.capacityMeshNodeId === edge.nodeIds[1]
       );
       if (node1?.center && node2?.center) {
+        const lowestZ1 = Math.min(...node1.availableZ);
+        const lowestZ2 = Math.min(...node2.availableZ);
+        const nodeCenter1Adj = {
+          x: node1.center.x + lowestZ1 * node1.width * 0.05,
+          y: node1.center.y - lowestZ1 * node1.width * 0.05
+        };
+        const nodeCenter2Adj = {
+          x: node2.center.x + lowestZ2 * node2.width * 0.05,
+          y: node2.center.y - lowestZ2 * node2.width * 0.05
+        };
         graphics.lines.push({
-          points: [node1.center, node2.center]
+          points: [nodeCenter1Adj, nodeCenter2Adj],
+          strokeDash: node1.availableZ.join(",") === node2.availableZ.join(",") ? void 0 : "10 5"
         });
       }
     }
@@ -1168,6 +1181,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   getTargetIfNodeContainsTarget(node) {
     const overlappingObstacles = this.getXYOverlappingObstacles(node);
     for (const target of this.targets) {
+      if (!target.availableZ.some((z) => node.availableZ.includes(z))) continue;
       const targetObstacle = overlappingObstacles.find(
         (o) => isPointInRect(target, o)
       );
@@ -1264,9 +1278,6 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         return true;
       }
     }
-    if (nodeRight < this.srj.bounds.minX || nodeLeft > this.srj.bounds.maxX || nodeBottom < this.srj.bounds.minY || nodeTop > this.srj.bounds.maxY) {
-      return true;
-    }
     return false;
   }
   getChildNodes(parent) {
@@ -1370,14 +1381,15 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         center: obstacle.center,
         width: obstacle.width,
         height: obstacle.height,
-        fill: "rgba(255,0,0,0.3)",
+        fill: obstacle.zLayers?.length === 1 && obstacle.zLayers?.includes(1) ? "rgba(0,0,255,0.3)" : "rgba(255,0,0,0.3)",
         stroke: "red",
-        label: ["obstacle", obstacle.zLayers.join(",")].join("\n")
+        label: ["obstacle", `z: ${obstacle.zLayers.join(",")}`].join("\n")
       });
     }
     const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
     for (const node of allNodes) {
       const lowestZ = Math.min(...node.availableZ);
+      const isNextToBeProcessed = this.unfinishedNodes.length > 0 && node === this.unfinishedNodes[this.unfinishedNodes.length - 1];
       graphics.rects.push({
         center: {
           x: node.center.x + lowestZ * node.width * 0.05,
@@ -1390,6 +1402,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
           "0": "rgba(0,200,200, 0.1)",
           "1": "rgba(0,0,200, 0.1)"
         }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+        stroke: isNextToBeProcessed ? "rgba(255,165,0,0.5)" : void 0,
         label: [
           node.capacityMeshNodeId,
           `availableZ: ${node.availableZ.join(",")}`,
@@ -1414,6 +1427,146 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver2_NodesUnderObstacles.ts
+var CapacityMeshNodeSolver2_NodeUnderObstacle = class extends CapacityMeshNodeSolver {
+  constructor(srj, opts = {}) {
+    super(srj, opts);
+    this.srj = srj;
+    this.opts = opts;
+  }
+  isNodeCompletelyOutsideBounds(node) {
+    return node.center.x + node.width / 2 < this.srj.bounds.minX || node.center.x - node.width / 2 > this.srj.bounds.maxX || node.center.y + node.height / 2 < this.srj.bounds.minY || node.center.y - node.height / 2 > this.srj.bounds.maxY;
+  }
+  isNodePartiallyOutsideBounds(node) {
+    return node.center.x - node.width / 2 < this.srj.bounds.minX || node.center.x + node.width / 2 > this.srj.bounds.maxX || node.center.y - node.height / 2 < this.srj.bounds.minY || node.center.y + node.height / 2 > this.srj.bounds.maxY;
+  }
+  createChildNodeAtPosition(parent, opts) {
+    const childNode = {
+      capacityMeshNodeId: this.getNextNodeId(),
+      center: opts.center,
+      width: opts.width,
+      height: opts.height,
+      layer: parent.layer,
+      availableZ: opts.availableZ,
+      _depth: opts._depth ?? (parent._depth ?? 0) + 1,
+      _parent: parent
+    };
+    const overlappingObstacles = this.getXYZOverlappingObstacles(childNode);
+    childNode._containsObstacle = overlappingObstacles.length > 0 || this.isNodePartiallyOutsideBounds(childNode);
+    const target = this.getTargetIfNodeContainsTarget(childNode);
+    if (target) {
+      childNode._targetConnectionName = target.connectionName;
+      childNode._containsTarget = true;
+    }
+    if (childNode._containsObstacle) {
+      childNode._completelyInsideObstacle = this.isNodeCompletelyInsideObstacle(childNode);
+    }
+    return childNode;
+  }
+  getZSubdivisionChildNodes(node) {
+    if (node.availableZ.length === 1) return [];
+    const childNodes = [];
+    const otherZBlocks = [[0], [1]];
+    for (const zBlock of otherZBlocks) {
+      const childNode = this.createChildNodeAtPosition(node, {
+        center: { ...node.center },
+        width: node.width,
+        height: node.height,
+        availableZ: zBlock,
+        // z-subdivision doesn't count towards depth, should be same as parent
+        _depth: node._depth
+      });
+      if (this.isNodeCompletelyOutsideBounds(childNode)) {
+        continue;
+      }
+      childNodes.push(childNode);
+    }
+    return childNodes;
+  }
+  getChildNodes(parent) {
+    if (parent._depth >= this.MAX_DEPTH) return [];
+    const childNodes = [];
+    const childNodeSize = { width: parent.width / 2, height: parent.height / 2 };
+    const childNodePositions = [
+      {
+        x: parent.center.x - childNodeSize.width / 2,
+        y: parent.center.y - childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x + childNodeSize.width / 2,
+        y: parent.center.y - childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x - childNodeSize.width / 2,
+        y: parent.center.y + childNodeSize.height / 2
+      },
+      {
+        x: parent.center.x + childNodeSize.width / 2,
+        y: parent.center.y + childNodeSize.height / 2
+      }
+    ];
+    for (const position of childNodePositions) {
+      const childNode = this.createChildNodeAtPosition(parent, {
+        center: position,
+        width: childNodeSize.width,
+        height: childNodeSize.height,
+        availableZ: parent.availableZ
+      });
+      if (this.isNodeCompletelyOutsideBounds(childNode)) {
+        continue;
+      }
+      childNodes.push(childNode);
+    }
+    return childNodes;
+  }
+  shouldNodeBeXYSubdivided(node) {
+    if (node._depth >= this.MAX_DEPTH) return false;
+    if (node._containsTarget) return true;
+    if (node.availableZ.length === 1 && node._depth <= this.MAX_DEPTH)
+      return true;
+    if (node._containsObstacle && !node._completelyInsideObstacle) return true;
+    return false;
+  }
+  _step() {
+    const nextNode = this.unfinishedNodes.pop();
+    if (!nextNode) {
+      this.solved = true;
+      return;
+    }
+    const childNodes = this.getChildNodes(nextNode);
+    const finishedNewNodes = [];
+    const unfinishedNewNodes = [];
+    for (const childNode of childNodes) {
+      const shouldBeXYSubdivided = this.shouldNodeBeXYSubdivided(childNode);
+      const shouldBeZSubdivided = childNode.availableZ.length > 1 && !shouldBeXYSubdivided && childNode._containsObstacle;
+      if (shouldBeXYSubdivided) {
+        unfinishedNewNodes.push(childNode);
+      } else if (!shouldBeXYSubdivided && !childNode._containsObstacle) {
+        finishedNewNodes.push(childNode);
+      } else if (!shouldBeXYSubdivided && childNode._containsTarget) {
+        if (shouldBeZSubdivided) {
+          const zSubNodes = this.getZSubdivisionChildNodes(childNode);
+          finishedNewNodes.push(
+            ...zSubNodes.filter(
+              (n) => n._containsTarget || !n._containsObstacle
+            )
+          );
+        } else {
+          finishedNewNodes.push(childNode);
+        }
+      } else if (shouldBeZSubdivided) {
+        finishedNewNodes.push(
+          ...this.getZSubdivisionChildNodes(childNode).filter(
+            (zSubNode) => !zSubNode._containsObstacle
+          )
+        );
+      }
+    }
+    this.unfinishedNodes.push(...unfinishedNewNodes);
+    this.finishedNodes.push(...finishedNewNodes);
+  }
+};
+
 // lib/solvers/CapacityMeshSolver/getNodeEdgeMap.ts
 function getNodeEdgeMap(edges) {
   const nodeEdgeMap = /* @__PURE__ */ new Map();
@@ -1712,7 +1865,10 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
         (seg) => seg.assignedPoints.map((ap) => ({
           x: ap.point.x,
           y: ap.point.y,
-          label: `${seg.capacityMeshNodeId}-${ap.connectionName}`,
+          label: [
+            `${seg.capacityMeshNodeId}-${ap.connectionName}`,
+            `z: ${seg.availableZ.join(",")}`
+          ].join("\n"),
           color: this.colorMap[ap.connectionName],
           step: 4
         }))
@@ -1904,7 +2060,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     const margin = isVia ? this.viaDiameter / 2 : this.obstacleMargin;
     const tooClose = node.x < this.bounds.minX + margin || node.x > this.bounds.maxX - margin || node.y < this.bounds.minY + margin || node.y > this.bounds.maxY - margin;
     if (tooClose && !isVia) {
-      if (distance(node, this.B) < margin * 2) {
+      if (distance(node, this.B) < margin * 2 || distance(node, this.A) < margin * 2) {
         return false;
       }
     }
@@ -2884,294 +3040,94 @@ var HighDensitySolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts
-var CapacityPathingSolver = class extends BaseSolver {
-  connectionsWithNodes;
-  usedNodeCapacityMap;
-  simpleRouteJson;
-  nodes;
-  edges;
-  GREEDY_MULTIPLIER = 1.1;
-  nodeMap;
-  nodeEdgeMap;
-  connectionNameToGoalNodeIds;
-  colorMap;
-  maxDepthOfNodes;
-  activeCandidateStraightLineDistance;
-  hyperParameters;
-  constructor({
-    simpleRouteJson,
-    nodes,
-    edges,
-    colorMap,
-    MAX_ITERATIONS = 1e6,
-    hyperParameters = {}
-  }) {
-    super();
-    this.MAX_ITERATIONS = MAX_ITERATIONS;
-    this.simpleRouteJson = simpleRouteJson;
-    this.nodes = nodes;
-    this.edges = edges;
-    this.colorMap = colorMap ?? {};
-    const { connectionsWithNodes, connectionNameToGoalNodeIds } = this.getConnectionsWithNodes();
-    this.connectionsWithNodes = connectionsWithNodes;
-    this.connectionNameToGoalNodeIds = connectionNameToGoalNodeIds;
-    this.hyperParameters = hyperParameters;
-    this.usedNodeCapacityMap = new Map(
-      this.nodes.map((node) => [node.capacityMeshNodeId, 0])
-    );
-    this.nodeMap = new Map(
-      this.nodes.map((node) => [node.capacityMeshNodeId, node])
-    );
-    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.maxDepthOfNodes = Math.max(
-      ...this.nodes.map((node) => node._depth ?? 0)
-    );
-  }
-  getTotalCapacity(node) {
-    const depth = node._depth ?? 0;
-    return (this.maxDepthOfNodes - depth + 1) ** 2;
+// node_modules/circuit-json-to-connectivity-map/dist/index.js
+var ConnectivityMap = class {
+  netMap;
+  idToNetMap;
+  constructor(netMap) {
+    this.netMap = netMap;
+    this.idToNetMap = {};
+    for (const [netId, ids] of Object.entries(netMap)) {
+      for (const id of ids) {
+        this.idToNetMap[id] = netId;
+      }
+    }
   }
-  getConnectionsWithNodes() {
-    const connectionsWithNodes = [];
-    const nodesWithTargets = this.nodes.filter((node) => node._containsTarget);
-    const connectionNameToGoalNodeIds = /* @__PURE__ */ new Map();
-    for (const connection of this.simpleRouteJson.connections) {
-      const nodesForConnection = [];
-      for (const point of connection.pointsToConnect) {
-        let closestNode = this.nodes[0];
-        let minDistance = Number.MAX_VALUE;
-        for (const node of nodesWithTargets) {
-          const distance3 = Math.sqrt(
-            (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
-          );
-          if (distance3 < minDistance) {
-            minDistance = distance3;
-            closestNode = node;
+  addConnections(connections) {
+    for (const connection of connections) {
+      const existingNets = /* @__PURE__ */ new Set();
+      for (const id of connection) {
+        const existingNetId = this.idToNetMap[id];
+        if (existingNetId) {
+          existingNets.add(existingNetId);
+        }
+      }
+      let targetNetId;
+      if (existingNets.size === 0) {
+        targetNetId = `connectivity_net${Object.keys(this.netMap).length}`;
+        this.netMap[targetNetId] = [];
+      } else if (existingNets.size === 1) {
+        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
+      } else {
+        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
+        for (const netId of existingNets) {
+          if (netId !== targetNetId) {
+            this.netMap[targetNetId].push(...this.netMap[netId]);
+            this.netMap[netId] = this.netMap[targetNetId];
+            for (const id of this.netMap[targetNetId]) {
+              this.idToNetMap[id] = targetNetId;
+            }
           }
         }
-        nodesForConnection.push(closestNode);
       }
-      if (nodesForConnection.length < 2) {
-        throw new Error(
-          `Not enough nodes for connection "${connection.name}", only ${nodesForConnection.length} found`
-        );
+      for (const id of connection) {
+        if (!this.netMap[targetNetId].includes(id)) {
+          this.netMap[targetNetId].push(id);
+        }
+        this.idToNetMap[id] = targetNetId;
       }
-      connectionNameToGoalNodeIds.set(
-        connection.name,
-        nodesForConnection.map((n) => n.capacityMeshNodeId)
-      );
-      connectionsWithNodes.push({
-        connection,
-        nodes: nodesForConnection,
-        pathFound: false
-      });
     }
-    return { connectionsWithNodes, connectionNameToGoalNodeIds };
-  }
-  currentConnectionIndex = 0;
-  candidates;
-  visitedNodes;
-  computeG(prevCandidate, node, endGoal) {
-    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node);
   }
-  computeH(prevCandidate, node, endGoal) {
-    return this.getDistanceBetweenNodes(node, endGoal);
+  getIdsConnectedToNet(netId) {
+    return this.netMap[netId] || [];
   }
-  getBacktrackedPath(candidate) {
-    const path = [];
-    let currentCandidate = candidate;
-    while (currentCandidate) {
-      path.push(currentCandidate.node);
-      currentCandidate = currentCandidate.prevCandidate;
-    }
-    return path;
+  getNetConnectedToId(id) {
+    return this.idToNetMap[id];
   }
-  getNeighboringNodes(node) {
-    return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap(
-      (edge) => edge.nodeIds.filter((n) => n !== node.capacityMeshNodeId)
-    ).map((n) => this.nodeMap.get(n));
+  areIdsConnected(id1, id2) {
+    if (id1 === id2) return true;
+    const netId1 = this.getNetConnectedToId(id1);
+    if (!netId1) return false;
+    const netId2 = this.getNetConnectedToId(id2);
+    if (!netId2) return false;
+    return netId1 === netId2 || netId2 === id1 || netId2 === id1;
   }
-  getCapacityPaths() {
-    const capacityPaths = [];
-    for (const connection of this.connectionsWithNodes) {
-      const path = connection.path;
-      if (path) {
-        capacityPaths.push({
-          capacityPathId: connection.connection.name,
-          connectionName: connection.connection.name,
-          nodeIds: path.map((node) => node.capacityMeshNodeId)
-        });
+  areAllIdsConnected(ids) {
+    const netId = this.getNetConnectedToId(ids[0]);
+    for (const id of ids) {
+      const nextNetId = this.getNetConnectedToId(id);
+      if (nextNetId === void 0) {
+        return false;
+      }
+      if (nextNetId !== netId) {
+        return false;
       }
     }
-    return capacityPaths;
+    return true;
   }
-  doesNodeHaveCapacityForTrace(node) {
-    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
-    const totalCapacity = this.getTotalCapacity(node);
-    return usedCapacity < totalCapacity;
-  }
-  canTravelThroughObstacle(node, connectionName) {
-    const goalNodeIds = this.connectionNameToGoalNodeIds.get(connectionName);
-    return goalNodeIds?.includes(node.capacityMeshNodeId) ?? false;
-  }
-  getDistanceBetweenNodes(A, B) {
-    return Math.sqrt(
-      (A.center.x - B.center.x) ** 2 + (A.center.y - B.center.y) ** 2
-    );
-  }
-  reduceCapacityAlongPath(nextConnection) {
-    for (const node of nextConnection.path ?? []) {
-      this.usedNodeCapacityMap.set(
-        node.capacityMeshNodeId,
-        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) + 1
-      );
-    }
-  }
-  isConnectedToEndGoal(node, endGoal) {
-    return this.nodeEdgeMap.get(node.capacityMeshNodeId).some((edge) => edge.nodeIds.includes(endGoal.capacityMeshNodeId));
-  }
-  _step() {
-    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
-    if (!nextConnection) {
-      this.solved = true;
-      return;
-    }
-    const [start, end] = nextConnection.nodes;
-    if (!this.candidates) {
-      this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }];
-      this.visitedNodes = /* @__PURE__ */ new Set([start.capacityMeshNodeId]);
-      this.activeCandidateStraightLineDistance = distance(
-        start.center,
-        end.center
-      );
-    }
-    this.candidates.sort((a, b) => a.f - b.f);
-    const currentCandidate = this.candidates.shift();
-    if (!currentCandidate) {
-      console.error(
-        `Ran out of candidates on connection ${nextConnection.connection.name}`
-      );
-      this.currentConnectionIndex++;
-      this.candidates = null;
-      this.visitedNodes = null;
-      return;
-    }
-    if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
-      nextConnection.path = this.getBacktrackedPath({
-        prevCandidate: currentCandidate,
-        node: end,
-        f: 0,
-        g: 0,
-        h: 0
-      });
-      this.reduceCapacityAlongPath(nextConnection);
-      this.currentConnectionIndex++;
-      this.candidates = null;
-      this.visitedNodes = null;
-      return;
-    }
-    const neighborNodes = this.getNeighboringNodes(currentCandidate.node);
-    for (const neighborNode of neighborNodes) {
-      if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
-        continue;
-      }
-      if (!this.doesNodeHaveCapacityForTrace(neighborNode)) {
-        continue;
-      }
-      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
-      if (neighborNode._containsObstacle && !this.canTravelThroughObstacle(neighborNode, connectionName)) {
-        continue;
-      }
-      const g = this.computeG(currentCandidate, neighborNode, end);
-      const h = this.computeH(currentCandidate, neighborNode, end);
-      const f = g + h * this.GREEDY_MULTIPLIER;
-      const newCandidate = {
-        prevCandidate: currentCandidate,
-        node: neighborNode,
-        f,
-        g,
-        h
-      };
-      this.candidates.push(newCandidate);
-    }
-    this.visitedNodes.add(currentCandidate.node.capacityMeshNodeId);
-  }
-  visualize() {
-    const graphics = {
-      lines: [],
-      points: [],
-      rects: [],
-      circles: []
-    };
-    if (this.connectionsWithNodes) {
-      for (let i = 0; i < this.connectionsWithNodes.length; i++) {
-        const conn = this.connectionsWithNodes[i];
-        if (conn.path && conn.path.length > 0) {
-          const pathPoints = conn.path.map(({ center: { x, y }, width }) => ({
-            // slight offset to allow viewing overlapping paths
-            x: x + (i % 10 + i % 19) * (0.01 * width),
-            y: y + (i % 10 + i % 19) * (0.01 * width)
-          }));
-          graphics.lines.push({
-            points: pathPoints,
-            strokeColor: this.colorMap[conn.connection.name]
-          });
-        }
-      }
-    }
-    for (const node of this.nodes) {
-      graphics.rects.push({
-        center: node.center,
-        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}
-${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}
-${node.width.toFixed(2)}x${node.height.toFixed(2)}`
-      });
-    }
-    if (this.connectionsWithNodes) {
-      for (const conn of this.connectionsWithNodes) {
-        if (conn.connection?.pointsToConnect) {
-          for (const point of conn.connection.pointsToConnect) {
-            graphics.points.push({
-              x: point.x,
-              y: point.y
-            });
-          }
-        }
+};
+
+// lib/utils/getConnectivityMapFromSimpleRouteJson.ts
+var getConnectivityMapFromSimpleRouteJson = (srj) => {
+  const connMap = new ConnectivityMap({});
+  for (const connection of srj.connections) {
+    for (const point of connection.pointsToConnect) {
+      if ("pcb_port_id" in point && point.pcb_port_id) {
+        connMap.addConnections([[connection.name, point.pcb_port_id]]);
       }
     }
-    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
-    if (nextConnection) {
-      const [start, end] = nextConnection.connection.pointsToConnect;
-      graphics.lines.push({
-        points: [
-          { x: start.x, y: start.y },
-          { x: end.x, y: end.y }
-        ],
-        strokeColor: "red",
-        strokeDash: "10 5"
-      });
-    }
-    if (this.candidates) {
-      const topCandidates = this.candidates.slice(0, 5);
-      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
-      topCandidates.forEach((candidate, index) => {
-        const opacity = 0.5 * (1 - index / 5);
-        const backtrackedPath = this.getBacktrackedPath(candidate);
-        graphics.lines.push({
-          points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
-          strokeColor: safeTransparentize(
-            this.colorMap[connectionName] ?? "red",
-            1 - opacity
-          )
-        });
-      });
-    }
-    return graphics;
   }
+  return connMap;
 };
 
 // lib/utils/getTunedTotalCapacity1.ts
@@ -3197,267 +3153,44 @@ var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxD
   return Math.max(1, depth);
 };
 
-// lib/solvers/CapacityPathingSolver/CapacityPathingSolver4_FlexibleNegativeCapacity_AvoidLowCapacity_FixedDistanceCost.ts
-var CapacityPathingSolver4_FlexibleNegativeCapacity = class extends CapacityPathingSolver {
-  NEGATIVE_CAPACITY_PENALTY_FACTOR = 1;
-  REDUCED_CAPACITY_PENALTY_FACTOR = 1;
-  get maxCapacityFactor() {
-    return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1;
-  }
-  /**
-   * In the FlexibleNegativeCapacity mode, we allow negative capacity
-   */
-  doesNodeHaveCapacityForTrace(node) {
-    return true;
-  }
-  getTotalCapacity(node) {
-    return getTunedTotalCapacity1(node, this.maxCapacityFactor);
+// lib/solvers/NetToPointPairsSolver/buildMinimumSpanningTree.ts
+var KDNode = class {
+  point;
+  left = null;
+  right = null;
+  constructor(point) {
+    this.point = point;
   }
-  /**
-   * Penalty you pay for using this node
-   */
-  getNodeCapacityPenalty(node) {
-    const totalCapacity = this.getTotalCapacity(node);
-    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
-    const remainingCapacity = totalCapacity - usedCapacity;
-    const dist = this.activeCandidateStraightLineDistance;
-    if (remainingCapacity <= 0) {
-      const penalty = (-remainingCapacity + 1) / totalCapacity * dist * (this.NEGATIVE_CAPACITY_PENALTY_FACTOR / 4);
-      return penalty ** 2;
+};
+var KDTree = class {
+  root = null;
+  constructor(points) {
+    if (points.length > 0) {
+      this.root = this.buildTree(points, 0);
     }
-    return 1 / remainingCapacity * dist * this.REDUCED_CAPACITY_PENALTY_FACTOR / 8;
-  }
-  /**
-   * We're rewarding travel into big nodes.
-   *
-   * To minimize shortest path, you'd want to comment this out.
-   */
-  getDistanceBetweenNodes(A, B) {
-    const dx = A.center.x - B.center.x;
-    const dy = A.center.y - B.center.y;
-    const szx = Math.max(A.width, B.width);
-    const szy = Math.max(A.height, B.height);
-    const dist = Math.sqrt(dx ** 2 + dy ** 2) / (szx * szy);
-    return dist;
-  }
-  computeG(prevCandidate, node, endGoal) {
-    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
   }
-  computeH(prevCandidate, node, endGoal) {
-    return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
+  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;
   }
-};
-
-// node_modules/circuit-json-to-connectivity-map/dist/index.js
-var ConnectivityMap = class {
-  netMap;
-  idToNetMap;
-  constructor(netMap) {
-    this.netMap = netMap;
-    this.idToNetMap = {};
-    for (const [netId, ids] of Object.entries(netMap)) {
-      for (const id of ids) {
-        this.idToNetMap[id] = netId;
-      }
+  // Find the nearest neighbor to a query point
+  findNearestNeighbor(queryPoint) {
+    if (!this.root) {
+      throw new Error("Tree is empty");
     }
-  }
-  addConnections(connections) {
-    for (const connection of connections) {
-      const existingNets = /* @__PURE__ */ new Set();
-      for (const id of connection) {
-        const existingNetId = this.idToNetMap[id];
-        if (existingNetId) {
-          existingNets.add(existingNetId);
-        }
-      }
-      let targetNetId;
-      if (existingNets.size === 0) {
-        targetNetId = `connectivity_net${Object.keys(this.netMap).length}`;
-        this.netMap[targetNetId] = [];
-      } else if (existingNets.size === 1) {
-        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
-      } else {
-        targetNetId = existingNets.values().next().value ?? `connectivity_net${Object.keys(this.netMap).length}`;
-        for (const netId of existingNets) {
-          if (netId !== targetNetId) {
-            this.netMap[targetNetId].push(...this.netMap[netId]);
-            this.netMap[netId] = this.netMap[targetNetId];
-            for (const id of this.netMap[targetNetId]) {
-              this.idToNetMap[id] = targetNetId;
-            }
-          }
-        }
-      }
-      for (const id of connection) {
-        if (!this.netMap[targetNetId].includes(id)) {
-          this.netMap[targetNetId].push(id);
-        }
-        this.idToNetMap[id] = targetNetId;
-      }
-    }
-  }
-  getIdsConnectedToNet(netId) {
-    return this.netMap[netId] || [];
-  }
-  getNetConnectedToId(id) {
-    return this.idToNetMap[id];
-  }
-  areIdsConnected(id1, id2) {
-    if (id1 === id2) return true;
-    const netId1 = this.getNetConnectedToId(id1);
-    if (!netId1) return false;
-    const netId2 = this.getNetConnectedToId(id2);
-    if (!netId2) return false;
-    return netId1 === netId2 || netId2 === id1 || netId2 === id1;
-  }
-  areAllIdsConnected(ids) {
-    const netId = this.getNetConnectedToId(ids[0]);
-    for (const id of ids) {
-      const nextNetId = this.getNetConnectedToId(id);
-      if (nextNetId === void 0) {
-        return false;
-      }
-      if (nextNetId !== netId) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// lib/utils/getConnectivityMapFromSimpleRouteJson.ts
-var getConnectivityMapFromSimpleRouteJson = (srj) => {
-  const connMap = new ConnectivityMap({});
-  for (const connection of srj.connections) {
-    for (const point of connection.pointsToConnect) {
-      if ("pcb_port_id" in point && point.pcb_port_id) {
-        connMap.addConnections([[connection.name, point.pcb_port_id]]);
-      }
-    }
-  }
-  return connMap;
-};
-
-// lib/solvers/CapacityMeshSolver/CapacityNodeTargetMerger.ts
-var CapacityNodeTargetMerger = class extends BaseSolver {
-  constructor(nodes, obstacles, connMap) {
-    super();
-    this.nodes = nodes;
-    this.connMap = connMap;
-    this.MAX_ITERATIONS = 1e5;
-    this.unprocessedObstacles = [...obstacles];
-    this.newNodes = [];
-    this.removedNodeIds = /* @__PURE__ */ new Set();
-  }
-  unprocessedObstacles;
-  newNodes;
-  removedNodeIds;
-  _step() {
-    const obstacle = this.unprocessedObstacles.pop();
-    if (!obstacle) {
-      for (const node of this.nodes) {
-        if (this.removedNodeIds.has(node.capacityMeshNodeId)) continue;
-        this.newNodes.push(node);
-      }
-      this.solved = true;
-      return;
-    }
-    const connectedNodes = this.nodes.filter((n) => {
-      if (!n._targetConnectionName) return false;
-      const implicitlyConnected = doRectsOverlap(n, obstacle);
-      return implicitlyConnected;
-    });
-    if (connectedNodes.length === 0) return;
-    const connectionName = connectedNodes[0]._targetConnectionName;
-    const bounds = {
-      minX: Infinity,
-      minY: Infinity,
-      maxX: -Infinity,
-      maxY: -Infinity
-    };
-    for (const node of connectedNodes) {
-      bounds.minX = Math.min(bounds.minX, node.center.x - node.width / 2);
-      bounds.minY = Math.min(bounds.minY, node.center.y - node.height / 2);
-      bounds.maxX = Math.max(bounds.maxX, node.center.x + node.width / 2);
-      bounds.maxY = Math.max(bounds.maxY, node.center.y + node.height / 2);
-    }
-    const newNode = {
-      capacityMeshNodeId: connectedNodes[0].capacityMeshNodeId,
-      center: {
-        x: (bounds.minX + bounds.maxX) / 2,
-        y: (bounds.minY + bounds.maxY) / 2
-      },
-      width: bounds.maxX - bounds.minX,
-      height: bounds.maxY - bounds.minY,
-      layer: connectedNodes[0].layer,
-      availableZ: connectedNodes[0].availableZ,
-      _completelyInsideObstacle: false,
-      _containsObstacle: true,
-      _containsTarget: true,
-      _targetConnectionName: connectionName,
-      _depth: connectedNodes[0]._depth,
-      _parent: connectedNodes[0]._parent
-    };
-    this.newNodes.push(newNode);
-    for (const node of connectedNodes) {
-      this.removedNodeIds.add(node.capacityMeshNodeId);
-    }
-  }
-  visualize() {
-    const graphics = {
-      rects: []
-    };
-    for (const node of this.newNodes) {
-      graphics.rects.push({
-        center: node.center,
-        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
-      });
-    }
-    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;
+    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) {
@@ -4347,6 +4080,7 @@ var createSegmentPointMap = (dedupedSegments, segmentIdToNodeIds) => {
 var UnravelSectionSolver = class extends BaseSolver {
   nodeMap;
   dedupedSegments;
+  dedupedSegmentMap;
   MUTABLE_HOPS = 1;
   unravelSection;
   candidates = [];
@@ -4366,6 +4100,14 @@ var UnravelSectionSolver = class extends BaseSolver {
     this.MUTABLE_HOPS = params.MUTABLE_HOPS ?? this.MUTABLE_HOPS;
     this.nodeMap = params.nodeMap;
     this.dedupedSegments = params.dedupedSegments;
+    if (params.dedupedSegmentMap) {
+      this.dedupedSegmentMap = params.dedupedSegmentMap;
+    } else {
+      this.dedupedSegmentMap = /* @__PURE__ */ new Map();
+      for (const segment of this.dedupedSegments) {
+        this.dedupedSegmentMap.set(segment.nodePortSegmentId, segment);
+      }
+    }
     this.nodeIdToSegmentIds = params.nodeIdToSegmentIds;
     this.segmentIdToNodeIds = params.segmentIdToNodeIds;
     this.rootNodeId = params.rootNodeId;
@@ -4524,14 +4266,20 @@ var UnravelSectionSolver = class extends BaseSolver {
       const [APointId, BPointId] = issue.segmentPoints;
       const pointA = this.getPointInCandidate(candidate, APointId);
       const pointB = this.getPointInCandidate(candidate, BPointId);
-      if (this.unravelSection.mutableSegmentIds.has(pointA.segmentId)) {
+      const aAvailableZ = this.dedupedSegmentMap.get(
+        pointA.segmentId
+      ).availableZ;
+      const bAvailableZ = this.dedupedSegmentMap.get(
+        pointB.segmentId
+      ).availableZ;
+      if (this.unravelSection.mutableSegmentIds.has(pointA.segmentId) && aAvailableZ.includes(pointB.z)) {
         operations.push({
           type: "change_layer",
           newZ: pointB.z,
           segmentPointIds: [APointId]
         });
       }
-      if (this.unravelSection.mutableSegmentIds.has(pointB.segmentId)) {
+      if (this.unravelSection.mutableSegmentIds.has(pointB.segmentId) && bAvailableZ.includes(pointA.z)) {
         operations.push({
           type: "change_layer",
           newZ: pointA.z,
@@ -4986,6 +4734,7 @@ var calculateNodeProbabilityOfFailure = (node, numSameLayerCrossings, numEntryEx
 // lib/solvers/UnravelSolver/UnravelMultiSectionSolver.ts
 var UnravelMultiSectionSolver = class extends BaseSolver {
   nodeMap;
+  dedupedSegmentMap;
   dedupedSegments;
   nodeIdToSegmentIds;
   segmentIdToNodeIds;
@@ -5009,6 +4758,10 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
     super();
     this.MAX_ITERATIONS = 1e5;
     this.dedupedSegments = getDedupedSegments(assignedSegments);
+    this.dedupedSegmentMap = /* @__PURE__ */ new Map();
+    for (const segment of this.dedupedSegments) {
+      this.dedupedSegmentMap.set(segment.nodePortSegmentId, segment);
+    }
     this.nodeMap = /* @__PURE__ */ new Map();
     for (const node of nodes) {
       this.nodeMap.set(node.capacityMeshNodeId, node);
@@ -5087,6 +4840,7 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
       );
       this.activeSolver = new UnravelSectionSolver({
         dedupedSegments: this.dedupedSegments,
+        dedupedSegmentMap: this.dedupedSegmentMap,
         nodeMap: this.nodeMap,
         nodeIdToSegmentIds: this.nodeIdToSegmentIds,
         segmentIdToNodeIds: this.segmentIdToNodeIds,
@@ -5113,148 +4867,963 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
           segmentPoint.z = pointModification.z ?? segmentPoint.z;
         }
       }
-      for (const nodeId of this.activeSolver.unravelSection.allNodeIds) {
-        this.nodePfMap.set(
-          nodeId,
-          this.computeNodePf(this.nodeMap.get(nodeId))
-        );
+      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)`;
+      if ((this.attemptsToFixNode.get(nodeId) ?? 0) === 0 && pf === 0) {
+        continue;
+      }
+      graphics.rects.push({
+        center: node.center,
+        label: [
+          nodeId,
+          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+          `Pf: ${probabilityOfFailure.toFixed(3)}`
+        ].join("\n"),
+        color,
+        width: node.width / 8,
+        height: node.height / 8
+      });
+    }
+    for (const segmentPoint of this.segmentPointMap.values()) {
+      const segment = this.dedupedSegmentMap.get(segmentPoint.segmentId);
+      graphics.points.push({
+        x: segmentPoint.x,
+        y: segmentPoint.y,
+        label: [
+          segmentPoint.segmentPointId,
+          segmentPoint.segmentId,
+          `z: ${segmentPoint.z}`,
+          `segment.availableZ: ${segment?.availableZ.join(",")}`
+        ].join("\n"),
+        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/utils/createRectFromCapacityNode.ts
+var createRectFromCapacityNode = (node, opts = {}) => {
+  const lowestZ = Math.min(...node.availableZ);
+  return {
+    center: !opts.rectMargin ? {
+      x: node.center.x + lowestZ * node.width * 0.05,
+      y: node.center.y - lowestZ * node.width * 0.05
+    } : node.center,
+    width: opts.rectMargin ? node.width - opts.rectMargin * 2 : Math.max(node.width - 0.5, node.width * 0.8),
+    height: opts.rectMargin ? node.height - opts.rectMargin * 2 : Math.max(node.height - 0.5, node.height * 0.8),
+    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(",")}`,
+      `${node._containsTarget ? "containsTarget" : ""}`,
+      `${node._containsObstacle ? "containsObstacle" : ""}`
+    ].filter(Boolean).join("\n")
+  };
+};
+
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts
+var CapacityPathingSolver = class extends BaseSolver {
+  connectionsWithNodes;
+  usedNodeCapacityMap;
+  simpleRouteJson;
+  nodes;
+  edges;
+  GREEDY_MULTIPLIER = 1.1;
+  nodeMap;
+  nodeEdgeMap;
+  connectionNameToGoalNodeIds;
+  colorMap;
+  maxDepthOfNodes;
+  activeCandidateStraightLineDistance;
+  debug_lastNodeCostMap;
+  hyperParameters;
+  constructor({
+    simpleRouteJson,
+    nodes,
+    edges,
+    colorMap,
+    MAX_ITERATIONS = 1e6,
+    hyperParameters = {}
+  }) {
+    super();
+    this.MAX_ITERATIONS = MAX_ITERATIONS;
+    this.simpleRouteJson = simpleRouteJson;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.colorMap = colorMap ?? {};
+    const { connectionsWithNodes, connectionNameToGoalNodeIds } = this.getConnectionsWithNodes();
+    this.connectionsWithNodes = connectionsWithNodes;
+    this.connectionNameToGoalNodeIds = connectionNameToGoalNodeIds;
+    this.hyperParameters = hyperParameters;
+    this.usedNodeCapacityMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, 0])
+    );
+    this.nodeMap = new Map(
+      this.nodes.map((node) => [node.capacityMeshNodeId, node])
+    );
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
+    this.maxDepthOfNodes = Math.max(
+      ...this.nodes.map((node) => node._depth ?? 0)
+    );
+    this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
+  }
+  getTotalCapacity(node) {
+    const depth = node._depth ?? 0;
+    return (this.maxDepthOfNodes - depth + 1) ** 2;
+  }
+  getConnectionsWithNodes() {
+    const connectionsWithNodes = [];
+    const nodesWithTargets = this.nodes.filter((node) => node._containsTarget);
+    const connectionNameToGoalNodeIds = /* @__PURE__ */ new Map();
+    for (const connection of this.simpleRouteJson.connections) {
+      const nodesForConnection = [];
+      for (const point of connection.pointsToConnect) {
+        let closestNode = this.nodes[0];
+        let minDistance = Number.MAX_VALUE;
+        for (const node of nodesWithTargets) {
+          const distance3 = Math.sqrt(
+            (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
+          );
+          if (distance3 < minDistance) {
+            minDistance = distance3;
+            closestNode = node;
+          }
+        }
+        nodesForConnection.push(closestNode);
+      }
+      if (nodesForConnection.length < 2) {
+        throw new Error(
+          `Not enough nodes for connection "${connection.name}", only ${nodesForConnection.length} found`
+        );
+      }
+      connectionNameToGoalNodeIds.set(
+        connection.name,
+        nodesForConnection.map((n) => n.capacityMeshNodeId)
+      );
+      connectionsWithNodes.push({
+        connection,
+        nodes: nodesForConnection,
+        pathFound: false
+      });
+    }
+    return { connectionsWithNodes, connectionNameToGoalNodeIds };
+  }
+  currentConnectionIndex = 0;
+  candidates;
+  visitedNodes;
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node);
+  }
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal);
+  }
+  getBacktrackedPath(candidate) {
+    const path = [];
+    let currentCandidate = candidate;
+    while (currentCandidate) {
+      path.push(currentCandidate.node);
+      currentCandidate = currentCandidate.prevCandidate;
+    }
+    return path;
+  }
+  getNeighboringNodes(node) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).flatMap(
+      (edge) => edge.nodeIds.filter((n) => n !== node.capacityMeshNodeId)
+    ).map((n) => this.nodeMap.get(n));
+  }
+  getCapacityPaths() {
+    const capacityPaths = [];
+    for (const connection of this.connectionsWithNodes) {
+      const path = connection.path;
+      if (path) {
+        capacityPaths.push({
+          capacityPathId: connection.connection.name,
+          connectionName: connection.connection.name,
+          nodeIds: path.map((node) => node.capacityMeshNodeId)
+        });
+      }
+    }
+    return capacityPaths;
+  }
+  doesNodeHaveCapacityForTrace(node) {
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const totalCapacity = this.getTotalCapacity(node);
+    if (node.availableZ.length === 1 && !node._containsTarget && usedCapacity > 0)
+      return false;
+    return usedCapacity < totalCapacity;
+  }
+  canTravelThroughObstacle(node, connectionName) {
+    const goalNodeIds = this.connectionNameToGoalNodeIds.get(connectionName);
+    return goalNodeIds?.includes(node.capacityMeshNodeId) ?? false;
+  }
+  getDistanceBetweenNodes(A, B) {
+    return Math.sqrt(
+      (A.center.x - B.center.x) ** 2 + (A.center.y - B.center.y) ** 2
+    );
+  }
+  reduceCapacityAlongPath(nextConnection) {
+    for (const node of nextConnection.path ?? []) {
+      this.usedNodeCapacityMap.set(
+        node.capacityMeshNodeId,
+        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) + 1
+      );
+    }
+  }
+  isConnectedToEndGoal(node, endGoal) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).some((edge) => edge.nodeIds.includes(endGoal.capacityMeshNodeId));
+  }
+  _step() {
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (!nextConnection) {
+      this.solved = true;
+      return;
+    }
+    const [start, end] = nextConnection.nodes;
+    if (!this.candidates) {
+      this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }];
+      this.debug_lastNodeCostMap = /* @__PURE__ */ new Map();
+      this.visitedNodes = /* @__PURE__ */ new Set([start.capacityMeshNodeId]);
+      this.activeCandidateStraightLineDistance = distance(
+        start.center,
+        end.center
+      );
+    }
+    this.candidates.sort((a, b) => a.f - b.f);
+    const currentCandidate = this.candidates.shift();
+    if (!currentCandidate) {
+      console.error(
+        `Ran out of candidates on connection ${nextConnection.connection.name}`
+      );
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
+      return;
+    }
+    if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
+      nextConnection.path = this.getBacktrackedPath({
+        prevCandidate: currentCandidate,
+        node: end,
+        f: 0,
+        g: 0,
+        h: 0
+      });
+      this.reduceCapacityAlongPath(nextConnection);
+      this.currentConnectionIndex++;
+      this.candidates = null;
+      this.visitedNodes = null;
+      return;
+    }
+    const neighborNodes = this.getNeighboringNodes(currentCandidate.node);
+    for (const neighborNode of neighborNodes) {
+      if (this.visitedNodes?.has(neighborNode.capacityMeshNodeId)) {
+        continue;
+      }
+      if (!this.doesNodeHaveCapacityForTrace(neighborNode)) {
+        continue;
+      }
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      if (neighborNode._containsObstacle && !this.canTravelThroughObstacle(neighborNode, connectionName)) {
+        continue;
+      }
+      const g = this.computeG(currentCandidate, neighborNode, end);
+      const h = this.computeH(currentCandidate, neighborNode, end);
+      const f = g + h * this.GREEDY_MULTIPLIER;
+      this.debug_lastNodeCostMap.set(neighborNode.capacityMeshNodeId, {
+        f,
+        g,
+        h
+      });
+      const newCandidate = {
+        prevCandidate: currentCandidate,
+        node: neighborNode,
+        f,
+        g,
+        h
+      };
+      this.candidates.push(newCandidate);
+    }
+    this.visitedNodes.add(currentCandidate.node.capacityMeshNodeId);
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    if (this.connectionsWithNodes) {
+      for (let i = 0; i < this.connectionsWithNodes.length; i++) {
+        const conn = this.connectionsWithNodes[i];
+        if (conn.path && conn.path.length > 0) {
+          const pathPoints = conn.path.map(({ center: { x, y }, width }) => ({
+            // slight offset to allow viewing overlapping paths
+            x: x + (i % 10 + i % 19) * (0.01 * width),
+            y: y + (i % 10 + i % 19) * (0.01 * width)
+          }));
+          graphics.lines.push({
+            points: pathPoints,
+            strokeColor: this.colorMap[conn.connection.name]
+          });
+        }
+      }
+    }
+    for (const node of this.nodes) {
+      const nodeCosts = this.debug_lastNodeCostMap.get(node.capacityMeshNodeId);
+      graphics.rects.push({
+        ...createRectFromCapacityNode(node),
+        label: [
+          `${node.capacityMeshNodeId}`,
+          `${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}`,
+          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+          `g: ${nodeCosts?.g !== void 0 ? nodeCosts.g.toFixed(2) : "?"}`,
+          `h: ${nodeCosts?.h !== void 0 ? nodeCosts.h.toFixed(2) : "?"}`,
+          `f: ${nodeCosts?.f !== void 0 ? nodeCosts.f.toFixed(2) : "?"}`
+        ].join("\n")
+      });
+    }
+    if (this.connectionsWithNodes) {
+      for (const conn of this.connectionsWithNodes) {
+        if (conn.connection?.pointsToConnect) {
+          for (const point of conn.connection.pointsToConnect) {
+            graphics.points.push({
+              x: point.x,
+              y: point.y
+            });
+          }
+        }
+      }
+    }
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (nextConnection) {
+      const [start, end] = nextConnection.connection.pointsToConnect;
+      graphics.lines.push({
+        points: [
+          { x: start.x, y: start.y },
+          { x: end.x, y: end.y }
+        ],
+        strokeColor: "red",
+        strokeDash: "10 5"
+      });
+    }
+    if (this.candidates) {
+      const topCandidates = this.candidates.slice(0, 5);
+      const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
+      topCandidates.forEach((candidate, index) => {
+        const opacity = 0.5 * (1 - index / 5);
+        const backtrackedPath = this.getBacktrackedPath(candidate);
+        graphics.lines.push({
+          points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
+          strokeColor: safeTransparentize(
+            this.colorMap[connectionName] ?? "red",
+            1 - opacity
+          )
+        });
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/CapacityPathingSolver/CapacityPathingSolver5.ts
+var CapacityPathingSolver5 = class extends CapacityPathingSolver {
+  NEGATIVE_CAPACITY_PENALTY_FACTOR = 1;
+  REDUCED_CAPACITY_PENALTY_FACTOR = 1;
+  constructor(...args) {
+    super(...args);
+    this.GREEDY_MULTIPLIER = 2.5;
+  }
+  get maxCapacityFactor() {
+    return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1;
+  }
+  getTotalCapacity(node) {
+    return getTunedTotalCapacity1(node, this.maxCapacityFactor);
+  }
+  /**
+   * Penalty you pay for using this node
+   */
+  getNodeCapacityPenalty(node) {
+    return 0.05;
+    if (node.availableZ.length === 1) {
+      return 0;
+    }
+    const totalCapacity = this.getTotalCapacity(node);
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const remainingCapacity = totalCapacity - usedCapacity;
+    const dist = this.activeCandidateStraightLineDistance;
+    if (remainingCapacity <= 0) {
+      const penalty = (-remainingCapacity + 1) / totalCapacity * dist * (this.NEGATIVE_CAPACITY_PENALTY_FACTOR / 4);
+      return penalty ** 2;
+    }
+    return 1 / remainingCapacity * dist * this.REDUCED_CAPACITY_PENALTY_FACTOR / 8;
+  }
+  /**
+   * We're rewarding travel into big nodes.
+   *
+   * To minimize shortest path, you'd want to comment this out.
+   */
+  getDistanceBetweenNodes(A, B) {
+    const dx = A.center.x - B.center.x;
+    const dy = A.center.y - B.center.y;
+    return Math.sqrt(dx ** 2 + dy ** 2);
+  }
+  computeG(prevCandidate, node, endGoal) {
+    return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
+  }
+  computeH(prevCandidate, node, endGoal) {
+    return this.getDistanceBetweenNodes(node, endGoal);
+  }
+};
+
+// lib/solvers/StrawSolver/StrawSolver.ts
+var StrawSolver = class extends BaseSolver {
+  multiLayerNodes;
+  strawNodes;
+  skippedNodes;
+  unprocessedNodes;
+  strawSize;
+  nodeIdCounter;
+  constructor(params) {
+    super();
+    this.strawSize = params.strawSize ?? 0.5;
+    this.multiLayerNodes = [];
+    this.strawNodes = [];
+    this.skippedNodes = [];
+    this.nodeIdCounter = 0;
+    this.unprocessedNodes = [];
+    for (const node of params.nodes) {
+      if (node.availableZ.length === 1) {
+        this.unprocessedNodes.push(node);
+      } else {
+        this.multiLayerNodes.push(node);
+      }
+    }
+  }
+  getCapacityOfMultiLayerNodesWithinBounds(bounds) {
+    let totalCapacity = 0;
+    for (const node of this.multiLayerNodes) {
+      const nodeMinX = node.center.x - node.width / 2;
+      const nodeMaxX = node.center.x + node.width / 2;
+      const nodeMinY = node.center.y - node.height / 2;
+      const nodeMaxY = node.center.y + node.height / 2;
+      const overlapMinX = Math.max(bounds.minX, nodeMinX);
+      const overlapMaxX = Math.min(bounds.maxX, nodeMaxX);
+      const overlapMinY = Math.max(bounds.minY, nodeMinY);
+      const overlapMaxY = Math.min(bounds.maxY, nodeMaxY);
+      if (overlapMinX < overlapMaxX && overlapMinY < overlapMaxY) {
+        const overlapWidth = overlapMaxX - overlapMinX;
+        const overlapHeight = overlapMaxY - overlapMinY;
+        const overlapArea = overlapWidth * overlapHeight;
+        const nodeArea = node.width * node.height;
+        const proportion = overlapArea / nodeArea;
+        totalCapacity += getTunedTotalCapacity1(node) * proportion;
+      }
+    }
+    return totalCapacity;
+  }
+  getSurroundingCapacities(node) {
+    const searchDistance = Math.min(node.width, node.height);
+    const leftSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2 - searchDistance,
+      maxX: node.center.x - node.width / 2,
+      minY: node.center.y - node.height / 2,
+      maxY: node.center.y + node.height / 2
+    });
+    const rightSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x + node.width / 2,
+      maxX: node.center.x + node.width / 2 + searchDistance,
+      minY: node.center.y - node.height / 2,
+      maxY: node.center.y + node.height / 2
+    });
+    const topSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2,
+      maxX: node.center.x + node.width / 2,
+      minY: node.center.y - node.height / 2 - searchDistance,
+      maxY: node.center.y - node.height / 2
+    });
+    const bottomSurroundingCapacity = this.getCapacityOfMultiLayerNodesWithinBounds({
+      minX: node.center.x - node.width / 2,
+      maxX: node.center.x + node.width / 2,
+      minY: node.center.y + node.height / 2,
+      maxY: node.center.y + node.height / 2 + searchDistance
+    });
+    return {
+      leftSurroundingCapacity,
+      rightSurroundingCapacity,
+      topSurroundingCapacity,
+      bottomSurroundingCapacity
+    };
+  }
+  /**
+   * Creates straw nodes from a single-layer node based on surrounding capacities
+   */
+  createStrawsForNode(node) {
+    const result = [];
+    const {
+      leftSurroundingCapacity,
+      rightSurroundingCapacity,
+      topSurroundingCapacity,
+      bottomSurroundingCapacity
+    } = this.getSurroundingCapacities(node);
+    const horizontalCapacity = leftSurroundingCapacity + rightSurroundingCapacity;
+    const verticalCapacity = topSurroundingCapacity + bottomSurroundingCapacity;
+    const layerPrefersFactor = 1;
+    const effectiveHorizontalCapacity = horizontalCapacity * layerPrefersFactor;
+    if (effectiveHorizontalCapacity > verticalCapacity) {
+      const numStraws = Math.floor(node.height / this.strawSize);
+      const strawHeight = node.height / numStraws;
+      for (let i = 0; i < numStraws; i++) {
+        const strawCenterY = node.center.y - node.height / 2 + i * strawHeight + strawHeight / 2;
+        result.push({
+          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
+          center: { x: node.center.x, y: strawCenterY },
+          width: node.width,
+          height: strawHeight,
+          layer: node.layer,
+          availableZ: [...node.availableZ],
+          _depth: node._depth,
+          _strawNode: true
+        });
+      }
+    } else {
+      const numStraws = Math.floor(node.width / this.strawSize);
+      const strawWidth = node.width / numStraws;
+      for (let i = 0; i < numStraws; i++) {
+        const strawCenterX = node.center.x - node.width / 2 + i * strawWidth + strawWidth / 2;
+        result.push({
+          capacityMeshNodeId: `${node.capacityMeshNodeId}_straw${i}`,
+          center: { x: strawCenterX, y: node.center.y },
+          width: strawWidth,
+          height: node.height,
+          layer: node.layer,
+          availableZ: [...node.availableZ],
+          _depth: node._depth,
+          _strawNode: true
+        });
       }
-      this.activeSolver = null;
     }
+    return result;
   }
-  visualize() {
-    if (this.activeSolver) {
-      return this.activeSolver.visualize();
+  getResultNodes() {
+    return [...this.multiLayerNodes, ...this.strawNodes, ...this.skippedNodes];
+  }
+  _step() {
+    const rootNode = this.unprocessedNodes.pop();
+    if (!rootNode) {
+      this.solved = true;
+      return;
+    }
+    if (rootNode.width < this.strawSize * 5 && rootNode.height < this.strawSize * 5) {
+      this.skippedNodes.push(rootNode);
+      return;
+    }
+    if (rootNode._containsTarget) {
+      this.skippedNodes.push(rootNode);
+      return;
     }
+    const strawNodes = this.createStrawsForNode(rootNode);
+    this.strawNodes.push(...strawNodes);
+  }
+  visualize() {
     const graphics = {
+      rects: [],
       lines: [],
       points: [],
-      rects: [],
       circles: [],
-      coordinateSystem: "cartesian",
-      title: "Unravel Multi Section Solver"
+      title: "Straw 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)`;
+    for (const node of this.unprocessedNodes) {
       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
+        width: node.width,
+        height: node.height,
+        fill: "rgba(200, 200, 200, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `${node.capacityMeshNodeId}
+Unprocessed
+${node.width}x${node.height}`
       });
     }
-    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"
+    for (const node of this.strawNodes) {
+      const color = node.availableZ[0] === 0 ? "rgba(0, 150, 255, 0.5)" : "rgba(255, 100, 0, 0.5)";
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        fill: color,
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `${node.capacityMeshNodeId}
+Layer: ${node.availableZ[0]}
+${node.width}x${node.height}`
       });
     }
-    const pointsBySegment = /* @__PURE__ */ new Map();
-    for (const point of this.segmentPointMap.values()) {
-      if (!pointsBySegment.has(point.segmentId)) {
-        pointsBySegment.set(point.segmentId, []);
+    for (const node of this.multiLayerNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width * 0.9,
+        height: node.height * 0.9,
+        fill: "rgba(100, 255, 100, 0.5)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: `${node.capacityMeshNodeId}
+Layers: ${node.availableZ.join(",")}
+${node.width}x${node.height}`
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
+var EPSILON = 5e-3;
+var SingleLayerNodeMergerSolver = class extends BaseSolver {
+  nodeMap;
+  currentBatchNodeIds;
+  absorbedNodeIds;
+  nextBatchNodeIds;
+  batchHadModifications;
+  newNodes;
+  constructor(nodes) {
+    super();
+    this.nodeMap = /* @__PURE__ */ new Map();
+    this.MAX_ITERATIONS = 1e5;
+    for (const node of nodes) {
+      this.nodeMap.set(node.capacityMeshNodeId, node);
+    }
+    this.newNodes = [];
+    this.absorbedNodeIds = /* @__PURE__ */ new Set();
+    const nodeWithArea = [];
+    for (const node of nodes) {
+      if (node.availableZ.length > 1) {
+        this.newNodes.push(node);
+        this.absorbedNodeIds.add(node.capacityMeshNodeId);
+      } else {
+        nodeWithArea.push([node.capacityMeshNodeId, node.width * node.height]);
       }
-      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"
+    nodeWithArea.sort((a, b) => a[1] - b[1]);
+    this.currentBatchNodeIds = nodeWithArea.map((n) => n[0]);
+    this.nextBatchNodeIds = [];
+    this.batchHadModifications = false;
+  }
+  getAdjacentSameLayerUnprocessedNodes(rootNode) {
+    const adjacentNodes = [];
+    for (const unprocessedNodeId of this.currentBatchNodeIds) {
+      if (this.absorbedNodeIds.has(unprocessedNodeId)) continue;
+      const unprocessedNode = this.nodeMap.get(unprocessedNodeId);
+      if (unprocessedNode.availableZ[0] !== rootNode.availableZ[0]) continue;
+      if (unprocessedNode._containsTarget && unprocessedNode._targetConnectionName !== rootNode._targetConnectionName)
+        continue;
+      if (!areNodesBordering(rootNode, unprocessedNode)) continue;
+      adjacentNodes.push(unprocessedNode);
+    }
+    return adjacentNodes;
+  }
+  _step() {
+    let rootNodeId = this.currentBatchNodeIds.pop();
+    while (rootNodeId && this.absorbedNodeIds.has(rootNodeId)) {
+      rootNodeId = this.currentBatchNodeIds.pop();
+    }
+    if (!rootNodeId) {
+      if (this.batchHadModifications) {
+        this.currentBatchNodeIds = this.nextBatchNodeIds.sort((a, b) => {
+          const A = this.nodeMap.get(a);
+          const B = this.nodeMap.get(b);
+          return A.width * A.height - B.width * B.height;
         });
+        this.nextBatchNodeIds = [];
+        this.batchHadModifications = false;
+        return;
       }
+      this.solved = true;
+      this.newNodes.push(
+        ...this.nextBatchNodeIds.map((id) => this.nodeMap.get(id))
+      );
+      return;
     }
-    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 rootNode = this.nodeMap.get(rootNodeId);
+    let rootNodeHasGrown = false;
+    const adjacentNodes = this.getAdjacentSameLayerUnprocessedNodes(rootNode);
+    if (adjacentNodes.length === 0) {
+      this.nextBatchNodeIds.push(rootNodeId);
+      return;
+    }
+    const adjacentNodesToLeft = adjacentNodes.filter(
+      (adjNode) => adjNode.center.x < rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
+    );
+    if (adjacentNodesToLeft.length > 0) {
+      const { width: leftAdjNodeWidth, height: leftAdjNodeHeight } = adjacentNodesToLeft[0];
+      const leftAdjNodesAreAllSameSize = adjacentNodesToLeft.every(
+        (adjNode) => adjNode.width === leftAdjNodeWidth && adjNode.height === leftAdjNodeHeight
+      );
+      const leftAdjNodesTakeUpEntireHeight = Math.abs(
+        adjacentNodesToLeft.reduce((acc, adjNode) => {
+          return acc + adjNode.height;
+        }, 0) - rootNode.height
+      ) < EPSILON;
+      if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
+        rootNode.width += leftAdjNodeWidth;
+        rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
+        for (const adjNode of adjacentNodesToLeft) {
+          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
         }
-        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"
-          });
+        rootNodeHasGrown = true;
+      }
+    }
+    const adjacentNodesToRight = adjacentNodes.filter(
+      (adjNode) => adjNode.center.x > rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
+    );
+    if (adjacentNodesToRight.length > 0 && !rootNodeHasGrown) {
+      const { width: rightAdjNodeWidth, height: rightAdjNodeHeight } = adjacentNodesToRight[0];
+      const rightAdjNodesAreAllSameSize = adjacentNodesToRight.every(
+        (adjNode) => adjNode.width === rightAdjNodeWidth && adjNode.height === rightAdjNodeHeight
+      );
+      const rightAdjNodesTakeUpEntireHeight = Math.abs(
+        adjacentNodesToRight.reduce((acc, adjNode) => {
+          return acc + adjNode.height;
+        }, 0) - rootNode.height
+      ) < EPSILON;
+      if (rightAdjNodesTakeUpEntireHeight && rightAdjNodesAreAllSameSize) {
+        rootNode.width += rightAdjNodeWidth;
+        rootNode.center.x = rootNode.center.x + rightAdjNodeWidth / 2;
+        for (const adjNode of adjacentNodesToRight) {
+          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
         }
+        rootNodeHasGrown = true;
       }
     }
-    return graphics;
-  }
-  getNodesWithPortPoints() {
-    if (!this.solved) {
-      throw new Error(
-        "CapacitySegmentToPointSolver not solved, can't give port points yet"
+    const adjacentNodesToTop = adjacentNodes.filter(
+      (adjNode) => adjNode.center.y > rootNode.center.y && Math.abs(adjNode.center.x - rootNode.center.x) < rootNode.width / 2
+    );
+    if (adjacentNodesToTop.length > 0 && !rootNodeHasGrown) {
+      const { width: topAdjNodeWidth, height: topAdjNodeHeight } = adjacentNodesToTop[0];
+      const topAdjNodesAreAllSameSize = adjacentNodesToTop.every(
+        (adjNode) => adjNode.width === topAdjNodeWidth && adjNode.height === topAdjNodeHeight
       );
+      const topAdjNodesTakeUpEntireWidth = Math.abs(
+        adjacentNodesToTop.reduce((acc, adjNode) => {
+          return acc + adjNode.width;
+        }, 0) - rootNode.width
+      ) < EPSILON;
+      if (topAdjNodesTakeUpEntireWidth && topAdjNodesAreAllSameSize) {
+        rootNode.height += topAdjNodeHeight;
+        rootNode.center.y = rootNode.center.y + topAdjNodeHeight / 2;
+        for (const adjNode of adjacentNodesToTop) {
+          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
+        }
+        rootNodeHasGrown = true;
+      }
     }
-    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
-          });
+    const adjacentNodesToBottom = adjacentNodes.filter(
+      (adjNode) => adjNode.center.y < rootNode.center.y && Math.abs(adjNode.center.x - rootNode.center.x) < rootNode.width / 2
+    );
+    if (adjacentNodesToBottom.length > 0 && !rootNodeHasGrown) {
+      const { width: bottomAdjNodeWidth, height: bottomAdjNodeHeight } = adjacentNodesToBottom[0];
+      const bottomAdjNodesAreAllSameSize = adjacentNodesToBottom.every(
+        (adjNode) => adjNode.width === bottomAdjNodeWidth && adjNode.height === bottomAdjNodeHeight
+      );
+      const bottomAdjNodesTakeUpEntireWidth = Math.abs(
+        adjacentNodesToBottom.reduce((acc, adjNode) => {
+          return acc + adjNode.width;
+        }, 0) - rootNode.width
+      ) < EPSILON;
+      if (bottomAdjNodesTakeUpEntireWidth && bottomAdjNodesAreAllSameSize) {
+        rootNode.height += bottomAdjNodeHeight;
+        rootNode.center.y = rootNode.center.y - bottomAdjNodeHeight / 2;
+        for (const adjNode of adjacentNodesToBottom) {
+          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
         }
+        rootNodeHasGrown = true;
       }
     }
-    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
-          });
+    if (rootNodeHasGrown) {
+      this.batchHadModifications = true;
+      this.currentBatchNodeIds.push(rootNodeId);
+    } else {
+      this.nextBatchNodeIds.unshift(rootNodeId);
+    }
+  }
+  visualize() {
+    const graphics = {
+      circles: [],
+      lines: [],
+      points: [],
+      rects: [],
+      coordinateSystem: "cartesian",
+      title: "Same Layer Node Merger"
+    };
+    for (const node of this.newNodes) {
+      graphics.rects.push(createRectFromCapacityNode(node));
+    }
+    const nextNodeIdInBatch = this.currentBatchNodeIds[this.currentBatchNodeIds.length - 1];
+    let adjacentNodes;
+    if (nextNodeIdInBatch) {
+      adjacentNodes = this.getAdjacentSameLayerUnprocessedNodes(
+        this.nodeMap.get(nextNodeIdInBatch)
+      );
+    }
+    for (const nodeId of this.currentBatchNodeIds) {
+      const node = this.nodeMap.get(nodeId);
+      if (this.absorbedNodeIds.has(nodeId)) continue;
+      if (node) {
+        const rect = createRectFromCapacityNode(node, {
+          rectMargin: 0.01
+        });
+        if (nodeId === nextNodeIdInBatch) {
+          rect.stroke = "rgba(0, 255, 0, 0.8)";
+        } else if (adjacentNodes?.some(
+          (adjNode) => adjNode.capacityMeshNodeId === nodeId
+        )) {
+          rect.stroke = "rgba(128, 0, 128, 0.8)";
+        } else {
+          rect.stroke = "rgba(255, 165, 0, 0.8)";
         }
+        rect.layer = `z${node.availableZ.join(",")}`;
+        rect.label = `${rect.label}
+(unprocessed)`;
+        graphics.rects.push(rect);
       }
     }
-    return Array.from(nodeWithPortPointsMap.values());
+    for (const nodeId of this.nextBatchNodeIds) {
+      const node = this.nodeMap.get(nodeId);
+      if (this.absorbedNodeIds.has(nodeId)) continue;
+      if (node) {
+        const rect = createRectFromCapacityNode(node, {
+          rectMargin: 0.01
+        });
+        rect.layer = `z${node.availableZ.join(",")}`;
+        rect.stroke = "rgba(0, 217, 255, 0.8)";
+        rect.label = `${rect.label}
+x: ${node.center.x}, y: ${node.center.y}
+${node.width}x${node.height}
+(next batch)`;
+        graphics.rects.push(rect);
+      }
+    }
+    return graphics;
   }
 };
 
@@ -5301,12 +5870,15 @@ var CapacityMeshSolver = class extends BaseSolver {
   segmentToPointOptimizer;
   highDensityRouteSolver;
   highDensityStitchSolver;
+  singleLayerNodeMerger;
+  strawSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
-  activeSolver = null;
+  activeSubSolver = null;
   connMap;
   srjWithPointPairs;
+  capacityNodes = null;
   pipelineDef = [
     definePipelineStep(
       "netToPointPairsSolver",
@@ -5322,39 +5894,65 @@ var CapacityMeshSolver = class extends BaseSolver {
         }
       }
     ),
-    definePipelineStep("nodeSolver", CapacityMeshNodeSolver, (cms) => [
-      cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
-      cms.opts
-    ]),
-    definePipelineStep("nodeTargetMerger", CapacityNodeTargetMerger, (cms) => [
-      cms.nodeSolver?.finishedNodes || [],
-      cms.srj.obstacles,
-      cms.connMap
-    ]),
-    definePipelineStep("edgeSolver", CapacityMeshEdgeSolver, (cms) => [
-      cms.nodeTargetMerger?.newNodes || []
-    ]),
+    // definePipelineStep("nodeSolver", CapacityMeshNodeSolver, (cms) => [
+    //   cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
+    //   cms.opts,
+    // ]),
     definePipelineStep(
-      "pathingSolver",
-      CapacityPathingSolver4_FlexibleNegativeCapacity,
+      "nodeSolver",
+      CapacityMeshNodeSolver2_NodeUnderObstacle,
       (cms) => [
-        {
-          simpleRouteJson: cms.srjWithPointPairs,
-          nodes: cms.nodeTargetMerger?.newNodes || [],
-          edges: cms.edgeSolver?.edges || [],
-          colorMap: cms.colorMap,
-          hyperParameters: {
-            MAX_CAPACITY_FACTOR: 1
-          }
-        }
+        cms.netToPointPairsSolver?.getNewSimpleRouteJson() || cms.srj,
+        cms.opts
       ]
     ),
+    // definePipelineStep("nodeTargetMerger", CapacityNodeTargetMerger, (cms) => [
+    //   cms.nodeSolver?.finishedNodes || [],
+    //   cms.srj.obstacles,
+    //   cms.connMap,
+    // ]),
+    // definePipelineStep("nodeTargetMerger", CapacityNodeTargetMerger2, (cms) => [
+    //   cms.nodeSolver?.finishedNodes || [],
+    //   cms.srj.obstacles,
+    //   cms.connMap,
+    //   cms.colorMap,
+    //   cms.srj.connections,
+    // ]),
+    definePipelineStep(
+      "singleLayerNodeMerger",
+      SingleLayerNodeMergerSolver,
+      (cms) => [cms.nodeSolver?.finishedNodes]
+    ),
+    definePipelineStep(
+      "strawSolver",
+      StrawSolver,
+      (cms) => [{ nodes: cms.singleLayerNodeMerger?.newNodes }],
+      {
+        onSolved: (cms) => {
+          cms.capacityNodes = cms.strawSolver?.getResultNodes();
+        }
+      }
+    ),
+    definePipelineStep("edgeSolver", CapacityMeshEdgeSolver, (cms) => [
+      cms.capacityNodes
+    ]),
+    definePipelineStep("pathingSolver", CapacityPathingSolver5, (cms) => [
+      {
+        simpleRouteJson: cms.srjWithPointPairs,
+        nodes: cms.capacityNodes,
+        edges: cms.edgeSolver?.edges || [],
+        colorMap: cms.colorMap,
+        hyperParameters: {
+          MAX_CAPACITY_FACTOR: 1
+        }
+      }
+    ]),
     definePipelineStep(
       "edgeToPortSegmentSolver",
       CapacityEdgeToPortSegmentSolver,
       (cms) => [
         {
-          nodes: cms.nodeTargetMerger?.newNodes || [],
+          nodes: cms.capacityNodes,
           edges: cms.edgeSolver?.edges || [],
           capacityPaths: cms.pathingSolver?.getCapacityPaths() || [],
           colorMap: cms.colorMap
@@ -5375,7 +5973,7 @@ var CapacityMeshSolver = class extends BaseSolver {
           {
             segments: allSegments,
             colorMap: cms.colorMap,
-            nodes: cms.nodeTargetMerger?.newNodes || []
+            nodes: cms.capacityNodes
           }
         ];
       }
@@ -5398,7 +5996,7 @@ var CapacityMeshSolver = class extends BaseSolver {
         {
           assignedSegments: cms.segmentToPointSolver?.solvedSegments || [],
           colorMap: cms.colorMap,
-          nodes: cms.nodeTargetMerger?.newNodes || []
+          nodes: cms.capacityNodes
         }
       ]
     ),
@@ -5428,26 +6026,24 @@ var CapacityMeshSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    if (this.activeSolver) {
-      this.activeSolver.step();
-      if (this.activeSolver.solved) {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
         this.endTimeOfPhase[pipelineStepDef.solverName] = performance.now();
         this.timeSpentOnPhase[pipelineStepDef.solverName] = this.endTimeOfPhase[pipelineStepDef.solverName] - this.startTimeOfPhase[pipelineStepDef.solverName];
         pipelineStepDef.onSolved?.(this);
-        this.activeSolver = null;
+        this.activeSubSolver = null;
         this.currentPipelineStepIndex++;
-      } else if (this.activeSolver.failed) {
-        this.error = this.activeSolver?.error;
+      } else if (this.activeSubSolver.failed) {
+        this.error = this.activeSubSolver?.error;
         this.failed = true;
-        this.activeSolver = null;
+        this.activeSubSolver = null;
       }
       return;
     }
     const constructorParams = pipelineStepDef.getConstructorParams(this);
-    this.activeSolver = new pipelineStepDef.solverClass(
-      ...constructorParams
-    );
-    this[pipelineStepDef.solverName] = this.activeSolver;
+    this.activeSubSolver = new pipelineStepDef.solverClass(...constructorParams);
+    this[pipelineStepDef.solverName] = this.activeSubSolver;
     this.timeSpentOnPhase[pipelineStepDef.solverName] = 0;
     this.startTimeOfPhase[pipelineStepDef.solverName] = performance.now();
   }
@@ -5455,9 +6051,13 @@ var CapacityMeshSolver = class extends BaseSolver {
     return this.pipelineDef[this.currentPipelineStepIndex]?.solverName ?? "none";
   }
   visualize() {
-    if (!this.solved && this.activeSolver) return this.activeSolver.visualize();
+    if (!this.solved && this.activeSubSolver)
+      return this.activeSubSolver.visualize();
     const netToPPSolver = this.netToPointPairsSolver?.visualize();
     const nodeViz = this.nodeSolver?.visualize();
+    const nodeTargetMergerViz = this.nodeTargetMerger?.visualize();
+    const singleLayerNodeMergerViz = this.singleLayerNodeMerger?.visualize();
+    const strawSolverViz = this.strawSolver?.visualize();
     const edgeViz = this.edgeSolver?.visualize();
     const pathingViz = this.pathingSolver?.visualize();
     const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
@@ -5470,14 +6070,37 @@ var CapacityMeshSolver = class extends BaseSolver {
       rects: [
         ...(this.srj.obstacles ?? []).map((o) => ({
           ...o,
-          fill: "rgba(255,0,0,0.25)"
+          fill: o.layers?.includes("top") ? "rgba(255,0,0,0.25)" : o.layers?.includes("bottom") ? "rgba(0,0,255,0.25)" : "rgba(255,0,0,0.25)"
         }))
+      ],
+      lines: [
+        {
+          points: [
+            // Add five points representing the bounds of the PCB
+            {
+              x: this.srj.bounds?.minX ?? -50,
+              y: this.srj.bounds?.minY ?? -50
+            },
+            { x: this.srj.bounds?.maxX ?? 50, y: this.srj.bounds?.minY ?? -50 },
+            { x: this.srj.bounds?.maxX ?? 50, y: this.srj.bounds?.maxY ?? 50 },
+            { x: this.srj.bounds?.minX ?? -50, y: this.srj.bounds?.maxY ?? 50 },
+            {
+              x: this.srj.bounds?.minX ?? -50,
+              y: this.srj.bounds?.minY ?? -50
+            }
+            // Close the rectangle
+          ],
+          strokeColor: "rgba(255,0,0,0.25)"
+        }
       ]
     };
     const visualizations = [
       problemViz,
       netToPPSolver,
       nodeViz,
+      nodeTargetMergerViz,
+      singleLayerNodeMergerViz,
+      strawSolverViz,
       edgeViz,
       pathingViz,
       edgeToPortSegmentViz,