@tscircuit/schematic-trace-solver 0.0.161 → 0.0.163

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
@@ -823,7 +825,7 @@ type CandidateLabel = {
     height: number;
 };
 type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "trace-clearance-violation" | "netlabel-collision";
-type CandidatePhase = "rotate" | "trace-anchor" | "outward-trace-anchor" | "shift" | "lateral-shift";
+type CandidatePhase = "rotate" | "trace-anchor" | "connected-rail-shift" | "outward-trace-anchor" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
     selected: boolean;
@@ -900,6 +902,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getNetLabelHeight;
     private getCandidateStatus;
     private isAcceptableTraceAnchorChipCollision;
+    private staysOutsideConnectedPinRow;
     private getBoundsStatus;
     private isTraceTooCloseToLabel;
     private getLabelTraceClearanceBounds;

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]
       });
     }
@@ -8802,6 +8831,7 @@ function getPaddedBounds(bounds, padding) {
 
 // lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts
 var LABEL_TRACE_CLEARANCE2 = 0.1;
+var CONNECTED_PIN_ROW_OVERLAP_TOLERANCE = 0.1;
 var AvailableNetOrientationSolver = class extends BaseSolver {
   inputProblem;
   traces;
@@ -9823,7 +9853,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       label
     });
     if (boundsStatus !== "valid") {
-      if (phase !== "trace-anchor" || boundsStatus !== "chip-collision" || !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds)) {
+      if (phase !== "trace-anchor" && phase !== "connected-rail-shift" || boundsStatus !== "chip-collision" || !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds) || phase === "connected-rail-shift" && !this.staysOutsideConnectedPinRow({ candidate, label, bounds })) {
         return boundsStatus;
       }
       const nonChipBoundsStatus = this.getBoundsStatus({
@@ -9877,6 +9907,15 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       return anchorPoint.y < chipBounds.minY - EPS12 || anchorPoint.y > chipBounds.maxY + EPS12;
     });
   }
+  staysOutsideConnectedPinRow(params) {
+    const { candidate, label, bounds } = params;
+    const pin = this.pinMap[label.pinIds[0]];
+    if (!pin || !isYOrientation(candidate.orientation)) return false;
+    if (candidate.anchorPoint.x < pin.x) {
+      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS12;
+    }
+    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS12;
+  }
   getBoundsStatus(candidateBoundsCheck) {
     const { bounds, labelIndex, label, ignoreChipCollisions } = candidateBoundsCheck;
     if (!ignoreChipCollisions) {
@@ -10031,8 +10070,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation,
         direction,
         baseAnchor: connectorSource,
-        maxSearchDistance: this.maxSearchDistance,
+        maxSearchDistance: this.getSearchDistanceLimit(label, orientation),
         outwardDistance: 0,
+        phase: "connected-rail-shift",
         stopOnTraceCollision: false,
         connectorSource,
         startDistance: 0

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -51,6 +51,7 @@ import { visualizeAvailableNetOrientationSolver } from "./visualize"
 import { AvailableNetOrientationObstacleIndex } from "./AvailableNetOrientationObstacleIndex"
 
 const LABEL_TRACE_CLEARANCE = 0.1
+const CONNECTED_PIN_ROW_OVERLAP_TOLERANCE = 0.1
 
 export class AvailableNetOrientationSolver extends BaseSolver {
   inputProblem: InputProblem
@@ -1443,9 +1444,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     })
     if (boundsStatus !== "valid") {
       if (
-        phase !== "trace-anchor" ||
+        (phase !== "trace-anchor" && phase !== "connected-rail-shift") ||
         boundsStatus !== "chip-collision" ||
-        !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds)
+        !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds) ||
+        (phase === "connected-rail-shift" &&
+          !this.staysOutsideConnectedPinRow({ candidate, label, bounds }))
       ) {
         return boundsStatus
       }
@@ -1525,6 +1528,20 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     })
   }
 
+  private staysOutsideConnectedPinRow(params: {
+    candidate: CandidateLabel
+    label: NetLabelPlacement
+    bounds: Bounds
+  }) {
+    const { candidate, label, bounds } = params
+    const pin = this.pinMap[label.pinIds[0]!]
+    if (!pin || !isYOrientation(candidate.orientation)) return false
+    if (candidate.anchorPoint.x < pin.x) {
+      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS
+    }
+    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS
+  }
+
   private getBoundsStatus(candidateBoundsCheck: {
     bounds: Bounds
     labelIndex: number
@@ -1756,8 +1773,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         orientation,
         direction,
         baseAnchor: connectorSource,
-        maxSearchDistance: this.maxSearchDistance,
+        maxSearchDistance: this.getSearchDistanceLimit(label, orientation),
         outwardDistance: 0,
+        phase: "connected-rail-shift",
         stopOnTraceCollision: false,
         connectorSource,
         startDistance: 0,

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -39,6 +39,7 @@ export type CandidateStatus =
 export type CandidatePhase =
   | "rotate"
   | "trace-anchor"
+  | "connected-rail-shift"
   | "outward-trace-anchor"
   | "shift"
   | "lateral-shift"

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -16,6 +16,7 @@ import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInp
 import { getGroundConnectionPolicy } from "./getGroundConnectionPolicy"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 import { getLabeledConnectionRouteReason } from "./isLabeledPeripheralConnection"
+import { shouldSeparateGroundNetRows } from "./shouldSeparateGroundNetRows"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -194,26 +195,32 @@ export class MspConnectionPairSolver extends BaseSolver {
       PinId,
       InputPin & { chipId: string }
     >
-    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 as InputPin & { chipId: string },
-            b as InputPin & { chipId: string },
-          ) ||
-          doesPairCrossRestrictedCenterLines({
-            inputProblem: this.inputProblem,
-            chipMap: this.chipMap,
-            pinIdMap,
-            p1: a as InputPin & { chipId: string },
-            p2: b as InputPin & { chipId: string },
-          }),
-      },
+    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!]!
@@ -237,13 +244,13 @@ export class MspConnectionPairSolver extends BaseSolver {
       }
 
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1!)!
-      const userNetId =
+      const pairUserNetId =
         this.userNetIdByPinId[pin1!] ?? this.userNetIdByPinId[pin2!]
       this.addMspConnectionPair({
         mspPairId: `${pin1}-${pin2}`,
         dcConnNetId: dcNetId,
         globalConnNetId,
-        userNetId,
+        userNetId: pairUserNetId,
         pins: [p1Obj, p2Obj],
       })
     }

package/lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts

@@ -16,11 +16,11 @@ import type { InputPin, PinId } from "lib/types/InputProblem"
  * - When multiple candidates have the same distance, we pick the one
  *   whose pinId is lexicographically smallest (for stable output).
  */
-export function getOrthogonalMinimumSpanningTree(
-  pins: InputPin[],
+export function getOrthogonalMinimumSpanningTree<Pin extends InputPin>(
+  pins: Pin[],
   opts: {
     maxDistance?: number
-    forbidEdge?: (a: InputPin, b: InputPin) => boolean
+    forbidEdge?: (a: Pin, b: Pin) => boolean
   } = {},
 ): Array<[PinId, PinId]> {
   const n = pins.length

package/lib/solvers/MspConnectionPairSolver/shouldSeparateGroundNetRows.ts

@@ -0,0 +1,40 @@
+import type { InputNetConnection, InputPin } from "lib/types/InputProblem"
+
+const SAME_RAIL_Y_TOLERANCE = 1e-6
+const MIN_GROUPED_RAIL_PIN_COUNT = 3
+
+function isGroupedHorizontalRail({
+  pin,
+  netPins,
+}: {
+  pin: InputPin & { chipId: string }
+  netPins: Array<InputPin & { chipId: string }>
+}) {
+  // Multiple pins from one symbol do not establish a grouped component rail.
+  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
+}
+
+export function shouldSeparateGroundNetRows({
+  netConnection,
+  netPins,
+  pin1,
+  pin2,
+}: {
+  netConnection?: InputNetConnection
+  netPins: Array<InputPin & { chipId: string }>
+  pin1: InputPin & { chipId: string }
+  pin2: InputPin & { chipId: string }
+}) {
+  if (!netConnection?.isGround || pin1.chipId === pin2.chipId) return false
+  if (Math.abs(pin1.y - pin2.y) <= SAME_RAIL_Y_TOLERANCE) return false
+
+  // Net labels preserve ground connectivity without a cross-row MSP edge.
+  return (
+    isGroupedHorizontalRail({ pin: pin1, netPins }) &&
+    isGroupedHorizontalRail({ pin: pin2, netPins })
+  )
+}

package/lib/types/InputProblem.ts

@@ -98,6 +98,9 @@ export 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

package/package.json

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