@tscircuit/schematic-trace-solver 0.0.108 → 0.0.110

package/dist/index.js

@@ -421,6 +421,7 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
 }
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
+var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
 var MspConnectionPairSolver = class extends BaseSolver {
   inputProblem;
@@ -436,7 +437,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
-    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1;
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
     this.globalConnMap = netConnMap;
@@ -3258,11 +3259,18 @@ var groupLabelsByChipAndOrientation = ({
   chips
 }) => {
   const groupedLabels = {};
+  const chipIdByPinId = new Map(
+    chips.flatMap(
+      (chip) => chip.pins.map((pin) => [pin.pinId, chip.chipId])
+    )
+  );
   for (const label of labels) {
     if (label.pinIds.length === 0) {
       continue;
     }
-    const chipId = label.pinIds[0].split(".")[0];
+    const pinId = label.pinIds[0];
+    const legacyChipId = pinId.includes(".") ? pinId.split(".")[0] : void 0;
+    const chipId = legacyChipId ?? chipIdByPinId.get(pinId);
     if (!chipId) {
       continue;
     }
@@ -3893,7 +3901,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       paddingBuffer: effectivePadding
       // Use the calculated, larger padding
     });
-    const getPathLength2 = (pts) => {
+    const getPathLength3 = (pts) => {
       let len = 0;
       for (let i = 0; i < pts.length - 1; i++) {
         const dx = pts[i + 1].x - pts[i].x;
@@ -3903,7 +3911,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       return len;
     };
     this.queuedCandidatePaths = candidates.sort(
-      (a, b) => getPathLength2(a) - getPathLength2(b)
+      (a, b) => getPathLength3(a) - getPathLength3(b)
     );
     this.obstacles = getObstacleRects(this.problem);
   }
@@ -5343,10 +5351,10 @@ var projectPointToPath = (point, path) => {
   let bestDistance = Number.POSITIVE_INFINITY;
   for (let i = 0; i < path.length - 1; i++) {
     const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
-    const distance4 = getDistance2(point, projectedPoint);
-    if (distance4 < bestDistance) {
+    const distance5 = getDistance2(point, projectedPoint);
+    if (distance5 < bestDistance) {
       bestPoint = projectedPoint;
-      bestDistance = distance4;
+      bestDistance = distance5;
     }
   }
   return bestPoint;
@@ -7160,11 +7168,11 @@ var getLabelHugDistance = (tracePath, obstacleLabel) => {
     obstacleLabel.width,
     obstacleLabel.height
   );
-  let distance4 = 0;
+  let distance5 = 0;
   for (const point of tracePath) {
-    distance4 += getPointDistanceFromRect(point, bounds);
+    distance5 += getPointDistanceFromRect(point, bounds);
   }
-  return distance4;
+  return distance5;
 };
 var getPointDistanceFromRect = (point, rect) => {
   const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
@@ -7441,16 +7449,16 @@ var Example28Solver = class extends BaseSolver {
     const outward = dir(label.orientation);
     if (outward.x === 0 && outward.y === 0) return null;
     for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
-      const distance4 = step * LABEL_OUTWARD_STEP;
+      const distance5 = step * LABEL_OUTWARD_STEP;
       const candidate = {
         ...label,
         anchorPoint: {
-          x: label.anchorPoint.x + outward.x * distance4,
-          y: label.anchorPoint.y + outward.y * distance4
+          x: label.anchorPoint.x + outward.x * distance5,
+          y: label.anchorPoint.y + outward.y * distance5
         },
         center: {
-          x: label.center.x + outward.x * distance4,
-          y: label.center.y + outward.y * distance4
+          x: label.center.x + outward.x * distance5,
+          y: label.center.y + outward.y * distance5
         }
       };
       const candidateWithClearance = {
@@ -8024,10 +8032,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS11; distance4 += LABEL_SEARCH_STEP) {
+    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
-        x: baseAnchor.x + direction.x * distance4,
-        y: baseAnchor.y + direction.y * distance4
+        x: baseAnchor.x + direction.x * distance5,
+        y: baseAnchor.y + direction.y * distance5
       };
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -8035,7 +8043,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         label,
         labelIndex,
         phase,
-        distance4,
+        distance5,
         outwardDistance
       );
       this.currentCandidateResults.push(result);
@@ -8047,11 +8055,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  evaluateCandidate(candidate, label, labelIndex, phase, distance4, outwardDistance) {
+  evaluateCandidate(candidate, label, labelIndex, phase, distance5, outwardDistance) {
     return {
       ...candidate,
       phase,
-      distance: distance4,
+      distance: distance5,
       outwardDistance,
       selected: false,
       status: this.getCandidateStatus({
@@ -8389,10 +8397,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (point.x < bounds.minX - EPS11 || point.x > bounds.maxX + EPS11 || point.y < bounds.minY - EPS11 || point.y > bounds.maxY + EPS11) {
         continue;
       }
-      for (const [side, distance4] of getSideDistances(point, bounds)) {
-        if (distance4 < nearestDistance) {
+      for (const [side, distance5] of getSideDistances(point, bounds)) {
+        if (distance5 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance4;
+          nearestDistance = distance5;
         }
       }
     }
@@ -8421,10 +8429,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
-      for (const [side, distance4] of getSideDistances(point, chip.bounds)) {
-        if (distance4 < nearestDistance) {
+      for (const [side, distance5] of getSideDistances(point, chip.bounds)) {
+        if (distance5 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance4;
+          nearestDistance = distance5;
         }
       }
     }
@@ -8825,17 +8833,17 @@ var getTraceLength = (trace) => {
   }
   return length;
 };
-var getPointAtTraceDistance = (trace, distance4) => {
+var getPointAtTraceDistance = (trace, distance5) => {
   let pathDistance = 0;
   for (let i = 0; i < trace.tracePath.length - 1; i++) {
     const start = trace.tracePath[i];
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance4 <= nextDistance + EPS12) {
+    if (distance5 <= nextDistance + EPS12) {
       const offset = Math.max(
         0,
-        Math.min(segmentLength, distance4 - pathDistance)
+        Math.min(segmentLength, distance5 - pathDistance)
       );
       const direction = getSegmentDirection(start, end);
       return {
@@ -8960,13 +8968,13 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
-    const distance4 = Math.min(traceLength, i * CANDIDATE_STEP);
-    distances.add(roundDistance(distance4));
+    const distance5 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance5));
   }
-  for (const distance4 of vertexDistances) {
-    distances.add(roundDistance(distance4));
+  for (const distance5 of vertexDistances) {
+    distances.add(roundDistance(distance5));
   }
-  return [...distances].filter((distance4) => distance4 >= -EPS12 && distance4 <= traceLength + EPS12).sort((a, b) => a - b);
+  return [...distances].filter((distance5) => distance5 >= -EPS12 && distance5 <= traceLength + EPS12).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -9144,7 +9152,7 @@ var getNetLabelHeight = (inputProblem, label) => {
     (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
   )?.netLabelHeight;
 };
-var roundDistance = (distance4) => Number(distance4.toFixed(6));
+var roundDistance = (distance5) => Number(distance5.toFixed(6));
 var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS12 && Math.abs(point.y - label.anchorPoint.y) <= EPS12 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
@@ -10110,6 +10118,457 @@ ${c.status}`
   }
 };
 
+// lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts
+import { distance as distance4, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
+var ROUTE_CLEARANCE = 0.2;
+var COORDINATE_TOLERANCE = 1e-9;
+var GROUND_NET_ID = "GND";
+var pointsAreEqual = (firstPoint, secondPoint) => {
+  return Math.abs(firstPoint.x - secondPoint.x) <= COORDINATE_TOLERANCE && Math.abs(firstPoint.y - secondPoint.y) <= COORDINATE_TOLERANCE;
+};
+var removeConsecutiveDuplicatePoints = (path) => {
+  const filteredPath = [];
+  for (const point of path) {
+    const previousPoint = filteredPath.at(-1);
+    if (!previousPoint || !pointsAreEqual(previousPoint, point)) {
+      filteredPath.push(point);
+    }
+  }
+  return filteredPath;
+};
+var getPathLength2 = (path) => {
+  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;
+};
+var getEscapePoint = ({
+  pin,
+  facingDirection
+}) => {
+  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;
+};
+var getOuterBounds = (obstacles) => {
+  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))
+  };
+};
+var getPerimeterCandidates = ({
+  connectionPair,
+  obstacles
+}) => {
+  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 = [];
+  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) => getPathLength2(firstPath) - getPathLength2(secondPath)
+  );
+};
+var getSegmentMidpoint = (startPoint, endPoint) => {
+  return {
+    x: (startPoint.x + endPoint.x) / 2,
+    y: (startPoint.y + endPoint.y) / 2
+  };
+};
+var getJunctionPoints = (sameNetTraces) => {
+  const junctionPoints = [];
+  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;
+};
+var getUnconnectedPins = ({
+  connectionPair,
+  sameNetTraces
+}) => {
+  const connectedPinIds = new Set(
+    sameNetTraces.flatMap((trace) => trace.pinIds)
+  );
+  return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId));
+};
+var getJunctionCandidates = ({
+  connectionPair,
+  sameNetTraces,
+  obstacles,
+  maxConnectionDistance
+}) => {
+  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 = [];
+  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 (distance4(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) => getPathLength2(firstPath) - getPathLength2(secondPath)
+  );
+};
+var pathCollidesWithObstacles = ({
+  path,
+  obstacles,
+  connectionPair,
+  rejectComponentBoundaryTravel
+}) => {
+  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 !== void 0 && lastPathPin !== void 0;
+  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 = /* @__PURE__ */ new Set();
+      if (segmentIndex === 0 && firstChipObstacle) {
+        excludedObstacles.add(firstChipObstacle);
+      }
+      if (pathConnectsPairPins && segmentIndex === path.length - 2 && secondChipObstacle) {
+        excludedObstacles.add(secondChipObstacle);
+      }
+      return excludedObstacles;
+    }
+  });
+  return collision !== null;
+};
+var hasParallelFailedConnection = ({
+  connectionPair,
+  failedConnectionPairs
+}) => {
+  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)
+    );
+  });
+};
+var segmentsOverlapBeyondEndpoint = ({
+  firstStart,
+  firstEnd,
+  secondStart,
+  secondEnd
+}) => {
+  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;
+};
+var getAllowedJunctionPoints = ({
+  connectionPair,
+  existingTrace
+}) => {
+  const existingPinIds = new Set(existingTrace.pinIds);
+  return connectionPair.pins.filter((pin) => existingPinIds.has(pin.pinId));
+};
+var pathCrossesExistingTraces = ({
+  path,
+  connectionPair,
+  existingTraces
+}) => {
+  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 (!doSegmentsIntersect3(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;
+};
+var UnroutedTraceRecoverySolver = class extends BaseSolver {
+  constructor(params) {
+    super();
+    this.params = params;
+    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) ?? void 0;
+  }
+  params;
+  inputProblem;
+  alreadySolvedTraces;
+  failedConnectionPairs;
+  queuedConnectionPairs;
+  maxConnectionDistance;
+  groundGlobalConnNetId;
+  solvedUnroutedTraces = [];
+  getConstructorParams() {
+    return this.params;
+  }
+  _step() {
+    const connectionPair = this.queuedConnectionPairs.shift();
+    if (!connectionPair) {
+      this.solved = true;
+      return;
+    }
+    if (connectionPair.globalConnNetId === this.groundGlobalConnNetId) {
+      return;
+    }
+    if (distance4(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() {
+    return {
+      newTraces: this.solvedUnroutedTraces,
+      allTracesMerged: [
+        ...this.alreadySolvedTraces,
+        ...this.solvedUnroutedTraces
+      ]
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem);
+    for (const trace of this.solvedUnroutedTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "blue"
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -10125,6 +10584,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver;
   longDistancePairSolver;
+  unroutedTraceRecoverySolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
   labelMergingSolver;
@@ -10195,13 +10655,24 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       }
     ),
+    definePipelineStep(
+      "unroutedTraceRecoverySolver",
+      UnroutedTraceRecoverySolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          failedConnectionPairs: instance.schematicTraceLinesSolver.failedConnectionPairs,
+          alreadySolvedTraces: instance.longDistancePairSolver.getOutput().allTracesMerged
+        }
+      ]
+    ),
     definePipelineStep(
       "traceOverlapShiftSolver",
       TraceOverlapShiftSolver,
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.longDistancePairSolver?.getOutput().allTracesMerged,
+          inputTracePaths: this.unroutedTraceRecoverySolver?.getOutput().allTracesMerged,
           globalConnMap: this.mspConnectionPairSolver.globalConnMap
         }
       ],
@@ -10217,7 +10688,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTraceMap: this.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-            this.longDistancePairSolver.getOutput().allTracesMerged.map(
+            this.unroutedTraceRecoverySolver.getOutput().allTracesMerged.map(
               (p) => [p.mspPairId, p]
             )
           )
@@ -10233,7 +10704,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       TraceLabelOverlapAvoidanceSolver,
       (instance) => {
         const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-          instance.longDistancePairSolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
+          instance.unroutedTraceRecoverySolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
         );
         const traces = Object.values(traceMap);
         const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;