@tscircuit/schematic-trace-solver 0.0.96 → 0.0.98

package/dist/index.js

@@ -585,54 +585,150 @@ import "graphics-debug";
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 
-// lib/solvers/GuidelinesSolver/getInputChipBounds.ts
-function getInputChipBounds(chip) {
-  const halfWidth = chip.width / 2;
-  const halfHeight = chip.height / 2;
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
+var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
+var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
+function getDimsForOrientation(params) {
+  const { orientation, netLabelWidth, netLabelHeight } = params;
+  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
+  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
+      height: horizWidth
+    };
+  }
   return {
-    minX: chip.center.x - halfWidth,
-    maxX: chip.center.x + halfWidth,
-    minY: chip.center.y - halfHeight,
-    maxY: chip.center.y + halfHeight
+    width: horizWidth,
+    height: horizHeight
   };
 }
-
-// lib/utils/textBoxBounds.ts
-function getTextBoxBounds(textBox, padding = {}) {
+function getCenterFromAnchor(anchor, orientation, width, height) {
+  switch (orientation) {
+    case "x+":
+      return { x: anchor.x + width / 2, y: anchor.y };
+    case "x-":
+      return { x: anchor.x - width / 2, y: anchor.y };
+    case "y+":
+      return { x: anchor.x, y: anchor.y + height / 2 };
+    case "y-":
+      return { x: anchor.x, y: anchor.y - height / 2 };
+  }
+}
+function getRectBounds(center, w, h) {
   return {
-    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
-    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
-    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
-    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2
   };
 }
-function boundsOverlap(a, b, eps = 1e-9) {
-  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
+import { calculateElbow } from "calculate-elbow";
+var MAX_SHORT_TRACE_DISTANCE = 0.15;
+var SHORT_TRACE_OVERSHOOT = MAX_SHORT_TRACE_DISTANCE / 7.5;
+var FALLBACK_ELBOW_MAX_OVERSHOOT = 0.2;
+function segmentDirection(from, to) {
+  if (to.x > from.x) return "x+";
+  if (to.x < from.x) return "x-";
+  if (to.y > from.y) return "y+";
+  if (to.y < from.y) return "y-";
+  return null;
 }
-function rectIntersectsAnyTextBox(bounds, inputProblem) {
-  for (const textBox of inputProblem.textBoxes ?? []) {
-    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+function pathMatchesPinDirections({
+  path,
+  pin1,
+  pin2
+}) {
+  const firstDirection = segmentDirection(path[0], path[1]);
+  const lastDirection = segmentDirection(
+    path[path.length - 1],
+    path[path.length - 2]
+  );
+  return firstDirection === pin1._facingDirection && lastDirection === pin2._facingDirection;
+}
+function calculateShortOrthogonalRoute(pin1, pin2) {
+  if (pin1.x === pin2.x || pin1.y === pin2.y) return null;
+  const firstDir = pin1._facingDirection;
+  const lastDir = pin2._facingDirection;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  let path = null;
+  if (firstDir?.startsWith("y") && lastDir?.startsWith("x")) {
+    let yOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "y+") {
+      yOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeY = start.y + yOffset;
+    const routeX = (start.x + end.x) / 2;
+    path = [
+      start,
+      { x: start.x, y: routeY },
+      { x: routeX, y: routeY },
+      { x: routeX, y: end.y },
+      end
+    ];
+  } else if (firstDir?.startsWith("x") && lastDir?.startsWith("y")) {
+    let xOffset = -SHORT_TRACE_OVERSHOOT;
+    if (firstDir === "x+") {
+      xOffset = SHORT_TRACE_OVERSHOOT;
+    }
+    const routeX = start.x + xOffset;
+    const routeY = (start.y + end.y) / 2;
+    path = [
+      start,
+      { x: routeX, y: start.y },
+      { x: routeX, y: routeY },
+      { x: end.x, y: routeY },
+      end
+    ];
   }
-  return false;
+  if (!path) return null;
+  if (pathMatchesPinDirections({ path, pin1, pin2 })) {
+    return path;
+  }
+  return null;
+}
+function calculateDirectShortPath(pin1, pin2) {
+  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
+  if (routingDistance > MAX_SHORT_TRACE_DISTANCE) return null;
+  const start = { x: pin1.x, y: pin1.y };
+  const end = { x: pin2.x, y: pin2.y };
+  const orthogonalRoute = calculateShortOrthogonalRoute(pin1, pin2);
+  if (orthogonalRoute) return orthogonalRoute;
+  let candidatePaths = [];
+  if (pin1.x !== pin2.x && pin1.y !== pin2.y) {
+    candidatePaths = [
+      [start, { x: pin2.x, y: pin1.y }, end],
+      [start, { x: pin1.x, y: pin2.y }, end]
+    ];
+  } else {
+    candidatePaths = [[start, end]];
+  }
+  for (const path of candidatePaths) {
+    if (pathMatchesPinDirections({ path, pin1, pin2 })) return path;
+  }
+  return calculateElbow(
+    {
+      x: pin1.x,
+      y: pin1.y,
+      facingDirection: pin1._facingDirection
+    },
+    {
+      x: pin2.x,
+      y: pin2.y,
+      facingDirection: pin2._facingDirection
+    },
+    {
+      overshoot: Math.min(
+        FALLBACK_ELBOW_MAX_OVERSHOOT,
+        Math.max(SHORT_TRACE_OVERSHOOT, routingDistance / 4)
+      )
+    }
+  );
 }
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
-var chipToRect = (chip) => {
-  const b = getInputChipBounds(chip);
-  return { kind: "chip", chipId: chip.chipId, ...b };
-};
-var getObstacleRects = (problem, opts = {}) => {
-  const chipRects = problem.chips.map(chipToRect);
-  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
-    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
-    return {
-      kind: "text_box",
-      textBox,
-      ...b
-    };
-  });
-  return [...chipRects, ...textBoxRects];
-};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts
 var EPS = 1e-9;
@@ -658,6 +754,21 @@ var segmentIntersectsRect = (a, b, r, eps = EPS) => {
     return overlap > eps;
   }
 };
+var segmentOverlapsRectBoundary = (a, b, r, eps = EPS) => {
+  if (isVertical(a, b, eps)) {
+    const onVerticalBoundary = Math.abs(a.x - r.minX) <= eps || Math.abs(a.x - r.maxX) <= eps;
+    if (!onVerticalBoundary) return false;
+    const overlap = Math.min(Math.max(a.y, b.y), r.maxY) - Math.max(Math.min(a.y, b.y), r.minY);
+    return overlap > eps;
+  }
+  if (isHorizontal(a, b, eps)) {
+    const onHorizontalBoundary = Math.abs(a.y - r.minY) <= eps || Math.abs(a.y - r.maxY) <= eps;
+    if (!onHorizontalBoundary) return false;
+    const overlap = Math.min(Math.max(a.x, b.x), r.maxX) - Math.max(Math.min(a.x, b.x), r.minX);
+    return overlap > eps;
+  }
+  return false;
+};
 var findFirstCollision = (pts, rects, opts = {}) => {
   for (let i = 0; i < pts.length - 1; i++) {
     const a = pts[i];
@@ -812,151 +923,55 @@ var pathKey = (pts, decimals = 6) => {
   return key;
 };
 
-// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
-var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
-var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
-function getDimsForOrientation(params) {
-  const { orientation, netLabelWidth, netLabelHeight } = params;
-  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
-  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
-  if (orientation === "y+" || orientation === "y-") {
-    return {
-      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
-      width: horizHeight,
-      height: horizWidth
-    };
-  }
+// lib/solvers/GuidelinesSolver/getInputChipBounds.ts
+function getInputChipBounds(chip) {
+  const halfWidth = chip.width / 2;
+  const halfHeight = chip.height / 2;
   return {
-    width: horizWidth,
-    height: horizHeight
+    minX: chip.center.x - halfWidth,
+    maxX: chip.center.x + halfWidth,
+    minY: chip.center.y - halfHeight,
+    maxY: chip.center.y + halfHeight
   };
 }
-function getCenterFromAnchor(anchor, orientation, width, height) {
-  switch (orientation) {
-    case "x+":
-      return { x: anchor.x + width / 2, y: anchor.y };
-    case "x-":
-      return { x: anchor.x - width / 2, y: anchor.y };
-    case "y+":
-      return { x: anchor.x, y: anchor.y + height / 2 };
-    case "y-":
-      return { x: anchor.x, y: anchor.y - height / 2 };
-  }
-}
-function getRectBounds(center, w, h) {
+
+// lib/utils/textBoxBounds.ts
+function getTextBoxBounds(textBox, padding = {}) {
   return {
-    minX: center.x - w / 2,
-    minY: center.y - h / 2,
-    maxX: center.x + w / 2,
-    maxY: center.y + h / 2
+    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
+    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
+    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
+    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
   };
 }
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
-import { calculateElbow } from "calculate-elbow";
-var MAX_SHORT_TRACE_DISTANCE = 0.15;
-var SHORT_TRACE_OVERSHOOT = MAX_SHORT_TRACE_DISTANCE / 7.5;
-var FALLBACK_ELBOW_MAX_OVERSHOOT = 0.2;
-function segmentDirection(from, to) {
-  if (to.x > from.x) return "x+";
-  if (to.x < from.x) return "x-";
-  if (to.y > from.y) return "y+";
-  if (to.y < from.y) return "y-";
-  return null;
-}
-function pathMatchesPinDirections({
-  path,
-  pin1,
-  pin2
-}) {
-  const firstDirection = segmentDirection(path[0], path[1]);
-  const lastDirection = segmentDirection(
-    path[path.length - 1],
-    path[path.length - 2]
-  );
-  return firstDirection === pin1._facingDirection && lastDirection === pin2._facingDirection;
-}
-function calculateShortOrthogonalRoute(pin1, pin2) {
-  if (pin1.x === pin2.x || pin1.y === pin2.y) return null;
-  const firstDir = pin1._facingDirection;
-  const lastDir = pin2._facingDirection;
-  const start = { x: pin1.x, y: pin1.y };
-  const end = { x: pin2.x, y: pin2.y };
-  let path = null;
-  if (firstDir?.startsWith("y") && lastDir?.startsWith("x")) {
-    let yOffset = -SHORT_TRACE_OVERSHOOT;
-    if (firstDir === "y+") {
-      yOffset = SHORT_TRACE_OVERSHOOT;
-    }
-    const routeY = start.y + yOffset;
-    const routeX = (start.x + end.x) / 2;
-    path = [
-      start,
-      { x: start.x, y: routeY },
-      { x: routeX, y: routeY },
-      { x: routeX, y: end.y },
-      end
-    ];
-  } else if (firstDir?.startsWith("x") && lastDir?.startsWith("y")) {
-    let xOffset = -SHORT_TRACE_OVERSHOOT;
-    if (firstDir === "x+") {
-      xOffset = SHORT_TRACE_OVERSHOOT;
-    }
-    const routeX = start.x + xOffset;
-    const routeY = (start.y + end.y) / 2;
-    path = [
-      start,
-      { x: routeX, y: start.y },
-      { x: routeX, y: routeY },
-      { x: end.x, y: routeY },
-      end
-    ];
-  }
-  if (!path) return null;
-  if (pathMatchesPinDirections({ path, pin1, pin2 })) {
-    return path;
-  }
-  return null;
+function boundsOverlap(a, b, eps = 1e-9) {
+  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
 }
-function calculateDirectShortPath(pin1, pin2) {
-  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
-  if (routingDistance > MAX_SHORT_TRACE_DISTANCE) return null;
-  const start = { x: pin1.x, y: pin1.y };
-  const end = { x: pin2.x, y: pin2.y };
-  const orthogonalRoute = calculateShortOrthogonalRoute(pin1, pin2);
-  if (orthogonalRoute) return orthogonalRoute;
-  let candidatePaths = [];
-  if (pin1.x !== pin2.x && pin1.y !== pin2.y) {
-    candidatePaths = [
-      [start, { x: pin2.x, y: pin1.y }, end],
-      [start, { x: pin1.x, y: pin2.y }, end]
-    ];
-  } else {
-    candidatePaths = [[start, end]];
-  }
-  for (const path of candidatePaths) {
-    if (pathMatchesPinDirections({ path, pin1, pin2 })) return path;
+function rectIntersectsAnyTextBox(bounds, inputProblem) {
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
   }
-  return calculateElbow(
-    {
-      x: pin1.x,
-      y: pin1.y,
-      facingDirection: pin1._facingDirection
-    },
-    {
-      x: pin2.x,
-      y: pin2.y,
-      facingDirection: pin2._facingDirection
-    },
-    {
-      overshoot: Math.min(
-        FALLBACK_ELBOW_MAX_OVERSHOOT,
-        Math.max(SHORT_TRACE_OVERSHOOT, routingDistance / 4)
-      )
-    }
-  );
+  return false;
 }
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var chipToRect = (chip) => {
+  const b = getInputChipBounds(chip);
+  return { kind: "chip", chipId: chip.chipId, ...b };
+};
+var getObstacleRects = (problem, opts = {}) => {
+  const chipRects = problem.chips.map(chipToRect);
+  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
+    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
+    return {
+      kind: "text_box",
+      textBox,
+      ...b
+    };
+  });
+  return [...chipRects, ...textBoxRects];
+};
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
@@ -1143,17 +1158,41 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex2) => {
         const lastSegIndex2 = path.length - 2;
+        const excludedRects = /* @__PURE__ */ new Set();
         if (segIndex2 === 0 || segIndex2 === lastSegIndex2) {
-          return this.textObstacles;
+          for (const textObstacle of this.textObstacles) {
+            excludedRects.add(textObstacle);
+          }
+        }
+        const segmentStart = path[segIndex2];
+        const segmentEnd = path[segIndex2 + 1];
+        const endpointEpsilon = 1e-9;
+        const segmentTouchesPin = (pin) => [segmentStart, segmentEnd].some(
+          (point) => Math.abs(point.x - pin.x) <= endpointEpsilon && Math.abs(point.y - pin.y) <= endpointEpsilon
+        );
+        for (const pin of this.pins) {
+          if (!segmentTouchesPin(pin)) continue;
+          const endpointChipObstacle = this.obstacles.find(
+            (obstacle) => obstacle.kind === "chip" && obstacle.chipId === pin.chipId
+          );
+          if (endpointChipObstacle && segmentOverlapsRectBoundary(
+            segmentStart,
+            segmentEnd,
+            endpointChipObstacle
+          )) {
+            excludedRects.add(endpointChipObstacle);
+          }
         }
         const adjacentEndpointSegIndex = segIndex2 === 1 ? 2 : segIndex2 === lastSegIndex2 - 1 ? lastSegIndex2 - 2 : null;
         if (adjacentEndpointSegIndex !== null && adjacentEndpointSegIndex >= 0 && adjacentEndpointSegIndex < lastSegIndex2 && this.isSegmentOutsidePinBand(
           path[adjacentEndpointSegIndex],
           path[adjacentEndpointSegIndex + 1]
         )) {
-          return this.endpointTextObstacles;
+          for (const textObstacle of this.endpointTextObstacles) {
+            excludedRects.add(textObstacle);
+          }
         }
-        return /* @__PURE__ */ new Set();
+        return excludedRects;
       }
     });
     if (!collision) {
@@ -1401,12 +1440,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(
@@ -1432,7 +1471,7 @@ var applyJogToTerminalSegment = ({
     return;
   }
   if (si === 0) {
-    if (isVertical4) {
+    if (isVertical5) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1452,7 +1491,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical4) {
+    if (isVertical5) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1548,10 +1587,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 {
@@ -1580,11 +1619,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;
@@ -1596,8 +1635,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,
@@ -1631,10 +1670,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 }
       ] : [
@@ -1645,7 +1684,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       if (collision) {
         blockingCollisions.push({
           start,
-          isVertical: isVertical4,
+          isVertical: isVertical5,
           obstacle: collision.rect
         });
       }
@@ -1828,9 +1867,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 };
         }
       }
@@ -3439,19 +3478,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];
@@ -3473,6 +3511,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;
@@ -4629,26 +4670,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 distance3 = getDistance2(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) < 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
   };
 };
 
@@ -4709,8 +5334,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,
@@ -4723,50 +5348,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 };
@@ -5230,9 +5855,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;
@@ -5242,12 +5867,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;
@@ -5256,6 +5888,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)
     );
@@ -5268,13 +5902,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();
@@ -5285,8 +5923,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,
@@ -5295,17 +5942,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");
@@ -5335,6 +5979,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
@@ -5413,160 +6070,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(
@@ -5629,7 +6132,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;
       }
     }
@@ -5644,14 +6147,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);
@@ -6414,16 +6917,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;
@@ -6446,7 +6949,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(
@@ -6457,7 +6960,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(
@@ -6496,7 +6999,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]];
@@ -6512,9 +7015,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),
@@ -6817,7 +7320,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
@@ -6890,7 +7393,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       outwardDistance,
       phase = "shift"
     } = params;
-    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS8; distance3 += LABEL_SEARCH_STEP) {
+    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS9; distance3 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance3,
         y: baseAnchor.y + direction.y * distance3
@@ -7127,9 +7630,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) {
@@ -7196,15 +7699,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,
@@ -7252,7 +7755,7 @@ 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)) {
@@ -7269,8 +7772,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;
@@ -7308,39 +7811,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";
@@ -7563,20 +8033,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)) {
@@ -7587,14 +8057,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
         });
       }
@@ -7769,7 +8239,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;
     }
@@ -7780,7 +8250,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;
     }
@@ -7794,20 +8264,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;
 
@@ -8816,11 +9286,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-"];
@@ -9033,7 +9503,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   availableNetOrientationSolver;
   railNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
+  preAlignmentNetLabelTraceCollisionSolver;
   netLabelTraceCollisionSolver;
+  traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
   startTimeOfPhase;
   endTimeOfPhase;
@@ -9218,7 +9690,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     ),
     definePipelineStep(
-      "netLabelTraceCollisionSolver",
+      "preAlignmentNetLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => [
         {
@@ -9228,6 +9700,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,