@tscircuit/schematic-trace-solver 0.0.65 → 0.0.67

package/dist/index.d.ts

@@ -384,6 +384,7 @@ declare class NetLabelPlacementSolver extends BaseSolver {
     queuedOverlappingSameNetTraceGroups: Array<OverlappingSameNetTraceGroup>;
     activeSubSolver: SingleNetLabelPlacementSolver | null;
     netLabelPlacements: Array<NetLabelPlacement>;
+    failedGroups: Array<OverlappingSameNetTraceGroup>;
     currentGroup: OverlappingSameNetTraceGroup | null;
     triedAnyOrientationFallbackForCurrentGroup: boolean;
     constructor(params: {
@@ -434,6 +435,7 @@ interface SingleOverlapSolverInput {
     problem: InputProblem;
     paddingBuffer: number;
     detourCount: number;
+    tracesToAvoidOverlapping?: SolvedTracePath[];
 }
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
@@ -447,6 +449,7 @@ declare class SingleOverlapSolver extends BaseSolver {
     problem: InputProblem;
     obstacles: ReturnType<typeof getObstacleRects>;
     label: NetLabelPlacement;
+    tracesToAvoidOverlapping: SolvedTracePath[];
     _tried: number;
     constructor(solverInput: SingleOverlapSolverInput);
     _step(): void;
@@ -460,6 +463,7 @@ interface OverlapCollectionSolverInput {
     mergedNetLabelPlacements: NetLabelPlacement[];
     mergedLabelNetIdMap: Record<string, Set<string>>;
     detourCounts: Map<string, number>;
+    tracesToAvoidOverlapping?: SolvedTracePath[];
 }
 /**
  * This is an internal solver that manages the step-by-step process of avoiding
@@ -471,6 +475,7 @@ declare class OverlapAvoidanceStepSolver extends BaseSolver {
     mergedNetLabelPlacements: NetLabelPlacement[];
     mergedLabelNetIdMap: Record<string, Set<string>>;
     allTraces: SolvedTracePath[];
+    tracesToAvoidOverlapping: SolvedTracePath[];
     modifiedTraces: SolvedTracePath[];
     private readonly PADDING_BUFFER;
     private detourCounts;
@@ -517,6 +522,7 @@ declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     private phase;
     detourCounts: Map<string, number>;
     labelMergingSolver?: MergedNetLabelObstacleSolver;
+    allInputTraces: SolvedTracePath[];
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {

package/dist/index.js

@@ -1059,6 +1059,32 @@ var applyJogToTerminalSegment = ({
   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;
+  if (pts.length === 2) {
+    if (isVertical4) {
+      const jogYNearStart = start.y + segDir * JOG_SIZE;
+      const jogYNearEnd = end.y - segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        0,
+        { x: start.x, y: jogYNearStart },
+        { x: start.x + offset, y: jogYNearStart },
+        { x: end.x + offset, y: jogYNearEnd },
+        { x: end.x, y: jogYNearEnd }
+      );
+    } else {
+      const jogXNearStart = start.x + segDir * JOG_SIZE;
+      const jogXNearEnd = end.x - segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        0,
+        { x: jogXNearStart, y: start.y },
+        { x: jogXNearStart, y: start.y + offset },
+        { x: jogXNearEnd, y: end.y + offset },
+        { x: jogXNearEnd, y: end.y }
+      );
+    }
+    return;
+  }
   if (si === 0) {
     if (isVertical4) {
       const jogY = start.y + segDir * JOG_SIZE;
@@ -1126,7 +1152,18 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
+    const containsStraightPinToPinTrace = (group) => group.pathsWithOverlap.some(({ solvedTracePathIndex }) => {
+      const path = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+      return path.tracePath.length === 2;
+    });
+    const groupShouldStayInPlace = this.overlappingTraceSegments.map(
+      containsStraightPinToPinTrace
+    );
+    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;
       return this.getObstacleAwareOffset({
@@ -1138,6 +1175,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     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];
+      if (offset === 0) return;
       const byPath = /* @__PURE__ */ new Map();
       for (const loc of group.pathsWithOverlap) {
         if (!byPath.has(loc.solvedTracePathIndex)) {
@@ -2146,6 +2184,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroups;
   queuedOverlappingSameNetTraceGroups;
   netLabelPlacements = [];
+  failedGroups = [];
   currentGroup = null;
   triedAnyOrientationFallbackForCurrentGroup = false;
   constructor(params) {
@@ -2351,8 +2390,12 @@ var NetLabelPlacementSolver = class extends BaseSolver {
         });
         return;
       }
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
+      if (this.currentGroup) {
+        this.failedGroups.push(this.currentGroup);
+      }
+      this.activeSubSolver = null;
+      this.currentGroup = null;
+      this.triedAnyOrientationFallbackForCurrentGroup = false;
       return;
     }
     if (this.activeSubSolver) {
@@ -3013,6 +3056,38 @@ var generateRerouteCandidates = ({
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
+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";
+    for (const trace of traces) {
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const traceSegStart = trace.tracePath[j];
+        const traceSegEnd = trace.tracePath[j + 1];
+        const isParallel = Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) < COINCIDENT_EPS;
+        if (!isParallel) continue;
+        const isCoincident = Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) < COINCIDENT_EPS;
+        if (!isCoincident) continue;
+        if (rangesOverlap1D(
+          pathSegStart[alongAxis],
+          pathSegEnd[alongAxis],
+          traceSegStart[alongAxis],
+          traceSegEnd[alongAxis]
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
 var SingleOverlapSolver = class extends BaseSolver {
   queuedCandidatePaths;
   solvedTracePath = null;
@@ -3020,12 +3095,14 @@ var SingleOverlapSolver = class extends BaseSolver {
   problem;
   obstacles;
   label;
+  tracesToAvoidOverlapping;
   _tried = 0;
   constructor(solverInput) {
     super();
     this.initialTrace = solverInput.trace;
     this.problem = solverInput.problem;
     this.label = solverInput.label;
+    this.tracesToAvoidOverlapping = (solverInput.tracesToAvoidOverlapping ?? []).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId);
     const effectivePadding = solverInput.paddingBuffer + solverInput.detourCount * solverInput.paddingBuffer;
     const candidates = generateRerouteCandidates({
       ...solverInput,
@@ -3054,7 +3131,7 @@ var SingleOverlapSolver = class extends BaseSolver {
     this._tried++;
     const nextCandidatePath = this.queuedCandidatePaths.shift();
     const simplifiedPath = simplifyPath(nextCandidatePath);
-    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
       this.solvedTracePath = simplifiedPath;
       this.solved = true;
     }
@@ -3159,6 +3236,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   mergedNetLabelPlacements;
   mergedLabelNetIdMap;
   allTraces;
+  tracesToAvoidOverlapping;
   modifiedTraces = [];
   PADDING_BUFFER = 0.1;
   detourCounts = /* @__PURE__ */ new Map();
@@ -3174,6 +3252,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements;
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
     this.allTraces = [...solverInput.traces];
+    this.tracesToAvoidOverlapping = solverInput.tracesToAvoidOverlapping ?? [];
     this.detourCounts = solverInput.detourCounts;
   }
   _step() {
@@ -3255,7 +3334,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount: detourCount2
+            detourCount: detourCount2,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -3290,7 +3370,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount: detourCount2
+            detourCount: detourCount2,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -3305,7 +3386,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         label: labelToAvoid,
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
-        detourCount
+        detourCount,
+        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
       });
     }
   }
@@ -3373,10 +3455,12 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   phase = "searching_for_overlaps";
   detourCounts = /* @__PURE__ */ new Map();
   labelMergingSolver;
+  allInputTraces;
   constructor(solverInput) {
     super();
     this.inputProblem = solverInput.inputProblem;
     this.unprocessedTraces = [...solverInput.traces];
+    this.allInputTraces = solverInput.traces;
     this.netLabelPlacements = solverInput.netLabelPlacements;
     this.cleanTraces = [];
     this.subSolvers = [];
@@ -3412,7 +3496,10 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
           initialNetLabelPlacements: this.netLabelPlacements,
           mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
-          detourCounts: this.detourCounts
+          detourCounts: this.detourCounts,
+          tracesToAvoidOverlapping: this.allInputTraces.filter(
+            (t) => t.mspPairId !== currentTargetTrace.mspPairId
+          )
         });
         this.subSolvers.push(subSolver);
       }
@@ -6198,28 +6285,29 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getSideOffsetAnchor(params) {
     const { anchorPoint, labelAnchorPoint, orientation, width, height } = params;
     const chipSide = this.getChipSideForPoint(labelAnchorPoint);
+    const sideClearance = this.getContainingChipSide(labelAnchorPoint) ? WICK_CLEARANCE : LABEL_SEARCH_STEP;
     if (isYOrientation(orientation) && chipSide === "left") {
       return {
-        x: anchorPoint.x - width / 2 - WICK_CLEARANCE,
+        x: anchorPoint.x - width / 2 - sideClearance,
         y: anchorPoint.y
       };
     }
     if (isYOrientation(orientation) && chipSide === "right") {
       return {
-        x: anchorPoint.x + width / 2 + WICK_CLEARANCE,
+        x: anchorPoint.x + width / 2 + sideClearance,
         y: anchorPoint.y
       };
     }
     if (isXOrientation(orientation) && chipSide === "bottom") {
       return {
         x: anchorPoint.x,
-        y: anchorPoint.y - height / 2 - WICK_CLEARANCE
+        y: anchorPoint.y - height / 2 - sideClearance
       };
     }
     if (isXOrientation(orientation) && chipSide === "top") {
       return {
         x: anchorPoint.x,
-        y: anchorPoint.y + height / 2 + WICK_CLEARANCE
+        y: anchorPoint.y + height / 2 + sideClearance
       };
     }
     return anchorPoint;

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -474,28 +474,31 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   }) {
     const { anchorPoint, labelAnchorPoint, orientation, width, height } = params
     const chipSide = this.getChipSideForPoint(labelAnchorPoint)
+    const sideClearance = this.getContainingChipSide(labelAnchorPoint)
+      ? WICK_CLEARANCE
+      : LABEL_SEARCH_STEP
     if (isYOrientation(orientation) && chipSide === "left") {
       return {
-        x: anchorPoint.x - width / 2 - WICK_CLEARANCE,
+        x: anchorPoint.x - width / 2 - sideClearance,
         y: anchorPoint.y,
       }
     }
     if (isYOrientation(orientation) && chipSide === "right") {
       return {
-        x: anchorPoint.x + width / 2 + WICK_CLEARANCE,
+        x: anchorPoint.x + width / 2 + sideClearance,
         y: anchorPoint.y,
       }
     }
     if (isXOrientation(orientation) && chipSide === "bottom") {
       return {
         x: anchorPoint.x,
-        y: anchorPoint.y - height / 2 - WICK_CLEARANCE,
+        y: anchorPoint.y - height / 2 - sideClearance,
       }
     }
     if (isXOrientation(orientation) && chipSide === "top") {
       return {
         x: anchorPoint.x,
-        y: anchorPoint.y + height / 2 + WICK_CLEARANCE,
+        y: anchorPoint.y + height / 2 + sideClearance,
       }
     }
     return anchorPoint

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -74,6 +74,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
   declare activeSubSolver: SingleNetLabelPlacementSolver | null
 
   netLabelPlacements: Array<NetLabelPlacement> = []
+  failedGroups: Array<OverlappingSameNetTraceGroup> = []
   currentGroup: OverlappingSameNetTraceGroup | null = null
   triedAnyOrientationFallbackForCurrentGroup = false
 
@@ -336,8 +337,13 @@ export class NetLabelPlacementSolver extends BaseSolver {
         return
       }
 
-      this.failed = true
-      this.error = this.activeSubSolver.error
+      // Record the failure for this group and continue to the next one
+      if (this.currentGroup) {
+        this.failedGroups.push(this.currentGroup)
+      }
+      this.activeSubSolver = null
+      this.currentGroup = null
+      this.triedAnyOrientationFallbackForCurrentGroup = false
       return
     }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -42,10 +42,13 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
 
   labelMergingSolver?: MergedNetLabelObstacleSolver
 
+  allInputTraces: SolvedTracePath[]
+
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
     super()
     this.inputProblem = solverInput.inputProblem
     this.unprocessedTraces = [...solverInput.traces]
+    this.allInputTraces = solverInput.traces
     this.netLabelPlacements = solverInput.netLabelPlacements
     this.cleanTraces = []
     this.subSolvers = []
@@ -88,6 +91,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
           mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
           detourCounts: this.detourCounts,
+          tracesToAvoidOverlapping: this.allInputTraces.filter(
+            (t) => t.mspPairId !== currentTargetTrace.mspPairId,
+          ),
         })
         this.subSolvers.push(subSolver)
       }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -19,6 +19,7 @@ export interface OverlapCollectionSolverInput {
   mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   detourCounts: Map<string, number>
+  tracesToAvoidOverlapping?: SolvedTracePath[]
 }
 
 /**
@@ -32,6 +33,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
   mergedLabelNetIdMap: Record<string, Set<string>>
 
   allTraces: SolvedTracePath[]
+  tracesToAvoidOverlapping: SolvedTracePath[]
   modifiedTraces: SolvedTracePath[] = []
 
   private readonly PADDING_BUFFER = 0.1
@@ -51,6 +53,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
     this.allTraces = [...solverInput.traces]
+    this.tracesToAvoidOverlapping = solverInput.tracesToAvoidOverlapping ?? []
     this.detourCounts = solverInput.detourCounts
   }
 
@@ -150,6 +153,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -192,6 +196,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -211,6 +216,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
         detourCount: detourCount,
+        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
       })
     }
   }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -16,9 +16,69 @@ interface SingleOverlapSolverInput {
   problem: InputProblem
   paddingBuffer: number
   detourCount: number
+  tracesToAvoidOverlapping?: SolvedTracePath[]
 }
 
 const MAX_TRIES = 5
+const COINCIDENT_EPS = 2e-3
+
+/**
+ * Returns true if any segment of the path is parallel and coincident
+ * (within COINCIDENT_EPS) with a segment of one of the given traces.
+ * Perpendicular crossings are allowed.
+ */
+const doesPathCoincideWithTraces = (
+  path: Point[],
+  traces: SolvedTracePath[],
+): boolean => {
+  const rangesOverlap1D = (a1: number, a2: number, b1: number, b2: number) =>
+    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 isVertical = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS
+    const isHorizontal =
+      Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS
+    if (!isVertical && !isHorizontal) continue
+
+    // For a vertical segment, coincidence is measured in x and overlap in y
+    // (and vice versa for horizontal)
+    const crossAxis = isVertical ? "x" : "y"
+    const alongAxis = isVertical ? "y" : "x"
+
+    for (const trace of traces) {
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const traceSegStart = trace.tracePath[j]!
+        const traceSegEnd = trace.tracePath[j + 1]!
+
+        const isParallel =
+          Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isParallel) continue
+
+        const isCoincident =
+          Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isCoincident) continue
+
+        if (
+          rangesOverlap1D(
+            pathSegStart[alongAxis],
+            pathSegEnd[alongAxis],
+            traceSegStart[alongAxis],
+            traceSegEnd[alongAxis],
+          )
+        ) {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
 
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
@@ -32,6 +92,7 @@ export class SingleOverlapSolver extends BaseSolver {
   problem: InputProblem
   obstacles: ReturnType<typeof getObstacleRects>
   label: NetLabelPlacement
+  tracesToAvoidOverlapping: SolvedTracePath[]
   _tried: number = 0
 
   constructor(solverInput: SingleOverlapSolverInput) {
@@ -39,6 +100,9 @@ export class SingleOverlapSolver extends BaseSolver {
     this.initialTrace = solverInput.trace
     this.problem = solverInput.problem
     this.label = solverInput.label
+    this.tracesToAvoidOverlapping = (
+      solverInput.tracesToAvoidOverlapping ?? []
+    ).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId)
 
     // Calculate an effective padding for this specific run based on the detourCount.
     const effectivePadding =
@@ -77,7 +141,10 @@ export class SingleOverlapSolver extends BaseSolver {
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
     const simplifiedPath = simplifyPath(nextCandidatePath)
 
-    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+    if (
+      !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) &&
+      !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)
+    ) {
       this.solvedTracePath = simplifiedPath
       this.solved = true
     }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -57,8 +57,28 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     // Shift only the overlapping segments, and move the shared endpoints
     // (the last point of the previous segment and the first point of the next
     // segment) so the polyline remains orthogonal without self-overlap.
+    // Groups containing a straight pin-to-pin trace (2 points, both endpoints
+    // are pins) keep their position when another group can shift instead:
+    // shifting such a trace would force jogs on an otherwise straight line.
+    const containsStraightPinToPinTrace = (
+      group: OverlappingTraceSegmentLocator,
+    ) =>
+      group.pathsWithOverlap.some(({ solvedTracePathIndex }) => {
+        const path =
+          this.traceNetIslands[group.connNetId][solvedTracePathIndex]!
+        return path.tracePath.length === 2
+      })
+
+    const groupShouldStayInPlace = this.overlappingTraceSegments.map(
+      containsStraightPinToPinTrace,
+    )
+    const someGroupCanShift = groupShouldStayInPlace.some(
+      (shouldStay) => !shouldStay,
+    )
+
     // Compute offsets for each island involved: alternate directions
     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
       return this.getObstacleAwareOffset({
@@ -76,6 +96,7 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     // For each net island group, shift only its overlapping segments and adjust adjacent joints
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx]!
+      if (offset === 0) return
 
       // Gather unique segment indices per path
       const byPath: Map<number, Set<number>> = new Map()

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts

@@ -29,6 +29,36 @@ export const applyJogToTerminalSegment = ({
       ? 1
       : -1
 
+  if (pts.length === 2) {
+    // The segment is both the first and last segment: both endpoints are
+    // pins, so jog inward on both sides to keep the endpoints anchored
+    if (isVertical) {
+      const jogYNearStart = start.y + segDir * JOG_SIZE
+      const jogYNearEnd = end.y - segDir * JOG_SIZE
+      pts.splice(
+        1,
+        0,
+        { x: start.x, y: jogYNearStart },
+        { x: start.x + offset, y: jogYNearStart },
+        { x: end.x + offset, y: jogYNearEnd },
+        { x: end.x, y: jogYNearEnd },
+      )
+    } else {
+      // Horizontal
+      const jogXNearStart = start.x + segDir * JOG_SIZE
+      const jogXNearEnd = end.x - segDir * JOG_SIZE
+      pts.splice(
+        1,
+        0,
+        { x: jogXNearStart, y: start.y },
+        { x: jogXNearStart, y: start.y + offset },
+        { x: jogXNearEnd, y: end.y + offset },
+        { x: jogXNearEnd, y: end.y },
+      )
+    }
+    return
+  }
+
   if (si === 0) {
     if (isVertical) {
       const jogY = start.y + segDir * JOG_SIZE

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "type": "module",
   "scripts": {
     "start": "cosmos",