@tscircuit/schematic-trace-solver 0.0.189 → 0.0.191

package/lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts

@@ -4,6 +4,8 @@ import type { InputProblem } from "lib/types/InputProblem"
 import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { minimizeTurnsWithFilteredLabels } from "lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels"
+import { preservesLabelAnchors } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors"
 import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
 import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
@@ -274,6 +276,33 @@ export function* getLocalTraceLabelShifts(
           }
         }
         if (blocked) continue
+        // A shifted leg can coincide with a redundant bend on another net.
+        // Try removing that bend with the existing cleanup, then validate
+        // both changed routes together below before yielding the proposal.
+        for (const [index, other] of traces.entries()) {
+          if (
+            other.globalConnNetId === trace.globalConnNetId ||
+            simplifyPath(other.tracePath).length <= 4 ||
+            !shiftedPaths.some((path) =>
+              doesPathCoincideWithTraces(path, [other]),
+            )
+          )
+            continue
+          const simplified = minimizeTurnsWithFilteredLabels({
+            inputProblem,
+            traces: [...traces, ...terminalTraces],
+            targetMspConnectionPairId: other.mspPairId,
+            allLabelPlacements: [...labels, ...fixedLabels],
+            mergedLabelNetIdMap: {},
+            paddingBuffer: CLEARANCE,
+          })
+          if (
+            simplifyPath(simplified.tracePath).length <
+              simplifyPath(other.tracePath).length &&
+            preservesLabelAnchors(labels, [other], [simplified])
+          )
+            traces[index] = simplified
+        }
         for (const [index, proposed] of traces.entries()) {
           const original = output.traces[index]!
           if (proposed === original) continue

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -14,6 +14,7 @@ import type {
 import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
 import { BaseSolver } from "../BaseSolver/BaseSolver"
+import { getParallelNetLabelPolicy } from "./getParallelNetLabelPolicy"
 import { getGroundConnectionPolicy } from "../MspConnectionPairSolver/getGroundConnectionPolicy"
 import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
@@ -180,6 +181,11 @@ export class LongDistancePairSolver extends BaseSolver {
 
     const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
     this.netConnMap = netConnMap
+    const canRecoverParallelPair = getParallelNetLabelPolicy(
+      inputProblem,
+      netConnMap,
+      primaryConnectedPinIds,
+    )
     const pinMap = new Map<PinId, InputPin & { chipId: string }>()
     for (const chip of inputProblem.chips) {
       this.chipMap[chip.chipId] = chip
@@ -226,6 +232,7 @@ export class LongDistancePairSolver extends BaseSolver {
             const targetPin = pinMap.get(otherPinId)
             if (!targetPin) return [] // Gracefully handle missing pins
             if (!canRouteGroundPair(sourcePin.pinId, targetPin.pinId)) return []
+            if (!canRecoverParallelPair(sourcePin, targetPin)) return []
             const isNamedTwoPinConnection = inputProblem.netConnections.some(
               (connection) =>
                 connection.pinIds.length === 2 &&

package/lib/solvers/LongDistancePairSolver/getParallelNetLabelPolicy.ts

@@ -0,0 +1,98 @@
+import { ConnectivityMap } from "connectivity-map"
+import type { InputPin, InputProblem, PinId } from "lib/types/InputProblem"
+import { DEFAULT_MAX_MSP_PAIR_DISTANCE } from "../MspConnectionPairSolver/MspConnectionPairSolver"
+import { getParallelRailPairs } from "../MspConnectionPairSolver/getParallelRailPairs"
+
+/** Keep distant parallel rail/ground branches local during trace recovery. */
+export const getParallelNetLabelPolicy = (
+  inputProblem: InputProblem,
+  netConnMap: ConnectivityMap,
+  connectedPinIds: ReadonlySet<PinId>,
+) => {
+  const maxDistance =
+    inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
+  const { extendedRailPinIds, separatedRailPinIds } = getParallelRailPairs(
+    inputProblem,
+    netConnMap,
+    maxDistance,
+  )
+  const groundNetIds = new Set<string>()
+  const namedPinIds = new Set<PinId>()
+  for (const connection of inputProblem.netConnections) {
+    const netId = netConnMap.getNetConnectedToId(connection.netId)
+    if (!netId) continue
+    for (const pinId of connection.pinIds) namedPinIds.add(pinId)
+    if (connection.isGround) {
+      groundNetIds.add(netId)
+    }
+  }
+
+  // Older inputs omit symbol metadata. Identify parallel two-terminal
+  // branches by their two named nets, without inferring capacitor types or
+  // requiring identical pin positions, sizes, or orientations.
+  const banks = new Map<string, PinId[][]>()
+  for (const chip of inputProblem.chips) {
+    // Preserve branches that use source wires or already participate in
+    // local routing. This policy only selects standalone named-net branches.
+    if (
+      chip.pins.length !== 2 ||
+      !chip.pins.every((pin) => namedPinIds.has(pin.pinId)) ||
+      chip.pins.some(
+        (pin) =>
+          connectedPinIds.has(pin.pinId) && !extendedRailPinIds.has(pin.pinId),
+      )
+    )
+      continue
+    const [first, second] = chip.pins.map((pin) =>
+      netConnMap.getNetConnectedToId(pin.pinId),
+    )
+    if (
+      !first ||
+      !second ||
+      first === second ||
+      groundNetIds.has(first) === groundNetIds.has(second)
+    ) {
+      continue
+    }
+    const key = JSON.stringify([
+      chip.sectionId ?? null,
+      ...[first, second].sort(),
+    ])
+    const bank = banks.get(key) ?? []
+    bank.push(chip.pins.map((pin) => pin.pinId))
+    banks.set(key, bank)
+  }
+  const bankPinIds = new Set(
+    [...banks.values()].filter((bank) => bank.length > 1).flat(2),
+  )
+  // Both shared rails and terminals separated by a large gap stay local.
+  // Do not recover wires between them or to distant IC pins.
+  for (const pinId of [...extendedRailPinIds, ...separatedRailPinIds]) {
+    bankPinIds.add(pinId)
+  }
+
+  // Explicit source wires may be recovered even beyond the local distance.
+  // Sharing a net ID alone does not request a physical wire between branches.
+  const physicalConnMap = new ConnectivityMap({})
+  for (const connection of inputProblem.directConnections) {
+    if (connection.netLabelWidth === undefined) {
+      physicalConnMap.addConnections([connection.pinIds])
+    }
+  }
+
+  return (first: InputPin, second: InputPin): boolean => {
+    if (!bankPinIds.has(first.pinId) && !bankPinIds.has(second.pinId))
+      return true
+    if (
+      Math.abs(first.x - second.x) + Math.abs(first.y - second.y) <=
+      maxDistance
+    ) {
+      return true
+    }
+    const physicalNetId = physicalConnMap.getNetConnectedToId(first.pinId)
+    return (
+      physicalNetId !== undefined &&
+      physicalNetId === physicalConnMap.getNetConnectedToId(second.pinId)
+    )
+  }
+}

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -17,6 +17,7 @@ import { getGroundConnectionPolicy } from "./getGroundConnectionPolicy"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 import { getLabeledConnectionRouteReason } from "./isLabeledPeripheralConnection"
 import { shouldSeparateGroundNetRows } from "./shouldSeparateGroundNetRows"
+import { getParallelRailPairs, getRailPairKey } from "./getParallelRailPairs"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -48,6 +49,7 @@ export class MspConnectionPairSolver extends BaseSolver {
   userNetIdByPinId: Record<string, string | undefined>
   directConnectionPinPairKeys: Set<string>
   private canRouteGroundPair: (firstPinId: PinId, secondPinId: PinId) => boolean
+  private parallelRailPairKeys: Set<string>
 
   constructor({ inputProblem }: { inputProblem: InputProblem }) {
     super()
@@ -61,6 +63,11 @@ export class MspConnectionPairSolver extends BaseSolver {
       getConnectivityMapsFromInputProblem(inputProblem)
     this.dcConnMap = directConnMap
     this.globalConnMap = netConnMap
+    this.parallelRailPairKeys = getParallelRailPairs(
+      inputProblem,
+      netConnMap,
+      this.maxMspPairDistance,
+    ).pairKeys
 
     this.pinMap = {}
     for (const chip of inputProblem.chips) {
@@ -145,6 +152,7 @@ export class MspConnectionPairSolver extends BaseSolver {
       })
       if (
         pairDistance > this.maxMspPairDistance &&
+        !this.parallelRailPairKeys.has(getRailPairKey(pin1!, pin2!)) &&
         !labeledConnectionRouteReason
       ) {
         // Too far apart; skip creating an MSP pair for this net
@@ -203,8 +211,9 @@ export class MspConnectionPairSolver extends BaseSolver {
       (pinId) => this.pinMap[pinId]!,
     )
     const msp = getOrthogonalMinimumSpanningTree(directlyConnectedPinObjects, {
-      maxDistance: this.maxMspPairDistance,
       forbidEdge: (a, b) =>
+        (Math.abs(a.x - b.x) + Math.abs(a.y - b.y) > this.maxMspPairDistance &&
+          !this.parallelRailPairKeys.has(getRailPairKey(a.pinId, b.pinId))) ||
         !this.canRouteGroundPair(a.pinId, b.pinId) ||
         shouldSeparateGroundNetRows({
           netConnection,
@@ -222,7 +231,20 @@ export class MspConnectionPairSolver extends BaseSolver {
         }),
     })
 
-    for (const [pin1, pin2] of msp) {
+    for (let [pin1, pin2] of msp) {
+      // Extended rails replace long-distance recovery, which visits pins in
+      // connectivity order. Preserve that order so an unchanged rail keeps
+      // its label at the same endpoint.
+      if (
+        this.parallelRailPairKeys.has(getRailPairKey(pin1!, pin2!)) &&
+        Math.abs(this.pinMap[pin1!]!.x - this.pinMap[pin2!]!.x) +
+          Math.abs(this.pinMap[pin1!]!.y - this.pinMap[pin2!]!.y) >
+          this.maxMspPairDistance &&
+        directlyConnectedPins.indexOf(pin1!) >
+          directlyConnectedPins.indexOf(pin2!)
+      ) {
+        ;[pin1, pin2] = [pin2, pin1]
+      }
       const p1Obj = this.pinMap[pin1!]!
       const p2Obj = this.pinMap[pin2!]!
       if (

package/lib/solvers/MspConnectionPairSolver/getParallelRailPairs.ts

@@ -0,0 +1,178 @@
+import type { ConnectivityMap } from "connectivity-map"
+import type { InputPin, InputProblem, PinId } from "lib/types/InputProblem"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+
+const EPS = 1e-6
+// Component scale supplies a minimum allowance, including two-capacitor rows
+// with no neighboring pitch to compare against.
+const MAX_RAIL_SPACING_IN_TERMINAL_SPANS = 4
+const MAX_RAIL_SPACING_MULTIPLIER = 2
+
+export const getRailPairKey = (first: PinId, second: PinId) =>
+  JSON.stringify([first, second].sort())
+
+/** Adjacent, outward-facing terminals can share a straight decoupling rail. */
+export const getParallelRailPairs = (
+  inputProblem: InputProblem,
+  netConnMap: ConnectivityMap,
+  maxMspPairDistance: number,
+) => {
+  const groundNetIds = new Set<string>()
+  const namedPinIds = new Set<PinId>()
+  const wiredPinIds = new Set<PinId>()
+  for (const connection of inputProblem.netConnections) {
+    for (const pinId of connection.pinIds) namedPinIds.add(pinId)
+    const netId = netConnMap.getNetConnectedToId(connection.netId)
+    if (netId && connection.isGround) {
+      groundNetIds.add(netId)
+    }
+  }
+  for (const connection of inputProblem.directConnections) {
+    const pinIds =
+      connection.netLabelWidth === undefined ? wiredPinIds : namedPinIds
+    for (const pinId of connection.pinIds) pinIds.add(pinId)
+  }
+
+  const rows: Array<{
+    sectionId?: string
+    direction: string
+    coordinate: number
+    axis: "x" | "y"
+    pins: Array<InputPin & { chipId: string; oppositeCoordinate: number }>
+  }> = []
+  for (const chip of inputProblem.chips) {
+    if (
+      chip.pins.length !== 2 ||
+      (chip.symbolName && !chip.symbolName.startsWith("capacitor")) ||
+      !chip.pins.every((pin) => namedPinIds.has(pin.pinId)) ||
+      chip.pins.some((pin) => wiredPinIds.has(pin.pinId))
+    )
+      continue
+    const nets = chip.pins.map((pin) =>
+      netConnMap.getNetConnectedToId(pin.pinId),
+    )
+    if (
+      !nets[0] ||
+      !nets[1] ||
+      nets[0] === nets[1] ||
+      groundNetIds.has(nets[0]) === groundNetIds.has(nets[1])
+    )
+      continue
+    const directions = chip.pins.map(
+      (pin) => pin._facingDirection ?? getPinDirection(pin, chip),
+    )
+    if (
+      directions[0]![0] !== directions[1]![0] ||
+      directions[0] === directions[1]
+    )
+      continue
+    const axis = directions[0]![0] as "x" | "y"
+    const along = axis === "x" ? "y" : "x"
+    if (Math.abs(chip.pins[0]![along] - chip.pins[1]![along]) > EPS) continue
+
+    for (const [index, pin] of chip.pins.entries()) {
+      const direction = directions[index]!
+      let row = rows.find(
+        (candidate) =>
+          candidate.sectionId === chip.sectionId &&
+          candidate.direction === direction &&
+          Math.abs(candidate.coordinate - pin[axis]) <= EPS,
+      )
+      if (!row) {
+        row = {
+          sectionId: chip.sectionId,
+          direction,
+          coordinate: pin[axis],
+          axis,
+          pins: [],
+        }
+        rows.push(row)
+      }
+      row.pins.push({
+        ...pin,
+        chipId: chip.chipId,
+        oppositeCoordinate: chip.pins[1 - index]![axis],
+      })
+    }
+  }
+
+  const pairKeys = new Set<string>()
+  const extendedRailPinIds = new Set<PinId>()
+  const separatedRailPinIds = new Set<PinId>()
+  for (const row of rows) {
+    const along = row.axis === "x" ? "y" : "x"
+    row.pins.sort(
+      (a, b) => a[along] - b[along] || a.pinId.localeCompare(b.pinId),
+    )
+    for (let index = 1; index < row.pins.length; index++) {
+      const first = row.pins[index - 1]!
+      const second = row.pins[index]!
+      const spacing = second[along] - first[along]
+      // A regular row may be widely spaced. Split at gaps that are much
+      // larger than the neighboring pitch, rather than imposing a fixed cap.
+      const neighboringSpacings = [
+        first[along] - (row.pins[index - 2]?.[along] ?? first[along]),
+        (row.pins[index + 1]?.[along] ?? second[along]) - second[along],
+      ].filter((gap) => gap > EPS)
+      const maxRailSpacing = Math.max(
+        MAX_RAIL_SPACING_MULTIPLIER * maxMspPairDistance,
+        MAX_RAIL_SPACING_MULTIPLIER *
+          (neighboringSpacings.length ? Math.min(...neighboringSpacings) : 0),
+        MAX_RAIL_SPACING_IN_TERMINAL_SPANS *
+          Math.max(
+            Math.abs(first[row.axis] - first.oppositeCoordinate),
+            Math.abs(second[row.axis] - second.oppositeCoordinate),
+          ),
+      )
+      // A different supply in between ends the supply rail; GND can continue.
+      if (
+        spacing <= EPS ||
+        netConnMap.getNetConnectedToId(first.pinId) !==
+          netConnMap.getNetConnectedToId(second.pinId)
+      )
+        continue
+      if (spacing > maxRailSpacing + EPS) {
+        // Recovery must retain this separation even when each capacitor has
+        // a different supply and does not belong to a same-net branch bank.
+        separatedRailPinIds.add(first.pinId)
+        separatedRailPinIds.add(second.pinId)
+        continue
+      }
+      // A component between the terminals breaks the row. Leave obstacle
+      // detours to ordinary local routing instead of extending this exception.
+      const minAcross = Math.min(
+        first[row.axis],
+        second[row.axis],
+        first.oppositeCoordinate,
+        second.oppositeCoordinate,
+      )
+      const maxAcross = Math.max(
+        first[row.axis],
+        second[row.axis],
+        first.oppositeCoordinate,
+        second.oppositeCoordinate,
+      )
+      if (
+        inputProblem.chips.some((chip) => {
+          if (chip.chipId === first.chipId || chip.chipId === second.chipId)
+            return false
+          const acrossSize = row.axis === "x" ? chip.width : chip.height
+          const alongSize = along === "x" ? chip.width : chip.height
+          return (
+            chip.center[row.axis] + acrossSize / 2 >= minAcross - EPS &&
+            chip.center[row.axis] - acrossSize / 2 <= maxAcross + EPS &&
+            chip.center[along] + alongSize / 2 > first[along] + EPS &&
+            chip.center[along] - alongSize / 2 < second[along] - EPS
+          )
+        })
+      )
+        continue
+      pairKeys.add(getRailPairKey(first.pinId, second.pinId))
+      if (spacing > maxMspPairDistance) {
+        extendedRailPinIds.add(first.pinId)
+        extendedRailPinIds.add(second.pinId)
+      }
+    }
+  }
+  return { pairKeys, extendedRailPinIds, separatedRailPinIds }
+}

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -1,6 +1,7 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { getParallelNetLabelPolicy } from "lib/solvers/LongDistancePairSolver/getParallelNetLabelPolicy"
 import { doesPairCrossRestrictedCenterLines } from "lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
@@ -84,6 +85,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
   private readonly recoveredTraceIds = new Set<string>()
   private chipMap: Record<ChipId, InputChip>
   private pinMap: Map<PinId, TraceRecoveryPin>
+  private canRecoverParallelPair: ReturnType<typeof getParallelNetLabelPolicy>
   private queuedCandidates: CandidatePair[]
   private currentCandidate: CandidatePair | null = null
   declare activeSubSolver: SchematicTraceSingleLineSolver2 | null
@@ -99,6 +101,15 @@ export class NetLabelToTraceSolver extends BaseSolver {
     )
     this.chipMap = chipMap
     this.pinMap = pinMap
+    this.canRecoverParallelPair = getParallelNetLabelPolicy(
+      this.inputProblem,
+      getConnectivityMapsFromInputProblem(this.inputProblem).netConnMap,
+      new Set(
+        input.traces
+          .filter((trace) => trace.pinIds.length > 1)
+          .flatMap((trace) => trace.pinIds),
+      ),
+    )
 
     this.queuedCandidates = this.buildCandidatePairs()
     this.stats.candidateCount = this.queuedCandidates.length
@@ -180,6 +191,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
           const firstPin = this.pinMap.get(firstLabel.pinIds[0]!)
           const secondPin = this.pinMap.get(secondLabel.pinIds[0]!)
           if (!firstPin || !secondPin) continue
+          if (!this.canRecoverParallelPair(firstPin, secondPin)) continue
           const perpendicularOffset = getPerpendicularOffset(
             firstPin,
             secondPin,
@@ -354,6 +366,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
               const firstPin = this.pinMap.get(firstPinId)
               const secondPin = this.pinMap.get(secondPinId)
               if (!firstPin || !secondPin) continue
+              if (!this.canRecoverParallelPair(firstPin, secondPin)) continue
               if (isDirectConnection && firstPin.chipId === secondPin.chipId)
                 continue
               const perpendicularOffset = getPerpendicularOffset(

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -7,7 +7,6 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
-import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
 
 interface SameNetJunctionAlignmentSolverInput {
@@ -32,18 +31,14 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
 
   override _step() {
     const alignment = alignSameNetJunctions(this.input)
-    const cycleCollapse = collapseSameNetCycles({
-      traces: alignment.traces,
-      netLabelPlacements: alignment.netLabelPlacements,
-    })
-    this.outputTraces = cycleCollapse.traces
+    this.outputTraces = alignment.traces
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: cycleCollapse.traces,
-      netLabelPlacements: cycleCollapse.netLabelPlacements,
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
     })
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount
-    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount
+    this.stats.collapsedCycleCount = alignment.collapsedCycleCount
     this.solved = true
   }
 

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -34,6 +34,7 @@ import {
   isCoordinateOnPinFacingSide,
 } from "./findNearestSharedPinExitRail"
 import { collapseRedundantSharedEndpointStubs } from "./collapseRedundantSharedEndpointStubs"
+import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { getSharedPin } from "./getSharedPin"
 
 interface AlignSameNetJunctionsInput {
@@ -1314,17 +1315,24 @@ export const alignSameNetJunctions = ({
     }
   }
 
-  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+  // Shared-stub collapse can remove the common pin from one trace path, so
+  // collapse cycles while both paths still expose their shared endpoint.
+  const cycleCollapse = collapseSameNetCycles({
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
+  })
+  outputTraces = collapseRedundantSharedEndpointStubs({
+    traces: cycleCollapse.traces,
+    netLabelPlacements: cycleCollapse.netLabelPlacements,
     netLabelConnectorTraceIds,
     multiPinNetPinIds: getMultiPinNetPinIds(inputProblem),
   })
-  outputTraces = collapsedSharedEndpointStubs
+  outputNetLabelPlacements = cycleCollapse.netLabelPlacements
 
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
     alignedJunctionCount,
+    collapsedCycleCount: cycleCollapse.collapsedCycleCount,
   }
 }

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts

@@ -11,6 +11,7 @@ import {
   pointsEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { findPerpendicularPathCrossings } from "lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 import { getSharedPin } from "./getSharedPin"
 import {
   pathEntersAnyNetLabel,
@@ -100,6 +101,25 @@ const getPerpendicularPathCrossings = (
   return crossings
 }
 
+const buildCollapsedSelfCyclePath = (
+  path: Point[],
+  firstSegmentIndex: number,
+  secondSegmentIndex: number,
+) => {
+  const intersectionPoint = getSegmentIntersection(
+    path[firstSegmentIndex]!,
+    path[firstSegmentIndex + 1]!,
+    path[secondSegmentIndex]!,
+    path[secondSegmentIndex + 1]!,
+  )
+  if (!intersectionPoint) return path
+  return simplifyPath([
+    ...path.slice(0, firstSegmentIndex + 1),
+    intersectionPoint,
+    ...path.slice(secondSegmentIndex + 1),
+  ])
+}
+
 const buildCollapsedCyclePath = ({
   targetTrace,
   targetPath,
@@ -209,6 +229,60 @@ const getBestCycleCollapseCandidate = ({
   const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace])
   let bestCandidate: CycleCollapseCandidate | null = null
 
+  const considerTracePath = (tracePath: Point[]) => {
+    const candidateTrace = { ...targetTrace, tracePath }
+    const candidateTargetVisibleLength = getVisibleTraceLength([candidateTrace])
+    if (
+      candidateTargetVisibleLength >
+      baselineTargetVisibleLength + TRACE_LENGTH_EPSILON
+    ) {
+      return
+    }
+    const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse({
+      targetTrace,
+      tracePath,
+      netLabelPlacements,
+    })
+    if (!candidateNetLabelPlacements) return
+
+    const candidateNetTraces = sameNetTraces.map((trace) => {
+      if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace
+      return trace
+    })
+    const netVisibleLength = getVisibleTraceLength(candidateNetTraces)
+    if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+      return
+    }
+    const candidate: CycleCollapseCandidate = {
+      tracePath,
+      netLabelPlacements: candidateNetLabelPlacements,
+      netVisibleLength,
+      netVisibleSegmentCount: getVisibleTraceSegmentCount(candidateNetTraces),
+    }
+    if (candidateIsBetter(candidate, bestCandidate)) {
+      bestCandidate = candidate
+    }
+  }
+
+  // Comparing a path with itself reports each crossing in both directions.
+  const selfCrossings = findPerpendicularPathCrossings(
+    targetTrace.tracePath,
+    targetTrace.tracePath,
+    { includeTerminalSegments: true },
+  ).filter(
+    ({ pathSegmentIndex, otherPathSegmentIndex }) =>
+      pathSegmentIndex < otherPathSegmentIndex,
+  )
+  for (const crossing of selfCrossings) {
+    considerTracePath(
+      buildCollapsedSelfCyclePath(
+        targetTrace.tracePath,
+        crossing.pathSegmentIndex,
+        crossing.otherPathSegmentIndex,
+      ),
+    )
+  }
+
   for (const donorTrace of sameNetTraces) {
     if (donorTrace.mspPairId === targetTrace.mspPairId) continue
     const sharedPin = getSharedPin({
@@ -228,44 +302,7 @@ const getBestCycleCollapseCandidate = ({
         donorPath,
         crossing,
       })
-      const candidateTrace = { ...targetTrace, tracePath }
-      const candidateTargetVisibleLength = getVisibleTraceLength([
-        candidateTrace,
-      ])
-      if (
-        candidateTargetVisibleLength >
-        baselineTargetVisibleLength + TRACE_LENGTH_EPSILON
-      ) {
-        continue
-      }
-      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
-        {
-          targetTrace,
-          tracePath,
-          netLabelPlacements,
-        },
-      )
-      if (!candidateNetLabelPlacements) continue
-
-      const candidateNetTraces = sameNetTraces.map((trace) => {
-        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace
-        return trace
-      })
-      const netVisibleLength = getVisibleTraceLength(candidateNetTraces)
-      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
-        continue
-      }
-      const netVisibleSegmentCount =
-        getVisibleTraceSegmentCount(candidateNetTraces)
-      const candidate = {
-        tracePath,
-        netLabelPlacements: candidateNetLabelPlacements,
-        netVisibleLength,
-        netVisibleSegmentCount,
-      }
-      if (candidateIsBetter(candidate, bestCandidate)) {
-        bestCandidate = candidate
-      }
+      considerTracePath(tracePath)
     }
   }
 

package/package.json

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