@tscircuit/schematic-trace-solver 0.0.158 → 0.0.159

package/dist/index.d.ts

@@ -202,6 +202,7 @@ declare class MspConnectionPairSolver extends BaseSolver {
     }>;
     userNetIdByPinId: Record<string, string | undefined>;
     directConnectionPinPairKeys: Set<string>;
+    private canRouteGroundPair;
     constructor({ inputProblem }: {
         inputProblem: InputProblem;
     });

package/dist/index.js

@@ -363,6 +363,48 @@ var getConnectivityMapsFromInputProblem = (inputProblem) => {
   return { directConnMap, netConnMap };
 };
 
+// lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy.ts
+import { ConnectivityMap as ConnectivityMap2 } from "connectivity-map";
+var MAX_LOCAL_GROUND_BRANCH_OFFSET = 1;
+var getGroundConnectionPolicy = (inputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetId = netConnMap.getNetConnectedToId("GND");
+  if (!groundNetId) return () => true;
+  const physicalConnMap = new ConnectivityMap2({});
+  for (const connection of inputProblem.directConnections) {
+    physicalConnMap.addConnections([connection.pinIds]);
+  }
+  const pins = new Map(
+    inputProblem.chips.flatMap(
+      (chip) => chip.pins.map((pin) => [pin.pinId, { pin, chip }])
+    )
+  );
+  const groundFacingPins = [...pins.values()].filter(
+    ({ pin, chip }) => chip.pins.length === 2 && netConnMap.getNetConnectedToId(pin.pinId) === groundNetId && (pin._facingDirection ?? getPinDirection(pin, chip)) === "y-"
+  );
+  const hasExplicitParallelGroundRail = groundFacingPins.some(({ pin: a }) => {
+    const group = physicalConnMap.getNetConnectedToId(a.pinId);
+    return group !== void 0 && groundFacingPins.some(
+      ({ pin: b }) => a.pinId !== b.pinId && Math.abs(a.y - b.y) < 1e-6 && Math.abs(a.x - b.x) > 1e-6 && physicalConnMap.getNetConnectedToId(b.pinId) === group
+    );
+  });
+  if (!hasExplicitParallelGroundRail) return () => true;
+  const isGroundFacingTerminal = (pinId) => {
+    const entry = pins.get(pinId);
+    return entry?.chip.pins.length === 2 && !physicalConnMap.getNetConnectedToId(pinId) && (entry.pin._facingDirection ?? getPinDirection(entry.pin, entry.chip)) === "y-";
+  };
+  return (firstPinId, secondPinId) => {
+    if (!groundNetId || netConnMap.getNetConnectedToId(firstPinId) !== groundNetId || netConnMap.getNetConnectedToId(secondPinId) !== groundNetId) {
+      return true;
+    }
+    if (!isGroundFacingTerminal(firstPinId) && !isGroundFacingTerminal(secondPinId))
+      return true;
+    const first = pins.get(firstPinId)?.pin;
+    const second = pins.get(secondPinId)?.pin;
+    return !first || !second || Math.abs(first.y - second.y) <= MAX_LOCAL_GROUND_BRANCH_OFFSET + 1e-6;
+  };
+};
+
 // lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
 function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   const n = pins.length;
@@ -512,9 +554,11 @@ var MspConnectionPairSolver = class extends BaseSolver {
   pinMap;
   userNetIdByPinId;
   directConnectionPinPairKeys;
+  canRouteGroundPair;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
+    this.canRouteGroundPair = getGroundConnectionPolicy(inputProblem);
     this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
@@ -571,6 +615,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins;
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
+      if (!this.canRouteGroundPair(pin1, pin2)) return;
       const pinPairKey = getPinPairKey([pin1, pin2]);
       let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
       if (this.directConnectionPinPairKeys.has(pinPairKey)) {
@@ -615,7 +660,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
       {
         maxDistance: this.maxMspPairDistance,
-        forbidEdge: (a, b) => arePinsInDifferentSchematicSections(
+        forbidEdge: (a, b) => !this.canRouteGroundPair(a.pinId, b.pinId) || arePinsInDifferentSchematicSections(
           this.inputProblem,
           a,
           b
@@ -4827,6 +4872,7 @@ var LongDistancePairSolver = class extends BaseSolver {
     super();
     this.params = params;
     const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
+    const canRouteGroundPair = getGroundConnectionPolicy(inputProblem);
     this.inputProblem = inputProblem;
     this.allSolvedTraces = [...alreadySolvedTraces];
     this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
@@ -4845,7 +4891,10 @@ var LongDistancePairSolver = class extends BaseSolver {
       }
     }
     this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
-      (connectionPair) => isLabeledPeripheralConnection({
+      (connectionPair) => canRouteGroundPair(
+        connectionPair.pins[0].pinId,
+        connectionPair.pins[1].pinId
+      ) && isLabeledPeripheralConnection({
         inputProblem: this.inputProblem,
         chipMap: this.chipMap,
         pins: connectionPair.pins
@@ -4865,6 +4914,7 @@ var LongDistancePairSolver = class extends BaseSolver {
         const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
           const targetPin = pinMap.get(otherPinId);
           if (!targetPin) return [];
+          if (!canRouteGroundPair(sourcePin.pinId, targetPin.pinId)) return [];
           const isNamedTwoPinConnection = inputProblem.netConnections.some(
             (connection) => connection.pinIds.length === 2 && connection.pinIds.includes(sourcePin.pinId) && connection.pinIds.includes(targetPin.pinId)
           );
@@ -12731,6 +12781,75 @@ var alignSameNetJunctions = ({
   };
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts
+var placeGroundRailLabelsAtOuterEnd = ({
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetId = netConnMap.getNetConnectedToId("GND");
+  if (!groundNetId) return netLabelPlacements;
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
+  const traceMap = Object.fromEntries(
+    traces.map((trace) => [trace.mspPairId, trace])
+  );
+  const obstacles = getObstacleRects(inputProblem);
+  const output = [...netLabelPlacements];
+  for (const rail of traces) {
+    if (rail.globalConnNetId !== groundNetId) continue;
+    const [a, b] = rail.pins;
+    if (a.chipId === b.chipId || !nearlyEqual(a.y, b.y) || ![a, b].every(
+      (pin) => pin._facingDirection === "y-" && chipMap.get(pin.chipId)?.pins.length === 2
+    ))
+      continue;
+    const path = simplifyPath(rail.tracePath);
+    if (path.length !== 4 || !isVertical2(path[0], path[1]) || !isHorizontal2(path[1], path[2]) || !isVertical2(path[2], path[3]) || path[1].y >= a.y)
+      continue;
+    for (const feed of traces) {
+      if (feed.globalConnNetId !== groundNetId) continue;
+      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId));
+      const icPin = feed.pins.find(
+        (pin) => !rail.pinIds.includes(pin.pinId) && (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2
+      );
+      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1].y)) continue;
+      const outer = shared.pinId === a.pinId ? b : a;
+      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue;
+      const anchorPoint = { x: outer.x, y: path[1].y };
+      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue;
+      for (let index = 0; index < output.length; index++) {
+        const label = output[index];
+        if (label.globalConnNetId !== groundNetId || label.orientation !== "y-" || !label.mspConnectionPairIds.some(
+          (id) => id === feed.mspPairId || id === rail.mspPairId
+        ) || !tracePathContainsPoint(feed.tracePath, label.anchorPoint) && !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
+          continue;
+        const center = getCenterFromAnchor(
+          anchorPoint,
+          label.orientation,
+          label.width,
+          label.height
+        );
+        const bounds = getRectBounds(center, label.width, label.height);
+        if (obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
+          (other, otherIndex) => otherIndex !== index && rectsOverlap(
+            bounds,
+            getRectBounds(other.center, other.width, other.height)
+          )
+        ))
+          continue;
+        output[index] = {
+          ...label,
+          anchorPoint,
+          center,
+          mspConnectionPairIds: [rail.mspPairId],
+          pinIds: [...rail.pinIds]
+        };
+      }
+    }
+  }
+  return output;
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
 var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   input;
@@ -12745,7 +12864,11 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   _step() {
     const result = alignSameNetJunctions(this.input);
     this.outputTraces = result.traces;
-    this.outputNetLabelPlacements = result.netLabelPlacements;
+    this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
+      inputProblem: this.input.inputProblem,
+      traces: result.traces,
+      netLabelPlacements: result.netLabelPlacements
+    });
     this.stats.alignedJunctionCount = result.alignedJunctionCount;
     this.solved = true;
   }

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -1,23 +1,24 @@
-import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import type { Point } from "@tscircuit/math-utils"
+import type { ConnectivityMap } from "connectivity-map"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import {
   DEFAULT_MAX_MSP_PAIR_DISTANCE,
   type MspConnectionPair,
 } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type {
-  InputProblem,
+  InputChip,
   InputPin,
+  InputProblem,
   PinId,
-  InputChip,
 } from "lib/types/InputProblem"
-import { BaseSolver } from "../BaseSolver/BaseSolver"
-import { SchematicTraceSingleLineSolver2 } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
-import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import type { ConnectivityMap } from "connectivity-map"
 import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { BaseSolver } from "../BaseSolver/BaseSolver"
+import { getGroundConnectionPolicy } from "../MspConnectionPairSolver/getGroundConnectionPolicy"
 import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { SchematicTraceSingleLineSolver2 } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
@@ -163,6 +164,7 @@ export class LongDistancePairSolver extends BaseSolver {
 
     const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } =
       this.params
+    const canRouteGroundPair = getGroundConnectionPolicy(inputProblem)
 
     this.inputProblem = inputProblem
     this.allSolvedTraces = [...alreadySolvedTraces]
@@ -189,6 +191,10 @@ export class LongDistancePairSolver extends BaseSolver {
     // new nearest-neighbor candidates.
     this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
       (connectionPair) =>
+        canRouteGroundPair(
+          connectionPair.pins[0].pinId,
+          connectionPair.pins[1].pinId,
+        ) &&
         isLabeledPeripheralConnection({
           inputProblem: this.inputProblem,
           chipMap: this.chipMap,
@@ -219,6 +225,7 @@ export class LongDistancePairSolver extends BaseSolver {
           .flatMap((otherPinId) => {
             const targetPin = pinMap.get(otherPinId)
             if (!targetPin) return [] // Gracefully handle missing pins
+            if (!canRouteGroundPair(sourcePin.pinId, targetPin.pinId)) return []
             const isNamedTwoPinConnection = inputProblem.netConnections.some(
               (connection) =>
                 connection.pinIds.length === 2 &&

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -13,6 +13,7 @@ import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDiffer
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
+import { getGroundConnectionPolicy } from "./getGroundConnectionPolicy"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 import { getLabeledConnectionRouteReason } from "./isLabeledPeripheralConnection"
 
@@ -45,11 +46,13 @@ export class MspConnectionPairSolver extends BaseSolver {
   pinMap: Record<string, InputPin & { chipId: string }>
   userNetIdByPinId: Record<string, string | undefined>
   directConnectionPinPairKeys: Set<string>
+  private canRouteGroundPair: (firstPinId: PinId, secondPinId: PinId) => boolean
 
   constructor({ inputProblem }: { inputProblem: InputProblem }) {
     super()
 
     this.inputProblem = inputProblem
+    this.canRouteGroundPair = getGroundConnectionPolicy(inputProblem)
     this.maxMspPairDistance =
       inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
 
@@ -124,6 +127,7 @@ export class MspConnectionPairSolver extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins
       const p1 = this.pinMap[pin1!]!
       const p2 = this.pinMap[pin2!]!
+      if (!this.canRouteGroundPair(pin1!, pin2!)) return
       const pinPairKey = getPinPairKey([pin1!, pin2!])
       // Explicit source traces are classified by straight-line distance when
       // their input is created; named nets retain the orthogonal route metric.
@@ -195,6 +199,7 @@ export class MspConnectionPairSolver extends BaseSolver {
       {
         maxDistance: this.maxMspPairDistance,
         forbidEdge: (a, b) =>
+          !this.canRouteGroundPair(a.pinId, b.pinId) ||
           arePinsInDifferentSchematicSections(
             this.inputProblem,
             a as InputPin & { chipId: string },

package/lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy.ts

@@ -0,0 +1,83 @@
+import { ConnectivityMap } from "connectivity-map"
+import type { InputProblem, PinId } from "lib/types/InputProblem"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
+
+// Keep nearby ground connections, but do not extend the usual 1 mm local
+// routing range vertically just because a sheet allows long signal traces.
+const MAX_LOCAL_GROUND_BRANCH_OFFSET = 1
+
+/** Avoid return wires between staggered, net-only ground-facing branches. */
+export const getGroundConnectionPolicy = (inputProblem: InputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const groundNetId = netConnMap.getNetConnectedToId("GND")
+  if (!groundNetId) return () => true
+  // Net identifiers do not constitute physical edges: two separate direct
+  // connections may have the same netId without requesting a wire between them.
+  const physicalConnMap = new ConnectivityMap({})
+  for (const connection of inputProblem.directConnections) {
+    physicalConnMap.addConnections([connection.pinIds])
+  }
+  const pins = new Map(
+    inputProblem.chips.flatMap((chip) =>
+      chip.pins.map((pin) => [pin.pinId, { pin, chip }] as const),
+    ),
+  )
+  const groundFacingPins = [...pins.values()].filter(
+    ({ pin, chip }) =>
+      chip.pins.length === 2 &&
+      netConnMap.getNetConnectedToId(pin.pinId) === groundNetId &&
+      (pin._facingDirection ?? getPinDirection(pin, chip)) === "y-",
+  )
+  // A deliberately wired, level bank of two-pin loads already has its own
+  // shared return rail. Do not extend that rail to independent lower branches
+  // just to reduce the number of GND symbols. Other ground topologies retain
+  // their existing routing behavior.
+  const hasExplicitParallelGroundRail = groundFacingPins.some(({ pin: a }) => {
+    const group = physicalConnMap.getNetConnectedToId(a.pinId)
+    return (
+      group !== undefined &&
+      groundFacingPins.some(
+        ({ pin: b }) =>
+          a.pinId !== b.pinId &&
+          Math.abs(a.y - b.y) < 1e-6 &&
+          Math.abs(a.x - b.x) > 1e-6 &&
+          physicalConnMap.getNetConnectedToId(b.pinId) === group,
+      )
+    )
+  })
+  if (!hasExplicitParallelGroundRail) return () => true
+  const isGroundFacingTerminal = (pinId: PinId) => {
+    const entry = pins.get(pinId)
+    return (
+      entry?.chip.pins.length === 2 &&
+      !physicalConnMap.getNetConnectedToId(pinId) &&
+      (entry.pin._facingDirection ?? getPinDirection(entry.pin, entry.chip)) ===
+        "y-"
+    )
+  }
+
+  return (firstPinId: PinId, secondPinId: PinId): boolean => {
+    if (
+      !groundNetId ||
+      netConnMap.getNetConnectedToId(firstPinId) !== groundNetId ||
+      netConnMap.getNetConnectedToId(secondPinId) !== groundNetId
+    ) {
+      return true
+    }
+    if (
+      !isGroundFacingTerminal(firstPinId) &&
+      !isGroundFacingTerminal(secondPinId)
+    )
+      return true
+    const first = pins.get(firstPinId)?.pin
+    const second = pins.get(secondPinId)?.pin
+    // Level ground pins can still form a shared decoupling rail. A staggered
+    // terminal would need a return detour; use its local GND label instead.
+    return (
+      !first ||
+      !second ||
+      Math.abs(first.y - second.y) <= MAX_LOCAL_GROUND_BRANCH_OFFSET + 1e-6
+    )
+  }
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -6,6 +6,7 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
+import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
 
 interface SameNetJunctionAlignmentSolverInput {
   inputProblem: InputProblem
@@ -29,7 +30,11 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
   override _step() {
     const result = alignSameNetJunctions(this.input)
     this.outputTraces = result.traces
-    this.outputNetLabelPlacements = result.netLabelPlacements
+    this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
+      inputProblem: this.input.inputProblem,
+      traces: result.traces,
+      netLabelPlacements: result.netLabelPlacements,
+    })
     this.stats.alignedJunctionCount = result.alignedJunctionCount
     this.solved = true
   }

package/lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts

@@ -0,0 +1,122 @@
+import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import {
+  rectsOverlap,
+  tracePathContainsPoint,
+} from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import {
+  isHorizontal,
+  isVertical,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import type { InputProblem } from "lib/types/InputProblem"
+
+/** Put a shared decoupling GND at the load end of its rail, away from the IC. */
+export const placeGroundRailLabelsAtOuterEnd = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+}: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}): NetLabelPlacement[] => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const groundNetId = netConnMap.getNetConnectedToId("GND")
+  if (!groundNetId) return netLabelPlacements
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]))
+  const traceMap = Object.fromEntries(
+    traces.map((trace) => [trace.mspPairId, trace]),
+  )
+  const obstacles = getObstacleRects(inputProblem)
+  const output = [...netLabelPlacements]
+
+  for (const rail of traces) {
+    if (rail.globalConnNetId !== groundNetId) continue
+    const [a, b] = rail.pins
+    if (
+      a.chipId === b.chipId ||
+      !nearlyEqual(a.y, b.y) ||
+      ![a, b].every(
+        (pin) =>
+          pin._facingDirection === "y-" &&
+          chipMap.get(pin.chipId)?.pins.length === 2,
+      )
+    )
+      continue
+    const path = simplifyPath(rail.tracePath)
+    if (
+      path.length !== 4 ||
+      !isVertical(path[0]!, path[1]!) ||
+      !isHorizontal(path[1]!, path[2]!) ||
+      !isVertical(path[2]!, path[3]!) ||
+      path[1]!.y >= a.y
+    )
+      continue
+
+    for (const feed of traces) {
+      if (feed.globalConnNetId !== groundNetId) continue
+      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId))
+      const icPin = feed.pins.find(
+        (pin) =>
+          !rail.pinIds.includes(pin.pinId) &&
+          (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2,
+      )
+      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1]!.y)) continue
+      const outer = shared.pinId === a.pinId ? b : a
+      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue
+      const anchorPoint = { x: outer.x, y: path[1]!.y }
+      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue
+
+      for (let index = 0; index < output.length; index++) {
+        const label = output[index]!
+        if (
+          label.globalConnNetId !== groundNetId ||
+          label.orientation !== "y-" ||
+          !label.mspConnectionPairIds.some(
+            (id) => id === feed.mspPairId || id === rail.mspPairId,
+          ) ||
+          (!tracePathContainsPoint(feed.tracePath, label.anchorPoint) &&
+            !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
+        )
+          continue
+        const center = getCenterFromAnchor(
+          anchorPoint,
+          label.orientation,
+          label.width,
+          label.height,
+        )
+        const bounds = getRectBounds(center, label.width, label.height)
+        if (
+          obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) ||
+          traceCrossesBoundsInterior(bounds, traceMap) ||
+          output.some(
+            (other, otherIndex) =>
+              otherIndex !== index &&
+              rectsOverlap(
+                bounds,
+                getRectBounds(other.center, other.width, other.height),
+              ),
+          )
+        )
+          continue
+        output[index] = {
+          ...label,
+          anchorPoint,
+          center,
+          mspConnectionPairIds: [rail.mspPairId],
+          pinIds: [...rail.pinIds],
+        }
+      }
+    }
+  }
+  return output
+}

package/package.json

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