@tscircuit/schematic-trace-solver 0.0.160 → 0.0.162

package/dist/index.d.ts

@@ -141,6 +141,8 @@ interface InputDirectConnection {
 interface InputNetConnection {
     netId: string;
     pinIds: Array<PinId>;
+    /** True when the authoritative source net is electrical ground. */
+    isGround?: boolean;
     /**
      * User-facing text to render for this net label. `netId` remains the stable
      * connectivity identifier and may be an internal id. When this is omitted
@@ -906,6 +908,9 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private shouldCheckTraceClearanceForLabel;
     private hasRoutedLabelOnSameNet;
     private isOutwardHorizontalFallback;
+    private canPlaceVerticalLabelOnHostRail;
+    private getTextBlockedMultiPinRailTraces;
+    private findValidNearbyRailCandidate;
     private hasPortOnlyLabelOnSameNet;
     private hasOppositeVerticalRailOnSameChipSide;
     private getSingleChipSideForNetConnection;

package/dist/index.js

@@ -539,6 +539,30 @@ var getLabeledConnectionRouteReason = ({
 };
 var isLabeledPeripheralConnection = (params) => getLabeledConnectionRouteReason(params) !== null;
 
+// lib/solvers/MspConnectionPairSolver/shouldSeparateGroundNetRows.ts
+var SAME_RAIL_Y_TOLERANCE = 1e-6;
+var MIN_GROUPED_RAIL_PIN_COUNT = 3;
+function isGroupedHorizontalRail({
+  pin,
+  netPins
+}) {
+  const sameRailPins = netPins.filter(
+    (otherPin) => Math.abs(otherPin.y - pin.y) <= SAME_RAIL_Y_TOLERANCE
+  );
+  const railChipIds = new Set(sameRailPins.map((railPin) => railPin.chipId));
+  return railChipIds.size >= MIN_GROUPED_RAIL_PIN_COUNT;
+}
+function shouldSeparateGroundNetRows({
+  netConnection,
+  netPins,
+  pin1,
+  pin2
+}) {
+  if (!netConnection?.isGround || pin1.chipId === pin2.chipId) return false;
+  if (Math.abs(pin1.y - pin2.y) <= SAME_RAIL_Y_TOLERANCE) return false;
+  return isGroupedHorizontalRail({ pin: pin1, netPins }) && isGroupedHorizontalRail({ pin: pin2, netPins });
+}
+
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
@@ -643,36 +667,41 @@ var MspConnectionPairSolver = class extends BaseSolver {
         return;
       }
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
-      const userNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
+      const userNetId2 = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
       const suppressNetLabel = pairDistance > this.maxMspPairDistance && labeledConnectionRouteReason === "overlapping-fallback-labels";
       this.addMspConnectionPair({
         mspPairId: `${pin1}-${pin2}`,
         dcConnNetId: dcNetId,
         globalConnNetId,
-        userNetId,
+        userNetId: userNetId2,
         suppressNetLabel,
         pins: [p1, p2]
       });
       return;
     }
     const pinIdMap = new Map(Object.entries(this.pinMap));
-    const msp = getOrthogonalMinimumSpanningTree(
-      directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
-      {
-        maxDistance: this.maxMspPairDistance,
-        forbidEdge: (a, b) => !this.canRouteGroundPair(a.pinId, b.pinId) || arePinsInDifferentSchematicSections(
-          this.inputProblem,
-          a,
-          b
-        ) || doesPairCrossRestrictedCenterLines({
-          inputProblem: this.inputProblem,
-          chipMap: this.chipMap,
-          pinIdMap,
-          p1: a,
-          p2: b
-        })
-      }
-    );
+    const userNetId = this.userNetIdByPinId[directlyConnectedPins[0]];
+    const netConnection = this.inputProblem.netConnections.find(
+      (connection) => connection.netId === userNetId
+    );
+    const directlyConnectedPinObjects = directlyConnectedPins.map(
+      (pinId) => this.pinMap[pinId]
+    );
+    const msp = getOrthogonalMinimumSpanningTree(directlyConnectedPinObjects, {
+      maxDistance: this.maxMspPairDistance,
+      forbidEdge: (a, b) => !this.canRouteGroundPair(a.pinId, b.pinId) || shouldSeparateGroundNetRows({
+        netConnection,
+        netPins: directlyConnectedPinObjects,
+        pin1: a,
+        pin2: b
+      }) || arePinsInDifferentSchematicSections(this.inputProblem, a, b) || doesPairCrossRestrictedCenterLines({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pinIdMap,
+        p1: a,
+        p2: b
+      })
+    });
     for (const [pin1, pin2] of msp) {
       const p1Obj = this.pinMap[pin1];
       const p2Obj = this.pinMap[pin2];
@@ -689,12 +718,12 @@ var MspConnectionPairSolver = class extends BaseSolver {
         continue;
       }
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
-      const userNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
+      const pairUserNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
       this.addMspConnectionPair({
         mspPairId: `${pin1}-${pin2}`,
         dcConnNetId: dcNetId,
         globalConnNetId,
-        userNetId,
+        userNetId: pairUserNetId,
         pins: [p1Obj, p2Obj]
       });
     }
@@ -5864,6 +5893,9 @@ var getLabelsLinkedToRailGroup = (group, netLabelPlacements, traces) => {
 var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
   const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]));
   const groupTraceIds = new Set(group.map((segment) => segment.traceId));
+  const groupIsWithinSingleComponent = [...groupTraceIds].every(
+    (traceId) => traceMap.get(traceId)?.pins.every((pin) => pin.chipId === group[0].componentId) === true
+  );
   const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
     (traceId) => traceMap.get(traceId)?.tracePath.length === 4
   );
@@ -5874,12 +5906,20 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
     netLabelPlacements,
     traces
   );
-  const anchoringLabels = linkedLabels.filter(
-    (label) => label.orientation === group[0].componentFacingDirection && label.mspConnectionPairIds.some((traceId) => {
+  const labelsOrientedAlongRail = new Set(
+    linkedLabels.filter(
+      (label) => orientation === "vertical" && (label.orientation === "y+" || label.orientation === "y-") || orientation === "horizontal" && (label.orientation === "x+" || label.orientation === "x-")
+    )
+  );
+  const anchoringLabels = linkedLabels.filter((label) => {
+    if (label.orientation !== group[0].componentFacingDirection && (!groupIsWithinSingleComponent || !labelsOrientedAlongRail.has(label))) {
+      return false;
+    }
+    return label.mspConnectionPairIds.some((traceId) => {
       const trace = traceMap.get(traceId);
       return trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint);
-    })
-  );
+    });
+  });
   const coordinates = getDistinctCoordinates(
     anchoringLabels.map(
       (label) => orientation === "vertical" ? label.anchorPoint.x : label.anchorPoint.y
@@ -5896,12 +5936,21 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
     )
   );
   if (labelIsAnchoredToRoutedBackbone) return coordinate;
+  if (anchoringLabels.some((label) => labelsOrientedAlongRail.has(label))) {
+    const railGroupSpan = Math.max(...group.map((segment) => segment.maxAlong)) - Math.min(...group.map((segment) => segment.minAlong));
+    const coordinateIsLocalToRailGroup = group.every(
+      (segment) => Math.abs(segment.coordinate - coordinate) <= railGroupSpan + RAIL_ALIGNMENT_EPSILON
+    );
+    if (coordinateIsLocalToRailGroup) return coordinate;
+    return null;
+  }
   const coordinateIsLocalToEveryTrace = group.every((segment) => {
     const trace = traceMap.get(segment.traceId);
     if (!trace) return false;
     return Math.abs(segment.coordinate - coordinate) <= distance4(trace.pins[0], trace.pins[1]) + RAIL_ALIGNMENT_EPSILON;
   });
-  return coordinateIsLocalToEveryTrace ? coordinate : null;
+  if (coordinateIsLocalToEveryTrace) return coordinate;
+  return null;
 };
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
@@ -8939,6 +8988,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const orientations = this.getAvailableOrientations(label);
     if (orientations.length === 0) return false;
     if (!orientations.includes(label.orientation)) return true;
+    if (this.getTextBlockedMultiPinRailTraces(label, orientations[0])) {
+      return true;
+    }
     if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false;
     const bounds = getRectBounds(label.center, label.width, label.height);
     return this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
@@ -9060,8 +9112,34 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const isTwoPinNet = netConnection?.pinIds.length === 2;
     const isDistanceSplitVerticalRail = (netConnection?.pinIds.length ?? 0) > 2 && isYOrientation(requiredOrientation) && this.hasPortOnlyLabelOnSameNet(label);
+    const textBlockedMultiPinRailTraces = this.getTextBlockedMultiPinRailTraces(
+      label,
+      requiredOrientation
+    );
     const isPairedSameSidePowerRail = isYOrientation(requiredOrientation) && this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation);
+    if (textBlockedMultiPinRailTraces) {
+      const nearbyCandidate = this.findValidNearbyRailCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+        textBlockedMultiPinRailTraces
+      );
+      if (nearbyCandidate) return nearbyCandidate;
+    }
     if (orientations.length === 1 && isYOrientation(requiredOrientation) && this.isOutwardHorizontalFallback(label) && this.hasTraceContinuingInOrientation(label, requiredOrientation) && (isDistanceSplitVerticalRail || isPairedSameSidePowerRail)) {
+      const hostRailCandidate = this.findValidTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex
+      );
+      if (hostRailCandidate) {
+        const canUseHostRail = this.canPlaceVerticalLabelOnHostRail(
+          hostRailCandidate,
+          label
+        );
+        if (canUseHostRail) return hostRailCandidate;
+        hostRailCandidate.selected = false;
+      }
       const traceAnchorCandidate2 = this.findValidOutwardTraceAnchorCandidate(
         label,
         requiredOrientation,
@@ -9495,14 +9573,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       maxSearchDistance,
       outwardDistance,
       phase = "shift",
-      stopOnTraceCollision = true
+      stopOnTraceCollision = true,
+      connectorSource,
+      startDistance = LABEL_SEARCH_STEP
     } = params;
-    for (let distance7 = LABEL_SEARCH_STEP; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
+    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance7,
         y: baseAnchor.y + direction.y * distance7
       };
-      const candidate = this.createCandidate(label, anchorPoint, orientation);
+      const candidate = this.createCandidate(
+        label,
+        anchorPoint,
+        orientation,
+        connectorSource
+      );
       const result = this.evaluateCandidate(
         candidate,
         label,
@@ -9878,6 +9963,113 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const chipSide = this.getChipSideForPoint(label.anchorPoint);
     return chipSide === "left" && label.orientation === "x-" || chipSide === "right" && label.orientation === "x+";
   }
+  canPlaceVerticalLabelOnHostRail(candidate, label) {
+    const isOnHostRail = label.mspConnectionPairIds.some((traceId) => {
+      const trace = this.traceMap[traceId];
+      return trace && tracePathContainsPoint(trace.tracePath, candidate.anchorPoint);
+    });
+    if (!isOnHostRail) return false;
+    const hostPin = this.pinMap[label.pinIds[0]];
+    if (!hostPin) return false;
+    if (label.pinIds.some(
+      (pinId) => this.pinMap[pinId]?.chipId !== hostPin.chipId
+    )) {
+      return false;
+    }
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (chip2) => chip2.chipId === hostPin.chipId
+    );
+    if (!chip) return false;
+    const labelBounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height
+    );
+    if (labelBounds.minY < chip.bounds.minY - EPS12 || labelBounds.maxY > chip.bounds.maxY + EPS12) {
+      return false;
+    }
+    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS12 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS12) {
+      return false;
+    }
+    return chip.pins.every(
+      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS12 || pin.y >= labelBounds.maxY - EPS12
+    );
+  }
+  getTextBlockedMultiPinRailTraces(label, orientation) {
+    if (!isYOrientation(orientation)) return null;
+    const componentId = this.pinMap[label.pinIds[0]]?.chipId;
+    const localTraces = Object.values(this.traceMap).filter(
+      (trace) => trace.globalConnNetId === label.globalConnNetId && trace.pins.every((pin) => pin.chipId === componentId)
+    );
+    const connectedPinIds = new Set(label.pinIds);
+    const connectedTraces = /* @__PURE__ */ new Set();
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const trace of localTraces) {
+        if (connectedTraces.has(trace)) continue;
+        if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId))) continue;
+        connectedTraces.add(trace);
+        for (const pinId of trace.pinIds) connectedPinIds.add(pinId);
+        changed = true;
+      }
+    }
+    if (connectedPinIds.size <= 3) return null;
+    const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]);
+    const direction = dir(orientation);
+    const pinX = pins[0].x;
+    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS12)) return null;
+    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS12);
+    const minY = Math.min(...pins.map((pin) => pin.y));
+    const maxY = Math.max(...pins.map((pin) => pin.y));
+    if (sidePins.some(
+      (pin) => pin.y >= minY - EPS12 && pin.y <= maxY + EPS12 && !connectedPinIds.has(pin.pinId)
+    ) || orientation === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS12 || orientation === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS12) {
+      return null;
+    }
+    const outerPinPosition = Math.max(
+      ...pins.map((pin) => pin.x * direction.x + pin.y * direction.y)
+    );
+    const blockedByText = (this.inputProblem.textBoxes ?? []).some(
+      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS12
+    );
+    return blockedByText ? [...connectedTraces] : null;
+  }
+  findValidNearbyRailCandidate(label, orientation, labelIndex, localTraces) {
+    if (!isYOrientation(orientation)) return null;
+    const direction = dir(orientation);
+    const connectorY = [
+      ...new Set(localTraces.flatMap((trace) => trace.pinIds))
+    ].map((pinId) => this.pinMap[pinId]).sort((a, b) => b.y * direction.y - a.y * direction.y)[0]?.y;
+    if (connectorY === void 0) return null;
+    const pinX = this.pinMap[label.pinIds[0]].x;
+    const railXs = [
+      ...new Set(
+        localTraces.flatMap((trace) => trace.tracePath.map((point) => point.x))
+      )
+    ].filter((x) => Math.abs(x - pinX) > EPS12).sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX));
+    for (const x of railXs) {
+      const connectorSource = { x, y: connectorY };
+      if (!Object.values(this.traceMap).some(
+        (trace) => trace.globalConnNetId === label.globalConnNetId && tracePathContainsPoint(trace.tracePath, connectorSource)
+      )) {
+        continue;
+      }
+      const candidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation,
+        direction,
+        baseAnchor: connectorSource,
+        maxSearchDistance: this.maxSearchDistance,
+        outwardDistance: 0,
+        stopOnTraceCollision: false,
+        connectorSource,
+        startDistance: 0
+      });
+      if (candidate) return candidate;
+    }
+    return null;
+  }
   hasPortOnlyLabelOnSameNet(label) {
     return this.outputNetLabelPlacements.some(
       (otherLabel) => otherLabel !== label && otherLabel.globalConnNetId === label.globalConnNetId && this.isPortOnlyLabel(otherLabel)

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -8,6 +8,7 @@ import {
   getDimsForOrientation,
   getRectBounds,
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type {
   ChipId,
@@ -250,6 +251,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const orientations = this.getAvailableOrientations(label)
     if (orientations.length === 0) return false
     if (!orientations.includes(label.orientation)) return true
+    if (this.getTextBlockedMultiPinRailTraces(label, orientations[0]!)) {
+      return true
+    }
     if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false
 
     const bounds = getRectBounds(label.center, label.width, label.height)
@@ -407,9 +411,22 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       (netConnection?.pinIds.length ?? 0) > 2 &&
       isYOrientation(requiredOrientation) &&
       this.hasPortOnlyLabelOnSameNet(label)
+    const textBlockedMultiPinRailTraces = this.getTextBlockedMultiPinRailTraces(
+      label,
+      requiredOrientation,
+    )
     const isPairedSameSidePowerRail =
       isYOrientation(requiredOrientation) &&
       this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation)
+    if (textBlockedMultiPinRailTraces) {
+      const nearbyCandidate = this.findValidNearbyRailCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+        textBlockedMultiPinRailTraces,
+      )
+      if (nearbyCandidate) return nearbyCandidate
+    }
     if (
       orientations.length === 1 &&
       isYOrientation(requiredOrientation) &&
@@ -417,9 +434,22 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       this.hasTraceContinuingInOrientation(label, requiredOrientation) &&
       (isDistanceSplitVerticalRail || 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 hostRailCandidate = this.findValidTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+      )
+      if (hostRailCandidate) {
+        const canUseHostRail = this.canPlaceVerticalLabelOnHostRail(
+          hostRailCandidate,
+          label,
+        )
+        if (canUseHostRail) return hostRailCandidate
+        hostRailCandidate.selected = false
+      }
+
+      // Keep the established outward column when the direct rail end is not a
+      // clear segment of the connected component side.
       const traceAnchorCandidate = this.findValidOutwardTraceAnchorCandidate(
         label,
         requiredOrientation,
@@ -785,7 +815,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
           connectedPinIds.add(pinId)
         }
       }
-
       // Multi-pin rails are routed as a chain of pairwise traces. Follow the
       // pairs only when they share both a pin and an aligned vertical rail,
       // which identifies one continuous rail. A shared pin alone can join
@@ -1012,6 +1041,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     outwardDistance: number
     phase?: CandidatePhase
     stopOnTraceCollision?: boolean
+    connectorSource?: Point
+    startDistance?: number
   }) {
     const {
       label,
@@ -1023,10 +1054,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       outwardDistance,
       phase = "shift",
       stopOnTraceCollision = true,
+      connectorSource,
+      startDistance = LABEL_SEARCH_STEP,
     } = params
 
     for (
-      let distance = LABEL_SEARCH_STEP;
+      let distance = startDistance;
       distance <= maxSearchDistance + EPS;
       distance += LABEL_SEARCH_STEP
     ) {
@@ -1034,7 +1067,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         x: baseAnchor.x + direction.x * distance,
         y: baseAnchor.y + direction.y * distance,
       }
-      const candidate = this.createCandidate(label, anchorPoint, orientation)
+      const candidate = this.createCandidate(
+        label,
+        anchorPoint,
+        orientation,
+        connectorSource,
+      )
       const result = this.evaluateCandidate(
         candidate,
         label,
@@ -1563,6 +1601,172 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
   }
 
+  private canPlaceVerticalLabelOnHostRail(
+    candidate: CandidateLabel,
+    label: NetLabelPlacement,
+  ) {
+    const isOnHostRail = label.mspConnectionPairIds.some((traceId) => {
+      const trace = this.traceMap[traceId]
+      return (
+        trace && tracePathContainsPoint(trace.tracePath, candidate.anchorPoint)
+      )
+    })
+    if (!isOnHostRail) return false
+
+    const hostPin = this.pinMap[label.pinIds[0]!]
+    if (!hostPin) return false
+    if (
+      label.pinIds.some(
+        (pinId) => this.pinMap[pinId]?.chipId !== hostPin.chipId,
+      )
+    ) {
+      return false
+    }
+
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (chip) => chip.chipId === hostPin.chipId,
+    )
+    if (!chip) return false
+
+    const labelBounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height,
+    )
+    if (
+      labelBounds.minY < chip.bounds.minY - EPS ||
+      labelBounds.maxY > chip.bounds.maxY + EPS
+    ) {
+      return false
+    }
+
+    if (
+      candidate.anchorPoint.x >= chip.bounds.minX - EPS &&
+      candidate.anchorPoint.x <= chip.bounds.maxX + EPS
+    ) {
+      return false
+    }
+
+    return chip.pins.every(
+      (pin) =>
+        label.pinIds.includes(pin.pinId) ||
+        pin.y <= labelBounds.minY + EPS ||
+        pin.y >= labelBounds.maxY - EPS,
+    )
+  }
+
+  private getTextBlockedMultiPinRailTraces(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+  ) {
+    if (!isYOrientation(orientation)) return null
+    const componentId = this.pinMap[label.pinIds[0]!]?.chipId
+    const localTraces = Object.values(this.traceMap).filter(
+      (trace) =>
+        trace.globalConnNetId === label.globalConnNetId &&
+        trace.pins.every((pin) => pin.chipId === componentId),
+    )
+    const connectedPinIds = new Set(label.pinIds)
+    const connectedTraces = new Set<SolvedTracePath>()
+    for (let changed = true; changed; ) {
+      changed = false
+      for (const trace of localTraces) {
+        if (connectedTraces.has(trace)) continue
+        if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId))) continue
+        connectedTraces.add(trace)
+        for (const pinId of trace.pinIds) connectedPinIds.add(pinId)
+        changed = true
+      }
+    }
+    if (connectedPinIds.size <= 3) return null
+
+    const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]!)
+    const direction = dir(orientation)
+    const pinX = pins[0]!.x
+    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS)) return null
+    const sidePins = this.inputProblem.chips
+      .find((chip) => chip.chipId === componentId)!
+      .pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS)
+    const minY = Math.min(...pins.map((pin) => pin.y))
+    const maxY = Math.max(...pins.map((pin) => pin.y))
+    if (
+      sidePins.some(
+        (pin) =>
+          pin.y >= minY - EPS &&
+          pin.y <= maxY + EPS &&
+          !connectedPinIds.has(pin.pinId),
+      ) ||
+      (orientation === "y-" &&
+        minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS) ||
+      (orientation === "y+" &&
+        maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS)
+    ) {
+      return null
+    }
+    const outerPinPosition = Math.max(
+      ...pins.map((pin) => pin.x * direction.x + pin.y * direction.y),
+    )
+    const blockedByText = (this.inputProblem.textBoxes ?? []).some(
+      (textBox) =>
+        textBox.chipId === componentId &&
+        textBox.center.x * direction.x + textBox.center.y * direction.y >
+          outerPinPosition + EPS,
+    )
+    return blockedByText ? [...connectedTraces] : null
+  }
+
+  private findValidNearbyRailCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+    localTraces: SolvedTracePath[],
+  ) {
+    if (!isYOrientation(orientation)) return null
+    const direction = dir(orientation)
+    const connectorY = [
+      ...new Set(localTraces.flatMap((trace) => trace.pinIds)),
+    ]
+      .map((pinId) => this.pinMap[pinId]!)
+      .sort((a, b) => b.y * direction.y - a.y * direction.y)[0]?.y
+    if (connectorY === undefined) return null
+
+    const pinX = this.pinMap[label.pinIds[0]!]!.x
+    const railXs = [
+      ...new Set(
+        localTraces.flatMap((trace) => trace.tracePath.map((point) => point.x)),
+      ),
+    ]
+      .filter((x) => Math.abs(x - pinX) > EPS)
+      .sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX))
+
+    for (const x of railXs) {
+      const connectorSource = { x, y: connectorY }
+      if (
+        !Object.values(this.traceMap).some(
+          (trace) =>
+            trace.globalConnNetId === label.globalConnNetId &&
+            tracePathContainsPoint(trace.tracePath, connectorSource),
+        )
+      ) {
+        continue
+      }
+      const candidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation,
+        direction,
+        baseAnchor: connectorSource,
+        maxSearchDistance: this.maxSearchDistance,
+        outwardDistance: 0,
+        stopOnTraceCollision: false,
+        connectorSource,
+        startDistance: 0,
+      })
+      if (candidate) return candidate
+    }
+    return null
+  }
+
   private hasPortOnlyLabelOnSameNet(label: NetLabelPlacement) {
     return this.outputNetLabelPlacements.some(
       (otherLabel) =>