@tscircuit/schematic-trace-solver 0.0.100 → 0.0.102

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;

package/dist/index.js

@@ -894,7 +894,7 @@ var generateEndpointCollisionDetours = ({
   collidingSegmentIndex,
   obstacle
 }) => {
-  if (path.length !== 3) return [];
+  if (path.length < 3 || path.length > 4) return [];
   const lastSegmentIndex = path.length - 2;
   if (collidingSegmentIndex !== 0 && collidingSegmentIndex !== lastSegmentIndex) {
     return [];
@@ -917,7 +917,7 @@ var generateEndpointCollisionDetours = ({
   const detours = [];
   for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
     for (const detourCoordinate of [...new Set(detourCoordinates)]) {
-      const orderedDetour = firstSegmentAxis === "y" ? [
+      const orderedDetourPrefix = firstSegmentAxis === "y" ? [
         start,
         { x: escapeCoordinate, y: start.y },
         { x: escapeCoordinate, y: detourCoordinate },
@@ -930,6 +930,7 @@ var generateEndpointCollisionDetours = ({
         { x: detourCoordinate, y: end.y },
         end
       ];
+      const orderedDetour = [...orderedDetourPrefix, ...orderedPath.slice(3)];
       const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour;
       if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour);
     }
@@ -1287,7 +1288,10 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     let { segIndex, rect } = collision;
     const isFirstSegment = segIndex === 0;
     const isLastSegment = segIndex === path.length - 2;
-    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+    const 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,
@@ -1297,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);
@@ -1539,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,
@@ -1627,6 +1632,7 @@ var applyJogToTerminalSegment = ({
 var EPS4 = 1e-6;
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
+  interactionKind;
   traceNetIslands;
   obstacleRects;
   SHIFT_DISTANCE = 0.1;
@@ -1634,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) {
@@ -1657,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) {
@@ -1680,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;
@@ -1697,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);
+              }
             }
           }
         }
@@ -1715,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,
@@ -1883,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];
@@ -1913,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)
+                    });
                   }
                 }
               }
@@ -1960,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;
@@ -2041,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
     });
@@ -4162,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];
@@ -4171,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,

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

@@ -357,8 +357,31 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     // Never move the first or last segments - move adjacent segment instead
     const isFirstSegment = segIndex === 0
     const isLastSegment = segIndex === path.length - 2
-
-    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+    const isEndpointChipObstacle =
+      rect.kind === "chip" &&
+      this.pins.some((pin) => pin.chipId === rect.chipId)
+    // U-shaped detours are local repairs for fixed MSP pairs obstructed by an
+    // intermediate obstacle. Endpoint-chip and optional long-distance routing
+    // require multi-trace or net-level selection instead.
+    const canGenerateEndpointDetour =
+      path.length === 3 ||
+      (path.length === 4 &&
+        this.connectionPair !== undefined &&
+        !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,
@@ -370,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)

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

@@ -28,7 +28,9 @@ export const generateEndpointCollisionDetours = ({
   collidingSegmentIndex: number
   obstacle: ObstacleRect
 }): Point[][] => {
-  if (path.length !== 3) return []
+  // Endpoint detours expand the initial L- and U-shaped elbow candidates.
+  // Longer paths have already been expanded and are handled by segment shifts.
+  if (path.length < 3 || path.length > 4) return []
 
   const lastSegmentIndex = path.length - 2
   if (
@@ -58,7 +60,7 @@ export const generateEndpointCollisionDetours = ({
   const detours: Point[][] = []
   for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
     for (const detourCoordinate of [...new Set(detourCoordinates)]) {
-      const orderedDetour =
+      const orderedDetourPrefix =
         firstSegmentAxis === "y"
           ? [
               start!,
@@ -75,6 +77,7 @@ export const generateEndpointCollisionDetours = ({
               end!,
             ]
 
+      const orderedDetour = [...orderedDetourPrefix, ...orderedPath.slice(3)]
       const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour
       if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour)
     }