@tscircuit/schematic-trace-solver 0.0.158 → 0.0.160

package/lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts

@@ -485,13 +485,15 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
         inlineBounds.some((bounds) =>
           pathIntersectsBounds(connector.tracePath, bounds),
         ) ||
-        inputProblem.chips.some((chip) =>
-          pathIntersectsBounds(connector.tracePath, {
-            minX: chip.center.x - chip.width / 2,
-            maxX: chip.center.x + chip.width / 2,
-            minY: chip.center.y - chip.height / 2,
-            maxY: chip.center.y + chip.height / 2,
-          }),
+        inputProblem.chips.some(
+          (chip) =>
+            !ownerChipIds.has(chip.chipId) &&
+            pathIntersectsBounds(connector.tracePath, {
+              minX: chip.center.x - chip.width / 2,
+              maxX: chip.center.x + chip.width / 2,
+              minY: chip.center.y - chip.height / 2,
+              maxY: chip.center.y + chip.height / 2,
+            }),
         ) ||
         (inputProblem.textBoxes ?? []).some((textBox) =>
           pathIntersectsBounds(connector.tracePath, getTextBoxBounds(textBox)),

package/lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels.ts

@@ -0,0 +1,295 @@
+import type { Bounds, Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+
+type StubDirection = "x+" | "x-" | "y+" | "y-"
+
+const LABEL_CLEARANCE = 0.05
+const MAX_OUTWARD_DISTANCE = 5
+
+const getStubDirection = (path: [Point, Point]): StubDirection => {
+  const [start, end] = path
+  if (Math.abs(end.x - start.x) >= Math.abs(end.y - start.y)) {
+    return end.x >= start.x ? "x+" : "x-"
+  }
+  return end.y >= start.y ? "y+" : "y-"
+}
+
+const getLabelBounds = (placement: {
+  center: Point
+  width: number
+  height: number
+  axis?: "x" | "y"
+}): Bounds => {
+  const renderedWidth =
+    placement.axis === "y" ? placement.height : placement.width
+  const renderedHeight =
+    placement.axis === "y" ? placement.width : placement.height
+  return {
+    minX: placement.center.x - renderedWidth / 2,
+    maxX: placement.center.x + renderedWidth / 2,
+    minY: placement.center.y - renderedHeight / 2,
+    maxY: placement.center.y + renderedHeight / 2,
+  }
+}
+
+const getPathBounds = (path: Point[]): Bounds => ({
+  minX: Math.min(...path.map((point) => point.x)),
+  maxX: Math.max(...path.map((point) => point.x)),
+  minY: Math.min(...path.map((point) => point.y)),
+  maxY: Math.max(...path.map((point) => point.y)),
+})
+
+const doesPathIntersectBounds = (path: Point[], bounds: Bounds) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    if (
+      boundsOverlap(getPathBounds([path[index]!, path[index + 1]!]), bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const shiftPoint = (
+  point: Point,
+  direction: StubDirection,
+  distance: number,
+): Point => {
+  switch (direction) {
+    case "x+":
+      return { x: point.x + distance, y: point.y }
+    case "x-":
+      return { x: point.x - distance, y: point.y }
+    case "y+":
+      return { x: point.x, y: point.y + distance }
+    case "y-":
+      return { x: point.x, y: point.y - distance }
+  }
+}
+
+const shiftTerminalPlacement = (
+  placement: InlineNetLabelPlacement,
+  direction: StubDirection,
+  distance: number,
+): InlineNetLabelPlacement => {
+  const [start, end] = placement.stubTracePath!
+  const shiftedEnd = shiftPoint(end, direction, distance)
+  return {
+    ...placement,
+    stubTracePath: [start, shiftedEnd],
+    anchorPoint: shiftPoint(placement.anchorPoint, direction, distance),
+    center: shiftPoint(placement.center, direction, distance),
+  }
+}
+
+const getRequiredOutwardDistance = (
+  movingBounds: Bounds,
+  obstacleBounds: Bounds,
+  direction: StubDirection,
+) => {
+  switch (direction) {
+    case "x+":
+      return obstacleBounds.maxX - movingBounds.minX + LABEL_CLEARANCE
+    case "x-":
+      return movingBounds.maxX - obstacleBounds.minX + LABEL_CLEARANCE
+    case "y+":
+      return obstacleBounds.maxY - movingBounds.minY + LABEL_CLEARANCE
+    case "y-":
+      return movingBounds.maxY - obstacleBounds.minY + LABEL_CLEARANCE
+  }
+}
+
+/**
+ * Moves a row of terminal inline labels farther outward when a retained
+ * anchored label occupies their near-pin column. Every terminal on the same
+ * component side moves together, preserving the row's alignment. Only the
+ * newly added stub segment and shifted text are collision-checked; the
+ * original pin-to-label segment was already validated when it was created.
+ * All points and bounds are in schematic-world millimetres, with +x right and
+ * +y up.
+ */
+export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
+  inputProblem,
+  traces,
+  anchoredNetLabelPlacements,
+  inlineNetLabelPlacements,
+}: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  anchoredNetLabelPlacements: NetLabelPlacement[]
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+}): {
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+  movedGroupCount: number
+} => {
+  const chipIdByPinId = new Map<string, string>()
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) chipIdByPinId.set(pin.pinId, chip.chipId)
+  }
+
+  const groups = new Map<
+    string,
+    Array<{
+      placementIndex: number
+      placement: InlineNetLabelPlacement
+      direction: StubDirection
+      ownerChipId?: string
+    }>
+  >()
+  for (const [
+    placementIndex,
+    placement,
+  ] of inlineNetLabelPlacements.entries()) {
+    if (!placement.stubTracePath || placement.pinIds.length !== 1) continue
+    const direction = getStubDirection(placement.stubTracePath)
+    const ownerChipId = chipIdByPinId.get(placement.pinIds[0]!)
+    const groupKey = `${ownerChipId ?? placement.pinIds[0]}::${direction}`
+    const group = groups.get(groupKey) ?? []
+    group.push({ placementIndex, placement, direction, ownerChipId })
+    groups.set(groupKey, group)
+  }
+
+  const outputPlacements = [...inlineNetLabelPlacements]
+  let movedGroupCount = 0
+
+  for (const group of groups.values()) {
+    const groupPlacementIndices = new Set(
+      group.map(({ placementIndex }) => placementIndex),
+    )
+    const fixedInlinePlacements = outputPlacements.filter(
+      (_, placementIndex) => !groupPlacementIndices.has(placementIndex),
+    )
+    const direction = group[0]!.direction
+    let distance = 0
+
+    for (
+      let iteration = 0;
+      iteration <= anchoredNetLabelPlacements.length;
+      iteration++
+    ) {
+      let requiredAdditionalDistance = 0
+      for (const { placement } of group) {
+        const shiftedPlacement = shiftTerminalPlacement(
+          placement,
+          direction,
+          distance,
+        )
+        const shiftedBounds = getLabelBounds(shiftedPlacement)
+        for (const anchoredPlacement of anchoredNetLabelPlacements) {
+          if (anchoredPlacement.globalConnNetId === placement.globalConnNetId) {
+            continue
+          }
+          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          if (!boundsOverlap(shiftedBounds, anchoredBounds)) continue
+          requiredAdditionalDistance = Math.max(
+            requiredAdditionalDistance,
+            getRequiredOutwardDistance(
+              shiftedBounds,
+              anchoredBounds,
+              direction,
+            ),
+          )
+        }
+      }
+      if (requiredAdditionalDistance <= 0) break
+      distance += requiredAdditionalDistance
+    }
+
+    if (distance <= 0 || distance > MAX_OUTWARD_DISTANCE) continue
+
+    const proposals = group.map(({ placement }) =>
+      shiftTerminalPlacement(placement, direction, distance),
+    )
+    const hasConflict = proposals.some((proposal, proposalIndex) => {
+      const originalPlacement = group[proposalIndex]!.placement
+      const originalEnd = originalPlacement.stubTracePath![1]
+      const shiftedEnd = proposal.stubTracePath![1]
+      const addedStubSegment: [Point, Point] = [originalEnd, shiftedEnd]
+      const labelBounds = getLabelBounds(proposal)
+      const ownerChipId = group[proposalIndex]!.ownerChipId
+
+      if (
+        anchoredNetLabelPlacements.some((anchoredPlacement) => {
+          if (anchoredPlacement.globalConnNetId === proposal.globalConnNetId) {
+            return false
+          }
+          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          return (
+            boundsOverlap(labelBounds, anchoredBounds) ||
+            doesPathIntersectBounds(addedStubSegment, anchoredBounds)
+          )
+        })
+      ) {
+        return true
+      }
+
+      for (const chip of inputProblem.chips) {
+        if (chip.chipId === ownerChipId) continue
+        const chipBounds: Bounds = {
+          minX: chip.center.x - chip.width / 2,
+          maxX: chip.center.x + chip.width / 2,
+          minY: chip.center.y - chip.height / 2,
+          maxY: chip.center.y + chip.height / 2,
+        }
+        if (
+          boundsOverlap(labelBounds, chipBounds) ||
+          doesPathIntersectBounds(addedStubSegment, chipBounds)
+        ) {
+          return true
+        }
+      }
+
+      for (const textBox of inputProblem.textBoxes ?? []) {
+        const textBounds = getTextBoxBounds(textBox)
+        if (
+          boundsOverlap(labelBounds, textBounds) ||
+          doesPathIntersectBounds(addedStubSegment, textBounds)
+        ) {
+          return true
+        }
+      }
+
+      for (const trace of traces) {
+        if (trace.globalConnNetId === proposal.globalConnNetId) continue
+        if (
+          doesPathIntersectBounds(trace.tracePath, labelBounds) ||
+          doesPathIntersectBounds(
+            trace.tracePath,
+            getPathBounds(addedStubSegment),
+          )
+        ) {
+          return true
+        }
+      }
+
+      for (const fixedPlacement of fixedInlinePlacements) {
+        const fixedBounds = getLabelBounds(fixedPlacement)
+        if (
+          boundsOverlap(labelBounds, fixedBounds) ||
+          doesPathIntersectBounds(addedStubSegment, fixedBounds) ||
+          (fixedPlacement.stubTracePath &&
+            doesPathIntersectBounds(fixedPlacement.stubTracePath, labelBounds))
+        ) {
+          return true
+        }
+      }
+
+      return false
+    })
+
+    if (hasConflict) continue
+    for (const [groupIndex, { placementIndex }] of group.entries()) {
+      outputPlacements[placementIndex] = proposals[groupIndex]!
+    }
+    movedGroupCount++
+  }
+
+  return {
+    inlineNetLabelPlacements: outputPlacements,
+    movedGroupCount,
+  }
+}

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/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -10,6 +10,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { getConnectivityMapsFromInputProblem } from "../MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
+import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents"
 
 /**
  * A group of traces that have at least one overlapping segment and
@@ -164,41 +165,12 @@ export class NetLabelPlacementSolver extends BaseSolver {
       ) as string[]
       const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id))
 
-      // Build adjacency from solved traces (edges)
-      const adj: Record<string, Set<string>> = {}
-      for (const pid of pinsInNet) adj[pid] = new Set()
-      for (const t of byGlobal[globalConnNetId] ?? []) {
-        const a = t.pins[0].pinId
-        const b = t.pins[1].pinId
-        if (adj[a] && adj[b]) {
-          adj[a].add(b)
-          adj[b].add(a)
-        }
-      }
-
-      // Find connected components based on trace edges
-      const visited = new Set<string>()
-      for (const pid of pinsInNet) {
-        if (visited.has(pid)) continue
-        const stack = [pid]
-        const component = new Set<string>()
-        visited.add(pid)
-        while (stack.length > 0) {
-          const u = stack.pop()!
-          component.add(u)
-          for (const v of adj[u] ?? []) {
-            if (!visited.has(v)) {
-              visited.add(v)
-              stack.push(v)
-            }
-          }
-        }
-
-        // Collect traces fully inside this component
-        const compTraces = (byGlobal[globalConnNetId] ?? []).filter(
-          (t) =>
-            component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId),
-        )
+      for (const traceConnectedComponent of getTraceConnectedPinComponents({
+        pinIds: pinsInNet,
+        traces: byGlobal[globalConnNetId] ?? [],
+      })) {
+        const component = new Set(traceConnectedComponent.pinIds)
+        const compTraces = traceConnectedComponent.traces
 
         if (compTraces.length > 0) {
           // This routed trace exists specifically because two endpoint labels

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
   }