@tscircuit/schematic-trace-solver 0.0.60 → 0.0.62

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -20,6 +20,7 @@ import {
   isYOrientation,
   rangesOverlap,
   rectsOverlap,
+  simplifyOrthogonalPath,
   traceCrossesBoundsInterior,
   tracePathCrossesAnyBounds,
   tracePathCrossesAnyTrace,
@@ -127,7 +128,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
   private applyCandidate(
     label: NetLabelPlacement,
-    candidate: CandidateLabel,
+    candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
     this.outputNetLabelPlacements[labelIndex] = {
@@ -139,14 +140,33 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
   private addConnectorTrace(
     label: NetLabelPlacement,
-    candidate: CandidateLabel,
+    candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
-    const tracePath = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation,
-    )
+    let tracePath: Point[]
+
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation)
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
+      }
+      tracePath = simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation,
+        ),
+      ])
+    } else {
+      tracePath = getConnectorTracePath(
+        label.anchorPoint,
+        candidate.anchorPoint,
+        candidate.orientation,
+      )
+    }
+
     if (tracePath.length < 2) return
 
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`
@@ -185,10 +205,19 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       labelIndex,
       orientations,
     )
+    if (rotatedCandidate) return rotatedCandidate
+
+    const shiftedCandidate = this.findValidShiftedCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
+    )
+    if (shiftedCandidate) return shiftedCandidate
 
-    return (
-      rotatedCandidate ??
-      this.findValidShiftedCandidate(label, orientations[0]!, labelIndex)
+    return this.findValidLateralShiftedCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
     )
   }
 
@@ -266,6 +295,63 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  /**
+   * When all candidates fail for the current (unshifted) position, try
+   * shifting the label anchor laterally — x for y-orientations, y for
+   * x-orientations — and re-attempting the required orientation.
+   *
+   * Offsets are tried in alternating sign order:
+   *   -1·step, +1·step, -2·step, +2·step, …
+   * so the nearest escape routes are tested first.
+   */
+  private findValidLateralShiftedCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ): EvaluatedCandidate | null {
+    const direction = dir(orientation)
+    const initialBaseAnchor = this.getSearchStartAnchor(label, orientation)
+
+    // Lateral axis: perpendicular to the orientation direction
+    const lateralDir: Point = {
+      x: isYOrientation(orientation) ? 1 : 0,
+      y: isXOrientation(orientation) ? 1 : 0,
+    }
+
+    const maxSteps = Math.ceil(this.maxSearchDistance / LABEL_SEARCH_STEP)
+
+    for (let step = 1; step <= maxSteps; step++) {
+      for (const sign of [-1, 1]) {
+        const lateralOffset = sign * step * LABEL_SEARCH_STEP
+        const baseAnchor = {
+          x: initialBaseAnchor.x + lateralDir.x * lateralOffset,
+          y: initialBaseAnchor.y + lateralDir.y * lateralOffset,
+        }
+
+        const maxSearchDistance = this.getLateralColumnMaxDistance(
+          label,
+          orientation,
+          baseAnchor,
+        )
+
+        const candidate = this.findValidCandidateInShiftColumn({
+          label,
+          labelIndex,
+          orientation,
+          direction,
+          baseAnchor,
+          maxSearchDistance,
+          outwardDistance: lateralOffset,
+          phase: "lateral-shift",
+        })
+
+        if (candidate) return candidate
+      }
+    }
+
+    return null
+  }
+
   private findValidCandidateInShiftColumn(params: {
     label: NetLabelPlacement
     labelIndex: number
@@ -274,6 +360,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     baseAnchor: Point
     maxSearchDistance: number
     outwardDistance: number
+    phase?: CandidatePhase
   }) {
     const {
       label,
@@ -283,6 +370,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       baseAnchor,
       maxSearchDistance,
       outwardDistance,
+      phase = "shift",
     } = params
 
     for (
@@ -299,7 +387,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         candidate,
         label,
         labelIndex,
-        "shift",
+        phase,
         distance,
         outwardDistance,
       )
@@ -412,6 +500,32 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return Math.min(this.maxSearchDistance, labelLength * 2)
   }
 
+  private getLateralColumnMaxDistance(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    baseAnchor: Point,
+  ) {
+    const chipId = label.pinIds
+      .map((pid) => this.pinMap[pid]?.chipId)
+      .find(Boolean)
+    const chip = chipId
+      ? this.chipObstacleSpatialIndex.chips.find((c) => c.chipId === chipId)
+      : null
+
+    if (chip) {
+      if (orientation === "y-")
+        return Math.max(0, baseAnchor.y - chip.bounds.minY)
+      if (orientation === "y+")
+        return Math.max(0, chip.bounds.maxY - baseAnchor.y)
+      if (orientation === "x-")
+        return Math.max(0, baseAnchor.x - chip.bounds.minX)
+      if (orientation === "x+")
+        return Math.max(0, chip.bounds.maxX - baseAnchor.x)
+    }
+
+    return this.getSearchDistanceLimit(label, orientation)
+  }
+
   private createCandidate(
     label: NetLabelPlacement,
     anchorPoint: Point,
@@ -474,6 +588,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       return "trace-collision"
     }
 
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
+        return "chip-collision"
+      }
+    }
+
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue
       const otherLabel = this.outputNetLabelPlacements[i]!

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -168,7 +168,7 @@ export const getConnectorTracePath = (
       : [source, { x: source.x, y: target.y }, target],
   )
 
-const simplifyOrthogonalPath = (path: Point[]) => {
+export const simplifyOrthogonalPath = (path: Point[]) => {
   const deduped = path.filter(
     (point, index) => index === 0 || !pointsEqual(point, path[index - 1]!),
   )

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -33,7 +33,7 @@ export type CandidateStatus =
   | "trace-collision"
   | "netlabel-collision"
 
-export type CandidatePhase = "rotate" | "shift"
+export type CandidatePhase = "rotate" | "shift" | "lateral-shift"
 
 export type EvaluatedCandidate = CandidateLabel & {
   status: CandidateStatus

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -0,0 +1,441 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import {
+  getDimsForOrientation,
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { rectIntersectsAnyTrace } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+
+type CandidateStatus =
+  | "ok"
+  | "chip-collision"
+  | "trace-collision"
+  | "label-collision"
+
+const ANCHOR_TRACE_CLEARANCE = 1e-4
+const SEGMENT_PARALLEL_EPS = 1e-6
+const CANDIDATE_STEP = 0.1
+
+const OUTWARD_DIR: Record<FacingDirection, { x: number; y: number }> = {
+  "x+": { x: 1, y: 0 },
+  "x-": { x: -1, y: 0 },
+  "y+": { x: 0, y: 1 },
+  "y-": { x: 0, y: -1 },
+}
+
+const CANDIDATE_STATUS_COLOR: Record<CandidateStatus, string> = {
+  ok: "green",
+  "label-collision": "orange",
+  "trace-collision": "darkorange",
+  "chip-collision": "red",
+}
+
+const CANDIDATE_STATUS_FILL: Record<CandidateStatus, string> = {
+  ok: "rgba(0, 200, 0, 0.25)",
+  "label-collision": "rgba(255, 160, 0, 0.2)",
+  "trace-collision": "rgba(200, 80, 0, 0.2)",
+  "chip-collision": "rgba(220, 0, 0, 0.15)",
+}
+
+type Candidate = {
+  orientation: FacingDirection
+  anchor: { x: number; y: number }
+  center: { x: number; y: number }
+  width: number
+  height: number
+  bounds: { minX: number; minY: number; maxX: number; maxY: number }
+  hostPairId?: MspConnectionPairId
+  hostSegIndex?: number
+  status: CandidateStatus | null
+}
+
+function boundsOverlap(
+  a: { minX: number; minY: number; maxX: number; maxY: number },
+  b: { minX: number; minY: number; maxX: number; maxY: number },
+): boolean {
+  return (
+    a.minX < b.maxX - 1e-9 &&
+    a.maxX > b.minX + 1e-9 &&
+    a.minY < b.maxY - 1e-9 &&
+    a.maxY > b.minY + 1e-9
+  )
+}
+
+function sampleAnchorsAlongSegment(
+  a: { x: number; y: number },
+  b: { x: number; y: number },
+): Array<{ x: number; y: number }> {
+  const dx = b.x - a.x
+  const dy = b.y - a.y
+  const len = Math.sqrt(dx * dx + dy * dy)
+  const steps = Math.max(1, Math.round(len / CANDIDATE_STEP))
+  const anchors: Array<{ x: number; y: number }> = []
+  for (let k = 0; k <= steps; k++) {
+    const t = k / steps
+    anchors.push({ x: a.x + t * dx, y: a.y + t * dy })
+  }
+  return anchors
+}
+
+export interface NetLabelNetLabelCollisionSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export class NetLabelNetLabelCollisionSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputNetLabelPlacements: NetLabelPlacement[]
+
+  currentCollision: [NetLabelPlacement, NetLabelPlacement] | null = null
+  currentLabelToMove: NetLabelPlacement | null = null
+  candidateResults: Candidate[] = []
+
+  private chipIndex: ChipObstacleSpatialIndex
+  private traceMap: Record<MspConnectionPairId, SolvedTracePath>
+  private skippedCollisionKeys = new Set<string>()
+
+  private labelsToTry: NetLabelPlacement[] = []
+  private candidateQueue: Candidate[] = []
+  private candidateIndex = 0
+
+  constructor(params: NetLabelNetLabelCollisionSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+    this.chipIndex =
+      params.inputProblem._chipObstacleSpatialIndex ??
+      new ChipObstacleSpatialIndex(params.inputProblem.chips)
+    this.traceMap = Object.fromEntries(
+      params.traces.map((t) => [t.mspPairId, t]),
+    ) as Record<MspConnectionPairId, SolvedTracePath>
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof NetLabelNetLabelCollisionSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  getOutput() {
+    return { netLabelPlacements: this.outputNetLabelPlacements }
+  }
+
+  private labelBounds(label: NetLabelPlacement) {
+    return getRectBounds(label.center, label.width, label.height)
+  }
+
+  private collisionKey(a: NetLabelPlacement, b: NetLabelPlacement) {
+    return [a.globalConnNetId, b.globalConnNetId].sort().join("::")
+  }
+
+  private findNextCollidingPair():
+    | [NetLabelPlacement, NetLabelPlacement]
+    | null {
+    const labels = this.outputNetLabelPlacements
+    for (let i = 0; i < labels.length; i++) {
+      for (let j = i + 1; j < labels.length; j++) {
+        const a = labels[i]!
+        const b = labels[j]!
+        if (a.globalConnNetId === b.globalConnNetId) continue
+        if (this.skippedCollisionKeys.has(this.collisionKey(a, b))) continue
+        if (boundsOverlap(this.labelBounds(a), this.labelBounds(b)))
+          return [a, b]
+      }
+    }
+    return null
+  }
+
+  private netLabelWidthOf(label: NetLabelPlacement): number | undefined {
+    if (label.orientation === "x+" || label.orientation === "x-")
+      return label.width
+    return label.height
+  }
+
+  private buildCandidatesForLabel(label: NetLabelPlacement): Candidate[] {
+    const netLabelWidth = this.netLabelWidthOf(label)
+    const candidates: Candidate[] = []
+
+    const buildCandidate = (
+      orientation: FacingDirection,
+      anchor: { x: number; y: number },
+      hostPairId?: MspConnectionPairId,
+      hostSegIndex?: number,
+    ): Candidate => {
+      const { width, height } = getDimsForOrientation({
+        orientation,
+        netLabelWidth,
+      })
+      const baseCenter = getCenterFromAnchor(anchor, orientation, width, height)
+      const outwardDir = OUTWARD_DIR[orientation]
+      const center = {
+        x: baseCenter.x + outwardDir.x * ANCHOR_TRACE_CLEARANCE,
+        y: baseCenter.y + outwardDir.y * ANCHOR_TRACE_CLEARANCE,
+      }
+      return {
+        orientation,
+        anchor,
+        center,
+        width,
+        height,
+        bounds: getRectBounds(center, width, height),
+        hostPairId,
+        hostSegIndex,
+        status: null,
+      }
+    }
+
+    const isPortOnly = label.mspConnectionPairIds.length === 0
+
+    if (isPortOnly) {
+      const allOrientations: FacingDirection[] = ["x+", "x-", "y+", "y-"]
+      const orderedOrientations = [
+        label.orientation,
+        ...allOrientations.filter((o) => o !== label.orientation),
+      ]
+      for (const orientation of orderedOrientations) {
+        candidates.push(buildCandidate(orientation, label.anchorPoint))
+      }
+    } else {
+      for (const mspPairId of label.mspConnectionPairIds) {
+        const trace = this.traceMap[mspPairId]
+        if (!trace) continue
+        const pts = trace.tracePath
+        for (let si = 0; si < pts.length - 1; si++) {
+          const segStart = pts[si]!
+          const segEnd = pts[si + 1]!
+          const isHorizontal =
+            Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS
+          const isVertical =
+            Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS
+          if (!isHorizontal && !isVertical) continue
+          let perpendicularOrientations: FacingDirection[]
+          if (isHorizontal) {
+            perpendicularOrientations = ["y+", "y-"]
+          } else {
+            perpendicularOrientations = ["x+", "x-"]
+          }
+          for (const anchor of sampleAnchorsAlongSegment(segStart, segEnd)) {
+            for (const orientation of perpendicularOrientations) {
+              candidates.push(
+                buildCandidate(
+                  orientation,
+                  anchor,
+                  mspPairId as MspConnectionPairId,
+                  si,
+                ),
+              )
+            }
+          }
+        }
+      }
+    }
+
+    return candidates
+  }
+
+  private checkCandidate(
+    candidate: Candidate,
+    movingLabelNetId: string,
+    obstacleLabels: NetLabelPlacement[],
+  ): CandidateStatus {
+    const { bounds, hostPairId, hostSegIndex } = candidate
+
+    if (this.chipIndex.getChipsInBounds(bounds).length > 0)
+      return "chip-collision"
+
+    if (
+      rectIntersectsAnyTrace(bounds, this.traceMap, hostPairId, hostSegIndex)
+        .hasIntersection
+    ) {
+      return "trace-collision"
+    }
+
+    for (const obstacle of obstacleLabels) {
+      if (obstacle.globalConnNetId === movingLabelNetId) continue
+      if (boundsOverlap(bounds, this.labelBounds(obstacle)))
+        return "label-collision"
+    }
+
+    return "ok"
+  }
+
+  private beginSearchForLabel(label: NetLabelPlacement) {
+    this.currentLabelToMove = label
+    this.candidateQueue = this.buildCandidatesForLabel(label)
+    this.candidateIndex = 0
+    this.candidateResults = []
+  }
+
+  private clearActiveSearch() {
+    this.currentCollision = null
+    this.currentLabelToMove = null
+    this.labelsToTry = []
+    this.candidateQueue = []
+    this.candidateIndex = 0
+    this.candidateResults = []
+  }
+
+  override _step() {
+    if (!this.currentCollision) {
+      const pair = this.findNextCollidingPair()
+      if (!pair) {
+        this.solved = true
+        return
+      }
+      this.currentCollision = pair
+      this.labelsToTry = [pair[1], pair[0]]
+      this.beginSearchForLabel(this.labelsToTry.shift()!)
+      return
+    }
+
+    if (this.candidateIndex >= this.candidateQueue.length) {
+      if (this.labelsToTry.length > 0) {
+        this.beginSearchForLabel(this.labelsToTry.shift()!)
+      } else {
+        this.skippedCollisionKeys.add(
+          this.collisionKey(this.currentCollision[0], this.currentCollision[1]),
+        )
+        this.clearActiveSearch()
+      }
+      return
+    }
+
+    const candidate = this.candidateQueue[this.candidateIndex++]!
+    const [labelA, labelB] = this.currentCollision
+    let fixedLabel: NetLabelPlacement
+    if (this.currentLabelToMove === labelB) {
+      fixedLabel = labelA
+    } else {
+      fixedLabel = labelB
+    }
+    const obstacleLabels = [
+      ...this.outputNetLabelPlacements.filter(
+        (l) => l !== labelA && l !== labelB,
+      ),
+      fixedLabel,
+    ]
+
+    const status = this.checkCandidate(
+      candidate,
+      this.currentLabelToMove!.globalConnNetId,
+      obstacleLabels,
+    )
+    candidate.status = status
+    this.candidateResults.push({ ...candidate })
+
+    if (status === "ok") {
+      const idx = this.outputNetLabelPlacements.indexOf(
+        this.currentLabelToMove!,
+      )
+      if (idx !== -1) {
+        this.outputNetLabelPlacements[idx] = {
+          ...this.currentLabelToMove!,
+          orientation: candidate.orientation,
+          anchorPoint: candidate.anchor,
+          width: candidate.width,
+          height: candidate.height,
+          center: candidate.center,
+        }
+      }
+      this.clearActiveSearch()
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.points) graphics.points = []
+
+    for (const trace of this.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      } as any)
+    }
+
+    for (const label of this.outputNetLabelPlacements) {
+      const isInActiveCollision =
+        this.currentCollision != null &&
+        (label === this.currentCollision[0] ||
+          label === this.currentCollision[1])
+
+      let labelFill: string
+      let labelStroke: string
+      let labelText: string
+      let pointColor: string
+      if (isInActiveCollision) {
+        labelFill = "rgba(255, 0, 0, 0.2)"
+        labelStroke = "red"
+        labelText = `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}\n⚠ COLLIDING`
+        pointColor = "red"
+      } else {
+        labelFill = getColorFromString(label.globalConnNetId, 0.35)
+        labelStroke = getColorFromString(label.globalConnNetId, 0.9)
+        labelText = `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`
+        pointColor = getColorFromString(label.globalConnNetId, 0.9)
+      }
+
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: labelFill,
+        strokeColor: labelStroke,
+        label: labelText,
+      } as any)
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: pointColor,
+        label: `anchorPoint\norientation: ${label.orientation}`,
+      } as any)
+    }
+
+    const movingNetId = this.currentLabelToMove
+      ? this.currentLabelToMove.netId
+      : "?"
+    for (const c of this.candidateResults) {
+      const statusColor = CANDIDATE_STATUS_COLOR[c.status!]
+      const statusFill = CANDIDATE_STATUS_FILL[c.status!]
+      let strokeDash: string | undefined
+      if (c.status !== "ok") strokeDash = "4 2"
+      graphics.rects.push({
+        center: c.center,
+        width: c.width,
+        height: c.height,
+        fill: statusFill,
+        strokeColor: statusColor,
+        strokeDash,
+        label: `candidate: ${c.status}\norientation: ${c.orientation}\nmoving: ${movingNetId}`,
+      } as any)
+      graphics.points.push({
+        x: c.anchor.x,
+        y: c.anchor.y,
+        color: statusColor,
+        label: `candidate anchor\n${c.status}`,
+      } as any)
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -26,6 +26,7 @@ import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/
 import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
 import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
+import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -80,6 +81,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
+  netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -300,6 +302,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "netLabelNetLabelCollisionSolver",
+      NetLabelNetLabelCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.netLabelTraceCollisionSolver!.getOutput().traces,
+          netLabelPlacements:
+            instance.netLabelTraceCollisionSolver!.getOutput()
+              .netLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {