@tscircuit/schematic-trace-solver 0.0.40 → 0.0.41

package/dist/index.d.ts

@@ -404,6 +404,35 @@ declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+declare class LongDistancePairSolver extends BaseSolver {
+    private params;
+    solvedLongDistanceTraces: SolvedTracePath[];
+    private queuedCandidatePairs;
+    private currentCandidatePair;
+    private subSolver;
+    private chipMap;
+    private inputProblem;
+    private netConnMap;
+    private newlyConnectedPinIds;
+    private allSolvedTraces;
+    constructor(params: {
+        inputProblem: InputProblem;
+        alreadySolvedTraces: SolvedTracePath[];
+        primaryMspConnectionPairs: MspConnectionPair[];
+    });
+    getConstructorParams(): {
+        inputProblem: InputProblem;
+        alreadySolvedTraces: SolvedTracePath[];
+        primaryMspConnectionPairs: MspConnectionPair[];
+    };
+    _step(): void;
+    visualize(): graphics_debug.GraphicsObject;
+    getOutput(): {
+        newTraces: SolvedTracePath[];
+        allTracesMerged: SolvedTracePath[];
+    };
+}
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -414,10 +443,16 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     solverClass: T;
     getConstructorParams: (instance: SchematicTracePipelineSolver) => ConstructorParameters<T>;
     onSolved?: (instance: SchematicTracePipelineSolver) => void;
+    shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean;
 };
+interface SchematicTracePipelineSolverParams {
+    inputProblem: InputProblem;
+    allowLongDistanceTraces?: boolean;
+}
 declare class SchematicTracePipelineSolver extends BaseSolver {
     mspConnectionPairSolver?: MspConnectionPairSolver;
     schematicTraceLinesSolver?: SchematicTraceLinesSolver;
+    longDistancePairSolver?: LongDistancePairSolver;
     traceOverlapShiftSolver?: TraceOverlapShiftSolver;
     netLabelPlacementSolver?: NetLabelPlacementSolver;
     traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver;
@@ -426,7 +461,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver>)[];
     constructor(inputProblem: InputProblem);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;
@@ -442,4 +477,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2 };
+export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2 };

package/dist/index.js

@@ -3100,19 +3100,203 @@ var expandChipsToFitPins = (problem) => {
   }
 };
 
+// lib/utils/does-trace-overlap-with-existing-traces.ts
+import { doSegmentsIntersect } from "@tscircuit/math-utils";
+function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
+  for (let i = 0; i < newTracePath.length - 1; i++) {
+    const newSegmentP1 = newTracePath[i];
+    const newSegmentP2 = newTracePath[i + 1];
+    for (const existingTrace of existingTraces) {
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegmentP1 = existingTrace.tracePath[j];
+        const existingSegmentP2 = existingTrace.tracePath[j + 1];
+        if (doSegmentsIntersect(
+          newSegmentP1,
+          newSegmentP2,
+          existingSegmentP1,
+          existingSegmentP2
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
+var NEAREST_NEIGHBOR_COUNT = 3;
+var distance = (p1, p2) => {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+};
+var LongDistancePairSolver = class extends BaseSolver {
+  constructor(params) {
+    super();
+    this.params = params;
+    const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
+    this.inputProblem = inputProblem;
+    this.allSolvedTraces = [...alreadySolvedTraces];
+    const primaryConnectedPinIds = /* @__PURE__ */ new Set();
+    for (const pair of primaryMspConnectionPairs) {
+      primaryConnectedPinIds.add(pair.pins[0].pinId);
+      primaryConnectedPinIds.add(pair.pins[1].pinId);
+    }
+    const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+    this.netConnMap = netConnMap;
+    const pinMap = /* @__PURE__ */ new Map();
+    for (const chip of inputProblem.chips) {
+      this.chipMap[chip.chipId] = chip;
+      for (const pin of chip.pins) {
+        pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
+      }
+    }
+    const candidatePairs = [];
+    const addedPairKeys = /* @__PURE__ */ new Set();
+    for (const netId of Object.keys(netConnMap.netMap)) {
+      const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId);
+      if (allPinIdsInNet.length < 2) continue;
+      const unconnectedPinIds = allPinIdsInNet.filter(
+        (pinId) => !primaryConnectedPinIds.has(pinId)
+      );
+      for (const unconnectedPinId of unconnectedPinIds) {
+        const sourcePin = pinMap.get(unconnectedPinId);
+        if (!sourcePin) continue;
+        const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
+          const targetPin = pinMap.get(otherPinId);
+          if (!targetPin) return [];
+          return [
+            {
+              pin: targetPin,
+              distance: distance(sourcePin, targetPin)
+            }
+          ];
+        }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
+        for (const neighbor of neighbors) {
+          const pair = [sourcePin, neighbor.pin];
+          const pairKey = pair.map((p) => p.pinId).sort().join("--");
+          if (!addedPairKeys.has(pairKey)) {
+            candidatePairs.push(pair);
+            addedPairKeys.add(pairKey);
+          }
+        }
+      }
+    }
+    this.queuedCandidatePairs = candidatePairs;
+  }
+  solvedLongDistanceTraces = [];
+  queuedCandidatePairs = [];
+  currentCandidatePair = null;
+  subSolver = null;
+  chipMap = {};
+  inputProblem;
+  netConnMap;
+  newlyConnectedPinIds = /* @__PURE__ */ new Set();
+  allSolvedTraces = [];
+  getConstructorParams() {
+    return this.params;
+  }
+  _step() {
+    if (this.subSolver?.solved) {
+      const newTracePath = this.subSolver.solvedTracePath;
+      if (newTracePath && this.currentCandidatePair) {
+        const isTraceClear = !doesTraceOverlapWithExistingTraces(
+          newTracePath,
+          this.allSolvedTraces
+        );
+        if (isTraceClear) {
+          const [p1, p2] = this.currentCandidatePair;
+          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
+          const mspPairId = `${p1.pinId}-${p2.pinId}`;
+          const newSolvedTrace = {
+            mspPairId,
+            dcConnNetId: globalConnNetId,
+            globalConnNetId,
+            pins: [p1, p2],
+            tracePath: newTracePath,
+            mspConnectionPairIds: [mspPairId],
+            pinIds: [p1.pinId, p2.pinId]
+          };
+          this.solvedLongDistanceTraces.push(newSolvedTrace);
+          this.allSolvedTraces.push(newSolvedTrace);
+          this.newlyConnectedPinIds.add(p1.pinId);
+          this.newlyConnectedPinIds.add(p2.pinId);
+        }
+      }
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+    } else if (this.subSolver?.failed) {
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+    }
+    if (this.subSolver) {
+      this.subSolver.step();
+      return;
+    }
+    while (this.queuedCandidatePairs.length > 0) {
+      const nextPair = this.queuedCandidatePairs.shift();
+      const [p1, p2] = nextPair;
+      if (this.newlyConnectedPinIds.has(p1.pinId) || this.newlyConnectedPinIds.has(p2.pinId)) {
+        continue;
+      }
+      this.currentCandidatePair = nextPair;
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: this.currentCandidatePair,
+        chipMap: this.chipMap
+      });
+      return;
+    }
+    this.solved = true;
+  }
+  visualize() {
+    if (this.subSolver) {
+      return this.subSolver.visualize();
+    }
+    const graphics = visualizeInputProblem(this.inputProblem);
+    for (const trace of this.solvedLongDistanceTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const [p1, p2] of this.queuedCandidatePairs) {
+      graphics.lines.push({
+        points: [p1, p2],
+        strokeColor: "gray",
+        strokeDash: "4 4"
+      });
+    }
+    return graphics;
+  }
+  getOutput() {
+    if (!this.solved) {
+      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces };
+    }
+    return {
+      newTraces: this.solvedLongDistanceTraces,
+      allTracesMerged: [
+        ...this.params.alreadySolvedTraces,
+        ...this.solvedLongDistanceTraces
+      ]
+    };
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,
     solverClass,
     getConstructorParams,
-    onSolved: opts.onSolved
+    onSolved: opts.onSolved,
+    shouldSkip: opts.shouldSkip
   };
 }
 var SchematicTracePipelineSolver = class extends BaseSolver {
   mspConnectionPairSolver;
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver;
+  longDistancePairSolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
   traceLabelOverlapAvoidanceSolver;
@@ -3155,6 +3339,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           // guidelines: this.guidelinesSolver!.guidelines,
           chipMap: this.mspConnectionPairSolver.chipMap
         }
+      ]
+    ),
+    definePipelineStep(
+      "longDistancePairSolver",
+      LongDistancePairSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
+          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths
+        }
       ],
       {
         onSolved: (schematicTraceLinesSolver) => {
@@ -3167,7 +3362,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.schematicTraceLinesSolver.solvedTracePaths,
+          inputTracePaths: this.longDistancePairSolver?.getOutput().allTracesMerged,
           globalConnMap: this.mspConnectionPairSolver.globalConnMap
         }
       ],
@@ -3183,10 +3378,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTraceMap: this.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-            this.schematicTraceLinesSolver.solvedTracePaths.map((p) => [
-              p.mspPairId,
-              p
-            ])
+            this.longDistancePairSolver.getOutput().allTracesMerged.map(
+              (p) => [p.mspPairId, p]
+            )
           )
         }
       ],
@@ -3200,10 +3394,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       TraceLabelOverlapAvoidanceSolver,
       (instance) => {
         const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-          instance.schematicTraceLinesSolver.solvedTracePaths.map((p) => [
-            p.mspPairId,
-            p
-          ])
+          instance.longDistancePairSolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
         );
         const traces = Object.values(traceMap);
         const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -0,0 +1,238 @@
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type {
+  InputProblem,
+  InputPin,
+  PinId,
+  InputChip,
+} from "lib/types/InputProblem"
+import { BaseSolver } from "../BaseSolver/BaseSolver"
+import { SchematicTraceSingleLineSolver2 } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { ConnectivityMap } from "connectivity-map"
+
+const NEAREST_NEIGHBOR_COUNT = 3
+
+const distance = (p1: InputPin, p2: InputPin) => {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2))
+}
+
+export class LongDistancePairSolver extends BaseSolver {
+  public solvedLongDistanceTraces: SolvedTracePath[] = []
+  private queuedCandidatePairs: Array<
+    [InputPin & { chipId: string }, InputPin & { chipId: string }]
+  > = []
+  private currentCandidatePair:
+    | [InputPin & { chipId: string }, InputPin & { chipId: string }]
+    | null = null
+  private subSolver: SchematicTraceSingleLineSolver2 | null = null
+  private chipMap: Record<string, InputChip> = {}
+  private inputProblem: InputProblem
+  private netConnMap: ConnectivityMap
+  private newlyConnectedPinIds = new Set<PinId>()
+  private allSolvedTraces: SolvedTracePath[] = []
+
+  constructor(
+    private params: {
+      inputProblem: InputProblem
+      alreadySolvedTraces: SolvedTracePath[]
+      primaryMspConnectionPairs: MspConnectionPair[]
+    },
+  ) {
+    super()
+
+    const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } =
+      this.params
+
+    this.inputProblem = inputProblem
+    this.allSolvedTraces = [...alreadySolvedTraces]
+
+    // 1. Create initial maps and sets for efficient lookup
+    const primaryConnectedPinIds = new Set<PinId>()
+    for (const pair of primaryMspConnectionPairs) {
+      primaryConnectedPinIds.add(pair.pins[0].pinId)
+      primaryConnectedPinIds.add(pair.pins[1].pinId)
+    }
+
+    const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+    this.netConnMap = netConnMap
+    const pinMap = new Map<PinId, InputPin & { chipId: string }>()
+    for (const chip of inputProblem.chips) {
+      this.chipMap[chip.chipId] = chip
+      for (const pin of chip.pins) {
+        pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
+      }
+    }
+
+    // 2. Generate candidate pairs using N-Nearest-Neighbors approach
+    const candidatePairs: Array<
+      [InputPin & { chipId: string }, InputPin & { chipId: string }]
+    > = []
+    const addedPairKeys = new Set<string>()
+
+    for (const netId of Object.keys(netConnMap.netMap)) {
+      const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId)
+      if (allPinIdsInNet.length < 2) continue
+
+      const unconnectedPinIds = allPinIdsInNet.filter(
+        (pinId) => !primaryConnectedPinIds.has(pinId),
+      )
+
+      for (const unconnectedPinId of unconnectedPinIds) {
+        const sourcePin = pinMap.get(unconnectedPinId)
+        if (!sourcePin) continue
+
+        const neighbors = allPinIdsInNet
+          .filter((otherPinId) => otherPinId !== unconnectedPinId)
+          .flatMap((otherPinId) => {
+            const targetPin = pinMap.get(otherPinId)
+            if (!targetPin) return [] // Gracefully handle missing pins
+            return [
+              {
+                pin: targetPin,
+                distance: distance(sourcePin, targetPin),
+              },
+            ]
+          })
+          .sort((a, b) => a.distance - b.distance)
+          .slice(0, NEAREST_NEIGHBOR_COUNT)
+
+        for (const neighbor of neighbors) {
+          const pair: [
+            InputPin & { chipId: string },
+            InputPin & { chipId: string },
+          ] = [sourcePin, neighbor.pin]
+          const pairKey = pair
+            .map((p) => p.pinId)
+            .sort()
+            .join("--")
+
+          if (!addedPairKeys.has(pairKey)) {
+            candidatePairs.push(pair)
+            addedPairKeys.add(pairKey)
+          }
+        }
+      }
+    }
+    this.queuedCandidatePairs = candidatePairs
+  }
+
+  override getConstructorParams() {
+    return this.params
+  }
+
+  override _step() {
+    // 1. Check if a sub-solver has finished and process its result
+    if (this.subSolver?.solved) {
+      const newTracePath = this.subSolver.solvedTracePath
+      if (newTracePath && this.currentCandidatePair) {
+        const isTraceClear = !doesTraceOverlapWithExistingTraces(
+          newTracePath,
+          this.allSolvedTraces,
+        )
+
+        if (isTraceClear) {
+          const [p1, p2] = this.currentCandidatePair
+          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId)!
+          const mspPairId = `${p1.pinId}-${p2.pinId}`
+
+          const newSolvedTrace: SolvedTracePath = {
+            mspPairId,
+            dcConnNetId: globalConnNetId,
+            globalConnNetId,
+            pins: [p1, p2],
+            tracePath: newTracePath,
+            mspConnectionPairIds: [mspPairId],
+            pinIds: [p1.pinId, p2.pinId],
+          }
+
+          this.solvedLongDistanceTraces.push(newSolvedTrace)
+          this.allSolvedTraces.push(newSolvedTrace)
+
+          this.newlyConnectedPinIds.add(p1.pinId)
+          this.newlyConnectedPinIds.add(p2.pinId)
+        }
+      }
+      this.subSolver = null
+      this.currentCandidatePair = null
+    } else if (this.subSolver?.failed) {
+      this.subSolver = null
+      this.currentCandidatePair = null
+    }
+
+    // 2. If a sub-solver is already running, let it continue
+    if (this.subSolver) {
+      this.subSolver.step()
+      return
+    }
+
+    // 3. Find the next valid candidate pair and start a new sub-solver
+    while (this.queuedCandidatePairs.length > 0) {
+      const nextPair = this.queuedCandidatePairs.shift()!
+      const [p1, p2] = nextPair
+
+      if (
+        this.newlyConnectedPinIds.has(p1.pinId) ||
+        this.newlyConnectedPinIds.has(p2.pinId)
+      ) {
+        continue
+      }
+
+      this.currentCandidatePair = nextPair
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: this.currentCandidatePair,
+        chipMap: this.chipMap,
+      })
+      return
+    }
+
+    // 4. If we've exited the loop, there are no more valid pairs to process
+    this.solved = true
+  }
+
+  override visualize() {
+    if (this.subSolver) {
+      return this.subSolver.visualize()
+    }
+
+    const graphics = visualizeInputProblem(this.inputProblem)
+
+    // Draw solved long-distance traces
+    for (const trace of this.solvedLongDistanceTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+
+    // Draw queued candidate pairs
+    for (const [p1, p2] of this.queuedCandidatePairs) {
+      graphics.lines!.push({
+        points: [p1, p2],
+        strokeColor: "gray",
+        strokeDash: "4 4",
+      })
+    }
+
+    return graphics
+  }
+
+  public getOutput(): {
+    newTraces: SolvedTracePath[]
+    allTracesMerged: SolvedTracePath[]
+  } {
+    if (!this.solved) {
+      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces }
+    }
+    return {
+      newTraces: this.solvedLongDistanceTraces,
+      allTracesMerged: [
+        ...this.params.alreadySolvedTraces,
+        ...this.solvedLongDistanceTraces,
+      ],
+    }
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -16,6 +16,7 @@ import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceS
 import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
 import { expandChipsToFitPins } from "./expandChipsToFitPins"
+import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePairSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -24,6 +25,7 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     instance: SchematicTracePipelineSolver,
   ) => ConstructorParameters<T>
   onSolved?: (instance: SchematicTracePipelineSolver) => void
+  shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean
 }
 
 function definePipelineStep<
@@ -37,6 +39,7 @@ function definePipelineStep<
   getConstructorParams: (instance: SchematicTracePipelineSolver) => P,
   opts: {
     onSolved?: (instance: SchematicTracePipelineSolver) => void
+    shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean
   } = {},
 ): PipelineStep<T> {
   return {
@@ -44,13 +47,20 @@ function definePipelineStep<
     solverClass,
     getConstructorParams,
     onSolved: opts.onSolved,
+    shouldSkip: opts.shouldSkip,
   }
 }
 
+export interface SchematicTracePipelineSolverParams {
+  inputProblem: InputProblem
+  allowLongDistanceTraces?: boolean
+}
+
 export class SchematicTracePipelineSolver extends BaseSolver {
   mspConnectionPairSolver?: MspConnectionPairSolver
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
+  longDistancePairSolver?: LongDistancePairSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
@@ -96,6 +106,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           chipMap: this.mspConnectionPairSolver!.chipMap,
         },
       ],
+    ),
+    definePipelineStep(
+      "longDistancePairSolver",
+      LongDistancePairSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          primaryMspConnectionPairs:
+            instance.mspConnectionPairSolver!.mspConnectionPairs,
+          alreadySolvedTraces:
+            instance.schematicTraceLinesSolver!.solvedTracePaths,
+        },
+      ],
       {
         onSolved: (schematicTraceLinesSolver) => {},
       },
@@ -106,7 +129,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.schematicTraceLinesSolver!.solvedTracePaths,
+          inputTracePaths:
+            this.longDistancePairSolver?.getOutput().allTracesMerged!,
           globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
         },
       ],
@@ -123,10 +147,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputTraceMap:
             this.traceOverlapShiftSolver?.correctedTraceMap ??
             Object.fromEntries(
-              this.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
-                p.mspPairId,
-                p,
-              ]),
+              this.longDistancePairSolver!.getOutput().allTracesMerged.map(
+                (p) => [p.mspPairId, p],
+              ),
             ),
         },
       ],
@@ -143,10 +166,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         const traceMap =
           instance.traceOverlapShiftSolver?.correctedTraceMap ??
           Object.fromEntries(
-            instance.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
-              p.mspPairId,
-              p,
-            ]),
+            instance
+              .longDistancePairSolver!.getOutput()
+              .allTracesMerged.map((p) => [p.mspPairId, p]),
           )
         const traces = Object.values(traceMap)
         const netLabelPlacements =

package/lib/utils/does-trace-overlap-with-existing-traces.ts

@@ -0,0 +1,33 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "../solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { doSegmentsIntersect } from "@tscircuit/math-utils"
+
+export function doesTraceOverlapWithExistingTraces(
+  newTracePath: Point[],
+  existingTraces: SolvedTracePath[],
+): boolean {
+  for (let i = 0; i < newTracePath.length - 1; i++) {
+    const newSegmentP1 = newTracePath[i]
+    const newSegmentP2 = newTracePath[i + 1]
+
+    for (const existingTrace of existingTraces) {
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegmentP1 = existingTrace.tracePath[j]
+        const existingSegmentP2 = existingTrace.tracePath[j + 1]
+
+        if (
+          doSegmentsIntersect(
+            newSegmentP1,
+            newSegmentP2,
+            existingSegmentP1,
+            existingSegmentP2,
+          )
+        ) {
+          return true // Found an intersection
+        }
+      }
+    }
+  }
+
+  return false // No intersections found
+}