@tscircuit/schematic-trace-solver 0.0.160 → 0.0.162

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/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/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.160",
+  "version": "0.0.162",
   "type": "module",
   "scripts": {
     "start": "cosmos",