Avoid long traces on labeled ground rails

lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -16,6 +16,7 @@ import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDiffer
 import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 
 const NEAREST_NEIGHBOR_COUNT = 3
+const GROUND_NET_ID = "GND"
 
 const distance = (p1: InputPin, p2: InputPin) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2))
@@ -91,6 +92,26 @@ export class LongDistancePairSolver extends BaseSolver {
       const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId)
       if (allPinIdsInNet.length < 2) continue
 
+      const labeledGroundConnection = inputProblem.netConnections.find(
+        (netConnection) =>
+          netConnection.netId === GROUND_NET_ID &&
+          netConnection.pinIds.some((pinId) => allPinIdsInNet.includes(pinId)),
+      )
+      const canPlaceGroundLabels =
+        (inputProblem.availableNetLabelOrientations[GROUND_NET_ID]?.length ??
+          0) > 0
+
+      // Long-distance ground connections are clearer as local GND labels.
+      // Keep short primary routes and preserve fallback routing when the
+      // caller has not provided a valid orientation for ground labels.
+      if (
+        labeledGroundConnection &&
+        labeledGroundConnection.pinIds.length > 2 &&
+        canPlaceGroundLabels
+      ) {
+        continue
+      }
+
       const unconnectedPinIds = allPinIdsInNet.filter(
         (pinId) => !primaryConnectedPinIds.has(pinId),
       )

tests/bug-reports/bug-report-20260806T093501Z/bug-report-20260806T093501Z.test.ts

@@ -43,24 +43,15 @@ test("bug-report-20260806T093501Z", () => {
     .traces.find(
       (trace) => trace.mspPairId === "schematic_port_25-schematic_port_42",
     )
-  expect(groundTrace?.tracePath).toEqual([
-    { x: -7.7, y: 3.299999999999999 },
-    { x: -7.7, y: 4.840999999999999 },
-    { x: -8.699999999999998, y: 4.840999999999999 },
-    { x: -8.699999999999998, y: 4.71 },
-    { x: -12, y: 4.71 },
-    { x: -12, y: 6.12 },
-  ])
+  expect(groundTrace).toBeUndefined()
 
   const finalOutput = solver.sameNetJunctionAlignmentSolver!.getOutput()
   expect(
     detectTraceLabelOverlap({
       traces: finalOutput.traces,
       netLabels: finalOutput.netLabelPlacements,
     }).map(({ trace, label }) => `${trace.mspPairId}->${label.netId}`),
-  ).toEqual([
-    "schematic_port_25-schematic_port_42->.C_CP > .pin2 to .U_GATE > .CPL",
-  ])
+  ).toEqual([])
 
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

tests/solvers/LongDistancePairSolver/skip-labeled-ground.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test"
+import { LongDistancePairSolver } from "lib/solvers/LongDistancePairSolver/LongDistancePairSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const createGroundProblem = ({
+  availableNetLabelOrientations,
+}: Pick<InputProblem, "availableNetLabelOrientations">): InputProblem => ({
+  chips: [
+    {
+      chipId: "C1",
+      center: { x: -5, y: 4 },
+      width: 1,
+      height: 2,
+      pins: [
+        {
+          pinId: "C1.neg",
+          x: -5,
+          y: 3,
+          _facingDirection: "y-",
+        },
+      ],
+    },
+    {
+      chipId: "U1",
+      center: { x: 0, y: 0 },
+      width: 3,
+      height: 2,
+      pins: [
+        {
+          pinId: "U1.GND",
+          x: -1.5,
+          y: 0.5,
+          _facingDirection: "x-",
+        },
+      ],
+    },
+    {
+      chipId: "LED1",
+      center: { x: 3, y: -4 },
+      width: 1,
+      height: 1,
+      pins: [
+        {
+          pinId: "LED1.neg",
+          x: 3,
+          y: -4.5,
+          _facingDirection: "y-",
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["C1.neg", "U1.GND", "LED1.neg"],
+    },
+  ],
+  availableNetLabelOrientations,
+  maxMspPairDistance: 1,
+})
+
+test("uses local labels instead of a long trace for a labeled ground net", () => {
+  const solver = new LongDistancePairSolver({
+    inputProblem: createGroundProblem({
+      availableNetLabelOrientations: { GND: ["y-"] },
+    }),
+    alreadySolvedTraces: [],
+    primaryMspConnectionPairs: [],
+    failedConnectionPairs: [],
+  })
+
+  solver.solve()
+
+  expect(solver.getOutput().newTraces).toHaveLength(0)
+})
+
+test("keeps fallback routing when ground labels cannot be placed", () => {
+  const solver = new LongDistancePairSolver({
+    inputProblem: createGroundProblem({
+      availableNetLabelOrientations: {},
+    }),
+    alreadySolvedTraces: [],
+    primaryMspConnectionPairs: [],
+    failedConnectionPairs: [],
+  })
+
+  solver.solve()
+
+  expect(solver.getOutput().newTraces.length).toBeGreaterThan(0)
+})