@tscircuit/schematic-trace-solver 0.0.163 → 0.0.165

package/dist/index.d.ts

@@ -1394,11 +1394,15 @@ declare class NetLabelToTraceSolver extends BaseSolver {
     activeSubSolver: SchematicTraceSingleLineSolver2 | null;
     constructor(input: InlineNetLabelOutput);
     getConstructorParams(): [InlineNetLabelOutput];
-    private isEligiblePortOnlyDirectConnectionLabel;
+    private isPortOnlyFallbackLabel;
+    private isDirectConnectionLabel;
+    private getMultiPinNetConnection;
     private buildCandidatePairs;
+    private buildRoutedComponentCandidates;
     private isSupersededConnectorTrace;
     private routeIntersectsRemainingLabels;
     private tryAcceptCurrentRoute;
+    private areCandidatePinsAlreadyConnected;
     _step(): void;
     getOutput(): {
         traces: SolvedTracePath[];

package/dist/index.js

@@ -1507,13 +1507,17 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       excludeRectsForSegment: (segIndex2) => {
         const lastSegIndex2 = path.length - 2;
         const excludedRects = /* @__PURE__ */ new Set();
-        if (segIndex2 === 0 || segIndex2 === lastSegIndex2) {
+        const segmentStart = path[segIndex2];
+        const segmentEnd = path[segIndex2 + 1];
+        const oppositeTerminalPin = segIndex2 === 0 ? PB : segIndex2 === lastSegIndex2 ? PA : null;
+        if (oppositeTerminalPin) {
           for (const textObstacle of this.textObstacles) {
-            excludedRects.add(textObstacle);
+            const textBounds = getTextBoxBounds(textObstacle.textBox);
+            if (textObstacle.textBox.chipId !== oppositeTerminalPin.chipId || !segmentIntersectsRect(segmentStart, segmentEnd, textBounds)) {
+              excludedRects.add(textObstacle);
+            }
           }
         }
-        const segmentStart = path[segIndex2];
-        const segmentEnd = path[segIndex2 + 1];
         const endpointEpsilon = 1e-9;
         const segmentTouchesPin = (pin) => [segmentStart, segmentEnd].some(
           (point) => Math.abs(point.x - pin.x) <= endpointEpsilon && Math.abs(point.y - pin.y) <= endpointEpsilon
@@ -15047,6 +15051,8 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
 var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
 var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
+var MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05;
+var MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25;
 var getCanonicalPairKey = (firstPinId, secondPinId) => [firstPinId, secondPinId].sort().join("--");
 var pathIntersectsRenderedLabel = (path, label) => {
   let width = label.width;
@@ -15067,12 +15073,21 @@ var pathIntersectsRenderedLabel = (path, label) => {
   }
   return false;
 };
-var getPerpendicularOffset = (firstPin, secondPin) => {
-  const xDistance = Math.abs(firstPin.x - secondPin.x);
-  const yDistance = Math.abs(firstPin.y - secondPin.y);
+var getPerpendicularOffset = (firstPoint, secondPoint) => {
+  const xDistance = Math.abs(firstPoint.x - secondPoint.x);
+  const yDistance = Math.abs(firstPoint.y - secondPoint.y);
   if (xDistance >= yDistance) return yDistance;
   return xDistance;
 };
+var arePinsCoFacingAlongSeparationAxis = (firstPin, secondPin) => {
+  if (firstPin._facingDirection !== secondPin._facingDirection) return false;
+  const xDistance = Math.abs(firstPin.x - secondPin.x);
+  const yDistance = Math.abs(firstPin.y - secondPin.y);
+  if (xDistance >= yDistance) {
+    return firstPin._facingDirection === "x+" || firstPin._facingDirection === "x-";
+  }
+  return firstPin._facingDirection === "y+" || firstPin._facingDirection === "y-";
+};
 var NetLabelToTraceSolver = class extends BaseSolver {
   constructor(input) {
     super();
@@ -15100,26 +15115,36 @@ var NetLabelToTraceSolver = class extends BaseSolver {
   getConstructorParams() {
     return [this.input];
   }
-  isEligiblePortOnlyDirectConnectionLabel(label, groundGlobalConnNetId) {
-    if (label.pinIds.length !== 1 || label.mspConnectionPairIds.length !== 0 || !label.netId || label.netId === "GND" || label.globalConnNetId === groundGlobalConnNetId) {
-      return false;
-    }
+  isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) {
+    return !(label.pinIds.length !== 1 || label.mspConnectionPairIds.length !== 0 || !label.netId || groundGlobalConnNetIds.has(label.globalConnNetId));
+  }
+  isDirectConnectionLabel(label) {
+    if (!label.netId || label.pinIds.length !== 1) return false;
     const pinId = label.pinIds[0];
     return this.inputProblem.directConnections.some(
       (connection) => connection.netId === label.netId && connection.pinIds.includes(pinId)
     );
   }
+  getMultiPinNetConnection(label) {
+    if (!label.netId || label.pinIds.length !== 1) return void 0;
+    const pinId = label.pinIds[0];
+    return this.inputProblem.netConnections.find(
+      (connection) => connection.isGround === false && connection.pinIds.length > 2 && connection.netId === label.netId && connection.pinIds.includes(pinId)
+    );
+  }
   buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
     );
-    const groundGlobalConnNetId = netConnMap.getNetConnectedToId("GND") ?? void 0;
+    const groundGlobalConnNetIds = /* @__PURE__ */ new Set();
+    for (const connection of this.inputProblem.netConnections) {
+      if (!connection.isGround) continue;
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId);
+      if (globalConnNetId) groundGlobalConnNetIds.add(globalConnNetId);
+    }
     const labelsByGlobalNet = /* @__PURE__ */ new Map();
     for (const label of this.input.netLabelPlacements) {
-      if (!this.isEligiblePortOnlyDirectConnectionLabel(
-        label,
-        groundGlobalConnNetId
-      )) {
+      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label)) {
         continue;
       }
       const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? [];
@@ -15135,6 +15160,16 @@ var NetLabelToTraceSolver = class extends BaseSolver {
           const firstPin = this.pinMap.get(firstLabel.pinIds[0]);
           const secondPin = this.pinMap.get(secondLabel.pinIds[0]);
           if (!firstPin || !secondPin) continue;
+          const perpendicularOffset = getPerpendicularOffset(
+            firstPin,
+            secondPin
+          );
+          const bothLabelsBelongToDirectConnections = this.isDirectConnectionLabel(firstLabel) && this.isDirectConnectionLabel(secondLabel);
+          const firstMultiPinNetConnection = this.getMultiPinNetConnection(firstLabel);
+          const secondMultiPinNetConnection = this.getMultiPinNetConnection(secondLabel);
+          if (!bothLabelsBelongToDirectConnections && (!firstMultiPinNetConnection || firstMultiPinNetConnection !== secondMultiPinNetConnection || perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)) {
+            continue;
+          }
           if (arePinsInDifferentSchematicSections(
             this.inputProblem,
             firstPin,
@@ -15155,18 +15190,103 @@ var NetLabelToTraceSolver = class extends BaseSolver {
             firstLabel,
             secondLabel,
             pins: [firstPin, secondPin],
-            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            perpendicularOffset,
             routeDistance: Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y),
-            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId)
+            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+            recoveryMode: "fallback_labels"
           });
         }
       }
     }
+    candidates.push(...this.buildRoutedComponentCandidates());
     candidates.sort(
       (first, second) => first.perpendicularOffset - second.perpendicularOffset || first.routeDistance - second.routeDistance || first.key.localeCompare(second.key)
     );
     return candidates;
   }
+  buildRoutedComponentCandidates() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    );
+    const candidates = [];
+    for (const connection of this.inputProblem.netConnections) {
+      if (connection.pinIds.length <= 2 || connection.isGround !== false)
+        continue;
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId);
+      if (!globalConnNetId) continue;
+      const traceConnectedPinComponents = getTraceConnectedPinComponents({
+        pinIds: connection.pinIds,
+        traces: this.outputTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId
+        )
+      }).filter((component) => component.traces.length > 0);
+      for (let firstIndex = 0; firstIndex < traceConnectedPinComponents.length; firstIndex++) {
+        for (let secondIndex = firstIndex + 1; secondIndex < traceConnectedPinComponents.length; secondIndex++) {
+          const firstComponent = traceConnectedPinComponents[firstIndex];
+          const secondComponent = traceConnectedPinComponents[secondIndex];
+          const firstLabel = this.input.netLabelPlacements.find(
+            (label) => label.globalConnNetId === globalConnNetId && label.mspConnectionPairIds.length > 0 && label.pinIds.some(
+              (pinId) => firstComponent.pinIds.includes(pinId)
+            )
+          );
+          const secondLabel = this.input.netLabelPlacements.find(
+            (label) => label.globalConnNetId === globalConnNetId && label.mspConnectionPairIds.length > 0 && label.pinIds.some(
+              (pinId) => secondComponent.pinIds.includes(pinId)
+            )
+          );
+          if (!firstLabel || !secondLabel || firstLabel === secondLabel)
+            continue;
+          if (getPerpendicularOffset(
+            firstLabel.anchorPoint,
+            secondLabel.anchorPoint
+          ) > MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET) {
+            continue;
+          }
+          let bestCandidate;
+          for (const firstPinId of firstComponent.pinIds) {
+            for (const secondPinId of secondComponent.pinIds) {
+              const firstPin = this.pinMap.get(firstPinId);
+              const secondPin = this.pinMap.get(secondPinId);
+              if (!firstPin || !secondPin) continue;
+              const perpendicularOffset = getPerpendicularOffset(
+                firstPin,
+                secondPin
+              );
+              if (perpendicularOffset > MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET || arePinsCoFacingAlongSeparationAxis(firstPin, secondPin) || arePinsInDifferentSchematicSections(
+                this.inputProblem,
+                firstPin,
+                secondPin
+              ) || doesPairCrossRestrictedCenterLines({
+                inputProblem: this.inputProblem,
+                chipMap: this.chipMap,
+                pinIdMap: this.pinMap,
+                p1: firstPin,
+                p2: secondPin
+              })) {
+                continue;
+              }
+              const routeDistance = Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y);
+              const candidate = {
+                firstLabel,
+                secondLabel,
+                pins: [firstPin, secondPin],
+                perpendicularOffset,
+                routeDistance,
+                key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+                recoveryMode: "routed_components",
+                netConnectionPinIds: connection.pinIds
+              };
+              if (!bestCandidate || candidate.routeDistance < bestCandidate.routeDistance || candidate.routeDistance === bestCandidate.routeDistance && (candidate.perpendicularOffset < bestCandidate.perpendicularOffset || candidate.perpendicularOffset === bestCandidate.perpendicularOffset && candidate.key.localeCompare(bestCandidate.key) < 0)) {
+                bestCandidate = candidate;
+              }
+            }
+          }
+          if (bestCandidate) candidates.push(bestCandidate);
+        }
+      }
+    }
+    return candidates;
+  }
   isSupersededConnectorTrace(trace, candidate) {
     if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
       return false;
@@ -15192,7 +15312,13 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     const retainedTraces = this.outputTraces.filter(
       (trace) => !this.isSupersededConnectorTrace(trace, candidate)
     );
-    if (doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
+    let collisionTraces = retainedTraces;
+    if (candidate.recoveryMode === "routed_components") {
+      collisionTraces = retainedTraces.filter(
+        (trace) => trace.globalConnNetId !== candidate.firstLabel.globalConnNetId
+      );
+    }
+    if (doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }
     const [firstPin, secondPin] = candidate.pins;
@@ -15207,11 +15333,22 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       pinIds: [firstPin.pinId, secondPin.pinId]
     };
     this.outputTraces = [...retainedTraces, recoveredTrace];
-    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
-      (label) => label !== candidate.firstLabel && label !== candidate.secondLabel
-    );
+    if (candidate.recoveryMode === "fallback_labels") {
+      this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+        (label) => label !== candidate.firstLabel && label !== candidate.secondLabel
+      );
+    }
     this.stats.recoveredTraceCount++;
   }
+  areCandidatePinsAlreadyConnected(candidate) {
+    if (!candidate.netConnectionPinIds) return false;
+    return getTraceConnectedPinComponents({
+      pinIds: candidate.netConnectionPinIds,
+      traces: this.outputTraces
+    }).some(
+      (component) => component.pinIds.includes(candidate.pins[0].pinId) && component.pinIds.includes(candidate.pins[1].pinId)
+    );
+  }
   _step() {
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -15226,7 +15363,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       return;
     }
     let candidate = this.queuedCandidates.shift();
-    while (candidate && (!this.outputNetLabelPlacements.includes(candidate.firstLabel) || !this.outputNetLabelPlacements.includes(candidate.secondLabel))) {
+    while (candidate && (!this.outputNetLabelPlacements.includes(candidate.firstLabel) || !this.outputNetLabelPlacements.includes(candidate.secondLabel) || this.areCandidatePinsAlreadyConnected(candidate))) {
       candidate = this.queuedCandidates.shift();
     }
     if (!candidate) {

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -12,6 +12,7 @@ import {
   getTraceRecoveryConnectivityMaps,
   type TraceRecoveryPin,
 } from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
+import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
 import type {
@@ -37,10 +38,14 @@ interface CandidatePair {
   perpendicularOffset: number
   routeDistance: number
   key: string
+  recoveryMode: "fallback_labels" | "routed_components"
+  netConnectionPinIds?: PinId[]
 }
 
 const AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-"
 const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
+const MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05
+const MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25
 
 const getCanonicalPairKey = (firstPinId: PinId, secondPinId: PinId) =>
   [firstPinId, secondPinId].sort().join("--")
@@ -70,14 +75,28 @@ export const pathIntersectsRenderedLabel = (
   return false
 }
 
-const getPerpendicularOffset = (
+const getPerpendicularOffset = (firstPoint: Point, secondPoint: Point) => {
+  const xDistance = Math.abs(firstPoint.x - secondPoint.x)
+  const yDistance = Math.abs(firstPoint.y - secondPoint.y)
+  if (xDistance >= yDistance) return yDistance
+  return xDistance
+}
+
+const arePinsCoFacingAlongSeparationAxis = (
   firstPin: TraceRecoveryPin,
   secondPin: TraceRecoveryPin,
 ) => {
+  if (firstPin._facingDirection !== secondPin._facingDirection) return false
   const xDistance = Math.abs(firstPin.x - secondPin.x)
   const yDistance = Math.abs(firstPin.y - secondPin.y)
-  if (xDistance >= yDistance) return yDistance
-  return xDistance
+  if (xDistance >= yDistance) {
+    return (
+      firstPin._facingDirection === "x+" || firstPin._facingDirection === "x-"
+    )
+  }
+  return (
+    firstPin._facingDirection === "y+" || firstPin._facingDirection === "y-"
+  )
 }
 
 export class NetLabelToTraceSolver extends BaseSolver {
@@ -113,20 +132,20 @@ export class NetLabelToTraceSolver extends BaseSolver {
     return [this.input]
   }
 
-  private isEligiblePortOnlyDirectConnectionLabel(
+  private isPortOnlyFallbackLabel(
     label: NetLabelPlacement,
-    groundGlobalConnNetId?: GlobalConnNetId,
+    groundGlobalConnNetIds: Set<GlobalConnNetId>,
   ) {
-    if (
+    return !(
       label.pinIds.length !== 1 ||
       label.mspConnectionPairIds.length !== 0 ||
       !label.netId ||
-      label.netId === "GND" ||
-      label.globalConnNetId === groundGlobalConnNetId
-    ) {
-      return false
-    }
+      groundGlobalConnNetIds.has(label.globalConnNetId)
+    )
+  }
 
+  private isDirectConnectionLabel(label: NetLabelPlacement) {
+    if (!label.netId || label.pinIds.length !== 1) return false
     const pinId = label.pinIds[0]!
     return this.inputProblem.directConnections.some(
       (connection) =>
@@ -134,20 +153,35 @@ export class NetLabelToTraceSolver extends BaseSolver {
     )
   }
 
+  private getMultiPinNetConnection(label: NetLabelPlacement) {
+    if (!label.netId || label.pinIds.length !== 1) return undefined
+    const pinId = label.pinIds[0]!
+    return this.inputProblem.netConnections.find(
+      (connection) =>
+        connection.isGround === false &&
+        connection.pinIds.length > 2 &&
+        connection.netId === label.netId &&
+        connection.pinIds.includes(pinId),
+    )
+  }
+
   private buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem,
     )
-    const groundGlobalConnNetId =
-      netConnMap.getNetConnectedToId("GND") ?? undefined
+    const groundGlobalConnNetIds = new Set<GlobalConnNetId>()
+    for (const connection of this.inputProblem.netConnections) {
+      if (!connection.isGround) continue
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId)
+      if (globalConnNetId) groundGlobalConnNetIds.add(globalConnNetId)
+    }
     const labelsByGlobalNet = new Map<GlobalConnNetId, NetLabelPlacement[]>()
 
     for (const label of this.input.netLabelPlacements) {
       if (
-        !this.isEligiblePortOnlyDirectConnectionLabel(
-          label,
-          groundGlobalConnNetId,
-        )
+        !this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) ||
+        (!this.isDirectConnectionLabel(label) &&
+          !this.getMultiPinNetConnection(label))
       ) {
         continue
       }
@@ -169,6 +203,25 @@ export class NetLabelToTraceSolver extends BaseSolver {
           const firstPin = this.pinMap.get(firstLabel.pinIds[0]!)
           const secondPin = this.pinMap.get(secondLabel.pinIds[0]!)
           if (!firstPin || !secondPin) continue
+          const perpendicularOffset = getPerpendicularOffset(
+            firstPin,
+            secondPin,
+          )
+          const bothLabelsBelongToDirectConnections =
+            this.isDirectConnectionLabel(firstLabel) &&
+            this.isDirectConnectionLabel(secondLabel)
+          const firstMultiPinNetConnection =
+            this.getMultiPinNetConnection(firstLabel)
+          const secondMultiPinNetConnection =
+            this.getMultiPinNetConnection(secondLabel)
+          if (
+            !bothLabelsBelongToDirectConnections &&
+            (!firstMultiPinNetConnection ||
+              firstMultiPinNetConnection !== secondMultiPinNetConnection ||
+              perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)
+          ) {
+            continue
+          }
           if (
             arePinsInDifferentSchematicSections(
               this.inputProblem,
@@ -194,16 +247,19 @@ export class NetLabelToTraceSolver extends BaseSolver {
             firstLabel,
             secondLabel,
             pins: [firstPin, secondPin],
-            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            perpendicularOffset,
             routeDistance:
               Math.abs(firstPin.x - secondPin.x) +
               Math.abs(firstPin.y - secondPin.y),
             key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+            recoveryMode: "fallback_labels",
           })
         }
       }
     }
 
+    candidates.push(...this.buildRoutedComponentCandidates())
+
     candidates.sort(
       (first, second) =>
         first.perpendicularOffset - second.perpendicularOffset ||
@@ -213,6 +269,129 @@ export class NetLabelToTraceSolver extends BaseSolver {
     return candidates
   }
 
+  private buildRoutedComponentCandidates() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem,
+    )
+    const candidates: CandidatePair[] = []
+
+    for (const connection of this.inputProblem.netConnections) {
+      if (connection.pinIds.length <= 2 || connection.isGround !== false)
+        continue
+      const globalConnNetId = netConnMap.getNetConnectedToId(connection.netId)
+      if (!globalConnNetId) continue
+
+      const traceConnectedPinComponents = getTraceConnectedPinComponents({
+        pinIds: connection.pinIds,
+        traces: this.outputTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId,
+        ),
+      }).filter((component) => component.traces.length > 0)
+
+      for (
+        let firstIndex = 0;
+        firstIndex < traceConnectedPinComponents.length;
+        firstIndex++
+      ) {
+        for (
+          let secondIndex = firstIndex + 1;
+          secondIndex < traceConnectedPinComponents.length;
+          secondIndex++
+        ) {
+          const firstComponent = traceConnectedPinComponents[firstIndex]!
+          const secondComponent = traceConnectedPinComponents[secondIndex]!
+          const firstLabel = this.input.netLabelPlacements.find(
+            (label) =>
+              label.globalConnNetId === globalConnNetId &&
+              label.mspConnectionPairIds.length > 0 &&
+              label.pinIds.some((pinId) =>
+                firstComponent.pinIds.includes(pinId),
+              ),
+          )
+          const secondLabel = this.input.netLabelPlacements.find(
+            (label) =>
+              label.globalConnNetId === globalConnNetId &&
+              label.mspConnectionPairIds.length > 0 &&
+              label.pinIds.some((pinId) =>
+                secondComponent.pinIds.includes(pinId),
+              ),
+          )
+          if (!firstLabel || !secondLabel || firstLabel === secondLabel)
+            continue
+          if (
+            getPerpendicularOffset(
+              firstLabel.anchorPoint,
+              secondLabel.anchorPoint,
+            ) > MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET
+          ) {
+            continue
+          }
+
+          let bestCandidate: CandidatePair | undefined
+          for (const firstPinId of firstComponent.pinIds) {
+            for (const secondPinId of secondComponent.pinIds) {
+              const firstPin = this.pinMap.get(firstPinId)
+              const secondPin = this.pinMap.get(secondPinId)
+              if (!firstPin || !secondPin) continue
+              const perpendicularOffset = getPerpendicularOffset(
+                firstPin,
+                secondPin,
+              )
+              if (
+                perpendicularOffset >
+                  MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET ||
+                arePinsCoFacingAlongSeparationAxis(firstPin, secondPin) ||
+                arePinsInDifferentSchematicSections(
+                  this.inputProblem,
+                  firstPin,
+                  secondPin,
+                ) ||
+                doesPairCrossRestrictedCenterLines({
+                  inputProblem: this.inputProblem,
+                  chipMap: this.chipMap,
+                  pinIdMap: this.pinMap,
+                  p1: firstPin,
+                  p2: secondPin,
+                })
+              ) {
+                continue
+              }
+
+              const routeDistance =
+                Math.abs(firstPin.x - secondPin.x) +
+                Math.abs(firstPin.y - secondPin.y)
+              const candidate: CandidatePair = {
+                firstLabel,
+                secondLabel,
+                pins: [firstPin, secondPin],
+                perpendicularOffset,
+                routeDistance,
+                key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+                recoveryMode: "routed_components",
+                netConnectionPinIds: connection.pinIds,
+              }
+              if (
+                !bestCandidate ||
+                candidate.routeDistance < bestCandidate.routeDistance ||
+                (candidate.routeDistance === bestCandidate.routeDistance &&
+                  (candidate.perpendicularOffset <
+                    bestCandidate.perpendicularOffset ||
+                    (candidate.perpendicularOffset ===
+                      bestCandidate.perpendicularOffset &&
+                      candidate.key.localeCompare(bestCandidate.key) < 0)))
+              ) {
+                bestCandidate = candidate
+              }
+            }
+          }
+          if (bestCandidate) candidates.push(bestCandidate)
+        }
+      }
+    }
+
+    return candidates
+  }
+
   private isSupersededConnectorTrace(
     trace: SolvedTracePath,
     candidate: CandidatePair,
@@ -247,8 +426,15 @@ export class NetLabelToTraceSolver extends BaseSolver {
     const retainedTraces = this.outputTraces.filter(
       (trace) => !this.isSupersededConnectorTrace(trace, candidate),
     )
+    let collisionTraces = retainedTraces
+    if (candidate.recoveryMode === "routed_components") {
+      collisionTraces = retainedTraces.filter(
+        (trace) =>
+          trace.globalConnNetId !== candidate.firstLabel.globalConnNetId,
+      )
+    }
     if (
-      doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) ||
+      doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) ||
       this.routeIntersectsRemainingLabels(tracePath, candidate)
     ) {
       return
@@ -267,13 +453,27 @@ export class NetLabelToTraceSolver extends BaseSolver {
     }
 
     this.outputTraces = [...retainedTraces, recoveredTrace]
-    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
-      (label) =>
-        label !== candidate.firstLabel && label !== candidate.secondLabel,
-    )
+    if (candidate.recoveryMode === "fallback_labels") {
+      this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+        (label) =>
+          label !== candidate.firstLabel && label !== candidate.secondLabel,
+      )
+    }
     this.stats.recoveredTraceCount++
   }
 
+  private areCandidatePinsAlreadyConnected(candidate: CandidatePair) {
+    if (!candidate.netConnectionPinIds) return false
+    return getTraceConnectedPinComponents({
+      pinIds: candidate.netConnectionPinIds,
+      traces: this.outputTraces,
+    }).some(
+      (component) =>
+        component.pinIds.includes(candidate.pins[0].pinId) &&
+        component.pinIds.includes(candidate.pins[1].pinId),
+    )
+  }
+
   override _step() {
     if (this.activeSubSolver) {
       this.activeSubSolver.step()
@@ -292,7 +492,8 @@ export class NetLabelToTraceSolver extends BaseSolver {
     while (
       candidate &&
       (!this.outputNetLabelPlacements.includes(candidate.firstLabel) ||
-        !this.outputNetLabelPlacements.includes(candidate.secondLabel))
+        !this.outputNetLabelPlacements.includes(candidate.secondLabel) ||
+        this.areCandidatePinsAlreadyConnected(candidate))
     ) {
       candidate = this.queuedCandidates.shift()
     }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -325,15 +325,26 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       excludeRectsForSegment: (segIndex) => {
         const lastSegIndex = path.length - 2
         const excludedRects = new Set<ObstacleRect>()
+        const segmentStart = path[segIndex]!
+        const segmentEnd = path[segIndex + 1]!
 
-        if (segIndex === 0 || segIndex === lastSegIndex) {
+        const oppositeTerminalPin =
+          segIndex === 0 ? PB : segIndex === lastSegIndex ? PA : null
+        if (oppositeTerminalPin) {
           for (const textObstacle of this.textObstacles) {
-            excludedRects.add(textObstacle)
+            // Preserve the existing terminal-segment clearance exception, but
+            // do not let a segment that wraps around the opposite endpoint cut
+            // through that component's actual text.
+            const textBounds = getTextBoxBounds(textObstacle.textBox)
+            if (
+              textObstacle.textBox.chipId !== oppositeTerminalPin.chipId ||
+              !segmentIntersectsRect(segmentStart, segmentEnd, textBounds)
+            ) {
+              excludedRects.add(textObstacle)
+            }
           }
         }
 
-        const segmentStart = path[segIndex]!
-        const segmentEnd = path[segIndex + 1]!
         const endpointEpsilon = 1e-9
         const segmentTouchesPin = (pin: MspConnectionPair["pins"][number]) =>
           [segmentStart, segmentEnd].some(