@tscircuit/schematic-trace-solver 0.0.97 → 0.0.99

package/dist/index.js

@@ -76,80 +76,39 @@ var BaseSolver = class {
 };
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
-import "connectivity-map";
+import { distance } from "@tscircuit/math-utils";
 
-// lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem.ts
-import { ConnectivityMap } from "connectivity-map";
-var getConnectivityMapsFromInputProblem = (inputProblem) => {
-  const directConnMap = new ConnectivityMap({});
-  for (const directConn of inputProblem.directConnections) {
-    directConnMap.addConnections([
-      directConn.netId ? [directConn.netId, ...directConn.pinIds] : directConn.pinIds
-    ]);
-  }
-  const netConnMap = new ConnectivityMap(directConnMap.netMap);
-  for (const netConn of inputProblem.netConnections) {
-    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]]);
-  }
-  return { directConnMap, netConnMap };
+// lib/utils/getColorFromString.ts
+var getColorFromString = (string, alpha = 1) => {
+  const hash = string.split("").reduce((acc, char) => {
+    return acc * 31 + char.charCodeAt(0);
+  }, 0);
+  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
 };
 
-// lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
-function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
-  const n = pins.length;
-  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY;
-  if (n <= 1) return [];
-  {
-    const seen = /* @__PURE__ */ new Set();
-    for (const p of pins) {
-      if (seen.has(p.pinId)) {
-        throw new Error(`Duplicate pinId detected: "${p.pinId}"`);
-      }
-      seen.add(p.pinId);
-    }
-  }
-  const manhattan = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-  const inTree = new Array(n).fill(false);
-  const bestDist = new Array(n).fill(Number.POSITIVE_INFINITY);
-  const parent = new Array(n).fill(-1);
-  let startIndex = 0;
-  for (let i = 1; i < n; i++) {
-    if (pins[i].pinId < pins[startIndex].pinId) startIndex = i;
+// lib/utils/arePinsInDifferentSchematicSections.ts
+var getSectionNameForPin = (sectionByChipId, sectionByPinId, pin) => {
+  if (pin.chipId) {
+    const chipSection = sectionByChipId.get(pin.chipId);
+    if (chipSection) return chipSection;
   }
-  bestDist[startIndex] = 0;
-  const edges = [];
-  for (let iter = 0; iter < n; iter++) {
-    let u = -1;
-    let best = Number.POSITIVE_INFINITY;
-    let bestId = "";
-    for (let i = 0; i < n; i++) {
-      if (!inTree[i]) {
-        const d = bestDist[i];
-        if (d < best || d === best && (bestId === "" || pins[i].pinId < bestId)) {
-          best = d;
-          bestId = pins[i].pinId;
-          u = i;
-        }
-      }
-    }
-    inTree[u] = true;
-    if (parent[u] !== -1) {
-      edges.push([pins[u].pinId, pins[parent[u]].pinId]);
-    }
-    for (let v = 0; v < n; v++) {
-      if (!inTree[v]) {
-        const d0 = manhattan(pins[u], pins[v]);
-        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false;
-        const d = d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0;
-        if (d < bestDist[v] || d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId) {
-          bestDist[v] = d;
-          parent[v] = u;
-        }
-      }
+  return sectionByPinId.get(pin.pinId);
+};
+var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
+  const sectionByChipId = /* @__PURE__ */ new Map();
+  const sectionByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    if (!chip.sectionId) continue;
+    sectionByChipId.set(chip.chipId, chip.sectionId);
+    for (const pin of chip.pins) {
+      sectionByPinId.set(pin.pinId, chip.sectionId);
     }
   }
-  return edges;
-}
+  if (sectionByChipId.size === 0) return false;
+  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1);
+  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2);
+  return s1 !== s2;
+};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
 var getPinDirection = (pin, chip) => {
@@ -181,6 +140,101 @@ var getPinDirection = (pin, chip) => {
   return "x-";
 };
 
+// lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
+var visualizeInputProblem = (inputProblem, opts = {}) => {
+  const {
+    connectionAlpha = 0.8,
+    chipAlpha = 0.8,
+    hideRatsNet = inputProblem._hideRatsNet ?? false
+  } = opts;
+  const graphics = {
+    lines: [],
+    points: [],
+    rects: []
+  };
+  const pinIdMap = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinIdMap.set(pin.pinId, pin);
+    }
+  }
+  for (const chip of inputProblem.chips) {
+    graphics.rects.push({
+      label: chip.chipId,
+      center: chip.center,
+      width: chip.width,
+      height: chip.height,
+      fill: getColorFromString(chip.chipId, chipAlpha)
+    });
+    for (const pin of chip.pins) {
+      graphics.points.push({
+        label: `${pin.pinId}
+${pin._facingDirection ?? getPinDirection(pin, chip)}`,
+        x: pin.x,
+        y: pin.y,
+        color: getColorFromString(pin.pinId, 0.8)
+      });
+    }
+  }
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    graphics.rects.push({
+      label: textBox.text ?? "schematic_text",
+      center: textBox.center,
+      width: textBox.width,
+      height: textBox.height,
+      fill: "rgba(160, 0, 220, 0.14)",
+      strokeColor: "rgba(160, 0, 220, 0.9)"
+    });
+  }
+  if (!hideRatsNet) {
+    for (const directConn of inputProblem.directConnections) {
+      const [pinId1, pinId2] = directConn.pinIds;
+      const pin1 = pinIdMap.get(pinId1);
+      const pin2 = pinIdMap.get(pinId2);
+      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+        continue;
+      }
+      graphics.lines.push({
+        points: [
+          {
+            x: pin1.x,
+            y: pin1.y
+          },
+          {
+            x: pin2.x,
+            y: pin2.y
+          }
+        ],
+        strokeColor: getColorFromString(
+          directConn.netId ?? `${pinId1}-${pinId2}`,
+          connectionAlpha
+        )
+      });
+    }
+    for (const netConn of inputProblem.netConnections) {
+      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
+      for (let i = 0; i < pins.length - 1; i++) {
+        for (let j = i + 1; j < pins.length; j++) {
+          const pin1 = pins[i];
+          const pin2 = pins[j];
+          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+            continue;
+          }
+          graphics.lines.push({
+            points: [
+              { x: pin1.x, y: pin1.y },
+              { x: pin2.x, y: pin2.y }
+            ],
+            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+            strokeDash: "4 2"
+          });
+        }
+      }
+    }
+  }
+  return graphics;
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines.ts
 var getRestrictedCenterLines = (params) => {
   const { pins, inputProblem, pinIdMap, chipMap } = params;
@@ -293,134 +347,81 @@ var doesPairCrossRestrictedCenterLines = (params) => {
   return hvCrosses && vhCrosses;
 };
 
-// lib/utils/getColorFromString.ts
-var getColorFromString = (string, alpha = 1) => {
-  const hash = string.split("").reduce((acc, char) => {
-    return acc * 31 + char.charCodeAt(0);
-  }, 0);
-  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
-};
-
-// lib/utils/arePinsInDifferentSchematicSections.ts
-var getSectionNameForPin = (sectionByChipId, sectionByPinId, pin) => {
-  if (pin.chipId) {
-    const chipSection = sectionByChipId.get(pin.chipId);
-    if (chipSection) return chipSection;
+// lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem.ts
+import { ConnectivityMap } from "connectivity-map";
+var getConnectivityMapsFromInputProblem = (inputProblem) => {
+  const directConnMap = new ConnectivityMap({});
+  for (const directConn of inputProblem.directConnections) {
+    directConnMap.addConnections([
+      directConn.netId ? [directConn.netId, ...directConn.pinIds] : directConn.pinIds
+    ]);
   }
-  return sectionByPinId.get(pin.pinId);
-};
-var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
-  const sectionByChipId = /* @__PURE__ */ new Map();
-  const sectionByPinId = /* @__PURE__ */ new Map();
-  for (const chip of inputProblem.chips) {
-    if (!chip.sectionId) continue;
-    sectionByChipId.set(chip.chipId, chip.sectionId);
-    for (const pin of chip.pins) {
-      sectionByPinId.set(pin.pinId, chip.sectionId);
-    }
+  const netConnMap = new ConnectivityMap(directConnMap.netMap);
+  for (const netConn of inputProblem.netConnections) {
+    netConnMap.addConnections([[netConn.netId, ...netConn.pinIds]]);
   }
-  if (sectionByChipId.size === 0) return false;
-  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1);
-  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2);
-  return s1 !== s2;
+  return { directConnMap, netConnMap };
 };
 
-// lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
-var visualizeInputProblem = (inputProblem, opts = {}) => {
-  const {
-    connectionAlpha = 0.8,
-    chipAlpha = 0.8,
-    hideRatsNet = inputProblem._hideRatsNet ?? false
-  } = opts;
-  const graphics = {
-    lines: [],
-    points: [],
-    rects: []
-  };
-  const pinIdMap = /* @__PURE__ */ new Map();
-  for (const chip of inputProblem.chips) {
-    for (const pin of chip.pins) {
-      pinIdMap.set(pin.pinId, pin);
-    }
-  }
-  for (const chip of inputProblem.chips) {
-    graphics.rects.push({
-      label: chip.chipId,
-      center: chip.center,
-      width: chip.width,
-      height: chip.height,
-      fill: getColorFromString(chip.chipId, chipAlpha)
-    });
-    for (const pin of chip.pins) {
-      graphics.points.push({
-        label: `${pin.pinId}
-${pin._facingDirection ?? getPinDirection(pin, chip)}`,
-        x: pin.x,
-        y: pin.y,
-        color: getColorFromString(pin.pinId, 0.8)
-      });
+// lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
+function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
+  const n = pins.length;
+  const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY;
+  if (n <= 1) return [];
+  {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of pins) {
+      if (seen.has(p.pinId)) {
+        throw new Error(`Duplicate pinId detected: "${p.pinId}"`);
+      }
+      seen.add(p.pinId);
     }
   }
-  for (const textBox of inputProblem.textBoxes ?? []) {
-    graphics.rects.push({
-      label: textBox.text ?? "schematic_text",
-      center: textBox.center,
-      width: textBox.width,
-      height: textBox.height,
-      fill: "rgba(160, 0, 220, 0.14)",
-      strokeColor: "rgba(160, 0, 220, 0.9)"
-    });
+  const manhattan = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+  const inTree = new Array(n).fill(false);
+  const bestDist = new Array(n).fill(Number.POSITIVE_INFINITY);
+  const parent = new Array(n).fill(-1);
+  let startIndex = 0;
+  for (let i = 1; i < n; i++) {
+    if (pins[i].pinId < pins[startIndex].pinId) startIndex = i;
   }
-  if (!hideRatsNet) {
-    for (const directConn of inputProblem.directConnections) {
-      const [pinId1, pinId2] = directConn.pinIds;
-      const pin1 = pinIdMap.get(pinId1);
-      const pin2 = pinIdMap.get(pinId2);
-      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-        continue;
+  bestDist[startIndex] = 0;
+  const edges = [];
+  for (let iter = 0; iter < n; iter++) {
+    let u = -1;
+    let best = Number.POSITIVE_INFINITY;
+    let bestId = "";
+    for (let i = 0; i < n; i++) {
+      if (!inTree[i]) {
+        const d = bestDist[i];
+        if (d < best || d === best && (bestId === "" || pins[i].pinId < bestId)) {
+          best = d;
+          bestId = pins[i].pinId;
+          u = i;
+        }
       }
-      graphics.lines.push({
-        points: [
-          {
-            x: pin1.x,
-            y: pin1.y
-          },
-          {
-            x: pin2.x,
-            y: pin2.y
-          }
-        ],
-        strokeColor: getColorFromString(
-          directConn.netId ?? `${pinId1}-${pinId2}`,
-          connectionAlpha
-        )
-      });
     }
-    for (const netConn of inputProblem.netConnections) {
-      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
-      for (let i = 0; i < pins.length - 1; i++) {
-        for (let j = i + 1; j < pins.length; j++) {
-          const pin1 = pins[i];
-          const pin2 = pins[j];
-          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-            continue;
-          }
-          graphics.lines.push({
-            points: [
-              { x: pin1.x, y: pin1.y },
-              { x: pin2.x, y: pin2.y }
-            ],
-            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
-            strokeDash: "4 2"
-          });
+    inTree[u] = true;
+    if (parent[u] !== -1) {
+      edges.push([pins[u].pinId, pins[parent[u]].pinId]);
+    }
+    for (let v = 0; v < n; v++) {
+      if (!inTree[v]) {
+        const d0 = manhattan(pins[u], pins[v]);
+        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false;
+        const d = d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0;
+        if (d < bestDist[v] || d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId) {
+          bestDist[v] = d;
+          parent[v] = u;
         }
       }
     }
   }
-  return graphics;
-};
+  return edges;
+}
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
+var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
 var MspConnectionPairSolver = class extends BaseSolver {
   inputProblem;
   mspConnectionPairs = [];
@@ -431,6 +432,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
   maxMspPairDistance;
   pinMap;
   userNetIdByPinId;
+  directConnectionPinPairKeys;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
@@ -449,7 +451,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       this.chipMap[chip.chipId] = chip;
     }
     this.userNetIdByPinId = {};
+    this.directConnectionPinPairKeys = /* @__PURE__ */ new Set();
     for (const dc of inputProblem.directConnections) {
+      this.directConnectionPinPairKeys.add(getPinPairKey(dc.pinIds));
       if (dc.netId) {
         const [a, b] = dc.pinIds;
         this.userNetIdByPinId[a] = dc.netId;
@@ -483,8 +487,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins;
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
-      const manhattanDist = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
-      if (manhattanDist > this.maxMspPairDistance) {
+      const pinPairKey = getPinPairKey([pin1, pin2]);
+      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey) ? distance(p1, p2) : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+      if (pairDistance > this.maxMspPairDistance) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -856,8 +861,70 @@ var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, eps = EPS2) =
     if (topNeighbor !== void 0) {
       out.push((colliding.maxY + topNeighbor) / 2);
     }
-    return out;
+    return out;
+  }
+};
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts
+var getSegmentAxis = (start, end) => {
+  if (isVertical(start, end)) return "x";
+  if (isHorizontal(start, end)) return "y";
+  return null;
+};
+var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
+  const nextPoint = path[index + 1];
+  if (!nextPoint) return true;
+  if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+    return false;
+  }
+  return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0;
+});
+var generateEndpointCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle
+}) => {
+  if (path.length !== 3) return [];
+  const lastSegmentIndex = path.length - 2;
+  if (collidingSegmentIndex !== 0 && collidingSegmentIndex !== lastSegmentIndex) {
+    return [];
+  }
+  const shouldReverse = collidingSegmentIndex === lastSegmentIndex;
+  const orderedPath = shouldReverse ? [...path].reverse() : path;
+  const [start, corner, end] = orderedPath;
+  const firstSegmentAxis = getSegmentAxis(start, corner);
+  const secondSegmentAxis = getSegmentAxis(corner, end);
+  if (!firstSegmentAxis || !secondSegmentAxis) return [];
+  if (firstSegmentAxis === secondSegmentAxis) return [];
+  const escapeCoordinates = [
+    ...midBetweenPointAndRect(secondSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(secondSegmentAxis, end, obstacle)
+  ];
+  const detourCoordinates = [
+    ...midBetweenPointAndRect(firstSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(firstSegmentAxis, end, obstacle)
+  ];
+  const detours = [];
+  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
+    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
+      const orderedDetour = firstSegmentAxis === "y" ? [
+        start,
+        { x: escapeCoordinate, y: start.y },
+        { x: escapeCoordinate, y: detourCoordinate },
+        { x: end.x, y: detourCoordinate },
+        end
+      ] : [
+        start,
+        { x: start.x, y: escapeCoordinate },
+        { x: detourCoordinate, y: escapeCoordinate },
+        { x: detourCoordinate, y: end.y },
+        end
+      ];
+      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour;
+      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour);
+    }
   }
+  return detours;
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
@@ -1210,6 +1277,29 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
     const isLastSegment = segIndex === path.length - 2;
+    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+      const detours = generateEndpointCollisionDetours({
+        path,
+        collidingSegmentIndex: segIndex,
+        obstacle: rect
+      }).filter((detour) => {
+        const key = pathKey(detour);
+        if (this.visited.has(key)) return false;
+        this.visited.add(key);
+        return true;
+      }).sort(
+        (a2, b2) => this.pathLength(a2) - this.pathLength(b2) || this.getPinBandPenalty(a2) - this.getPinBandPenalty(b2)
+      );
+      for (const detour of detours) {
+        const nextCollisionRects = new Set(collisionRects);
+        nextCollisionRects.add(rect);
+        this.queue.push({
+          path: detour,
+          collisionRects: nextCollisionRects
+        });
+      }
+      return;
+    }
     if (isFirstSegment) {
       if (path.length < 3) {
         return;
@@ -1440,12 +1530,12 @@ var applyJogToTerminalSegment = ({
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical4 = Math.abs(start.x - end.x) < EPS11;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS11;
-  if (!isVertical4 && !isHorizontal3) return;
-  const segDir = isVertical4 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS11;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS11;
+  if (!isVertical5 && !isHorizontal4) return;
+  const segDir = isVertical5 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
-    if (isVertical4) {
+    if (isVertical5) {
       const jogYNearStart = start.y + segDir * JOG_SIZE;
       const jogYNearEnd = end.y - segDir * JOG_SIZE;
       pts.splice(
@@ -1471,7 +1561,7 @@ var applyJogToTerminalSegment = ({
     return;
   }
   if (si === 0) {
-    if (isVertical4) {
+    if (isVertical5) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1491,7 +1581,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical4) {
+    if (isVertical5) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1587,10 +1677,10 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical4 = Math.abs(start.x - end.x) < EPS4;
-            const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-            if (!isVertical4 && !isHorizontal3) continue;
-            if (isVertical4) {
+            const isVertical5 = Math.abs(start.x - end.x) < EPS4;
+            const isHorizontal4 = Math.abs(start.y - end.y) < EPS4;
+            if (!isVertical5 && !isHorizontal4) continue;
+            if (isVertical5) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -1619,11 +1709,11 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   }) {
     const blockingCollisions = this.getBlockingCollisions({ group, offset });
     if (blockingCollisions.length === 0) return offset;
-    const crossesThroughObstacle = (candidateOffset) => blockingCollisions.some(({ start, isVertical: isVertical4, obstacle }) => {
+    const crossesThroughObstacle = (candidateOffset) => blockingCollisions.some(({ start, isVertical: isVertical5, obstacle }) => {
       let orig;
       let min;
       let max;
-      if (isVertical4) {
+      if (isVertical5) {
         orig = start.x;
         min = obstacle.minX;
         max = obstacle.maxX;
@@ -1635,8 +1725,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const next = orig + candidateOffset;
       return orig <= min + EPS4 && next >= max - EPS4 || orig >= max - EPS4 && next <= min + EPS4;
     });
-    const edges = blockingCollisions.map(({ start, isVertical: isVertical4, obstacle }) => {
-      if (isVertical4) {
+    const edges = blockingCollisions.map(({ start, isVertical: isVertical5, obstacle }) => {
+      if (isVertical5) {
         return {
           coord: start.x,
           lowEdge: obstacle.minX,
@@ -1670,10 +1760,10 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const start = trace.tracePath[traceSegmentIndex];
       const end = trace.tracePath[traceSegmentIndex + 1];
       if (!start || !end) continue;
-      const isVertical4 = Math.abs(start.x - end.x) < EPS4;
-      const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-      if (!isVertical4 && !isHorizontal3) continue;
-      const shiftedSegment = isVertical4 ? [
+      const isVertical5 = Math.abs(start.x - end.x) < EPS4;
+      const isHorizontal4 = Math.abs(start.y - end.y) < EPS4;
+      if (!isVertical5 && !isHorizontal4) continue;
+      const shiftedSegment = isVertical5 ? [
         { ...start, x: start.x + offset },
         { ...end, x: end.x + offset }
       ] : [
@@ -1684,7 +1774,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       if (collision) {
         blockingCollisions.push({
           start,
-          isVertical: isVertical4,
+          isVertical: isVertical5,
           obstacle: collision.rect
         });
       }
@@ -1867,9 +1957,9 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS11;
-        const isVertical4 = Math.abs(p1.x - p2.x) < EPS11;
-        if (!isHorizontal3 && !isVertical4) {
+        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS11;
+        const isVertical5 = Math.abs(p1.x - p2.x) < EPS11;
+        if (!isHorizontal4 && !isVertical5) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
       }
@@ -2961,7 +3051,7 @@ var mergeLabelGroup = (group, groupKey) => {
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/filterLabelsAtTraceEdges.ts
-import { distance } from "@tscircuit/math-utils";
+import { distance as distance2 } from "@tscircuit/math-utils";
 var filterLabelsAtTraceEdges = ({
   labels,
   traces,
@@ -2994,8 +3084,8 @@ var filterLabelsAtTraceEdges = ({
       if (trace.tracePath.length === 0) continue;
       const startPoint = trace.tracePath[0];
       const endPoint = trace.tracePath[trace.tracePath.length - 1];
-      const startDist = distance(label.center, startPoint);
-      const endDist = distance(label.center, endPoint);
+      const startDist = distance2(label.center, startPoint);
+      const endDist = distance2(label.center, endPoint);
       if (startDist <= distanceThreshold || endDist <= distanceThreshold) {
         isNearTraceEdge = true;
         break;
@@ -3478,19 +3568,18 @@ var generateRerouteCandidates = ({
   return [...fourPointCandidates, ...snipReconnectCandidates];
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
-var MAX_TRIES = 5;
+// lib/utils/doesPathCoincideWithTraces.ts
 var COINCIDENT_EPS = 2e-3;
 var doesPathCoincideWithTraces = (path, traces) => {
   const rangesOverlap1D = (a1, a2, b1, b2) => Math.min(Math.max(a1, a2), Math.max(b1, b2)) - Math.max(Math.min(a1, a2), Math.min(b1, b2)) > COINCIDENT_EPS;
   for (let i = 0; i < path.length - 1; i++) {
     const pathSegStart = path[i];
     const pathSegEnd = path[i + 1];
-    const isVertical4 = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS;
-    const isHorizontal3 = Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS;
-    if (!isVertical4 && !isHorizontal3) continue;
-    const crossAxis = isVertical4 ? "x" : "y";
-    const alongAxis = isVertical4 ? "y" : "x";
+    const isVertical5 = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS;
+    const isHorizontal4 = Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS;
+    if (!isVertical5 && !isHorizontal4) continue;
+    const crossAxis = isVertical5 ? "x" : "y";
+    const alongAxis = isVertical5 ? "y" : "x";
     for (const trace of traces) {
       for (let j = 0; j < trace.tracePath.length - 1; j++) {
         const traceSegStart = trace.tracePath[j];
@@ -3512,6 +3601,9 @@ var doesPathCoincideWithTraces = (path, traces) => {
   }
   return false;
 };
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
+var MAX_TRIES = 5;
 var SingleOverlapSolver = class extends BaseSolver {
   queuedCandidatePaths;
   solvedTracePath = null;
@@ -4075,7 +4167,7 @@ function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
 
 // lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
 var NEAREST_NEIGHBOR_COUNT = 3;
-var distance2 = (p1, p2) => {
+var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 var LongDistancePairSolver = class extends BaseSolver {
@@ -4116,7 +4208,7 @@ var LongDistancePairSolver = class extends BaseSolver {
           return [
             {
               pin: targetPin,
-              distance: distance2(sourcePin, targetPin)
+              distance: distance3(sourcePin, targetPin)
             }
           ];
         }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
@@ -4668,26 +4760,610 @@ var balanceZShapes = ({
     if (Math.abs(len1Original - len2Original) < 1e-3) {
       continue;
     }
-    if (isHVHZShape) {
-      const idealX = (p1.x + p4.x) / 2;
-      p2New = { x: idealX, y: p2.y };
-      p3New = { x: idealX, y: p3.y };
-    } else {
-      const idealY = (p1.y + p4.y) / 2;
-      p2New = { x: p2.x, y: idealY };
-      p3New = { x: p3.x, y: idealY };
-    }
-    const collides = segmentIntersectsAnyRect(p1, p2New, combinedObstacles) || segmentIntersectsAnyRect(p2New, p3New, combinedObstacles) || segmentIntersectsAnyRect(p3New, p4, combinedObstacles) || segmentIntersectsAnyRect(p1, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3New, labelBounds) || segmentIntersectsAnyRect(p3New, p4, labelBounds);
-    if (!collides) {
-      newPath[i + 1] = p2New;
-      newPath[i + 2] = p3New;
-      i = 0;
+    if (isHVHZShape) {
+      const idealX = (p1.x + p4.x) / 2;
+      p2New = { x: idealX, y: p2.y };
+      p3New = { x: idealX, y: p3.y };
+    } else {
+      const idealY = (p1.y + p4.y) / 2;
+      p2New = { x: p2.x, y: idealY };
+      p3New = { x: p3.x, y: idealY };
+    }
+    const collides = segmentIntersectsAnyRect(p1, p2New, combinedObstacles) || segmentIntersectsAnyRect(p2New, p3New, combinedObstacles) || segmentIntersectsAnyRect(p3New, p4, combinedObstacles) || segmentIntersectsAnyRect(p1, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3New, labelBounds) || segmentIntersectsAnyRect(p3New, p4, labelBounds);
+    if (!collides) {
+      newPath[i + 1] = p2New;
+      newPath[i + 2] = p3New;
+      i = 0;
+    }
+  }
+  const finalSimplifiedPath = simplifyPath(newPath);
+  return {
+    ...targetTrace,
+    tracePath: finalSimplifiedPath
+  };
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts
+var RAIL_ALIGNMENT_EPSILON = 2e-3;
+var nearlyEqual = (a, b) => Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON;
+var isHorizontal2 = (a, b) => nearlyEqual(a.y, b.y);
+var isVertical2 = (a, b) => nearlyEqual(a.x, b.x);
+var isPositiveLength = (a, b) => Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON || Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON;
+var getRailOrientation = (a, b) => {
+  if (!isPositiveLength(a, b)) return null;
+  if (isVertical2(a, b)) return "vertical";
+  if (isHorizontal2(a, b)) return "horizontal";
+  return null;
+};
+var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
+var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
+var getDistinctCoordinates = (coordinates) => {
+  const distinct = [];
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate);
+    }
+  }
+  return distinct;
+};
+var getMergedIntervalLength = (intervals) => {
+  const groups = [];
+  for (const interval of intervals) {
+    const group = groups.find(
+      (items) => nearlyEqual(items[0].coordinate, interval.coordinate)
+    );
+    if (group) group.push(interval);
+    else groups.push([interval]);
+  }
+  return groups.reduce((total, group) => {
+    const sorted = [...group].sort((a, b) => a.min - b.min);
+    let groupLength = 0;
+    let currentMin = sorted[0].min;
+    let currentMax = sorted[0].max;
+    for (const interval of sorted.slice(1)) {
+      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+        currentMax = Math.max(currentMax, interval.max);
+      } else {
+        groupLength += currentMax - currentMin;
+        currentMin = interval.min;
+        currentMax = interval.max;
+      }
+    }
+    return total + groupLength + currentMax - currentMin;
+  }, 0);
+};
+var getVisibleTraceLength = (traces) => {
+  const horizontal = [];
+  const vertical = [];
+  for (const trace of traces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index];
+      const end = trace.tracePath[index + 1];
+      if (isHorizontal2(start, end)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x)
+        });
+      } else if (isVertical2(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y)
+        });
+      }
+    }
+  }
+  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical);
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
+var moveRailSegments = (trace, segments, coordinate) => {
+  const pointsToMove = /* @__PURE__ */ new Set();
+  for (const segment of segments) {
+    pointsToMove.add(segment.segmentIndex);
+    pointsToMove.add(segment.segmentIndex + 1);
+  }
+  const orientation = segments[0].orientation;
+  const tracePath = simplifyPath(
+    trace.tracePath.map((point, index) => {
+      if (!pointsToMove.has(index)) return point;
+      return orientation === "vertical" ? { ...point, x: coordinate } : { ...point, y: coordinate };
+    })
+  );
+  return { ...trace, tracePath };
+};
+
+// lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
+var EPS5 = 1e-6;
+var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
+var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS5 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS5;
+var getTraceCorners = (path) => {
+  const corners = [];
+  for (let i = 1; i < path.length - 1; i++) {
+    const previousPoint = path[i - 1];
+    const cornerPoint = path[i];
+    const nextPoint = path[i + 1];
+    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
+      corners.push(cornerPoint);
+    }
+  }
+  return corners;
+};
+var tracePathContainsPoint = (path, point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    if (isPointOnSegment(point, path[i], path[i + 1])) return true;
+  }
+  return false;
+};
+var getDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var getUniquePinCount = (pinIds) => new Set(pinIds).size;
+var isTraceCorner = (a, b, c) => getSegmentOrientation(a, b) !== getSegmentOrientation(b, c);
+var isPointOnSegment = (point, start, end) => {
+  if (getSegmentOrientation(start, end) === "horizontal") {
+    return Math.abs(point.y - start.y) <= EPS5 && point.x >= Math.min(start.x, end.x) - EPS5 && point.x <= Math.max(start.x, end.x) + EPS5;
+  }
+  return Math.abs(point.x - start.x) <= EPS5 && point.y >= Math.min(start.y, end.y) - EPS5 && point.y <= Math.max(start.y, end.y) + EPS5;
+};
+var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS5 ? "horizontal" : "vertical";
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts
+var getAnchoredTraceIds = (label, traces) => new Set(
+  traces.filter(
+    (trace) => trace.globalConnNetId === label.globalConnNetId && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
+  ).map((trace) => trace.mspPairId)
+);
+var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
+  const anchoredBefore = getAnchoredTraceIds(label, before);
+  if (anchoredBefore.size === 0) return true;
+  const anchoredAfter = getAnchoredTraceIds(label, after);
+  return [...anchoredBefore].every((traceId) => anchoredAfter.has(traceId));
+});
+
+// lib/solvers/Example28Solver/types.ts
+var EPS6 = 1e-9;
+
+// lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
+var segmentRunsAlongRectBoundary = (start, end, rect) => {
+  const isVertical5 = Math.abs(start.x - end.x) < EPS6;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS6;
+  if (isVertical5) {
+    return Math.abs(start.x - rect.minX) < EPS6 || Math.abs(start.x - rect.maxX) < EPS6;
+  }
+  if (isHorizontal4) {
+    return Math.abs(start.y - rect.minY) < EPS6 || Math.abs(start.y - rect.maxY) < EPS6;
+  }
+  return false;
+};
+
+// lib/solvers/Example28Solver/geometry.ts
+var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
+var getPathLength = (path) => {
+  let length = 0;
+  for (let i = 0; i < path.length - 1; i++) {
+    length += Math.abs(path[i + 1].x - path[i].x) + Math.abs(path[i + 1].y - path[i].y);
+  }
+  return length;
+};
+var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS6 || Math.abs(start.y - end.y) < EPS6;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS6 ? "horizontal" : "vertical";
+var projectPointToSegment = (point, start, end) => {
+  if (Math.abs(start.x - end.x) < EPS6) {
+    return {
+      x: start.x,
+      y: Math.min(
+        Math.max(point.y, Math.min(start.y, end.y)),
+        Math.max(start.y, end.y)
+      )
+    };
+  }
+  if (Math.abs(start.y - end.y) < EPS6) {
+    return {
+      x: Math.min(
+        Math.max(point.x, Math.min(start.x, end.x)),
+        Math.max(start.x, end.x)
+      ),
+      y: start.y
+    };
+  }
+  return start;
+};
+var getPointToSegmentDistance = (point, start, end) => getDistance2(point, projectPointToSegment(point, start, end));
+var getSegments = (path) => {
+  const segments = [];
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    if (!isAxisAlignedSegment(start, end)) continue;
+    segments.push({
+      start,
+      end,
+      orientation: getSegmentOrientation2(start, end)
+    });
+  }
+  return segments;
+};
+var findSegmentContainingPoint = (path, point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    if (!isAxisAlignedSegment(start, end)) continue;
+    if (getPointToSegmentDistance(point, start, end) > 1e-6) continue;
+    return {
+      index: i,
+      start,
+      end,
+      orientation: getSegmentOrientation2(start, end)
+    };
+  }
+  return null;
+};
+var isPointWithinSegmentPrimaryRange = (point, segment) => {
+  if (segment.orientation === "horizontal") {
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS6 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS6;
+  }
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS6 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS6;
+};
+var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
+  const matchingSegments = getSegments(path).filter(
+    (segment) => segment.orientation === orientation
+  );
+  if (matchingSegments.length === 0) return null;
+  const containingSegments = matchingSegments.filter(
+    (segment) => isPointWithinSegmentPrimaryRange(anchorPoint, segment)
+  );
+  const candidateSegments = containingSegments.length > 0 ? containingSegments : matchingSegments;
+  const isNearStart = originalSegmentIndex < originalSegmentCount / 2;
+  return isNearStart ? candidateSegments[0] : candidateSegments[candidateSegments.length - 1];
+};
+var projectPointToPath = (point, path) => {
+  let bestPoint = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < path.length - 1; i++) {
+    const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
+    const distance4 = getDistance2(point, projectedPoint);
+    if (distance4 < bestDistance) {
+      bestPoint = projectedPoint;
+      bestDistance = distance4;
+    }
+  }
+  return bestPoint;
+};
+var segmentsIntersect = (a1, a2, b1, b2) => {
+  const aVertical = Math.abs(a1.x - a2.x) < EPS6;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS6;
+  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS6 && value <= Math.max(p1, p2) + EPS6;
+  if (aVertical && bVertical) {
+    if (Math.abs(a1.x - b1.x) > EPS6) return false;
+    const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
+    return overlap > EPS6;
+  }
+  if (!aVertical && !bVertical) {
+    if (Math.abs(a1.y - b1.y) > EPS6) return false;
+    const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
+    return overlap > EPS6;
+  }
+  const verticalA = aVertical ? a1 : b1;
+  const verticalB = aVertical ? a2 : b2;
+  const horizontalA = aVertical ? b1 : a1;
+  const horizontalB = aVertical ? b2 : a2;
+  return between(verticalA.x, horizontalA.x, horizontalB.x) && between(horizontalA.y, verticalA.y, verticalB.y);
+};
+var countPathIntersections = (pathA, pathB) => {
+  let count = 0;
+  for (let i = 0; i < pathA.length - 1; i++) {
+    for (let j = 0; j < pathB.length - 1; j++) {
+      if (segmentsIntersect(pathA[i], pathA[i + 1], pathB[j], pathB[j + 1])) {
+        count++;
+      }
+    }
+  }
+  return count;
+};
+var isPathCollidingWithChipInterior = (path, chipObstacles) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    for (const obstacle of chipObstacles) {
+      if (!segmentIntersectsRect(start, end, obstacle)) continue;
+      if (segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
+      return true;
+    }
+  }
+  return false;
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/scoreRailAlignment.ts
+var countOtherNetCrossings = (traces, allTraces) => {
+  let crossings = 0;
+  for (const trace of traces) {
+    for (const otherTrace of allTraces) {
+      if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
+      crossings += countPathIntersections(trace.tracePath, otherTrace.tracePath);
+    }
+  }
+  return crossings;
+};
+var getTraceGeometryMetrics = (traces, allTraces) => ({
+  turnCount: traces.reduce(
+    (total, trace) => total + countTurns(trace.tracePath),
+    0
+  ),
+  visibleLength: getVisibleTraceLength(traces),
+  pathLength: traces.reduce(
+    (sum, trace) => sum + getPathLength(trace.tracePath),
+    0
+  ),
+  otherNetCrossings: countOtherNetCrossings(traces, allTraces)
+});
+var scoreIsBetter = (candidate, best) => {
+  if (candidate.turnCount !== best.turnCount)
+    return candidate.turnCount < best.turnCount;
+  if (!nearlyEqual(candidate.visibleLength, best.visibleLength))
+    return candidate.visibleLength < best.visibleLength;
+  if (!nearlyEqual(candidate.pathLength, best.pathLength))
+    return candidate.pathLength < best.pathLength;
+  if (candidate.otherNetCrossings !== best.otherNetCrossings)
+    return candidate.otherNetCrossings < best.otherNetCrossings;
+  if (!nearlyEqual(candidate.displacement, best.displacement))
+    return candidate.displacement < best.displacement;
+  return candidate.coordinate < best.coordinate;
+};
+var isReadabilityImprovement = (candidate, baseline) => candidate.turnCount <= baseline.turnCount && (candidate.turnCount < baseline.turnCount || candidate.visibleLength <= baseline.visibleLength + RAIL_ALIGNMENT_EPSILON);
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts
+var tracePathChanged = (original, candidate) => original.tracePath.length !== candidate.tracePath.length || candidate.tracePath.some(
+  (point, index) => !pointsEqual(point, original.tracePath[index])
+);
+var evaluateRailGroup = ({
+  group,
+  traces,
+  netLabelPlacements,
+  obstacles,
+  eligibleTraceIds
+}) => {
+  const groupTraceIds = new Set(group.map((segment) => segment.traceId));
+  const originalGroupTraces = traces.filter(
+    (trace) => groupTraceIds.has(trace.mspPairId)
+  );
+  const baseline = getTraceGeometryMetrics(originalGroupTraces, traces);
+  const coordinates = getDistinctCoordinates(
+    group.map((segment) => segment.coordinate)
+  );
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== group[0].globalConnNetId
+  );
+  const immutableSameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === group[0].globalConnNetId && !eligibleTraceIds.has(trace.mspPairId)
+  );
+  let best = null;
+  for (const coordinate of coordinates) {
+    const candidateMap = /* @__PURE__ */ new Map();
+    for (const trace of originalGroupTraces) {
+      const candidateTrace = moveRailSegments(
+        trace,
+        group.filter((segment) => segment.traceId === trace.mspPairId),
+        coordinate
+      );
+      candidateMap.set(trace.mspPairId, candidateTrace);
+    }
+    const candidateTraces = [...candidateMap.values()];
+    const allCandidateTraces = traces.map(
+      (trace) => candidateMap.get(trace.mspPairId) ?? trace
+    );
+    const candidatesAreClear = candidateTraces.every(
+      (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
+        traces: [candidate2],
+        netLabels: netLabelPlacements
+      }).length === 0 && !doesPathCoincideWithTraces(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
+        candidate2.tracePath,
+        immutableSameNetTraces.filter(
+          (trace) => trace.mspPairId !== candidate2.mspPairId
+        )
+      )
+    );
+    if (!candidatesAreClear) continue;
+    if (!preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)) {
+      continue;
+    }
+    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces);
+    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
+    if (!isReadabilityImprovement(metrics, baseline)) continue;
+    const score = {
+      ...metrics,
+      displacement: group.reduce(
+        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+        0
+      ),
+      coordinate
+    };
+    const changedTraceIds = candidateTraces.filter((candidate2) => {
+      const original = traces.find(
+        (trace) => trace.mspPairId === candidate2.mspPairId
+      );
+      return tracePathChanged(original, candidate2);
+    }).map((trace) => trace.mspPairId);
+    if (changedTraceIds.length === 0) continue;
+    const candidate = { traces: allCandidateTraces, changedTraceIds, score };
+    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
+  }
+  return best;
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts
+var getMovableRailSegments = (trace) => {
+  const segments = [];
+  const path = trace.tracePath;
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const previous = path[segmentIndex - 1];
+    const start = path[segmentIndex];
+    const end = path[segmentIndex + 1];
+    const next = path[segmentIndex + 2];
+    const orientation = getRailOrientation(start, end);
+    if (!orientation) continue;
+    const previousOrientation = getRailOrientation(previous, start);
+    const nextOrientation = getRailOrientation(end, next);
+    if (!previousOrientation || !nextOrientation) continue;
+    if (previousOrientation === orientation || nextOrientation === orientation)
+      continue;
+    const alongValues = orientation === "vertical" ? [start.y, end.y] : [start.x, end.x];
+    segments.push({
+      traceId: trace.mspPairId,
+      segmentIndex,
+      globalConnNetId: trace.globalConnNetId,
+      orientation,
+      coordinate: orientation === "vertical" ? start.x : start.y,
+      minAlong: Math.min(...alongValues),
+      maxAlong: Math.max(...alongValues)
+    });
+  }
+  return segments;
+};
+var railIsOutsideComponent = (segment, chip, facingDirection) => {
+  const minX = chip.center.x - chip.width / 2;
+  const maxX = chip.center.x + chip.width / 2;
+  const minY = chip.center.y - chip.height / 2;
+  const maxY = chip.center.y + chip.height / 2;
+  switch (facingDirection) {
+    case "x-":
+      return segment.orientation === "vertical" && segment.coordinate <= minX + RAIL_ALIGNMENT_EPSILON;
+    case "x+":
+      return segment.orientation === "vertical" && segment.coordinate >= maxX - RAIL_ALIGNMENT_EPSILON;
+    case "y+":
+      return segment.orientation === "horizontal" && segment.coordinate >= maxY - RAIL_ALIGNMENT_EPSILON;
+    case "y-":
+      return segment.orientation === "horizontal" && segment.coordinate <= minY + RAIL_ALIGNMENT_EPSILON;
+  }
+};
+var getComponentSideRailSegments = (trace, chipMap) => {
+  const segments = [];
+  for (const segment of getMovableRailSegments(trace)) {
+    const associations = trace.pins.flatMap((pin, pinIndex) => {
+      const chip = chipMap.get(pin.chipId);
+      if (!chip) return [];
+      const componentFacingDirection = pin._facingDirection ?? getPinDirection(pin, chip);
+      if (!railIsOutsideComponent(segment, chip, componentFacingDirection)) {
+        return [];
+      }
+      return [
+        {
+          componentId: chip.chipId,
+          componentFacingDirection,
+          distanceFromEndpoint: pinIndex === 0 ? segment.segmentIndex : trace.tracePath.length - 2 - segment.segmentIndex
+        }
+      ];
+    });
+    associations.sort((a, b) => a.distanceFromEndpoint - b.distanceFromEndpoint);
+    const association = associations[0];
+    if (!association) continue;
+    segments.push({ ...segment, ...association });
+  }
+  return segments;
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailGroups.ts
+var getCorridor = (a, b) => {
+  const overlapMin = Math.max(a.minAlong, b.minAlong);
+  const overlapMax = Math.min(a.maxAlong, b.maxAlong);
+  const along = (overlapMin + overlapMax) / 2;
+  return a.orientation === "vertical" ? [
+    { x: a.coordinate, y: along },
+    { x: b.coordinate, y: along }
+  ] : [
+    { x: along, y: a.coordinate },
+    { x: along, y: b.coordinate }
+  ];
+};
+var corridorIsClear = (a, b, obstacles) => {
+  if (!rangesTouchOrOverlap(a, b)) return true;
+  const [start, end] = getCorridor(a, b);
+  return !obstacles.some(
+    (obstacle) => segmentIntersectsRect(start, end, obstacle)
+  );
+};
+var tracesSharePin = (a, b, traceMap) => {
+  if (a.traceId === b.traceId) return true;
+  const aPinIds = new Set(traceMap.get(a.traceId).pins.map((pin) => pin.pinId));
+  return traceMap.get(b.traceId).pins.some((pin) => aPinIds.has(pin.pinId));
+};
+var canJoinRailGroup = (start, current, candidate, traceMap, obstacles) => candidate.globalConnNetId === start.globalConnNetId && candidate.orientation === start.orientation && candidate.componentId === start.componentId && candidate.componentFacingDirection === start.componentFacingDirection && (rangesTouchOrOverlap(current, candidate) || tracesSharePin(current, candidate, traceMap)) && corridorIsClear(current, candidate, obstacles);
+var getRailGroups = (traces, eligibleTraceIds, inputProblem, obstacles) => {
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
+  const segments = traces.filter((trace) => eligibleTraceIds.has(trace.mspPairId)).flatMap((trace) => getComponentSideRailSegments(trace, chipMap));
+  const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]));
+  const visited = /* @__PURE__ */ new Set();
+  const groups = [];
+  for (let startIndex = 0; startIndex < segments.length; startIndex++) {
+    if (visited.has(startIndex)) continue;
+    const start = segments[startIndex];
+    const queue = [startIndex];
+    const group = [];
+    visited.add(startIndex);
+    for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+      const current = segments[queue[queueIndex]];
+      group.push(current);
+      for (let candidateIndex = 0; candidateIndex < segments.length; candidateIndex++) {
+        if (visited.has(candidateIndex)) continue;
+        const candidate = segments[candidateIndex];
+        if (!canJoinRailGroup(start, current, candidate, traceMap, obstacles)) {
+          continue;
+        }
+        visited.add(candidateIndex);
+        queue.push(candidateIndex);
+      }
+    }
+    const traceCount = new Set(group.map((segment) => segment.traceId)).size;
+    const hasDifferentCoordinates = group.some(
+      (segment) => !nearlyEqual(segment.coordinate, group[0].coordinate)
+    );
+    if (traceCount >= 2 && hasDifferentCoordinates) groups.push(group);
+  }
+  return groups;
+};
+
+// lib/solvers/TraceCleanupSolver/alignSameNetRails.ts
+var alignSameNetRails = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  eligibleTraceIds
+}) => {
+  let outputTraces = [...traces];
+  const obstacles = getObstacleRects(inputProblem);
+  const alignedTraceIds = /* @__PURE__ */ new Set();
+  let alignedRailGroupCount = 0;
+  const maximumPasses = Math.max(
+    1,
+    traces.reduce((sum, trace) => sum + trace.tracePath.length, 0)
+  );
+  for (let pass = 0; pass < maximumPasses; pass++) {
+    const groups = getRailGroups(
+      outputTraces,
+      eligibleTraceIds,
+      inputProblem,
+      obstacles
+    );
+    let applied = null;
+    for (const group of groups) {
+      applied = evaluateRailGroup({
+        group,
+        traces: outputTraces,
+        netLabelPlacements,
+        obstacles,
+        eligibleTraceIds
+      });
+      if (applied) break;
     }
+    if (!applied) break;
+    outputTraces = applied.traces;
+    alignedRailGroupCount++;
+    for (const traceId of applied.changedTraceIds) alignedTraceIds.add(traceId);
   }
-  const finalSimplifiedPath = simplifyPath(newPath);
   return {
-    ...targetTrace,
-    tracePath: finalSimplifiedPath
+    traces: outputTraces,
+    alignedRailGroupCount,
+    alignedTraceCount: alignedTraceIds.size
   };
 };
 
@@ -4748,8 +5424,8 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS5 = 1e-6;
-var isVertical2 = (a, b, eps = EPS5) => Math.abs(a.x - b.x) < eps;
+var EPS7 = 1e-6;
+var isVertical3 = (a, b, eps = EPS7) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -4762,50 +5438,50 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS5 && Math.abs(p2.y - (y + height)) < EPS5) {
+  if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
     c2 = { x: x + width + padding, y: y - padding };
-    if (isVertical2(p1, p2)) {
+    if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
     } else {
       i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
     }
-    if (isVertical2(p2, p3)) {
+    if (isVertical3(p2, p3)) {
       i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS5 && Math.abs(p2.y - (y + height)) < EPS5) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
     c2 = { x: x - padding, y: y - padding };
-    if (isVertical2(p1, p2)) {
+    if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
     } else {
       i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
     }
-    if (isVertical2(p2, p3)) {
+    if (isVertical3(p2, p3)) {
       i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS5 && Math.abs(p2.y - y) < EPS5) {
+  } else if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - y) < EPS7) {
     c2 = { x: x + width + padding, y: y + height + padding };
-    if (isVertical2(p1, p2)) {
+    if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
     } else {
       i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
     }
-    if (isVertical2(p2, p3)) {
+    if (isVertical3(p2, p3)) {
       i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS5 && Math.abs(p2.y - y) < EPS5) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - y) < EPS7) {
     c2 = { x: x - padding, y: y + height + padding };
-    if (isVertical2(p1, p2)) {
+    if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
     } else {
       i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
     }
-    if (isVertical2(p2, p3)) {
+    if (isVertical3(p2, p3)) {
       i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
@@ -5269,9 +5945,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS6 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS6;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS6;
+var EPS8 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS8;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS8;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -5281,12 +5957,19 @@ var is4PointRectangle = (path) => {
 };
 
 // lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
+var DEFAULT_OPERATIONS = [
+  "untangling_traces",
+  "minimizing_turns",
+  "balancing_l_shapes"
+];
 var TraceCleanupSolver = class extends BaseSolver {
   input;
   outputTraces;
   traceIdQueue;
   tracesMap;
-  pipelineStep = "untangling_traces";
+  operations;
+  operationIndex = 0;
+  pipelineStep;
   activeTraceId = null;
   // New property
   activeSubSolver = null;
@@ -5295,6 +5978,8 @@ var TraceCleanupSolver = class extends BaseSolver {
     this.input = solverInput;
     this.outputTraces = [...solverInput.allTraces];
     this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
+    this.operations = solverInput.operations ?? DEFAULT_OPERATIONS;
+    this.pipelineStep = this.operations[0] ?? null;
     this.traceIdQueue = Array.from(
       solverInput.allTraces.map((e) => e.mspPairId)
     );
@@ -5307,13 +5992,17 @@ var TraceCleanupSolver = class extends BaseSolver {
         this.outputTraces = output.traces;
         this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
         this.activeSubSolver = null;
-        this.pipelineStep = "minimizing_turns";
+        this._advancePipeline();
       } else if (this.activeSubSolver.failed) {
         this.activeSubSolver = null;
-        this.pipelineStep = "minimizing_turns";
+        this._advancePipeline();
       }
       return;
     }
+    if (!this.pipelineStep) {
+      this.solved = true;
+      return;
+    }
     switch (this.pipelineStep) {
       case "untangling_traces":
         this._runUntangleTracesStep();
@@ -5324,8 +6013,17 @@ var TraceCleanupSolver = class extends BaseSolver {
       case "balancing_l_shapes":
         this._runBalanceLShapesStep();
         break;
+      case "aligning_same_net_rails":
+        this._runAlignSameNetRailsStep();
+        break;
     }
   }
+  _advancePipeline() {
+    this.operationIndex++;
+    this.pipelineStep = this.operations[this.operationIndex] ?? null;
+    this.traceIdQueue = this.outputTraces.map((trace) => trace.mspPairId);
+    if (this.pipelineStep) this.activeTraceId = null;
+  }
   _runUntangleTracesStep() {
     this.activeSubSolver = new UntangleTraceSubsolver({
       ...this.input,
@@ -5334,17 +6032,14 @@ var TraceCleanupSolver = class extends BaseSolver {
   }
   _runMinimizeTurnsStep() {
     if (this.traceIdQueue.length === 0) {
-      this.pipelineStep = "balancing_l_shapes";
-      this.traceIdQueue = Array.from(
-        this.input.allTraces.map((e) => e.mspPairId)
-      );
+      this._advancePipeline();
       return;
     }
     this._processTrace("minimizing_turns");
   }
   _runBalanceLShapesStep() {
     if (this.traceIdQueue.length === 0) {
-      this.solved = true;
+      this._advancePipeline();
       return;
     }
     this._processTrace("balancing_l_shapes");
@@ -5374,6 +6069,19 @@ var TraceCleanupSolver = class extends BaseSolver {
     this.tracesMap.set(targetMspConnectionPairId, updatedTrace);
     this.outputTraces = Array.from(this.tracesMap.values());
   }
+  _runAlignSameNetRailsStep() {
+    const alignment = alignSameNetRails({
+      inputProblem: this.input.inputProblem,
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.allLabelPlacements,
+      eligibleTraceIds: this.input.eligibleTraceIds ?? new Set(this.outputTraces.map((trace) => trace.mspPairId))
+    });
+    this.outputTraces = alignment.traces;
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
+    this.stats.alignedRailGroupCount = alignment.alignedRailGroupCount;
+    this.stats.alignedTraceCount = alignment.alignedTraceCount;
+    this._advancePipeline();
+  }
   getOutput() {
     return {
       traces: this.outputTraces
@@ -5452,160 +6160,6 @@ var dir = (facingDirection) => {
   throw new Error(`Invalid facing direction: ${facingDirection}`);
 };
 
-// lib/solvers/Example28Solver/types.ts
-var EPS7 = 1e-9;
-
-// lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
-var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical4 = Math.abs(start.x - end.x) < EPS7;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS7;
-  if (isVertical4) {
-    return Math.abs(start.x - rect.minX) < EPS7 || Math.abs(start.x - rect.maxX) < EPS7;
-  }
-  if (isHorizontal3) {
-    return Math.abs(start.y - rect.minY) < EPS7 || Math.abs(start.y - rect.maxY) < EPS7;
-  }
-  return false;
-};
-
-// lib/solvers/Example28Solver/geometry.ts
-var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
-var getPathLength = (path) => {
-  let length = 0;
-  for (let i = 0; i < path.length - 1; i++) {
-    length += Math.abs(path[i + 1].x - path[i].x) + Math.abs(path[i + 1].y - path[i].y);
-  }
-  return length;
-};
-var getDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS7 || Math.abs(start.y - end.y) < EPS7;
-var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS7 ? "horizontal" : "vertical";
-var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS7) {
-    return {
-      x: start.x,
-      y: Math.min(
-        Math.max(point.y, Math.min(start.y, end.y)),
-        Math.max(start.y, end.y)
-      )
-    };
-  }
-  if (Math.abs(start.y - end.y) < EPS7) {
-    return {
-      x: Math.min(
-        Math.max(point.x, Math.min(start.x, end.x)),
-        Math.max(start.x, end.x)
-      ),
-      y: start.y
-    };
-  }
-  return start;
-};
-var getPointToSegmentDistance = (point, start, end) => getDistance(point, projectPointToSegment(point, start, end));
-var getSegments = (path) => {
-  const segments = [];
-  for (let i = 0; i < path.length - 1; i++) {
-    const start = path[i];
-    const end = path[i + 1];
-    if (!isAxisAlignedSegment(start, end)) continue;
-    segments.push({
-      start,
-      end,
-      orientation: getSegmentOrientation(start, end)
-    });
-  }
-  return segments;
-};
-var findSegmentContainingPoint = (path, point) => {
-  for (let i = 0; i < path.length - 1; i++) {
-    const start = path[i];
-    const end = path[i + 1];
-    if (!isAxisAlignedSegment(start, end)) continue;
-    if (getPointToSegmentDistance(point, start, end) > 1e-6) continue;
-    return {
-      index: i,
-      start,
-      end,
-      orientation: getSegmentOrientation(start, end)
-    };
-  }
-  return null;
-};
-var isPointWithinSegmentPrimaryRange = (point, segment) => {
-  if (segment.orientation === "horizontal") {
-    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS7 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS7;
-  }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS7 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS7;
-};
-var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
-  const matchingSegments = getSegments(path).filter(
-    (segment) => segment.orientation === orientation
-  );
-  if (matchingSegments.length === 0) return null;
-  const containingSegments = matchingSegments.filter(
-    (segment) => isPointWithinSegmentPrimaryRange(anchorPoint, segment)
-  );
-  const candidateSegments = containingSegments.length > 0 ? containingSegments : matchingSegments;
-  const isNearStart = originalSegmentIndex < originalSegmentCount / 2;
-  return isNearStart ? candidateSegments[0] : candidateSegments[candidateSegments.length - 1];
-};
-var projectPointToPath = (point, path) => {
-  let bestPoint = null;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (let i = 0; i < path.length - 1; i++) {
-    const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
-    const distance3 = getDistance(point, projectedPoint);
-    if (distance3 < bestDistance) {
-      bestPoint = projectedPoint;
-      bestDistance = distance3;
-    }
-  }
-  return bestPoint;
-};
-var segmentsIntersect = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS7;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS7;
-  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS7 && value <= Math.max(p1, p2) + EPS7;
-  if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS7) return false;
-    const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
-    return overlap > EPS7;
-  }
-  if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS7) return false;
-    const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
-    return overlap > EPS7;
-  }
-  const verticalA = aVertical ? a1 : b1;
-  const verticalB = aVertical ? a2 : b2;
-  const horizontalA = aVertical ? b1 : a1;
-  const horizontalB = aVertical ? b2 : a2;
-  return between(verticalA.x, horizontalA.x, horizontalB.x) && between(horizontalA.y, verticalA.y, verticalB.y);
-};
-var countPathIntersections = (pathA, pathB) => {
-  let count = 0;
-  for (let i = 0; i < pathA.length - 1; i++) {
-    for (let j = 0; j < pathB.length - 1; j++) {
-      if (segmentsIntersect(pathA[i], pathA[i + 1], pathB[j], pathB[j + 1])) {
-        count++;
-      }
-    }
-  }
-  return count;
-};
-var isPathCollidingWithChipInterior = (path, chipObstacles) => {
-  for (let i = 0; i < path.length - 1; i++) {
-    const start = path[i];
-    const end = path[i + 1];
-    for (const obstacle of chipObstacles) {
-      if (!segmentIntersectsRect(start, end, obstacle)) continue;
-      if (segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      return true;
-    }
-  }
-  return false;
-};
-
 // lib/solvers/Example28Solver/getMovedAnchorPointForReroute.ts
 var getMovedAnchorPointForReroute = (anchorPoint, originalTracePath, reroutedTracePath) => {
   const originalSegment = findSegmentContainingPoint(
@@ -5668,7 +6222,7 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
     const end = path[i + 1];
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS6) {
         return true;
       }
     }
@@ -5683,14 +6237,14 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS7) total += overlap;
+      if (overlap > EPS6) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical4 = Math.abs(start.x - end.x) < EPS7;
-  if (isVertical4) {
+  const isVertical5 = Math.abs(start.x - end.x) < EPS6;
+  if (isVertical5) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
   return Math.min(Math.max(start.x, end.x), rect.maxX) - Math.max(Math.min(start.x, end.x), rect.minX);
@@ -6101,11 +6655,11 @@ var getLabelHugDistance = (tracePath, obstacleLabel) => {
     obstacleLabel.width,
     obstacleLabel.height
   );
-  let distance3 = 0;
+  let distance4 = 0;
   for (const point of tracePath) {
-    distance3 += getPointDistanceFromRect(point, bounds);
+    distance4 += getPointDistanceFromRect(point, bounds);
   }
-  return distance3;
+  return distance4;
 };
 var getPointDistanceFromRect = (point, rect) => {
   const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
@@ -6382,16 +6936,16 @@ var Example28Solver = class extends BaseSolver {
     const outward = dir(label.orientation);
     if (outward.x === 0 && outward.y === 0) return null;
     for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
-      const distance3 = step * LABEL_OUTWARD_STEP;
+      const distance4 = step * LABEL_OUTWARD_STEP;
       const candidate = {
         ...label,
         anchorPoint: {
-          x: label.anchorPoint.x + outward.x * distance3,
-          y: label.anchorPoint.y + outward.y * distance3
+          x: label.anchorPoint.x + outward.x * distance4,
+          y: label.anchorPoint.y + outward.y * distance4
         },
         center: {
-          x: label.center.x + outward.x * distance3,
-          y: label.center.y + outward.y * distance3
+          x: label.center.x + outward.x * distance4,
+          y: label.center.y + outward.y * distance4
         }
       };
       const candidateWithClearance = {
@@ -6453,16 +7007,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS8 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS8;
+var EPS9 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS9;
 var CANDIDATE_SELECTED_COLOR2 = "blue";
 var CANDIDATE_REJECTED_COLOR2 = "red";
 
 // lib/solvers/AvailableNetOrientationSolver/geometry.ts
 var isYOrientation = (orientation) => orientation === "y+" || orientation === "y-";
 var isXOrientation = (orientation) => orientation === "x+" || orientation === "x-";
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS8;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS9;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -6485,7 +7039,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS8 || p1.x >= interiorBounds.maxX - EPS8) {
+    if (p1.x <= interiorBounds.minX + EPS9 || p1.x >= interiorBounds.maxX - EPS9) {
       return false;
     }
     return rangesOverlap(
@@ -6496,7 +7050,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS8 || p1.y >= interiorBounds.maxY - EPS8) {
+    if (p1.y <= interiorBounds.minY + EPS9 || p1.y >= interiorBounds.maxY - EPS9) {
       return false;
     }
     return rangesOverlap(
@@ -6535,7 +7089,7 @@ var getConnectorTracePath = (source, target, orientation) => simplifyOrthogonalP
 );
 var simplifyOrthogonalPath = (path) => {
   const deduped = path.filter(
-    (point, index) => index === 0 || !pointsEqual(point, path[index - 1])
+    (point, index) => index === 0 || !pointsEqual2(point, path[index - 1])
   );
   if (deduped.length < 3) return deduped;
   const simplified = [deduped[0]];
@@ -6551,9 +7105,9 @@ var simplifyOrthogonalPath = (path) => {
   simplified.push(deduped[deduped.length - 1]);
   return simplified;
 };
-var pointsEqual = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS8;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS8;
+var pointsEqual2 = (a, b) => sameX2(a, b) && sameY2(a, b);
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS9;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS9;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -6856,7 +7410,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const maxSearchDistance = this.getSearchDistanceLimit(label, orientation);
     const maxOutwardDistance = outwardDirection.x === 0 && outwardDirection.y === 0 ? 0 : this.maxSearchDistance;
-    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS8; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS9; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -6929,10 +7483,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       outwardDistance,
       phase = "shift"
     } = params;
-    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS8; distance3 += LABEL_SEARCH_STEP) {
+    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS9; distance4 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
-        x: baseAnchor.x + direction.x * distance3,
-        y: baseAnchor.y + direction.y * distance3
+        x: baseAnchor.x + direction.x * distance4,
+        y: baseAnchor.y + direction.y * distance4
       };
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -6940,7 +7494,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         label,
         labelIndex,
         phase,
-        distance3,
+        distance4,
         outwardDistance
       );
       this.currentCandidateResults.push(result);
@@ -6952,11 +7506,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  evaluateCandidate(candidate, label, labelIndex, phase, distance3, outwardDistance) {
+  evaluateCandidate(candidate, label, labelIndex, phase, distance4, outwardDistance) {
     return {
       ...candidate,
       phase,
-      distance: distance3,
+      distance: distance4,
       outwardDistance,
       selected: false,
       status: this.getCandidateStatus({
@@ -7166,9 +7720,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS8 || anchorPoint.x > chipBounds.maxX + EPS8;
+        return anchorPoint.x < chipBounds.minX - EPS9 || anchorPoint.x > chipBounds.maxX + EPS9;
       }
-      return anchorPoint.y < chipBounds.minY - EPS8 || anchorPoint.y > chipBounds.maxY + EPS8;
+      return anchorPoint.y < chipBounds.minY - EPS9 || anchorPoint.y > chipBounds.maxY + EPS9;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -7235,15 +7789,15 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (i === labelIndex) continue;
       const label = this.outputNetLabelPlacements[i];
       const otherBounds = getRectBounds(label.center, label.width, label.height);
-      if (rectsOverlap(bounds, otherBounds)) return true;
+      if (rectsOverlap2(bounds, otherBounds)) return true;
     }
     return false;
   }
   sharesChipBoundary(bounds) {
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS8;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS8;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS9 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS9;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS9 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS9;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -7291,13 +7845,13 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      if (point.x < bounds.minX - EPS8 || point.x > bounds.maxX + EPS8 || point.y < bounds.minY - EPS8 || point.y > bounds.maxY + EPS8) {
+      if (point.x < bounds.minX - EPS9 || point.x > bounds.maxX + EPS9 || point.y < bounds.minY - EPS9 || point.y > bounds.maxY + EPS9) {
         continue;
       }
-      for (const [side, distance3] of getSideDistances(point, bounds)) {
-        if (distance3 < nearestDistance) {
+      for (const [side, distance4] of getSideDistances(point, bounds)) {
+        if (distance4 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance3;
+          nearestDistance = distance4;
         }
       }
     }
@@ -7308,8 +7862,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistanceSq = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      const dx = point.x < bounds.minX - EPS8 ? bounds.minX - point.x : point.x > bounds.maxX + EPS8 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS8 ? bounds.minY - point.y : point.y > bounds.maxY + EPS8 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS9 ? bounds.minX - point.x : point.x > bounds.maxX + EPS9 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS9 ? bounds.minY - point.y : point.y > bounds.maxY + EPS9 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -7326,10 +7880,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
-      for (const [side, distance3] of getSideDistances(point, chip.bounds)) {
-        if (distance3 < nearestDistance) {
+      for (const [side, distance4] of getSideDistances(point, chip.bounds)) {
+        if (distance4 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance3;
+          nearestDistance = distance4;
         }
       }
     }
@@ -7347,39 +7901,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
-var EPS9 = 1e-6;
-var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
-var getTraceCorners = (path) => {
-  const corners = [];
-  for (let i = 1; i < path.length - 1; i++) {
-    const previousPoint = path[i - 1];
-    const cornerPoint = path[i];
-    const nextPoint = path[i + 1];
-    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
-      corners.push(cornerPoint);
-    }
-  }
-  return corners;
-};
-var tracePathContainsPoint = (path, point) => {
-  for (let i = 0; i < path.length - 1; i++) {
-    if (isPointOnSegment(point, path[i], path[i + 1])) return true;
-  }
-  return false;
-};
-var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var getUniquePinCount = (pinIds) => new Set(pinIds).size;
-var isTraceCorner = (a, b, c) => getSegmentOrientation2(a, b) !== getSegmentOrientation2(b, c);
-var isPointOnSegment = (point, start, end) => {
-  if (getSegmentOrientation2(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS9 && point.x >= Math.min(start.x, end.x) - EPS9 && point.x <= Math.max(start.x, end.x) + EPS9;
-  }
-  return Math.abs(point.x - start.x) <= EPS9 && point.y >= Math.min(start.y, end.y) - EPS9 && point.y <= Math.max(start.y, end.y) + EPS9;
-};
-var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS9 ? "horizontal" : "vertical";
-
 // lib/solvers/RailNetLabelCornerPlacementSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR3 = "blue";
 var CANDIDATE_REJECTED_COLOR3 = "red";
@@ -7602,20 +8123,20 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
   intersectsAnyChip(bounds) {
     return this.inputProblem.chips.some(
-      (chip) => rectsOverlap2(bounds, getRectBounds(chip.center, chip.width, chip.height))
+      (chip) => rectsOverlap(bounds, getRectBounds(chip.center, chip.width, chip.height))
     );
   }
   intersectsAnyOtherNetLabel(bounds, labelIndex) {
     return this.outputNetLabelPlacements.some((label, index) => {
       if (index === labelIndex) return false;
-      return rectsOverlap2(
+      return rectsOverlap(
         bounds,
         getRectBounds(label.center, label.width, label.height)
       );
     });
   }
   getCornerCandidatesForLabel(label) {
-    const isVertical4 = label.orientation === "y+" || label.orientation === "y-";
+    const isVertical5 = label.orientation === "y+" || label.orientation === "y-";
     const candidates = [];
     const seenCornerKeys = /* @__PURE__ */ new Set();
     for (const trace of this.getTraceLinesForLabel(label)) {
@@ -7626,14 +8147,14 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
         if (seenCornerKeys.has(key)) continue;
         seenCornerKeys.add(key);
         const pinAligned = pins.some((pin) => {
-          if (isVertical4) return Math.abs(pin.x - anchorPoint.x) < EPS9;
-          return Math.abs(pin.y - anchorPoint.y) < EPS9;
+          if (isVertical5) return Math.abs(pin.x - anchorPoint.x) < EPS5;
+          return Math.abs(pin.y - anchorPoint.y) < EPS5;
         });
         if (!pinAligned) continue;
         candidates.push({
           anchorPoint,
           traceId: trace.mspPairId,
-          distance: getDistance2(anchorPoint, label.anchorPoint),
+          distance: getDistance(anchorPoint, label.anchorPoint),
           pinAligned
         });
       }
@@ -7763,17 +8284,17 @@ var getTraceLength = (trace) => {
   }
   return length;
 };
-var getPointAtTraceDistance = (trace, distance3) => {
+var getPointAtTraceDistance = (trace, distance4) => {
   let pathDistance = 0;
   for (let i = 0; i < trace.tracePath.length - 1; i++) {
     const start = trace.tracePath[i];
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance3 <= nextDistance + EPS10) {
+    if (distance4 <= nextDistance + EPS10) {
       const offset = Math.max(
         0,
-        Math.min(segmentLength, distance3 - pathDistance)
+        Math.min(segmentLength, distance4 - pathDistance)
       );
       const direction = getSegmentDirection(start, end);
       return {
@@ -7808,7 +8329,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
   if (interior.minX >= interior.maxX || interior.minY >= interior.maxY) {
     return false;
   }
-  if (isVertical3(start, end)) {
+  if (isVertical4(start, end)) {
     if (start.x <= interior.minX + EPS10 || start.x >= interior.maxX - EPS10) {
       return false;
     }
@@ -7819,7 +8340,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
       interior.maxY
     );
   }
-  if (isHorizontal2(start, end)) {
+  if (isHorizontal3(start, end)) {
     if (start.y <= interior.minY + EPS10 || start.y >= interior.maxY - EPS10) {
       return false;
     }
@@ -7833,20 +8354,20 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
   return false;
 };
 var isPointOnSegment2 = (point, start, end) => {
-  if (isHorizontal2(start, end)) {
+  if (isHorizontal3(start, end)) {
     return Math.abs(point.y - start.y) <= EPS10 && point.x >= Math.min(start.x, end.x) - EPS10 && point.x <= Math.max(start.x, end.x) + EPS10;
   }
-  if (isVertical3(start, end)) {
+  if (isVertical4(start, end)) {
     return Math.abs(point.x - start.x) <= EPS10 && point.y >= Math.min(start.y, end.y) - EPS10 && point.y <= Math.max(start.y, end.y) + EPS10;
   }
   return false;
 };
 var getSegmentDirection = (start, end) => ({
-  x: isVertical3(start, end) ? 0 : Math.sign(end.x - start.x),
-  y: isHorizontal2(start, end) ? 0 : Math.sign(end.y - start.y)
+  x: isVertical4(start, end) ? 0 : Math.sign(end.x - start.x),
+  y: isHorizontal3(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS10;
-var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS10;
+var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS10;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS10;
 var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS10;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
@@ -7898,13 +8419,13 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
-    const distance3 = Math.min(traceLength, i * CANDIDATE_STEP);
-    distances.add(roundDistance(distance3));
+    const distance4 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance4));
   }
-  for (const distance3 of vertexDistances) {
-    distances.add(roundDistance(distance3));
+  for (const distance4 of vertexDistances) {
+    distances.add(roundDistance(distance4));
   }
-  return [...distances].filter((distance3) => distance3 >= -EPS10 && distance3 <= traceLength + EPS10).sort((a, b) => a - b);
+  return [...distances].filter((distance4) => distance4 >= -EPS10 && distance4 <= traceLength + EPS10).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -8082,7 +8603,7 @@ var getNetLabelHeight = (inputProblem, label) => {
     (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
   )?.netLabelHeight;
 };
-var roundDistance = (distance3) => Number(distance3.toFixed(6));
+var roundDistance = (distance4) => Number(distance4.toFixed(6));
 var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
@@ -8855,11 +9376,11 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         for (let si = 0; si < pts.length - 1; si++) {
           const segStart = pts[si];
           const segEnd = pts[si + 1];
-          const isHorizontal3 = Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS;
-          const isVertical4 = Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS;
-          if (!isHorizontal3 && !isVertical4) continue;
+          const isHorizontal4 = Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS;
+          const isVertical5 = Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS;
+          if (!isHorizontal4 && !isVertical5) continue;
           let perpendicularOrientations;
-          if (isHorizontal3) {
+          if (isHorizontal4) {
             perpendicularOrientations = ["y+", "y-"];
           } else {
             perpendicularOrientations = ["x+", "x-"];
@@ -9072,7 +9593,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   availableNetOrientationSolver;
   railNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
+  preAlignmentNetLabelTraceCollisionSolver;
   netLabelTraceCollisionSolver;
+  traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
   startTimeOfPhase;
   endTimeOfPhase;
@@ -9257,7 +9780,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     ),
     definePipelineStep(
-      "netLabelTraceCollisionSolver",
+      "preAlignmentNetLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => [
         {
@@ -9267,6 +9790,41 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       ]
     ),
+    definePipelineStep(
+      "traceCleanupSolver2",
+      TraceCleanupSolver,
+      (instance) => {
+        const collisionOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            allTraces: collisionOutput.traces,
+            allLabelPlacements: collisionOutput.netLabelPlacements,
+            mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+            paddingBuffer: 0.1,
+            operations: ["aligning_same_net_rails"],
+            eligibleTraceIds: new Set(
+              instance.traceCleanupSolver.getOutput().traces.map((trace) => trace.mspPairId)
+            )
+          }
+        ];
+      }
+    ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => {
+        const previousCollisionOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.traceCleanupSolver2.getOutput().traces,
+            netLabelPlacements: previousCollisionOutput.netLabelPlacements
+          }
+        ];
+      }
+    ),
     definePipelineStep(
       "netLabelNetLabelCollisionSolver",
       NetLabelNetLabelCollisionSolver,