@tscircuit/schematic-trace-solver 0.0.157 → 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)
           );
@@ -12322,6 +12372,9 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
+import { getSegmentIntersection as getSegmentIntersection3 } from "@tscircuit/math-utils/line-intersections";
+
 // lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
 var NET_LABEL_INTERIOR_INSET = 1e-6;
 var pathIntersectsAnyNetLabel = ({
@@ -12363,6 +12416,7 @@ var pathEntersAnyNetLabel = ({
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
 var MAX_SHARED_PIN_RAIL_OFFSET = 0.05;
+var MIN_RETURN_STEM_LENGTH = 0.05;
 var getSharedPin = ({
   donorTrace,
   branchTrace
@@ -12400,6 +12454,7 @@ var railIsOnFacingSide = ({
   pin
 }) => {
   if (pin._facingDirection === "y+") return railY > pin.y;
+  if (pin._facingDirection === "y-") return railY < pin.y;
   return false;
 };
 var railIsOnSharedPinFacingSide = ({
@@ -12532,6 +12587,27 @@ var candidateIsClear = ({
   if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
     return false;
   }
+  for (const otherTrace of otherNetTraces) {
+    const countIntersections = (path) => {
+      const intersections = /* @__PURE__ */ new Set();
+      for (let i = 1; i < path.length; i++) {
+        for (let j = 1; j < otherTrace.tracePath.length; j++) {
+          const point = getSegmentIntersection3(
+            path[i - 1],
+            path[i],
+            otherTrace.tracePath[j - 1],
+            otherTrace.tracePath[j]
+          );
+          if (point)
+            intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
+        }
+      }
+      return intersections.size;
+    };
+    if (countIntersections(candidateTrace.tracePath) > countIntersections(originalTrace.tracePath)) {
+      return false;
+    }
+  }
   if (!attachedLabelIndexes.every(
     (index) => tracePathContainsPoint(
       candidateTrace.tracePath,
@@ -12569,6 +12645,57 @@ var candidateIsClear = ({
   if (!originalRail || !candidateRail) return false;
   return Math.abs(originalRail.start.y - candidateRail.start.y) <= MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET;
 };
+var getAlignedReturnBranchPath = ({
+  donorTrace,
+  branchTrace,
+  returnStemScale = 1
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const railPin = getOtherPin({ trace: donorTrace, sharedPin });
+  const returnPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!railPin || !returnPin) return null;
+  const facing = sharedPin._facingDirection;
+  if (facing !== "y+" && facing !== "y-") return null;
+  if (railPin._facingDirection !== facing || returnPin._facingDirection !== facing)
+    return null;
+  if (!nearlyEqual(sharedPin.y, railPin.y)) return null;
+  const donorPath = simplifyPath(donorTrace.tracePath);
+  if (donorPath.length !== 4) return null;
+  const rail = getLongestHorizontalSegment(donorTrace);
+  if (!rail || !railIsOnFacingSide({ railY: rail.start.y, pin: sharedPin }))
+    return null;
+  if (!isVertical2(donorPath[0], donorPath[1]) || !isVertical2(donorPath[2], donorPath[3]))
+    return null;
+  const sharedFirst = branchTrace.pins[0].pinId === sharedPin.pinId;
+  const path = simplifyPath(
+    sharedFirst ? branchTrace.tracePath : [...branchTrace.tracePath].reverse()
+  );
+  if (path.length !== 6) return null;
+  if (!isVertical2(path[0], path[1]) || !isHorizontal2(path[1], path[2]) || !isVertical2(path[2], path[3]) || !isHorizontal2(path[3], path[4]) || !isVertical2(path[4], path[5]))
+    return null;
+  if (!railIsOnFacingSide({ railY: path[1].y, pin: sharedPin }) || !railIsOnFacingSide({ railY: path[4].y, pin: returnPin }))
+    return null;
+  const direction = facing === "y+" ? 1 : -1;
+  if (direction * (returnPin.y - rail.start.y) <= 0) return null;
+  const minX = Math.min(sharedPin.x, railPin.x);
+  const maxX = Math.max(sharedPin.x, railPin.x);
+  if (path[2].x < minX || path[2].x > maxX) return null;
+  if (nearlyEqual(path[2].x, railPin.x) && nearlyEqual(path[1].y, rail.start.y))
+    return null;
+  const returnRailY = returnPin.y + (path[4].y - returnPin.y) * returnStemScale;
+  if (Math.abs(returnRailY - returnPin.y) < MIN_RETURN_STEM_LENGTH - 1e-6)
+    return null;
+  const candidate = simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: sharedPin.x, y: rail.start.y },
+    { x: railPin.x, y: rail.start.y },
+    { x: railPin.x, y: returnRailY },
+    { x: returnPin.x, y: returnRailY },
+    { x: returnPin.x, y: returnPin.y }
+  ]);
+  return sharedFirst ? candidate : candidate.reverse();
+};
 var alignSameNetJunctions = ({
   inputProblem,
   traces,
@@ -12576,63 +12703,74 @@ var alignSameNetJunctions = ({
 }) => {
   let outputTraces = [...traces];
   let outputNetLabelPlacements = [...netLabelPlacements];
-  const alignedBranchTraceIds = /* @__PURE__ */ new Set();
   let alignedJunctionCount = 0;
-  const donorTraceIds = traces.map((trace) => trace.mspPairId);
-  const pendingDonorTraceIds = new Set(donorTraceIds);
-  for (let donorIndex = 0; donorIndex < donorTraceIds.length; donorIndex++) {
-    const donorTraceId = donorTraceIds[donorIndex];
-    pendingDonorTraceIds.delete(donorTraceId);
-    const donorTrace = outputTraces.find(
-      (trace) => trace.mspPairId === donorTraceId
-    );
-    for (const branchTrace of outputTraces) {
-      if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
-      if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
-      if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
-      const candidatePath = getAlignedBranchPath({ donorTrace, branchTrace });
-      if (!candidatePath) continue;
-      const candidateTrace = { ...branchTrace, tracePath: candidatePath };
-      const originalPair = [donorTrace, branchTrace];
-      const candidatePair = [donorTrace, candidateTrace];
-      const removesVisibleSegment = getVisibleTraceSegmentCount(candidatePair) < getVisibleTraceSegmentCount(originalPair);
-      const shortensVisibleTrace = getVisibleTraceLength(candidatePair) < getVisibleTraceLength(originalPair) && !nearlyEqual(
-        getVisibleTraceLength(candidatePair),
-        getVisibleTraceLength(originalPair)
+  for (const alignReturnBranches of [false, true]) {
+    const alignedBranchTraceIds = /* @__PURE__ */ new Set();
+    const donorTraceIds = traces.map((trace) => trace.mspPairId);
+    const pendingDonorTraceIds = new Set(donorTraceIds);
+    for (let donorIndex = 0; donorIndex < donorTraceIds.length; donorIndex++) {
+      const donorTraceId = donorTraceIds[donorIndex];
+      pendingDonorTraceIds.delete(donorTraceId);
+      const donorTrace = outputTraces.find(
+        (trace) => trace.mspPairId === donorTraceId
       );
-      if (!removesVisibleSegment && !shortensVisibleTrace) {
-        continue;
-      }
-      const attachedLabelIndexes = getAttachedLabelIndexes(
-        branchTrace,
-        outputNetLabelPlacements
-      );
-      const candidateNetLabelPlacements = moveAttachedLabels({
-        trace: branchTrace,
-        reroutedTracePath: candidatePath,
-        netLabelPlacements: outputNetLabelPlacements,
-        attachedLabelIndexes
-      });
-      if (!candidateIsClear({
-        candidateTrace,
-        originalTrace: branchTrace,
-        traces: outputTraces,
-        inputProblem,
-        candidateNetLabelPlacements,
-        attachedLabelIndexes
-      })) {
-        continue;
-      }
-      outputTraces = outputTraces.map((trace) => {
-        if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
-        return trace;
-      });
-      outputNetLabelPlacements = candidateNetLabelPlacements;
-      alignedBranchTraceIds.add(branchTrace.mspPairId);
-      alignedJunctionCount++;
-      if (!pendingDonorTraceIds.has(branchTrace.mspPairId)) {
-        donorTraceIds.push(branchTrace.mspPairId);
-        pendingDonorTraceIds.add(branchTrace.mspPairId);
+      for (const branchTrace of outputTraces) {
+        if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
+        if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
+        if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
+        const candidatePaths = alignReturnBranches ? [1, 0.5, 0.25].map(
+          (returnStemScale) => getAlignedReturnBranchPath({
+            donorTrace,
+            branchTrace,
+            returnStemScale
+          })
+        ) : [getAlignedBranchPath({ donorTrace, branchTrace })];
+        for (const candidatePath of candidatePaths) {
+          if (!candidatePath) continue;
+          const candidateTrace = { ...branchTrace, tracePath: candidatePath };
+          const originalPair = [donorTrace, branchTrace];
+          const candidatePair = [donorTrace, candidateTrace];
+          const removesVisibleSegment = getVisibleTraceSegmentCount(candidatePair) < getVisibleTraceSegmentCount(originalPair);
+          const shortensVisibleTrace = getVisibleTraceLength(candidatePair) < getVisibleTraceLength(originalPair) && !nearlyEqual(
+            getVisibleTraceLength(candidatePair),
+            getVisibleTraceLength(originalPair)
+          );
+          if (!removesVisibleSegment && !shortensVisibleTrace) {
+            continue;
+          }
+          const attachedLabelIndexes = getAttachedLabelIndexes(
+            branchTrace,
+            outputNetLabelPlacements
+          );
+          const candidateNetLabelPlacements = moveAttachedLabels({
+            trace: branchTrace,
+            reroutedTracePath: candidatePath,
+            netLabelPlacements: outputNetLabelPlacements,
+            attachedLabelIndexes
+          });
+          if (!candidateIsClear({
+            candidateTrace,
+            originalTrace: branchTrace,
+            traces: outputTraces,
+            inputProblem,
+            candidateNetLabelPlacements,
+            attachedLabelIndexes
+          })) {
+            continue;
+          }
+          outputTraces = outputTraces.map((trace) => {
+            if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
+            return trace;
+          });
+          outputNetLabelPlacements = candidateNetLabelPlacements;
+          alignedBranchTraceIds.add(branchTrace.mspPairId);
+          alignedJunctionCount++;
+          if (!pendingDonorTraceIds.has(branchTrace.mspPairId)) {
+            donorTraceIds.push(branchTrace.mspPairId);
+            pendingDonorTraceIds.add(branchTrace.mspPairId);
+          }
+          break;
+        }
       }
     }
   }
@@ -12643,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;
@@ -12657,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
   }