@tscircuit/schematic-trace-solver 0.0.112 → 0.0.114

package/dist/index.d.ts

@@ -244,6 +244,7 @@ declare class TraceOverlapIssueSolver extends BaseSolver {
     overlappingTraceSegments: OverlappingTraceSegmentLocator[];
     interactionKind: TraceInteractionKind;
     traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
+    traceIdsToShift?: Set<MspConnectionPairId>;
     obstacleRects: ReturnType<typeof getObstacleRects>;
     SHIFT_DISTANCE: number;
     correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath>;
@@ -252,6 +253,7 @@ declare class TraceOverlapIssueSolver extends BaseSolver {
         overlappingTraceSegments: OverlappingTraceSegmentLocator[];
         interactionKind: TraceInteractionKind;
         traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
+        traceIdsToShift?: Set<MspConnectionPairId>;
     });
     _step(): void;
     private applyOffsets;
@@ -284,6 +286,7 @@ declare class TraceOverlapShiftSolver extends BaseSolver {
     inputProblem: InputProblem;
     inputTracePaths: Array<SolvedTracePath>;
     globalConnMap: ConnectivityMap;
+    traceIdsToShift?: Set<MspConnectionPairId>;
     activeSubSolver: TraceOverlapIssueSolver | null;
     /**
      * A traceNetIsland is a set of traces that are connected via the globalConnMap
@@ -295,6 +298,7 @@ declare class TraceOverlapShiftSolver extends BaseSolver {
         inputProblem: InputProblem;
         inputTracePaths: Array<SolvedTracePath>;
         globalConnMap: ConnectivityMap;
+        traceIdsToShift?: Set<MspConnectionPairId>;
     });
     getConstructorParams(): ConstructorParameters<typeof TraceOverlapShiftSolver>[0];
     computeTraceNetIslands(): Record<ConnNetId, Array<SolvedTracePath>>;
@@ -582,6 +586,8 @@ declare class LongDistancePairSolver extends BaseSolver {
     solvedLongDistanceTraces: SolvedTracePath[];
     private queuedCandidatePairs;
     private currentCandidatePair;
+    private queuedFailedConnectionPairs;
+    private currentFailedConnectionPair;
     private subSolver;
     private chipMap;
     private inputProblem;
@@ -592,12 +598,15 @@ declare class LongDistancePairSolver extends BaseSolver {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     });
     getConstructorParams(): {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     };
+    private acceptFailedConnectionPair;
     _step(): void;
     visualize(): graphics_debug.GraphicsObject;
     getOutput(): {
@@ -1071,6 +1080,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     traceCleanupSolver?: TraceCleanupSolver;
     example28Solver?: Example28Solver;
     availableNetOrientationSolver?: AvailableNetOrientationSolver;
+    postLabelTraceOverlapShiftSolver?: TraceOverlapShiftSolver;
     railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver;
     traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver;
     preAlignmentNetLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;

package/dist/index.js

@@ -420,6 +420,33 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   return edges;
 }
 
+// lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts
+var isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins
+}) => {
+  const [firstPin, secondPin] = pins;
+  const directConnection = inputProblem.directConnections.find(
+    (connection) => connection.pinIds.includes(firstPin.pinId) && connection.pinIds.includes(secondPin.pinId)
+  );
+  if (directConnection?.netLabelWidth === void 0) return false;
+  const firstChip = chipMap[firstPin.chipId];
+  const secondChip = chipMap[secondPin.chipId];
+  if (!firstChip || !secondChip) return false;
+  const hasSinglePinPeripheral = firstChip.pins.length === 1 || secondChip.pins.length === 1;
+  if (!hasSinglePinPeripheral) return false;
+  let firstFacingDirection = firstPin._facingDirection;
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip);
+  }
+  let secondFacingDirection = secondPin._facingDirection;
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip);
+  }
+  return firstFacingDirection === "x-" && secondFacingDirection === "x+" || firstFacingDirection === "x+" && secondFacingDirection === "x-";
+};
+
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
@@ -489,8 +516,16 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
       const pinPairKey = getPinPairKey([pin1, pin2]);
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey) ? distance(p1, p2) : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2);
+      }
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2]
+      });
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -1744,6 +1779,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
   interactionKind;
   traceNetIslands;
+  traceIdsToShift;
   obstacleRects;
   SHIFT_DISTANCE = 0.1;
   correctedTraceMap = {};
@@ -1752,6 +1788,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     this.overlappingTraceSegments = params.overlappingTraceSegments;
     this.interactionKind = params.interactionKind;
     this.traceNetIslands = params.traceNetIslands;
+    this.traceIdsToShift = params.traceIdsToShift;
     this.obstacleRects = getObstacleRects(params.inputProblem);
     for (const { connNetId, pathsWithOverlap } of this.overlappingTraceSegments) {
       for (const {
@@ -1769,7 +1806,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       return path.tracePath.length === 2;
     });
     const groupShouldStayInPlace = this.overlappingTraceSegments.map(
-      containsStraightPinToPinTrace
+      (group) => {
+        if (!this.traceIdsToShift) return containsStraightPinToPinTrace(group);
+        return group.pathsWithOverlap.every(({ solvedTracePathIndex }) => {
+          const path = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+          return !this.traceIdsToShift.has(path.mspPairId);
+        });
+      }
     );
     const someGroupCanShift = groupShouldStayInPlace.some(
       (shouldStay) => !shouldStay
@@ -2049,6 +2092,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
   inputProblem;
   inputTracePaths;
   globalConnMap;
+  traceIdsToShift;
   /**
    * A traceNetIsland is a set of traces that are connected via the globalConnMap
    */
@@ -2060,6 +2104,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     this.inputProblem = params.inputProblem;
     this.inputTracePaths = params.inputTracePaths;
     this.globalConnMap = params.globalConnMap;
+    this.traceIdsToShift = params.traceIdsToShift;
     for (const tracePath of this.inputTracePaths) {
       const { mspPairId } = tracePath;
       this.correctedTraceMap[mspPairId] = tracePath;
@@ -2070,7 +2115,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return {
       inputProblem: this.inputProblem,
       inputTracePaths: this.inputTracePaths,
-      globalConnMap: this.globalConnMap
+      globalConnMap: this.globalConnMap,
+      traceIdsToShift: this.traceIdsToShift
     };
   }
   computeTraceNetIslands() {
@@ -2158,6 +2204,9 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
+              if (this.traceIdsToShift && !this.traceIdsToShift.has(pathA.mspPairId) && !this.traceIdsToShift.has(pathB.mspPairId)) {
+                continue;
+              }
               const ptsB = pathB.tracePath;
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
@@ -2307,7 +2356,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       inputProblem: this.inputProblem,
       interactionKind,
       overlappingTraceSegments,
-      traceNetIslands: this.traceNetIslands
+      traceNetIslands: this.traceNetIslands,
+      traceIdsToShift: this.traceIdsToShift
     });
   }
   visualize() {
@@ -4480,6 +4530,13 @@ var LongDistancePairSolver = class extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
       }
     }
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) => isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: connectionPair.pins
+      })
+    );
     const candidatePairs = [];
     const addedPairKeys = /* @__PURE__ */ new Set();
     for (const netId of Object.keys(netConnMap.netMap)) {
@@ -4520,6 +4577,8 @@ var LongDistancePairSolver = class extends BaseSolver {
   solvedLongDistanceTraces = [];
   queuedCandidatePairs = [];
   currentCandidatePair = null;
+  queuedFailedConnectionPairs = [];
+  currentFailedConnectionPair = null;
   subSolver = null;
   chipMap = {};
   inputProblem;
@@ -4529,8 +4588,31 @@ var LongDistancePairSolver = class extends BaseSolver {
   getConstructorParams() {
     return this.params;
   }
+  acceptFailedConnectionPair(tracePath) {
+    const connectionPair = this.currentFailedConnectionPair;
+    if (!connectionPair) return;
+    const solvedTrace = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId)
+    };
+    this.solvedLongDistanceTraces.push(solvedTrace);
+    this.allSolvedTraces.push(solvedTrace);
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId);
+    }
+  }
   _step() {
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath;
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath);
+      }
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath;
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -4561,11 +4643,23 @@ var LongDistancePairSolver = class extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null;
       this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
     }
     if (this.subSolver) {
       this.subSolver.step();
       return;
     }
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift();
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair;
+      this.currentCandidatePair = failedConnectionPair.pins;
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap
+      });
+      return;
+    }
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift();
       const [p1, p2] = nextPair;
@@ -10632,6 +10726,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   traceCleanupSolver;
   example28Solver;
   availableNetOrientationSolver;
+  postLabelTraceOverlapShiftSolver;
   railNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
   preAlignmentNetLabelTraceCollisionSolver;
@@ -10687,7 +10782,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
-          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths
+          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths,
+          failedConnectionPairs: instance.schematicTraceLinesSolver.failedConnectionPairs
         }
       ],
       {
@@ -10807,6 +10903,22 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       ]
     ),
+    definePipelineStep(
+      "postLabelTraceOverlapShiftSolver",
+      TraceOverlapShiftSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          inputTracePaths: instance.availableNetOrientationSolver.traces,
+          globalConnMap: instance.mspConnectionPairSolver.globalConnMap,
+          traceIdsToShift: new Set(
+            instance.availableNetOrientationSolver.traces.filter(
+              (trace) => trace.mspPairId.startsWith("available-net-orientation-")
+            ).map((trace) => trace.mspPairId)
+          )
+        }
+      ]
+    ),
     definePipelineStep(
       "railNetLabelCornerPlacementSolver",
       RailNetLabelCornerPlacementSolver,
@@ -10814,7 +10926,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: instance.availableNetOrientationSolver.traces,
+            traces: Object.values(
+              instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
+            ),
             netLabelPlacements: instance.availableNetOrientationSolver.outputNetLabelPlacements
           }
         ];
@@ -10826,7 +10940,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: instance.availableNetOrientationSolver.traces,
+          traces: Object.values(
+            instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
+          ),
           netLabelPlacements: instance.railNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
@@ -10837,7 +10953,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: instance.availableNetOrientationSolver.traces,
+          traces: Object.values(
+            instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
+          ),
           netLabelPlacements: instance.traceAnchoredNetLabelOverlapSolver.outputNetLabelPlacements
         }
       ]

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -13,6 +13,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { ConnectivityMap } from "connectivity-map"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
@@ -28,6 +29,8 @@ export class LongDistancePairSolver extends BaseSolver {
   private currentCandidatePair:
     | [InputPin & { chipId: string }, InputPin & { chipId: string }]
     | null = null
+  private queuedFailedConnectionPairs: MspConnectionPair[] = []
+  private currentFailedConnectionPair: MspConnectionPair | null = null
   private subSolver: SchematicTraceSingleLineSolver2 | null = null
   private chipMap: Record<string, InputChip> = {}
   private inputProblem: InputProblem
@@ -40,6 +43,7 @@ export class LongDistancePairSolver extends BaseSolver {
       inputProblem: InputProblem
       alreadySolvedTraces: SolvedTracePath[]
       primaryMspConnectionPairs: MspConnectionPair[]
+      failedConnectionPairs: MspConnectionPair[]
     },
   ) {
     super()
@@ -66,6 +70,16 @@ export class LongDistancePairSolver extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
       }
     }
+    // Retry failed MSP pairs with their existing identity before creating
+    // new nearest-neighbor candidates.
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) =>
+        isLabeledPeripheralConnection({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pins: connectionPair.pins,
+        }),
+    )
 
     // 2. Generate candidate pairs using N-Nearest-Neighbors approach
     const candidatePairs: Array<
@@ -129,9 +143,36 @@ export class LongDistancePairSolver extends BaseSolver {
     return this.params
   }
 
+  private acceptFailedConnectionPair(tracePath: SolvedTracePath["tracePath"]) {
+    const connectionPair = this.currentFailedConnectionPair
+    if (!connectionPair) return
+
+    // Reuse the original pair so downstream solvers retain its connectivity
+    // IDs, user net ID, pins, and MSP pair ID.
+    const solvedTrace: SolvedTracePath = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId),
+    }
+    this.solvedLongDistanceTraces.push(solvedTrace)
+    this.allSolvedTraces.push(solvedTrace)
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId)
+    }
+  }
+
   override _step() {
     // 1. Check if a sub-solver has finished and process its result
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath)
+      }
+      this.subSolver = null
+      this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -166,6 +207,7 @@ export class LongDistancePairSolver extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null
       this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
     }
 
     // 2. If a sub-solver is already running, let it continue
@@ -174,6 +216,18 @@ export class LongDistancePairSolver extends BaseSolver {
       return
     }
 
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift()
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair
+      this.currentCandidatePair = failedConnectionPair.pins
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap,
+      })
+      return
+    }
+
     // 3. Find the next valid candidate pair and start a new sub-solver
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift()!

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -14,6 +14,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
+import { isLabeledPeripheralConnection } from "./isLabeledPeripheralConnection"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -116,10 +117,18 @@ export class MspConnectionPairSolver extends BaseSolver {
       const pinPairKey = getPinPairKey([pin1!, pin2!])
       // Explicit source traces are classified by straight-line distance when
       // their input is created; named nets retain the orthogonal route metric.
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey)
-        ? distance(p1, p2)
-        : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2)
+      }
+      // Labeled one-pin peripherals need a real trace even when they are far
+      // apart; skipping the MSP pair would leave only the fallback path.
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2],
+      })
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }

package/lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts

@@ -0,0 +1,44 @@
+import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+
+type PinWithChipId = InputPin & { chipId: string }
+
+export const isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins,
+}: {
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+  pins: [PinWithChipId, PinWithChipId]
+}): boolean => {
+  const [firstPin, secondPin] = pins
+  const directConnection = inputProblem.directConnections.find(
+    (connection) =>
+      connection.pinIds.includes(firstPin.pinId) &&
+      connection.pinIds.includes(secondPin.pinId),
+  )
+  if (directConnection?.netLabelWidth === undefined) return false
+
+  const firstChip = chipMap[firstPin.chipId]
+  const secondChip = chipMap[secondPin.chipId]
+  if (!firstChip || !secondChip) return false
+
+  const hasSinglePinPeripheral =
+    firstChip.pins.length === 1 || secondChip.pins.length === 1
+  if (!hasSinglePinPeripheral) return false
+
+  let firstFacingDirection = firstPin._facingDirection
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip)
+  }
+  let secondFacingDirection = secondPin._facingDirection
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip)
+  }
+
+  return (
+    (firstFacingDirection === "x-" && secondFacingDirection === "x+") ||
+    (firstFacingDirection === "x+" && secondFacingDirection === "x-")
+  )
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -79,6 +79,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
   availableNetOrientationSolver?: AvailableNetOrientationSolver
+  postLabelTraceOverlapShiftSolver?: TraceOverlapShiftSolver
   railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
   preAlignmentNetLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
@@ -139,6 +140,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             instance.mspConnectionPairSolver!.mspConnectionPairs,
           alreadySolvedTraces:
             instance.schematicTraceLinesSolver!.solvedTracePaths,
+          failedConnectionPairs:
+            instance.schematicTraceLinesSolver!.failedConnectionPairs,
         },
       ],
       {
@@ -280,6 +283,24 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "postLabelTraceOverlapShiftSolver",
+      TraceOverlapShiftSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          inputTracePaths: instance.availableNetOrientationSolver!.traces,
+          globalConnMap: instance.mspConnectionPairSolver!.globalConnMap,
+          traceIdsToShift: new Set(
+            instance
+              .availableNetOrientationSolver!.traces.filter((trace) =>
+                trace.mspPairId.startsWith("available-net-orientation-"),
+              )
+              .map((trace) => trace.mspPairId),
+          ),
+        },
+      ],
+    ),
     definePipelineStep(
       "railNetLabelCornerPlacementSolver",
       RailNetLabelCornerPlacementSolver,
@@ -287,7 +308,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: instance.availableNetOrientationSolver!.traces,
+            traces: Object.values(
+              instance.postLabelTraceOverlapShiftSolver!.correctedTraceMap,
+            ),
             netLabelPlacements:
               instance.availableNetOrientationSolver!.outputNetLabelPlacements,
           },
@@ -300,7 +323,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: instance.availableNetOrientationSolver!.traces,
+          traces: Object.values(
+            instance.postLabelTraceOverlapShiftSolver!.correctedTraceMap,
+          ),
           netLabelPlacements:
             instance.railNetLabelCornerPlacementSolver!
               .outputNetLabelPlacements,
@@ -313,7 +338,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: instance.availableNetOrientationSolver!.traces,
+          traces: Object.values(
+            instance.postLabelTraceOverlapShiftSolver!.correctedTraceMap,
+          ),
           netLabelPlacements:
             instance.traceAnchoredNetLabelOverlapSolver!
               .outputNetLabelPlacements,

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

@@ -26,6 +26,7 @@ export class TraceOverlapIssueSolver extends BaseSolver {
   overlappingTraceSegments: OverlappingTraceSegmentLocator[]
   interactionKind: TraceInteractionKind
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
+  traceIdsToShift?: Set<MspConnectionPairId>
   obstacleRects: ReturnType<typeof getObstacleRects>
 
   SHIFT_DISTANCE = 0.1
@@ -37,11 +38,13 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     overlappingTraceSegments: OverlappingTraceSegmentLocator[]
     interactionKind: TraceInteractionKind
     traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
+    traceIdsToShift?: Set<MspConnectionPairId>
   }) {
     super()
     this.overlappingTraceSegments = params.overlappingTraceSegments
     this.interactionKind = params.interactionKind
     this.traceNetIslands = params.traceNetIslands
+    this.traceIdsToShift = params.traceIdsToShift
     this.obstacleRects = getObstacleRects(params.inputProblem)
 
     // Only add the relevant traces to the correctedTraceMap
@@ -76,7 +79,14 @@ export class TraceOverlapIssueSolver extends BaseSolver {
       })
 
     const groupShouldStayInPlace = this.overlappingTraceSegments.map(
-      containsStraightPinToPinTrace,
+      (group) => {
+        if (!this.traceIdsToShift) return containsStraightPinToPinTrace(group)
+        return group.pathsWithOverlap.every(({ solvedTracePathIndex }) => {
+          const path =
+            this.traceNetIslands[group.connNetId][solvedTracePathIndex]!
+          return !this.traceIdsToShift!.has(path.mspPairId)
+        })
+      },
     )
     const someGroupCanShift = groupShouldStayInPlace.some(
       (shouldStay) => !shouldStay,

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -34,6 +34,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
   inputProblem: InputProblem
   inputTracePaths: Array<SolvedTracePath>
   globalConnMap: ConnectivityMap
+  traceIdsToShift?: Set<MspConnectionPairId>
 
   declare activeSubSolver: TraceOverlapIssueSolver | null
 
@@ -50,11 +51,13 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     inputProblem: InputProblem
     inputTracePaths: Array<SolvedTracePath>
     globalConnMap: ConnectivityMap
+    traceIdsToShift?: Set<MspConnectionPairId>
   }) {
     super()
     this.inputProblem = params.inputProblem
     this.inputTracePaths = params.inputTracePaths
     this.globalConnMap = params.globalConnMap
+    this.traceIdsToShift = params.traceIdsToShift
 
     for (const tracePath of this.inputTracePaths) {
       const { mspPairId } = tracePath
@@ -71,6 +74,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       inputProblem: this.inputProblem,
       inputTracePaths: this.inputTracePaths,
       globalConnMap: this.globalConnMap,
+      traceIdsToShift: this.traceIdsToShift,
     }
   }
 
@@ -211,6 +215,13 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb]!
+              if (
+                this.traceIdsToShift &&
+                !this.traceIdsToShift.has(pathA.mspPairId) &&
+                !this.traceIdsToShift.has(pathB.mspPairId)
+              ) {
+                continue
+              }
               const ptsB = pathB.tracePath
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb]!
@@ -392,6 +403,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       interactionKind,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands,
+      traceIdsToShift: this.traceIdsToShift,
     })
   }