@tscircuit/schematic-trace-solver 0.0.101 → 0.0.103

package/dist/index.d.ts

@@ -239,8 +239,10 @@ interface OverlappingTraceSegmentLocator {
         traceSegmentIndex: number;
     }>;
 }
+type TraceInteractionKind = "overlap" | "point_contact";
 declare class TraceOverlapIssueSolver extends BaseSolver {
     overlappingTraceSegments: OverlappingTraceSegmentLocator[];
+    interactionKind: TraceInteractionKind;
     traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
     obstacleRects: ReturnType<typeof getObstacleRects>;
     SHIFT_DISTANCE: number;
@@ -248,9 +250,12 @@ declare class TraceOverlapIssueSolver extends BaseSolver {
     constructor(params: {
         inputProblem: InputProblem;
         overlappingTraceSegments: OverlappingTraceSegmentLocator[];
+        interactionKind: TraceInteractionKind;
         traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
     });
     _step(): void;
+    private applyOffsets;
+    private countDifferentNetIntersections;
     private getObstacleAwareOffset;
     private getBlockingCollisions;
     visualize(): GraphicsObject;
@@ -258,14 +263,15 @@ declare class TraceOverlapIssueSolver extends BaseSolver {
 
 type ConnNetId = string;
 /**
- * This solver finds traces that overlap (coincident and parallel) and aren't
- * connected via the globalConnMap, then shifts them to avoid the overlap in
- * such a way that minimizes the resulting intersections
+ * This solver finds traces that overlap or meet collinearly and aren't
+ * connected via the globalConnMap, then shifts them apart in the direction
+ * that minimizes the resulting intersections.
  *
  * All traces are orthogonal, so for traces to be considered overlapping, they
- * need to each have a segment where both are horizontal or both are vertical
- * AND the segments must be within 1e-6 of each other in X (if vertical) or
- * Y (if horizontal)
+ * need to each have a segment where both are horizontal or both are vertical,
+ * the segments must be on the same axis, and their ranges must overlap. A
+ * point contact is also handled when both segments are internal rails, where
+ * it can be separated without moving an anchored terminal segment.
  *
  * Each iteration, we find overlapping traces that aren't part of the same net.
  * This is the same as finding two "trace net islands" that have an overlap.
@@ -294,6 +300,7 @@ declare class TraceOverlapShiftSolver extends BaseSolver {
     computeTraceNetIslands(): Record<ConnNetId, Array<SolvedTracePath>>;
     findNextOverlapIssue(): {
         overlappingTraceSegments: Array<OverlappingTraceSegmentLocator>;
+        interactionKind: TraceInteractionKind;
     } | null;
     private findNextDiagonalSegment;
     private findAndFixNextDiagonalSegment;
@@ -753,6 +760,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private finish;
     private setCurrentLabel;
     private findCorrectedCandidate;
+    private hasTraceContinuingInOrientation;
     private findValidRotatedCandidate;
     private findValidTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;

package/dist/index.js

@@ -1291,6 +1291,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     const isEndpointChipObstacle = rect.kind === "chip" && this.pins.some((pin) => pin.chipId === rect.chipId);
     const canGenerateEndpointDetour = path.length === 3 || path.length === 4 && this.connectionPair !== void 0 && !isEndpointChipObstacle;
     if (canGenerateEndpointDetour && (isFirstSegment || isLastSegment)) {
+      const compareDetours = path.length === 4 ? (a2, b2) => this.getPinBandPenalty(a2) - this.getPinBandPenalty(b2) || this.pathLength(a2) - this.pathLength(b2) : (a2, b2) => this.pathLength(a2) - this.pathLength(b2) || this.getPinBandPenalty(a2) - this.getPinBandPenalty(b2);
       const detours = generateEndpointCollisionDetours({
         path,
         collidingSegmentIndex: segIndex,
@@ -1300,9 +1301,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         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)
-      );
+      }).sort(compareDetours);
       for (const detour of detours) {
         const nextCollisionRects = new Set(collisionRects);
         nextCollisionRects.add(rect);
@@ -1542,6 +1541,9 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
+import { doSegmentsIntersect } from "@tscircuit/math-utils";
+
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts
 var applyJogToTerminalSegment = ({
   pts,
@@ -1630,6 +1632,7 @@ var applyJogToTerminalSegment = ({
 var EPS4 = 1e-6;
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
+  interactionKind;
   traceNetIslands;
   obstacleRects;
   SHIFT_DISTANCE = 0.1;
@@ -1637,6 +1640,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   constructor(params) {
     super();
     this.overlappingTraceSegments = params.overlappingTraceSegments;
+    this.interactionKind = params.interactionKind;
     this.traceNetIslands = params.traceNetIslands;
     this.obstacleRects = getObstacleRects(params.inputProblem);
     for (const { connNetId, pathsWithOverlap } of this.overlappingTraceSegments) {
@@ -1660,19 +1664,64 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     const someGroupCanShift = groupShouldStayInPlace.some(
       (shouldStay) => !shouldStay
     );
-    const offsets = this.overlappingTraceSegments.map((group, idx) => {
-      if (someGroupCanShift && groupShouldStayInPlace[idx]) return 0;
-      const n = Math.floor(idx / 2) + 1;
-      const signed = idx % 2 === 0 ? -n : n;
+    const getSeparationOffsets = (firstDirection) => this.overlappingTraceSegments.map((group, groupIndex) => {
+      if (someGroupCanShift && groupShouldStayInPlace[groupIndex]) return 0;
+      const n = Math.floor(groupIndex / 2) + 1;
+      const direction = groupIndex % 2 === 0 ? firstDirection : -firstDirection;
       return this.getObstacleAwareOffset({
         group,
-        offset: signed * this.SHIFT_DISTANCE
+        offset: direction * n * this.SHIFT_DISTANCE
       });
     });
+    const establishedOffsets = getSeparationOffsets(-1);
+    const isCompoundOverlap = this.interactionKind === "overlap" && this.overlappingTraceSegments.some(
+      (group) => group.pathsWithOverlap.length > 1
+    );
+    if (isCompoundOverlap) {
+      this.correctedTraceMap = this.applyOffsets(establishedOffsets);
+      this.solved = true;
+      return;
+    }
+    const offsetCandidates = this.interactionKind === "overlap" ? [establishedOffsets, getSeparationOffsets(1)] : [];
+    if (this.interactionKind === "point_contact") {
+      const movableGroupIndexes = this.overlappingTraceSegments.map((_, groupIndex) => groupIndex).filter(
+        (groupIndex) => !someGroupCanShift || !groupShouldStayInPlace[groupIndex]
+      ).reverse();
+      for (const groupIndex of movableGroupIndexes) {
+        const group = this.overlappingTraceSegments[groupIndex];
+        for (const direction of [-1, 1]) {
+          const offsets = this.overlappingTraceSegments.map(() => 0);
+          offsets[groupIndex] = this.getObstacleAwareOffset({
+            group,
+            offset: direction * this.SHIFT_DISTANCE
+          });
+          offsetCandidates.push(offsets);
+        }
+      }
+    }
+    const candidates = offsetCandidates.map((offsets) => {
+      const correctedTraceMap = this.applyOffsets(offsets);
+      return {
+        correctedTraceMap,
+        intersectionCount: this.countDifferentNetIntersections(correctedTraceMap),
+        totalDisplacement: offsets.reduce(
+          (total, offset) => total + Math.abs(offset),
+          0
+        )
+      };
+    });
+    candidates.sort(
+      (a, b) => a.intersectionCount - b.intersectionCount || a.totalDisplacement - b.totalDisplacement
+    );
+    this.correctedTraceMap = candidates[0].correctedTraceMap;
+    this.solved = true;
+  }
+  applyOffsets(offsets) {
+    const correctedTraceMap = { ...this.correctedTraceMap };
     const eq = (a, b) => Math.abs(a - b) < EPS4;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
-    this.overlappingTraceSegments.forEach((group, gidx) => {
-      const offset = offsets[gidx];
+    this.overlappingTraceSegments.forEach((group, groupIndex) => {
+      const offset = offsets[groupIndex];
       if (offset === 0) return;
       const byPath = /* @__PURE__ */ new Map();
       for (const loc of group.pathsWithOverlap) {
@@ -1683,9 +1732,22 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       }
       for (const [pathIdx, segIdxSet] of byPath) {
         const original = this.traceNetIslands[group.connNetId][pathIdx];
-        const current = this.correctedTraceMap[original.mspPairId] ?? original;
+        const current = correctedTraceMap[original.mspPairId] ?? original;
         const pts = current.tracePath.map((p) => ({ ...p }));
         const segIdxsRev = Array.from(segIdxSet).sort((a, b) => a - b).reverse();
+        const segmentAxes = /* @__PURE__ */ new Map();
+        for (const si of segIdxsRev) {
+          const start = pts[si];
+          const end = pts[si + 1];
+          if (!start || !end) continue;
+          if (Math.abs(start.x - end.x) < EPS4) {
+            segmentAxes.set(si, "vertical");
+          } else if (Math.abs(start.y - end.y) < EPS4) {
+            segmentAxes.set(si, "horizontal");
+          }
+        }
+        const shiftedXPointIndexes = /* @__PURE__ */ new Set();
+        const shiftedYPointIndexes = /* @__PURE__ */ new Set();
         const JOG_SIZE = this.SHIFT_DISTANCE;
         for (const si of segIdxsRev) {
           if (si < 0 || si >= pts.length - 1) continue;
@@ -1700,15 +1762,25 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            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 {
-              start.y += offset;
-              end.y += offset;
+            const axis = segmentAxes.get(si);
+            if (axis === "vertical") {
+              if (!shiftedXPointIndexes.has(si)) {
+                start.x += offset;
+                shiftedXPointIndexes.add(si);
+              }
+              if (!shiftedXPointIndexes.has(si + 1)) {
+                end.x += offset;
+                shiftedXPointIndexes.add(si + 1);
+              }
+            } else if (axis === "horizontal") {
+              if (!shiftedYPointIndexes.has(si)) {
+                start.y += offset;
+                shiftedYPointIndexes.add(si);
+              }
+              if (!shiftedYPointIndexes.has(si + 1)) {
+                end.y += offset;
+                shiftedYPointIndexes.add(si + 1);
+              }
             }
           }
         }
@@ -1718,13 +1790,39 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
             cleaned.push(p);
           }
         }
-        this.correctedTraceMap[original.mspPairId] = {
+        correctedTraceMap[original.mspPairId] = {
           ...current,
           tracePath: cleaned
         };
       }
     });
-    this.solved = true;
+    return correctedTraceMap;
+  }
+  countDifferentNetIntersections(correctedTraceMap) {
+    const traces = Object.values(this.traceNetIslands).flatMap(
+      (island) => island.map((trace) => correctedTraceMap[trace.mspPairId] ?? trace)
+    );
+    let intersectionCount = 0;
+    for (let traceIndex = 0; traceIndex < traces.length; traceIndex++) {
+      const trace = traces[traceIndex];
+      for (let otherTraceIndex = traceIndex + 1; otherTraceIndex < traces.length; otherTraceIndex++) {
+        const otherTrace = traces[otherTraceIndex];
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
+        for (let segmentIndex = 0; segmentIndex < trace.tracePath.length - 1; segmentIndex++) {
+          for (let otherSegmentIndex = 0; otherSegmentIndex < otherTrace.tracePath.length - 1; otherSegmentIndex++) {
+            if (doSegmentsIntersect(
+              trace.tracePath[segmentIndex],
+              trace.tracePath[segmentIndex + 1],
+              otherTrace.tracePath[otherSegmentIndex],
+              otherTrace.tracePath[otherSegmentIndex + 1]
+            )) {
+              intersectionCount++;
+            }
+          }
+        }
+      }
+    }
+    return intersectionCount;
   }
   getObstacleAwareOffset({
     group,
@@ -1886,15 +1984,58 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
         const pathsB = this.traceNetIslands[netB] || [];
         const overlapsA = [];
         const overlapsB = [];
+        const pointContacts = [];
         const seenA = /* @__PURE__ */ new Set();
         const seenB = /* @__PURE__ */ new Set();
-        const overlaps1D = (a1, a2, b1, b2) => {
+        const getRangeOverlap1D = (a1, a2, b1, b2) => {
           const minA = Math.min(a1, a2);
           const maxA = Math.max(a1, a2);
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
-          const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS11;
+          return Math.min(maxA, maxB) - Math.max(minA, minB);
+        };
+        const recordCollinearInteraction = ({
+          pathAIndex,
+          segmentAIndex,
+          pathBIndex,
+          segmentBIndex,
+          rangeOverlap
+        }) => {
+          if (rangeOverlap > EPS11) {
+            const keyA = `${pathAIndex}:${segmentAIndex}`;
+            const keyB = `${pathBIndex}:${segmentBIndex}`;
+            if (!seenA.has(keyA)) {
+              overlapsA.push({
+                solvedTracePathIndex: pathAIndex,
+                traceSegmentIndex: segmentAIndex
+              });
+              seenA.add(keyA);
+            }
+            if (!seenB.has(keyB)) {
+              overlapsB.push({
+                solvedTracePathIndex: pathBIndex,
+                traceSegmentIndex: segmentBIndex
+              });
+              seenB.add(keyB);
+            }
+            return;
+          }
+          if (rangeOverlap < -EPS11) return;
+          const pathA = pathsA[pathAIndex].tracePath;
+          const pathB = pathsB[pathBIndex].tracePath;
+          const segmentAStart = pathA[segmentAIndex];
+          const segmentAEnd = pathA[segmentAIndex + 1];
+          const segmentBStart = pathB[segmentBIndex];
+          const segmentBEnd = pathB[segmentBIndex + 1];
+          const hasTerminalSegment = segmentAIndex === 0 || segmentAIndex === pathA.length - 2 || segmentBIndex === 0 || segmentBIndex === pathB.length - 2;
+          if (hasTerminalSegment) return;
+          pointContacts.push({
+            pathAIndex,
+            segmentAIndex,
+            pathBIndex,
+            segmentBIndex,
+            combinedLength: Math.abs(segmentAStart.x - segmentAEnd.x) + Math.abs(segmentAStart.y - segmentAEnd.y) + Math.abs(segmentBStart.x - segmentBEnd.x) + Math.abs(segmentBStart.y - segmentBEnd.y)
+          });
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1916,45 +2057,23 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
                   if (Math.abs(a1.x - b1.x) < EPS11) {
-                    if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
-                      const keyA = `${pa}:${sa}`;
-                      const keyB = `${pb}:${sb}`;
-                      if (!seenA.has(keyA)) {
-                        overlapsA.push({
-                          solvedTracePathIndex: pa,
-                          traceSegmentIndex: sa
-                        });
-                        seenA.add(keyA);
-                      }
-                      if (!seenB.has(keyB)) {
-                        overlapsB.push({
-                          solvedTracePathIndex: pb,
-                          traceSegmentIndex: sb
-                        });
-                        seenB.add(keyB);
-                      }
-                    }
+                    recordCollinearInteraction({
+                      pathAIndex: pa,
+                      segmentAIndex: sa,
+                      pathBIndex: pb,
+                      segmentBIndex: sb,
+                      rangeOverlap: getRangeOverlap1D(a1.y, a2.y, b1.y, b2.y)
+                    });
                   }
                 } else if (aHorz && bHorz) {
                   if (Math.abs(a1.y - b1.y) < EPS11) {
-                    if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
-                      const keyA = `${pa}:${sa}`;
-                      const keyB = `${pb}:${sb}`;
-                      if (!seenA.has(keyA)) {
-                        overlapsA.push({
-                          solvedTracePathIndex: pa,
-                          traceSegmentIndex: sa
-                        });
-                        seenA.add(keyA);
-                      }
-                      if (!seenB.has(keyB)) {
-                        overlapsB.push({
-                          solvedTracePathIndex: pb,
-                          traceSegmentIndex: sb
-                        });
-                        seenB.add(keyB);
-                      }
-                    }
+                    recordCollinearInteraction({
+                      pathAIndex: pa,
+                      segmentAIndex: sa,
+                      pathBIndex: pb,
+                      segmentBIndex: sb,
+                      rangeOverlap: getRangeOverlap1D(a1.x, a2.x, b1.x, b2.x)
+                    });
                   }
                 }
               }
@@ -1963,12 +2082,41 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
         }
         if (overlapsA.length > 0 && overlapsB.length > 0) {
           return {
+            interactionKind: "overlap",
             overlappingTraceSegments: [
               { connNetId: netA, pathsWithOverlap: overlapsA },
               { connNetId: netB, pathsWithOverlap: overlapsB }
             ]
           };
         }
+        const bestPointContact = pointContacts.sort(
+          (a, b) => b.combinedLength - a.combinedLength
+        )[0];
+        if (bestPointContact) {
+          return {
+            interactionKind: "point_contact",
+            overlappingTraceSegments: [
+              {
+                connNetId: netA,
+                pathsWithOverlap: [
+                  {
+                    solvedTracePathIndex: bestPointContact.pathAIndex,
+                    traceSegmentIndex: bestPointContact.segmentAIndex
+                  }
+                ]
+              },
+              {
+                connNetId: netB,
+                pathsWithOverlap: [
+                  {
+                    solvedTracePathIndex: bestPointContact.pathBIndex,
+                    traceSegmentIndex: bestPointContact.segmentBIndex
+                  }
+                ]
+              }
+            ]
+          };
+        }
       }
     }
     return null;
@@ -2044,9 +2192,10 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    const { overlappingTraceSegments } = overlapIssue;
+    const { interactionKind, overlappingTraceSegments } = overlapIssue;
     this.activeSubSolver = new TraceOverlapIssueSolver({
       inputProblem: this.inputProblem,
+      interactionKind,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands
     });
@@ -4165,7 +4314,7 @@ var expandChipsToFitPins = (problem) => {
 };
 
 // lib/utils/does-trace-overlap-with-existing-traces.ts
-import { doSegmentsIntersect } from "@tscircuit/math-utils";
+import { doSegmentsIntersect as doSegmentsIntersect2 } from "@tscircuit/math-utils";
 function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
   for (let i = 0; i < newTracePath.length - 1; i++) {
     const newSegmentP1 = newTracePath[i];
@@ -4174,7 +4323,7 @@ function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
       for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
         const existingSegmentP1 = existingTrace.tracePath[j];
         const existingSegmentP2 = existingTrace.tracePath[j + 1];
-        if (doSegmentsIntersect(
+        if (doSegmentsIntersect2(
           newSegmentP1,
           newSegmentP2,
           existingSegmentP1,
@@ -7335,6 +7484,26 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findCorrectedCandidate(label, labelIndex) {
     const orientations = this.getAvailableOrientations(label);
+    const requiredOrientation = orientations[0];
+    const isTwoPinNet = this.inputProblem.netConnections.some(
+      (connection) => connection.netId === label.netId && connection.pinIds.length === 2
+    );
+    if (isTwoPinNet && orientations.length === 1 && isYOrientation(requiredOrientation) && this.hasTraceContinuingInOrientation(label, requiredOrientation)) {
+      const alignedCandidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation: requiredOrientation,
+        direction: dir(requiredOrientation),
+        baseAnchor: this.getWickOffsetAnchor(
+          label.anchorPoint,
+          requiredOrientation
+        ),
+        maxSearchDistance: this.maxSearchDistance,
+        outwardDistance: 0,
+        stopOnTraceCollision: false
+      });
+      if (alignedCandidate) return alignedCandidate;
+    }
     const rotatedCandidate = this.findValidRotatedCandidate(
       label,
       labelIndex,
@@ -7359,6 +7528,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       labelIndex
     );
   }
+  hasTraceContinuingInOrientation(label, orientation) {
+    const direction = dir(orientation);
+    return Object.values(this.traceMap).some((trace) => {
+      if (trace.globalConnNetId !== label.globalConnNetId) return false;
+      const path = trace.tracePath;
+      return path.some((point, pointIndex) => {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS9 || Math.abs(point.y - label.anchorPoint.y) > EPS9) {
+          return false;
+        }
+        return [path[pointIndex - 1], path[pointIndex + 1]].some(
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS9 && (neighbor.y - point.y) * direction.y > EPS9
+        );
+      });
+    });
+  }
   findValidRotatedCandidate(label, labelIndex, orientations) {
     for (const orientation of orientations) {
       const candidate = this.createCandidate(
@@ -7504,7 +7688,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       baseAnchor,
       maxSearchDistance,
       outwardDistance,
-      phase = "shift"
+      phase = "shift",
+      stopOnTraceCollision = true
     } = params;
     for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS9; distance4 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
@@ -7525,7 +7710,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         result.selected = true;
         return result;
       }
-      if (result.status === "trace-collision") break;
+      if (stopOnTraceCollision && result.status === "trace-collision") break;
     }
     return null;
   }

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -11,6 +11,7 @@ import {
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputPin, InputProblem } from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 import { EPS, LABEL_SEARCH_STEP, WICK_CLEARANCE } from "./constants"
 import {
   getConnectorTracePath,
@@ -22,8 +23,8 @@ import {
   rectsOverlap,
   simplifyOrthogonalPath,
   traceCrossesBoundsInterior,
-  tracePathIntersectsBounds,
   tracePathCrossesAnyBounds,
+  tracePathIntersectsBounds,
 } from "./geometry"
 import { getPinMap, getTracePins, toNetLabelPlacementPatch } from "./traces"
 import type {
@@ -36,7 +37,6 @@ import type {
   EvaluatedCandidate,
 } from "./types"
 import { visualizeAvailableNetOrientationSolver } from "./visualize"
-import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 const LABEL_TRACE_CLEARANCE = 0.1
 
@@ -182,6 +182,34 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
   private findCorrectedCandidate(label: NetLabelPlacement, labelIndex: number) {
     const orientations = this.getAvailableOrientations(label)
+    const requiredOrientation = orientations[0]!
+    const isTwoPinNet = this.inputProblem.netConnections.some(
+      (connection) =>
+        connection.netId === label.netId && connection.pinIds.length === 2,
+    )
+    if (
+      isTwoPinNet &&
+      orientations.length === 1 &&
+      isYOrientation(requiredOrientation) &&
+      this.hasTraceContinuingInOrientation(label, requiredOrientation)
+    ) {
+      // Keep two-pin vertical net labels aligned with the existing trace.
+      const alignedCandidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation: requiredOrientation,
+        direction: dir(requiredOrientation),
+        baseAnchor: this.getWickOffsetAnchor(
+          label.anchorPoint,
+          requiredOrientation,
+        ),
+        maxSearchDistance: this.maxSearchDistance,
+        outwardDistance: 0,
+        stopOnTraceCollision: false,
+      })
+      if (alignedCandidate) return alignedCandidate
+    }
+
     const rotatedCandidate = this.findValidRotatedCandidate(
       label,
       labelIndex,
@@ -210,6 +238,31 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
   }
 
+  private hasTraceContinuingInOrientation(
+    label: NetLabelPlacement,
+    orientation: "y+" | "y-",
+  ) {
+    const direction = dir(orientation)
+    return Object.values(this.traceMap).some((trace) => {
+      if (trace.globalConnNetId !== label.globalConnNetId) return false
+      const path = trace.tracePath
+      return path.some((point, pointIndex) => {
+        if (
+          Math.abs(point.x - label.anchorPoint.x) > EPS ||
+          Math.abs(point.y - label.anchorPoint.y) > EPS
+        ) {
+          return false
+        }
+        return [path[pointIndex - 1], path[pointIndex + 1]].some(
+          (neighbor) =>
+            neighbor &&
+            Math.abs(neighbor.x - point.x) <= EPS &&
+            (neighbor.y - point.y) * direction.y > EPS,
+        )
+      })
+    })
+  }
+
   private findValidRotatedCandidate(
     label: NetLabelPlacement,
     labelIndex: number,
@@ -401,6 +454,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     maxSearchDistance: number
     outwardDistance: number
     phase?: CandidatePhase
+    stopOnTraceCollision?: boolean
   }) {
     const {
       label,
@@ -411,6 +465,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       maxSearchDistance,
       outwardDistance,
       phase = "shift",
+      stopOnTraceCollision = true,
     } = params
 
     for (
@@ -437,7 +492,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         result.selected = true
         return result
       }
-      if (result.status === "trace-collision") break
+      if (stopOnTraceCollision && result.status === "trace-collision") break
     }
 
     return null

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -370,6 +370,18 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         !isEndpointChipObstacle)
 
     if (canGenerateEndpointDetour && (isFirstSegment || isLastSegment)) {
+      // A three-point detour replaces an L elbow, so the shortest valid route
+      // remains the best choice. A four-point detour preserves the far side of
+      // a U elbow; prefer the candidate that keeps its new internal rails out
+      // of the pin band, then use length to choose between equivalent routes.
+      const compareDetours =
+        path.length === 4
+          ? (a: Point[], b: Point[]) =>
+              this.getPinBandPenalty(a) - this.getPinBandPenalty(b) ||
+              this.pathLength(a) - this.pathLength(b)
+          : (a: Point[], b: Point[]) =>
+              this.pathLength(a) - this.pathLength(b) ||
+              this.getPinBandPenalty(a) - this.getPinBandPenalty(b)
       const detours = generateEndpointCollisionDetours({
         path,
         collidingSegmentIndex: segIndex,
@@ -381,11 +393,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
           this.visited.add(key)
           return true
         })
-        .sort(
-          (a, b) =>
-            this.pathLength(a) - this.pathLength(b) ||
-            this.getPinBandPenalty(a) - this.getPinBandPenalty(b),
-        )
+        .sort(compareDetours)
 
       for (const detour of detours) {
         const nextCollisionRects = new Set(collisionRects)