@tscircuit/schematic-trace-solver 0.0.108 → 0.0.110

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -16,6 +16,7 @@ import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInp
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 
 export type MspConnectionPairId = string
+export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
 
 const getPinPairKey = (pinIds: [PinId, PinId]) => [...pinIds].sort().join("::")
 
@@ -45,7 +46,8 @@ export class MspConnectionPairSolver extends BaseSolver {
     super()
 
     this.inputProblem = inputProblem
-    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1
+    this.maxMspPairDistance =
+      inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
 
     const { directConnMap, netConnMap } =
       getConnectivityMapsFromInputProblem(inputProblem)

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -27,6 +27,7 @@ import { RailNetLabelCornerPlacementSolver } from "../RailNetLabelCornerPlacemen
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
 import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
+import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -70,6 +71,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
   longDistancePairSolver?: LongDistancePairSolver
+  unroutedTraceRecoverySolver?: UnroutedTraceRecoverySolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
   labelMergingSolver?: MergedNetLabelObstacleSolver
@@ -143,6 +145,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         onSolved: (schematicTraceLinesSolver) => {},
       },
     ),
+    definePipelineStep(
+      "unroutedTraceRecoverySolver",
+      UnroutedTraceRecoverySolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          failedConnectionPairs:
+            instance.schematicTraceLinesSolver!.failedConnectionPairs,
+          alreadySolvedTraces:
+            instance.longDistancePairSolver!.getOutput().allTracesMerged,
+        },
+      ],
+    ),
     definePipelineStep(
       "traceOverlapShiftSolver",
       TraceOverlapShiftSolver,
@@ -150,7 +165,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTracePaths:
-            this.longDistancePairSolver?.getOutput().allTracesMerged!,
+            this.unroutedTraceRecoverySolver?.getOutput().allTracesMerged!,
           globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
         },
       ],
@@ -167,7 +182,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputTraceMap:
             this.traceOverlapShiftSolver?.correctedTraceMap ??
             Object.fromEntries(
-              this.longDistancePairSolver!.getOutput().allTracesMerged.map(
+              this.unroutedTraceRecoverySolver!.getOutput().allTracesMerged.map(
                 (p) => [p.mspPairId, p],
               ),
             ),
@@ -187,7 +202,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           instance.traceOverlapShiftSolver?.correctedTraceMap ??
           Object.fromEntries(
             instance
-              .longDistancePairSolver!.getOutput()
+              .unroutedTraceRecoverySolver!.getOutput()
               .allTracesMerged.map((p) => [p.mspPairId, p]),
           )
         const traces = Object.values(traceMap)

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/groupLabelsByChipAndOrientation.ts

@@ -7,7 +7,8 @@ import type { InputProblem } from "lib/types/InputProblem"
  * with the same orientation relative to that chip.
  *
  * @param labels An array of NetLabelPlacement objects to be grouped.
- * @param chips An array of Chip objects from the InputProblem. (Currently not directly used for grouping logic, but part of the signature).
+ * @param chips Chips from the input problem, used to resolve opaque pin IDs to
+ * their owning component.
  * @returns A record where keys are in the format "chipId-orientation" (e.g., "U1-left")
  *          and values are arrays of NetLabelPlacement objects belonging to that group.
  */
@@ -19,6 +20,11 @@ export const groupLabelsByChipAndOrientation = ({
   chips: InputProblem["chips"]
 }): Record<string, NetLabelPlacement[]> => {
   const groupedLabels: Record<string, NetLabelPlacement[]> = {}
+  const chipIdByPinId = new Map(
+    chips.flatMap((chip) =>
+      chip.pins.map((pin) => [pin.pinId, chip.chipId] as const),
+    ),
+  )
 
   for (const label of labels) {
     if (label.pinIds.length === 0) {
@@ -26,10 +32,12 @@ export const groupLabelsByChipAndOrientation = ({
       continue
     }
 
-    // Extract chipId from the first pinId (e.g., "U1.1" -> "U1")
-    const chipId = label.pinIds[0].split(".")[0]
+    const pinId = label.pinIds[0]!
+    // Preserve historical group IDs for component-qualified pins while using
+    // the input's pin ownership for opaque IDs such as schematic_port_123.
+    const legacyChipId = pinId.includes(".") ? pinId.split(".")[0] : undefined
+    const chipId = legacyChipId ?? chipIdByPinId.get(pinId)
     if (!chipId) {
-      // Should not happen if pinIds are well-formed, but good to guard
       continue
     }
 

package/lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts

@@ -0,0 +1,592 @@
+import type { Point } from "@tscircuit/math-utils"
+import { distance, doSegmentsIntersect } from "@tscircuit/math-utils"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import {
+  DEFAULT_MAX_MSP_PAIR_DISTANCE,
+  type MspConnectionPair,
+} from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  findFirstCollision,
+  isHorizontal,
+  isVertical,
+  segmentOverlapsRectBoundary,
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import {
+  getObstacleRects,
+  type ObstacleRect,
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem, PinId } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+
+const ROUTE_CLEARANCE = 0.2
+const COORDINATE_TOLERANCE = 1e-9
+const GROUND_NET_ID = "GND"
+
+const pointsAreEqual = (firstPoint: Point, secondPoint: Point): boolean => {
+  return (
+    Math.abs(firstPoint.x - secondPoint.x) <= COORDINATE_TOLERANCE &&
+    Math.abs(firstPoint.y - secondPoint.y) <= COORDINATE_TOLERANCE
+  )
+}
+
+const removeConsecutiveDuplicatePoints = (path: Point[]): Point[] => {
+  const filteredPath: Point[] = []
+  for (const point of path) {
+    const previousPoint = filteredPath.at(-1)
+    if (!previousPoint || !pointsAreEqual(previousPoint, point)) {
+      filteredPath.push(point)
+    }
+  }
+  return filteredPath
+}
+
+const getPathLength = (path: Point[]): number => {
+  let pathLength = 0
+  for (let pointIndex = 0; pointIndex < path.length - 1; pointIndex++) {
+    const startPoint = path[pointIndex]!
+    const endPoint = path[pointIndex + 1]!
+    pathLength +=
+      Math.abs(endPoint.x - startPoint.x) + Math.abs(endPoint.y - startPoint.y)
+  }
+  return pathLength
+}
+
+const getEscapePoint = ({
+  pin,
+  facingDirection,
+}: {
+  pin: Point
+  facingDirection: FacingDirection
+}): Point => {
+  const escapePoint = { x: pin.x, y: pin.y }
+  if (facingDirection === "x+") {
+    escapePoint.x += ROUTE_CLEARANCE
+  }
+  if (facingDirection === "x-") {
+    escapePoint.x -= ROUTE_CLEARANCE
+  }
+  if (facingDirection === "y+") {
+    escapePoint.y += ROUTE_CLEARANCE
+  }
+  if (facingDirection === "y-") {
+    escapePoint.y -= ROUTE_CLEARANCE
+  }
+  return escapePoint
+}
+
+const getOuterBounds = (obstacles: ObstacleRect[]) => {
+  return {
+    minX: Math.min(...obstacles.map((obstacle) => obstacle.minX)),
+    minY: Math.min(...obstacles.map((obstacle) => obstacle.minY)),
+    maxX: Math.max(...obstacles.map((obstacle) => obstacle.maxX)),
+    maxY: Math.max(...obstacles.map((obstacle) => obstacle.maxY)),
+  }
+}
+
+const getPerimeterCandidates = ({
+  connectionPair,
+  obstacles,
+}: {
+  connectionPair: MspConnectionPair
+  obstacles: ObstacleRect[]
+}): Point[][] => {
+  const [firstPin, secondPin] = connectionPair.pins
+  const firstEscapePoint = getEscapePoint({
+    pin: firstPin,
+    facingDirection: firstPin._facingDirection!,
+  })
+  const secondEscapePoint = getEscapePoint({
+    pin: secondPin,
+    facingDirection: secondPin._facingDirection!,
+  })
+  const outerBounds = getOuterBounds(obstacles)
+  const horizontalChannels = [
+    outerBounds.minY - ROUTE_CLEARANCE,
+    outerBounds.maxY + ROUTE_CLEARANCE,
+  ]
+  const verticalChannels = [
+    outerBounds.minX - ROUTE_CLEARANCE,
+    outerBounds.maxX + ROUTE_CLEARANCE,
+  ]
+  const candidates: Point[][] = []
+
+  for (const channelY of horizontalChannels) {
+    candidates.push(
+      removeConsecutiveDuplicatePoints([
+        firstPin,
+        firstEscapePoint,
+        { x: firstEscapePoint.x, y: channelY },
+        { x: secondEscapePoint.x, y: channelY },
+        secondEscapePoint,
+        secondPin,
+      ]),
+    )
+  }
+
+  for (const channelX of verticalChannels) {
+    candidates.push(
+      removeConsecutiveDuplicatePoints([
+        firstPin,
+        firstEscapePoint,
+        { x: channelX, y: firstEscapePoint.y },
+        { x: channelX, y: secondEscapePoint.y },
+        secondEscapePoint,
+        secondPin,
+      ]),
+    )
+  }
+
+  return candidates.sort(
+    (firstPath, secondPath) =>
+      getPathLength(firstPath) - getPathLength(secondPath),
+  )
+}
+
+const getSegmentMidpoint = (startPoint: Point, endPoint: Point): Point => {
+  return {
+    x: (startPoint.x + endPoint.x) / 2,
+    y: (startPoint.y + endPoint.y) / 2,
+  }
+}
+
+const getJunctionPoints = (sameNetTraces: SolvedTracePath[]): Point[] => {
+  const junctionPoints: Point[] = []
+  for (const trace of sameNetTraces) {
+    for (
+      let pointIndex = 0;
+      pointIndex < trace.tracePath.length - 1;
+      pointIndex++
+    ) {
+      const startPoint = trace.tracePath[pointIndex]!
+      const endPoint = trace.tracePath[pointIndex + 1]!
+      junctionPoints.push(startPoint)
+      junctionPoints.push(getSegmentMidpoint(startPoint, endPoint))
+    }
+    const lastPoint = trace.tracePath.at(-1)
+    if (lastPoint) {
+      junctionPoints.push(lastPoint)
+    }
+  }
+  return junctionPoints
+}
+
+const getUnconnectedPins = ({
+  connectionPair,
+  sameNetTraces,
+}: {
+  connectionPair: MspConnectionPair
+  sameNetTraces: SolvedTracePath[]
+}) => {
+  const connectedPinIds = new Set(
+    sameNetTraces.flatMap((trace) => trace.pinIds),
+  )
+  return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId))
+}
+
+const getJunctionCandidates = ({
+  connectionPair,
+  sameNetTraces,
+  obstacles,
+  maxConnectionDistance,
+}: {
+  connectionPair: MspConnectionPair
+  sameNetTraces: SolvedTracePath[]
+  obstacles: ObstacleRect[]
+  maxConnectionDistance: number
+}): Point[][] => {
+  const outerBounds = getOuterBounds(obstacles)
+  const horizontalChannels = [
+    outerBounds.minY - ROUTE_CLEARANCE,
+    outerBounds.maxY + ROUTE_CLEARANCE,
+  ]
+  const verticalChannels = [
+    outerBounds.minX - ROUTE_CLEARANCE,
+    outerBounds.maxX + ROUTE_CLEARANCE,
+  ]
+  const candidates: Point[][] = []
+  const junctionPoints = getJunctionPoints(sameNetTraces)
+  const unconnectedPins = getUnconnectedPins({
+    connectionPair,
+    sameNetTraces,
+  })
+
+  for (const pin of unconnectedPins) {
+    const escapePoint = getEscapePoint({
+      pin,
+      facingDirection: pin._facingDirection!,
+    })
+    for (const junctionPoint of junctionPoints) {
+      if (distance(pin, junctionPoint) > maxConnectionDistance) {
+        continue
+      }
+      candidates.push(
+        removeConsecutiveDuplicatePoints([
+          pin,
+          escapePoint,
+          { x: escapePoint.x, y: junctionPoint.y },
+          junctionPoint,
+        ]),
+      )
+      candidates.push(
+        removeConsecutiveDuplicatePoints([
+          pin,
+          escapePoint,
+          { x: junctionPoint.x, y: escapePoint.y },
+          junctionPoint,
+        ]),
+      )
+      for (const channelY of horizontalChannels) {
+        candidates.push(
+          removeConsecutiveDuplicatePoints([
+            pin,
+            escapePoint,
+            { x: escapePoint.x, y: channelY },
+            { x: junctionPoint.x, y: channelY },
+            junctionPoint,
+          ]),
+        )
+      }
+      for (const channelX of verticalChannels) {
+        candidates.push(
+          removeConsecutiveDuplicatePoints([
+            pin,
+            escapePoint,
+            { x: channelX, y: escapePoint.y },
+            { x: channelX, y: junctionPoint.y },
+            junctionPoint,
+          ]),
+        )
+      }
+    }
+  }
+
+  return candidates.sort(
+    (firstPath, secondPath) =>
+      getPathLength(firstPath) - getPathLength(secondPath),
+  )
+}
+
+const pathCollidesWithObstacles = ({
+  path,
+  obstacles,
+  connectionPair,
+  rejectComponentBoundaryTravel,
+}: {
+  path: Point[]
+  obstacles: ObstacleRect[]
+  connectionPair: MspConnectionPair
+  rejectComponentBoundaryTravel: boolean
+}): boolean => {
+  const firstPathPoint = path[0]!
+  const lastPathPoint = path.at(-1)!
+  const firstPathPin = connectionPair.pins.find((pin) =>
+    pointsAreEqual(pin, firstPathPoint),
+  )
+  const lastPathPin = connectionPair.pins.find((pin) =>
+    pointsAreEqual(pin, lastPathPoint),
+  )
+  const pathConnectsPairPins =
+    firstPathPin !== undefined && lastPathPin !== undefined
+  const firstChipObstacle = obstacles.find(
+    (obstacle) =>
+      obstacle.kind === "chip" && obstacle.chipId === firstPathPin?.chipId,
+  )
+  const secondChipObstacle = obstacles.find(
+    (obstacle) =>
+      obstacle.kind === "chip" && obstacle.chipId === lastPathPin?.chipId,
+  )
+  if (
+    rejectComponentBoundaryTravel &&
+    firstChipObstacle &&
+    segmentOverlapsRectBoundary(path[0]!, path[1]!, firstChipObstacle)
+  ) {
+    return true
+  }
+  if (
+    rejectComponentBoundaryTravel &&
+    secondChipObstacle &&
+    segmentOverlapsRectBoundary(
+      path[path.length - 2]!,
+      path[path.length - 1]!,
+      secondChipObstacle,
+    )
+  ) {
+    return true
+  }
+  const collision = findFirstCollision(path, obstacles, {
+    excludeRectsForSegment: (segmentIndex) => {
+      const excludedObstacles = new Set<ObstacleRect>()
+      if (segmentIndex === 0 && firstChipObstacle) {
+        excludedObstacles.add(firstChipObstacle)
+      }
+      if (
+        pathConnectsPairPins &&
+        segmentIndex === path.length - 2 &&
+        secondChipObstacle
+      ) {
+        excludedObstacles.add(secondChipObstacle)
+      }
+      return excludedObstacles
+    },
+  })
+  return collision !== null
+}
+
+const hasParallelFailedConnection = ({
+  connectionPair,
+  failedConnectionPairs,
+}: {
+  connectionPair: MspConnectionPair
+  failedConnectionPairs: MspConnectionPair[]
+}): boolean => {
+  const connectionChipIds = new Set(
+    connectionPair.pins.map((pin) => pin.chipId),
+  )
+  return failedConnectionPairs.some((otherConnectionPair) => {
+    if (otherConnectionPair.mspPairId === connectionPair.mspPairId) {
+      return false
+    }
+    return otherConnectionPair.pins.every((pin) =>
+      connectionChipIds.has(pin.chipId),
+    )
+  })
+}
+
+const segmentsOverlapBeyondEndpoint = ({
+  firstStart,
+  firstEnd,
+  secondStart,
+  secondEnd,
+}: {
+  firstStart: Point
+  firstEnd: Point
+  secondStart: Point
+  secondEnd: Point
+}): boolean => {
+  if (
+    isHorizontal(firstStart, firstEnd) &&
+    isHorizontal(secondStart, secondEnd)
+  ) {
+    const overlapLength =
+      Math.min(
+        Math.max(firstStart.x, firstEnd.x),
+        Math.max(secondStart.x, secondEnd.x),
+      ) -
+      Math.max(
+        Math.min(firstStart.x, firstEnd.x),
+        Math.min(secondStart.x, secondEnd.x),
+      )
+    return overlapLength > COORDINATE_TOLERANCE
+  }
+  if (isVertical(firstStart, firstEnd) && isVertical(secondStart, secondEnd)) {
+    const overlapLength =
+      Math.min(
+        Math.max(firstStart.y, firstEnd.y),
+        Math.max(secondStart.y, secondEnd.y),
+      ) -
+      Math.max(
+        Math.min(firstStart.y, firstEnd.y),
+        Math.min(secondStart.y, secondEnd.y),
+      )
+    return overlapLength > COORDINATE_TOLERANCE
+  }
+  return false
+}
+
+const getAllowedJunctionPoints = ({
+  connectionPair,
+  existingTrace,
+}: {
+  connectionPair: MspConnectionPair
+  existingTrace: SolvedTracePath
+}): Point[] => {
+  const existingPinIds = new Set<PinId>(existingTrace.pinIds)
+  return connectionPair.pins.filter((pin) => existingPinIds.has(pin.pinId))
+}
+
+const pathCrossesExistingTraces = ({
+  path,
+  connectionPair,
+  existingTraces,
+}: {
+  path: Point[]
+  connectionPair: MspConnectionPair
+  existingTraces: SolvedTracePath[]
+}): boolean => {
+  for (const existingTrace of existingTraces) {
+    if (existingTrace.globalConnNetId === connectionPair.globalConnNetId) {
+      continue
+    }
+    const allowedJunctionPoints = getAllowedJunctionPoints({
+      connectionPair,
+      existingTrace,
+    })
+    for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+      const pathStart = path[pathIndex]!
+      const pathEnd = path[pathIndex + 1]!
+      for (
+        let traceIndex = 0;
+        traceIndex < existingTrace.tracePath.length - 1;
+        traceIndex++
+      ) {
+        const traceStart = existingTrace.tracePath[traceIndex]!
+        const traceEnd = existingTrace.tracePath[traceIndex + 1]!
+        if (!doSegmentsIntersect(pathStart, pathEnd, traceStart, traceEnd)) {
+          continue
+        }
+        const intersectionIsAllowedJunction = allowedJunctionPoints.some(
+          (junctionPoint) =>
+            (pointsAreEqual(pathStart, junctionPoint) ||
+              pointsAreEqual(pathEnd, junctionPoint)) &&
+            (pointsAreEqual(traceStart, junctionPoint) ||
+              pointsAreEqual(traceEnd, junctionPoint)),
+        )
+        if (
+          intersectionIsAllowedJunction &&
+          !segmentsOverlapBeyondEndpoint({
+            firstStart: pathStart,
+            firstEnd: pathEnd,
+            secondStart: traceStart,
+            secondEnd: traceEnd,
+          })
+        ) {
+          continue
+        }
+        return true
+      }
+    }
+  }
+  return false
+}
+
+export class UnroutedTraceRecoverySolver extends BaseSolver {
+  private inputProblem: InputProblem
+  private alreadySolvedTraces: SolvedTracePath[]
+  private failedConnectionPairs: MspConnectionPair[]
+  private queuedConnectionPairs: MspConnectionPair[]
+  private maxConnectionDistance: number
+  private groundGlobalConnNetId?: string
+  public solvedUnroutedTraces: SolvedTracePath[] = []
+
+  constructor(
+    private params: {
+      inputProblem: InputProblem
+      failedConnectionPairs: MspConnectionPair[]
+      alreadySolvedTraces: SolvedTracePath[]
+    },
+  ) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.alreadySolvedTraces = params.alreadySolvedTraces
+    this.failedConnectionPairs = params.failedConnectionPairs
+    this.queuedConnectionPairs = [...params.failedConnectionPairs]
+    this.maxConnectionDistance =
+      this.inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem,
+    )
+    this.groundGlobalConnNetId =
+      netConnMap.getNetConnectedToId(GROUND_NET_ID) ?? undefined
+  }
+
+  override getConstructorParams() {
+    return this.params
+  }
+
+  override _step() {
+    const connectionPair = this.queuedConnectionPairs.shift()
+    if (!connectionPair) {
+      this.solved = true
+      return
+    }
+    if (connectionPair.globalConnNetId === this.groundGlobalConnNetId) {
+      return
+    }
+    if (
+      distance(connectionPair.pins[0], connectionPair.pins[1]) >
+      this.maxConnectionDistance
+    ) {
+      return
+    }
+
+    const obstacles = getObstacleRects(this.inputProblem)
+    const existingTraces = [
+      ...this.alreadySolvedTraces,
+      ...this.solvedUnroutedTraces,
+    ]
+    const sameNetTraces = existingTraces.filter(
+      (trace) => trace.globalConnNetId === connectionPair.globalConnNetId,
+    )
+    const junctionCandidates = getJunctionCandidates({
+      connectionPair,
+      sameNetTraces,
+      obstacles,
+      maxConnectionDistance: this.maxConnectionDistance,
+    })
+    const perimeterCandidates = getPerimeterCandidates({
+      connectionPair,
+      obstacles,
+    })
+    const candidates = [...junctionCandidates, ...perimeterCandidates]
+    const rejectComponentBoundaryTravel = hasParallelFailedConnection({
+      connectionPair,
+      failedConnectionPairs: this.failedConnectionPairs,
+    })
+
+    for (const tracePath of candidates) {
+      if (
+        pathCollidesWithObstacles({
+          path: tracePath,
+          obstacles,
+          connectionPair,
+          rejectComponentBoundaryTravel,
+        })
+      ) {
+        continue
+      }
+      if (
+        pathCrossesExistingTraces({
+          path: tracePath,
+          connectionPair,
+          existingTraces,
+        })
+      ) {
+        continue
+      }
+      this.solvedUnroutedTraces.push({
+        ...connectionPair,
+        tracePath,
+        mspConnectionPairIds: [connectionPair.mspPairId],
+        pinIds: connectionPair.pins.map((pin) => pin.pinId),
+      })
+      return
+    }
+  }
+
+  getOutput(): {
+    newTraces: SolvedTracePath[]
+    allTracesMerged: SolvedTracePath[]
+  } {
+    return {
+      newTraces: this.solvedUnroutedTraces,
+      allTracesMerged: [
+        ...this.alreadySolvedTraces,
+        ...this.solvedUnroutedTraces,
+      ],
+    }
+  }
+
+  override visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem)
+    for (const trace of this.solvedUnroutedTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "blue",
+      })
+    }
+    return graphics
+  }
+}