@tscircuit/schematic-trace-solver 0.0.160 → 0.0.161

package/dist/index.d.ts

@@ -906,6 +906,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

@@ -5864,6 +5864,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 +5877,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 +5907,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 +8959,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 +9083,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 +9544,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 +9934,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) =>

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts

@@ -53,6 +53,12 @@ export const getFixedLabelCoordinate = (
 ) => {
   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,
   )
@@ -66,16 +72,27 @@ export const getFixedLabelCoordinate = (
     netLabelPlacements,
     traces,
   )
-  const anchoringLabels = linkedLabels.filter(
-    (label) =>
-      label.orientation === group[0]!.componentFacingDirection &&
-      label.mspConnectionPairIds.some((traceId) => {
-        const trace = traceMap.get(traceId)
-        return (
-          trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
-        )
-      }),
+  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,
@@ -95,11 +112,24 @@ export const getFixedLabelCoordinate = (
       (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4,
     ),
   )
-  // A multi-turn label trace is an intentional routed backbone, so its rail
-  // coordinate may propagate through the local component chain. Labels riding
-  // a single movable rail remain subject to the per-connection locality gate.
+  // A multi-turn label trace is an intentional routed backbone, so its
+  // coordinate may propagate through the connected rail group.
   if (labelIsAnchoredToRoutedBackbone) return coordinate
 
+  // A label at a same-component rail end may set the shared bus 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
+  }
+
   // Rail cleanup is local: a label cannot pull a connection farther than the
   // span of the pins that connection already joins.
   const coordinateIsLocalToEveryTrace = group.every((segment) => {
@@ -110,5 +140,6 @@ export const getFixedLabelCoordinate = (
       distance(trace.pins[0]!, trace.pins[1]!) + RAIL_ALIGNMENT_EPSILON
     )
   })
-  return coordinateIsLocalToEveryTrace ? coordinate : null
+  if (coordinateIsLocalToEveryTrace) return coordinate
+  return null
 }

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.160",
+  "version": "0.0.161",
   "type": "module",
   "scripts": {
     "start": "cosmos",