@tscircuit/schematic-trace-solver 0.0.117 → 0.0.119

package/dist/index.d.ts

@@ -721,12 +721,13 @@ interface AvailableNetOrientationSolverParams {
 type CandidateLabel = {
     orientation: FacingDirection;
     anchorPoint: Point;
+    connectorSource?: Point;
     center: Point;
     width: number;
     height: number;
 };
 type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "trace-clearance-violation" | "netlabel-collision";
-type CandidatePhase = "rotate" | "trace-anchor" | "shift" | "lateral-shift";
+type CandidatePhase = "rotate" | "trace-anchor" | "outward-trace-anchor" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
     selected: boolean;
@@ -744,6 +745,8 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     currentLabelIndex: number | null;
     currentLabel: NetLabelPlacement | null;
     currentCandidateResults: EvaluatedCandidate[];
+    blockedStandaloneLabelIndex: number | null;
+    blockedStandaloneLabelTargetAnchorX: number | null;
     private traceMap;
     private chipObstacleSpatialIndex;
     private maxSearchDistance;
@@ -766,6 +769,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private hasTraceContinuingInOrientation;
     private findValidRotatedCandidate;
     private findValidTraceAnchorCandidate;
+    private findValidOutwardTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
@@ -799,6 +803,10 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getLabelTraceClearanceBounds;
     private shouldCheckTraceClearanceForLabel;
     private hasRoutedLabelOnSameNet;
+    private isOutwardHorizontalFallback;
+    private hasPortOnlyLabelOnSameNet;
+    private hasOppositeVerticalRailOnSameChipSide;
+    private getSingleChipSideForNetConnection;
     private isPortOnlyLabel;
     private intersectsAnyOtherNetLabel;
     private sharesChipBoundary;

package/dist/index.js

@@ -7848,6 +7848,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   currentLabelIndex = null;
   currentLabel = null;
   currentCandidateResults = [];
+  blockedStandaloneLabelIndex = null;
+  blockedStandaloneLabelTargetAnchorX = null;
   traceMap;
   chipObstacleSpatialIndex;
   maxSearchDistance;
@@ -7901,6 +7903,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       return this.isPortOnlyLabel(label) && this.isStandaloneSinglePinNetLabel(label) && orientations.length === 1 && isYOrientation(orientations[0]) && this.labelIntersectsDifferentNetTrace(label);
     });
     if (blockedStandaloneLabelIndex === void 0) return indices;
+    this.blockedStandaloneLabelIndex = blockedStandaloneLabelIndex;
+    this.blockedStandaloneLabelTargetAnchorX = null;
     const blockedLabel = this.outputNetLabelPlacements[blockedStandaloneLabelIndex];
     const requiredOrientation = this.getAvailableOrientations(blockedLabel)[0];
     const chipSide = this.getChipSideForPoint(blockedLabel.anchorPoint);
@@ -7920,6 +7924,22 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const bY = this.outputNetLabelPlacements[b].anchorPoint.y;
       return requiredOrientation === "y+" ? bY - aY : aY - bY;
     });
+    const blockedLabelWidth = this.getNetLabelWidth(blockedLabel);
+    let columnLabelIndex;
+    if (blockedLabelWidth !== void 0) {
+      columnLabelIndex = labelsToOrder.find((index) => {
+        if (index === blockedStandaloneLabelIndex) return false;
+        const label = this.outputNetLabelPlacements[index];
+        return this.getNetLabelWidth(label) === blockedLabelWidth;
+      });
+    }
+    if (columnLabelIndex !== void 0) {
+      const columnLabel = this.outputNetLabelPlacements[columnLabelIndex];
+      this.blockedStandaloneLabelTargetAnchorX = this.getSearchStartAnchor(
+        columnLabel,
+        requiredOrientation
+      ).x;
+    }
     for (let i = 0; i < affectedSlots.length; i++) {
       indices[affectedSlots[i]] = labelsToOrder[i];
     }
@@ -7975,9 +7995,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   findCorrectedCandidate(label, labelIndex) {
     const orientations = this.getAvailableOrientations(label);
     const requiredOrientation = orientations[0];
-    const isTwoPinNet = this.inputProblem.netConnections.some(
-      (connection) => connection.netId === label.netId && connection.pinIds.length === 2
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
     );
+    const isTwoPinNet = netConnection?.pinIds.length === 2;
+    const isDistanceSplitUpwardRail = (netConnection?.pinIds.length ?? 0) > 2 && requiredOrientation === "y+" && this.hasPortOnlyLabelOnSameNet(label);
+    const isPairedSameSidePowerRail = isYOrientation(requiredOrientation) && this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation);
+    if (orientations.length === 1 && isYOrientation(requiredOrientation) && this.isOutwardHorizontalFallback(label) && this.hasTraceContinuingInOrientation(label, requiredOrientation) && (isDistanceSplitUpwardRail || isPairedSameSidePowerRail)) {
+      const traceAnchorCandidate2 = this.findValidOutwardTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex
+      );
+      if (traceAnchorCandidate2) return traceAnchorCandidate2;
+    }
     if (isTwoPinNet && orientations.length === 1 && isYOrientation(requiredOrientation) && this.hasTraceContinuingInOrientation(label, requiredOrientation)) {
       const alignedCandidate = this.findValidCandidateInShiftColumn({
         label,
@@ -8079,6 +8110,72 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
+  findValidOutwardTraceAnchorCandidate(label, orientation, labelIndex) {
+    const direction = dir(orientation);
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y;
+        const bAlongDirection = b.x * direction.x + b.y * direction.y;
+        return bAlongDirection - aAlongDirection;
+      }
+    );
+    for (const connectorSource of candidatePoints) {
+      const preservedColumnAnchor = this.getSearchStartAnchor(
+        label,
+        orientation
+      );
+      const preservedColumnCandidate = this.createCandidate(
+        label,
+        {
+          x: preservedColumnAnchor.x,
+          y: connectorSource.y
+        },
+        orientation,
+        connectorSource
+      );
+      const preservedColumnResult = this.evaluateCandidate(
+        preservedColumnCandidate,
+        label,
+        labelIndex,
+        "outward-trace-anchor"
+      );
+      this.currentCandidateResults.push(preservedColumnResult);
+      if (preservedColumnResult.status === "valid") {
+        preservedColumnResult.selected = true;
+        return preservedColumnResult;
+      }
+      const outwardDirection = this.getPerpendicularOutwardDirection(
+        connectorSource,
+        orientation
+      );
+      if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
+      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+        const anchorPoint = {
+          x: connectorSource.x + outwardDirection.x * distance5,
+          y: connectorSource.y + outwardDirection.y * distance5
+        };
+        const candidate = this.createCandidate(
+          label,
+          anchorPoint,
+          orientation,
+          connectorSource
+        );
+        const result = this.evaluateCandidate(
+          candidate,
+          label,
+          labelIndex,
+          "outward-trace-anchor",
+          distance5
+        );
+        this.currentCandidateResults.push(result);
+        if (result.status === "valid") {
+          result.selected = true;
+          return result;
+        }
+      }
+    }
+    return null;
+  }
   getTraceAnchorCandidatePoints(label) {
     const seen = /* @__PURE__ */ new Set();
     const points = [];
@@ -8236,7 +8333,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ]);
     }
     return getConnectorTracePath(
-      label.anchorPoint,
+      candidate.connectorSource ?? label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation
     );
@@ -8270,13 +8367,17 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       netLabelWidth: this.getNetLabelWidth(label),
       netLabelHeight: this.getNetLabelHeight(label)
     });
-    return this.getSideOffsetAnchor({
+    const searchStartAnchor = this.getSideOffsetAnchor({
       anchorPoint,
       labelAnchorPoint: label.anchorPoint,
       orientation,
       width,
       height
     });
+    if (this.blockedStandaloneLabelIndex !== null && label === this.outputNetLabelPlacements[this.blockedStandaloneLabelIndex] && isYOrientation(orientation) && this.blockedStandaloneLabelTargetAnchorX !== null) {
+      searchStartAnchor.x = this.blockedStandaloneLabelTargetAnchorX;
+    }
+    return searchStartAnchor;
   }
   getWickOffsetAnchor(anchorPoint, orientation) {
     const direction = dir(orientation);
@@ -8366,7 +8467,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return this.getSearchDistanceLimit(label, orientation);
   }
-  createCandidate(label, anchorPoint, orientation) {
+  createCandidate(label, anchorPoint, orientation, connectorSource) {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth: this.getNetLabelWidth(label),
@@ -8375,6 +8476,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     return {
       orientation,
       anchorPoint,
+      connectorSource,
       width,
       height,
       center: getCenterFromAnchor(anchorPoint, orientation, width, height)
@@ -8528,6 +8630,59 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return false;
   }
+  isOutwardHorizontalFallback(label) {
+    const chipSide = this.getChipSideForPoint(label.anchorPoint);
+    return chipSide === "left" && label.orientation === "x-" || chipSide === "right" && label.orientation === "x+";
+  }
+  hasPortOnlyLabelOnSameNet(label) {
+    return this.outputNetLabelPlacements.some(
+      (otherLabel) => otherLabel !== label && otherLabel.globalConnNetId === label.globalConnNetId && this.isPortOnlyLabel(otherLabel)
+    );
+  }
+  hasOppositeVerticalRailOnSameChipSide(label, orientation) {
+    const currentConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
+    );
+    if (!currentConnection) return false;
+    const currentSide = this.getSingleChipSideForNetConnection(currentConnection);
+    if (!currentSide) return false;
+    const oppositeOrientation = orientation === "y+" ? "y-" : "y+";
+    return this.inputProblem.netConnections.some((connection) => {
+      if (connection === currentConnection || connection.pinIds.length < 2) {
+        return false;
+      }
+      const availableOrientations = this.inputProblem.availableNetLabelOrientations[connection.netId] ?? [];
+      if (availableOrientations.length !== 1 || availableOrientations[0] !== oppositeOrientation) {
+        return false;
+      }
+      const connectionSide = this.getSingleChipSideForNetConnection(connection);
+      return connectionSide?.chipId === currentSide.chipId && connectionSide.side === currentSide.side;
+    });
+  }
+  getSingleChipSideForNetConnection(connection) {
+    if (connection.pinIds.length < 2) return null;
+    const pins = connection.pinIds.map((pinId) => this.pinMap[pinId]);
+    if (pins.some((pin) => !pin)) return null;
+    const chipIds = new Set(pins.map((pin) => pin.chipId));
+    if (chipIds.size !== 1) return null;
+    const chipId = pins[0].chipId;
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (candidate) => candidate.chipId === chipId
+    );
+    if (!chip) return null;
+    const sides = new Set(
+      pins.map((pin) => {
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS11) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS11) return "right";
+        return null;
+      })
+    );
+    if (sides.size !== 1 || sides.has(null)) return null;
+    return {
+      chipId,
+      side: [...sides][0]
+    };
+  }
   isPortOnlyLabel(label) {
     return label.mspConnectionPairIds.length === 0;
   }
@@ -8536,6 +8691,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (i === labelIndex) continue;
       const label = this.outputNetLabelPlacements[i];
       const otherBounds = getRectBounds(label.center, label.width, label.height);
+      if (i === this.blockedStandaloneLabelIndex && isYOrientation(label.orientation)) {
+        otherBounds.minX -= LABEL_SEARCH_STEP;
+        otherBounds.maxX += LABEL_SEARCH_STEP;
+      }
       if (rectsOverlap2(bounds, otherBounds)) return true;
     }
     return false;

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -9,7 +9,11 @@ import {
   getRectBounds,
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type {
+  InputNetConnection,
+  InputPin,
+  InputProblem,
+} from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 import { EPS, LABEL_SEARCH_STEP, WICK_CLEARANCE } from "./constants"
@@ -51,6 +55,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   currentLabel: NetLabelPlacement | null = null
   currentCandidateResults: EvaluatedCandidate[] = []
 
+  blockedStandaloneLabelIndex: number | null = null
+  blockedStandaloneLabelTargetAnchorX: number | null = null
   private traceMap: Record<string, SolvedTracePath>
   private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   private maxSearchDistance: number
@@ -122,6 +128,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       )
     })
     if (blockedStandaloneLabelIndex === undefined) return indices
+    this.blockedStandaloneLabelIndex = blockedStandaloneLabelIndex
+    this.blockedStandaloneLabelTargetAnchorX = null
 
     const blockedLabel =
       this.outputNetLabelPlacements[blockedStandaloneLabelIndex]!
@@ -152,6 +160,23 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       const bY = this.outputNetLabelPlacements[b]!.anchorPoint.y
       return requiredOrientation === "y+" ? bY - aY : aY - bY
     })
+    const blockedLabelWidth = this.getNetLabelWidth(blockedLabel)
+    let columnLabelIndex: number | undefined
+    if (blockedLabelWidth !== undefined) {
+      columnLabelIndex = labelsToOrder.find((index) => {
+        if (index === blockedStandaloneLabelIndex) return false
+        const label = this.outputNetLabelPlacements[index]!
+        return this.getNetLabelWidth(label) === blockedLabelWidth
+      })
+    }
+    if (columnLabelIndex !== undefined) {
+      const columnLabel = this.outputNetLabelPlacements[columnLabelIndex]!
+      // Reuse the established same-width column instead of a nearby search step.
+      this.blockedStandaloneLabelTargetAnchorX = this.getSearchStartAnchor(
+        columnLabel,
+        requiredOrientation,
+      ).x
+    }
     for (let i = 0; i < affectedSlots.length; i++) {
       indices[affectedSlots[i]!] = labelsToOrder[i]!
     }
@@ -229,10 +254,35 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   private findCorrectedCandidate(label: NetLabelPlacement, labelIndex: number) {
     const orientations = this.getAvailableOrientations(label)
     const requiredOrientation = orientations[0]!
-    const isTwoPinNet = this.inputProblem.netConnections.some(
-      (connection) =>
-        connection.netId === label.netId && connection.pinIds.length === 2,
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId,
     )
+    const isTwoPinNet = netConnection?.pinIds.length === 2
+    const isDistanceSplitUpwardRail =
+      (netConnection?.pinIds.length ?? 0) > 2 &&
+      requiredOrientation === "y+" &&
+      this.hasPortOnlyLabelOnSameNet(label)
+    const isPairedSameSidePowerRail =
+      isYOrientation(requiredOrientation) &&
+      this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation)
+    if (
+      orientations.length === 1 &&
+      isYOrientation(requiredOrientation) &&
+      this.isOutwardHorizontalFallback(label) &&
+      this.hasTraceContinuingInOrientation(label, requiredOrientation) &&
+      (isDistanceSplitUpwardRail || isPairedSameSidePowerRail)
+    ) {
+      // Keep the established outward column, but attach at the furthest trace
+      // point in the required vertical direction. This places y+ labels above
+      // a rail and y- labels below it while using a short horizontal connector.
+      const traceAnchorCandidate = this.findValidOutwardTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+      )
+      if (traceAnchorCandidate) return traceAnchorCandidate
+    }
+
     if (
       isTwoPinNet &&
       orientations.length === 1 &&
@@ -369,6 +419,86 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  private findValidOutwardTraceAnchorCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ) {
+    const direction = dir(orientation)
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y
+        const bAlongDirection = b.x * direction.x + b.y * direction.y
+        return bAlongDirection - aAlongDirection
+      },
+    )
+
+    for (const connectorSource of candidatePoints) {
+      const preservedColumnAnchor = this.getSearchStartAnchor(
+        label,
+        orientation,
+      )
+      const preservedColumnCandidate = this.createCandidate(
+        label,
+        {
+          x: preservedColumnAnchor.x,
+          y: connectorSource.y,
+        },
+        orientation,
+        connectorSource,
+      )
+      const preservedColumnResult = this.evaluateCandidate(
+        preservedColumnCandidate,
+        label,
+        labelIndex,
+        "outward-trace-anchor",
+      )
+      this.currentCandidateResults.push(preservedColumnResult)
+      if (preservedColumnResult.status === "valid") {
+        preservedColumnResult.selected = true
+        return preservedColumnResult
+      }
+
+      const outwardDirection = this.getPerpendicularOutwardDirection(
+        connectorSource,
+        orientation,
+      )
+      if (outwardDirection.x === 0 && outwardDirection.y === 0) continue
+
+      for (
+        let distance = LABEL_SEARCH_STEP;
+        distance <= this.maxSearchDistance + EPS;
+        distance += LABEL_SEARCH_STEP
+      ) {
+        const anchorPoint = {
+          x: connectorSource.x + outwardDirection.x * distance,
+          y: connectorSource.y + outwardDirection.y * distance,
+        }
+        const candidate = this.createCandidate(
+          label,
+          anchorPoint,
+          orientation,
+          connectorSource,
+        )
+        const result = this.evaluateCandidate(
+          candidate,
+          label,
+          labelIndex,
+          "outward-trace-anchor",
+          distance,
+        )
+        this.currentCandidateResults.push(result)
+
+        if (result.status === "valid") {
+          result.selected = true
+          return result
+        }
+      }
+    }
+
+    return null
+  }
+
   private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
     const seen = new Set<string>()
     const points: Point[] = []
@@ -571,7 +701,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     label: NetLabelPlacement,
     candidate: Pick<
       EvaluatedCandidate,
-      "anchorPoint" | "orientation" | "phase"
+      "anchorPoint" | "connectorSource" | "orientation" | "phase"
     >,
   ) {
     if (candidate.phase === "lateral-shift") {
@@ -591,7 +721,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     }
 
     return getConnectorTracePath(
-      label.anchorPoint,
+      candidate.connectorSource ?? label.anchorPoint,
       candidate.anchorPoint,
       candidate.orientation,
     )
@@ -637,13 +767,23 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       netLabelHeight: this.getNetLabelHeight(label),
     })
 
-    return this.getSideOffsetAnchor({
+    const searchStartAnchor = this.getSideOffsetAnchor({
       anchorPoint,
       labelAnchorPoint: label.anchorPoint,
       orientation,
       width,
       height,
     })
+    if (
+      this.blockedStandaloneLabelIndex !== null &&
+      label ===
+        this.outputNetLabelPlacements[this.blockedStandaloneLabelIndex] &&
+      isYOrientation(orientation) &&
+      this.blockedStandaloneLabelTargetAnchorX !== null
+    ) {
+      searchStartAnchor.x = this.blockedStandaloneLabelTargetAnchorX
+    }
+    return searchStartAnchor
   }
 
   private getWickOffsetAnchor(
@@ -779,6 +919,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     label: NetLabelPlacement,
     anchorPoint: Point,
     orientation: FacingDirection,
+    connectorSource?: Point,
   ): CandidateLabel {
     const { width, height } = getDimsForOrientation({
       orientation,
@@ -788,6 +929,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return {
       orientation,
       anchorPoint,
+      connectorSource,
       width,
       height,
       center: getCenterFromAnchor(anchorPoint, orientation, width, height),
@@ -998,6 +1140,89 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return false
   }
 
+  private isOutwardHorizontalFallback(label: NetLabelPlacement) {
+    const chipSide = this.getChipSideForPoint(label.anchorPoint)
+    return (
+      (chipSide === "left" && label.orientation === "x-") ||
+      (chipSide === "right" && label.orientation === "x+")
+    )
+  }
+
+  private hasPortOnlyLabelOnSameNet(label: NetLabelPlacement) {
+    return this.outputNetLabelPlacements.some(
+      (otherLabel) =>
+        otherLabel !== label &&
+        otherLabel.globalConnNetId === label.globalConnNetId &&
+        this.isPortOnlyLabel(otherLabel),
+    )
+  }
+
+  private hasOppositeVerticalRailOnSameChipSide(
+    label: NetLabelPlacement,
+    orientation: "y+" | "y-",
+  ) {
+    const currentConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId,
+    )
+    if (!currentConnection) return false
+
+    const currentSide =
+      this.getSingleChipSideForNetConnection(currentConnection)
+    if (!currentSide) return false
+
+    const oppositeOrientation = orientation === "y+" ? "y-" : "y+"
+    return this.inputProblem.netConnections.some((connection) => {
+      if (connection === currentConnection || connection.pinIds.length < 2) {
+        return false
+      }
+      const availableOrientations =
+        this.inputProblem.availableNetLabelOrientations[connection.netId] ?? []
+      if (
+        availableOrientations.length !== 1 ||
+        availableOrientations[0] !== oppositeOrientation
+      ) {
+        return false
+      }
+
+      const connectionSide = this.getSingleChipSideForNetConnection(connection)
+      return (
+        connectionSide?.chipId === currentSide.chipId &&
+        connectionSide.side === currentSide.side
+      )
+    })
+  }
+
+  private getSingleChipSideForNetConnection(
+    connection: InputNetConnection,
+  ): { chipId: string; side: "left" | "right" } | null {
+    if (connection.pinIds.length < 2) return null
+
+    const pins = connection.pinIds.map((pinId) => this.pinMap[pinId])
+    if (pins.some((pin) => !pin)) return null
+    const chipIds = new Set(pins.map((pin) => pin!.chipId))
+    if (chipIds.size !== 1) return null
+
+    const chipId = pins[0]!.chipId
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (candidate) => candidate.chipId === chipId,
+    )
+    if (!chip) return null
+
+    const sides = new Set(
+      pins.map((pin) => {
+        if (Math.abs(pin!.x - chip.bounds.minX) <= EPS) return "left"
+        if (Math.abs(pin!.x - chip.bounds.maxX) <= EPS) return "right"
+        return null
+      }),
+    )
+    if (sides.size !== 1 || sides.has(null)) return null
+
+    return {
+      chipId,
+      side: [...sides][0] as "left" | "right",
+    }
+  }
+
   private isPortOnlyLabel(label: NetLabelPlacement) {
     return label.mspConnectionPairIds.length === 0
   }
@@ -1007,6 +1232,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       if (i === labelIndex) continue
       const label = this.outputNetLabelPlacements[i]!
       const otherBounds = getRectBounds(label.center, label.width, label.height)
+      if (
+        i === this.blockedStandaloneLabelIndex &&
+        isYOrientation(label.orientation)
+      ) {
+        // Keep later labels one search step away from the blocked label.
+        otherBounds.minX -= LABEL_SEARCH_STEP
+        otherBounds.maxX += LABEL_SEARCH_STEP
+      }
       if (rectsOverlap(bounds, otherBounds)) return true
     }
     return false

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -22,6 +22,7 @@ export type ChipSide = "left" | "right" | "top" | "bottom"
 export type CandidateLabel = {
   orientation: FacingDirection
   anchorPoint: Point
+  connectorSource?: Point
   center: Point
   width: number
   height: number
@@ -38,6 +39,7 @@ export type CandidateStatus =
 export type CandidatePhase =
   | "rotate"
   | "trace-anchor"
+  | "outward-trace-anchor"
   | "shift"
   | "lateral-shift"
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.117",
+  "version": "0.0.119",
   "type": "module",
   "scripts": {
     "start": "cosmos",