@tscircuit/schematic-trace-solver 0.0.62 → 0.0.64

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -280,6 +280,26 @@ export class NetLabelPlacementSolver extends BaseSolver {
     )?.netLabelWidth
   }
 
+  private getNetLabelHeightForGroup(
+    group: OverlappingSameNetTraceGroup,
+  ): number | undefined {
+    if (group.netId) {
+      const ncHeight = this.inputProblem.netConnections.find(
+        (nc) => nc.netId === group.netId,
+      )?.netLabelHeight
+      if (ncHeight !== undefined) return ncHeight
+    }
+
+    const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? []
+    if (group.portOnlyPinId) {
+      pinIds.push(group.portOnlyPinId)
+    }
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelHeight
+  }
+
   override _step() {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement!)
@@ -304,12 +324,14 @@ export class NetLabelPlacementSolver extends BaseSolver {
       ) {
         this.triedAnyOrientationFallbackForCurrentGroup = true
         const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
+        const netLabelHeight = this.getNetLabelHeightForGroup(this.currentGroup)
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
           overlappingSameNetTraceGroup: this.currentGroup,
           availableOrientations: fullOrients,
           netLabelWidth,
+          netLabelHeight,
         })
         return
       }
@@ -340,6 +362,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
     this.triedAnyOrientationFallbackForCurrentGroup = false
 
     const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup)
+    const netLabelHeight = this.getNetLabelHeightForGroup(this.currentGroup)
 
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
@@ -349,6 +372,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
         netId
       ] ?? ["x+", "x-", "y+", "y-"],
       netLabelWidth,
+      netLabelHeight,
     })
   }
 

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -58,8 +58,9 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
 
   chipObstacleSpatialIndex: ChipObstacleSpatialIndex
 
-  // Optional override for the width of the net label (per netId)
+  // Optional override for the width/height of the net label (per netId)
   netLabelWidth?: number
+  netLabelHeight?: number
 
   netLabelPlacement: NetLabelPlacement | null = null
   testedCandidates: Array<{
@@ -79,6 +80,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup
     availableOrientations: FacingDirection[]
     netLabelWidth?: number
+    netLabelHeight?: number
   }) {
     super()
     this.inputProblem = params.inputProblem
@@ -86,6 +88,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     this.overlappingSameNetTraceGroup = params.overlappingSameNetTraceGroup
     this.availableOrientations = params.availableOrientations
     this.netLabelWidth = params.netLabelWidth
+    this.netLabelHeight = params.netLabelHeight
 
     this.chipObstacleSpatialIndex =
       params.inputProblem._chipObstacleSpatialIndex ??
@@ -101,6 +104,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
       availableOrientations: this.availableOrientations,
       netLabelWidth: this.netLabelWidth,
+      netLabelHeight: this.netLabelHeight,
     }
   }
 
@@ -119,6 +123,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
         overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
         availableOrientations: this.availableOrientations,
         netLabelWidth: this.netLabelWidth,
+        netLabelHeight: this.netLabelHeight,
       })
       this.testedCandidates.push(...res.testedCandidates)
       if (res.placement) {
@@ -230,6 +235,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
             const { width, height } = getDimsForOrientation({
               orientation,
               netLabelWidth: this.netLabelWidth,
+              netLabelHeight: this.netLabelHeight,
             })
             const center = getCenterFromAnchor(
               anchor,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts

@@ -6,23 +6,28 @@ export const NET_LABEL_HORIZONTAL_HEIGHT = 0.2
 export function getDimsForOrientation(params: {
   orientation: FacingDirection
   netLabelWidth?: number
+  netLabelHeight?: number
 }) {
-  const { orientation, netLabelWidth } = params
+  const { orientation, netLabelWidth, netLabelHeight } = params
   const horizWidth =
     typeof netLabelWidth === "number"
       ? netLabelWidth
       : NET_LABEL_HORIZONTAL_WIDTH
+  const horizHeight =
+    typeof netLabelHeight === "number"
+      ? netLabelHeight
+      : NET_LABEL_HORIZONTAL_HEIGHT
 
   if (orientation === "y+" || orientation === "y-") {
     return {
-      // Rotated, so width/height swap
-      width: NET_LABEL_HORIZONTAL_HEIGHT,
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
       height: horizWidth,
     }
   }
   return {
     width: horizWidth,
-    height: NET_LABEL_HORIZONTAL_HEIGHT,
+    height: horizHeight,
   }
 }
 

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -22,6 +22,7 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
   overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup
   availableOrientations: FacingDirection[]
   netLabelWidth?: number
+  netLabelHeight?: number
 }): {
   placement: NetLabelPlacement | null
   testedCandidates: Array<{
@@ -43,6 +44,7 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     overlappingSameNetTraceGroup,
     availableOrientations,
     netLabelWidth,
+    netLabelHeight,
   } = params
 
   const pinId = overlappingSameNetTraceGroup.portOnlyPinId
@@ -103,6 +105,7 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     const { width, height } = getDimsForOrientation({
       orientation,
       netLabelWidth,
+      netLabelHeight,
     })
     // Place label fully outside the chip: shift center slightly outward
     const baseCenter = getCenterFromAnchor(anchor, orientation, width, height)

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -72,31 +72,27 @@ function buildMergedObstacleLabel(
   }
 }
 
-interface TraceInnerLabelOverlap {
+interface TraceLabelOverlap {
   trace: SolvedTracePath
   label: NetLabelPlacement
 }
 
 /**
- * Detects overlaps where a trace's INTERIOR (non-endpoint) segments cross a label.
- * Traces are allowed to boundary a label at their endpoints (pin locations),
- * just not allowed to cross through it in the middle.
+ * Detects overlaps where a trace segment intersects a label from another net.
+ * Point-only contact is allowed by segmentIntersectsRect; positive overlap on
+ * a label edge is still a visual collision and should be rerouted.
  */
-function detectInnerTraceLabelOverlaps(
+function detectTraceLabelOverlaps(
   traces: SolvedTracePath[],
   labels: NetLabelPlacement[],
-): TraceInnerLabelOverlap[] {
-  const overlaps: TraceInnerLabelOverlap[] = []
+): TraceLabelOverlap[] {
+  const overlaps: TraceLabelOverlap[] = []
   for (const trace of traces) {
     for (const label of labels) {
       if (trace.globalConnNetId === label.globalConnNetId) continue
       const bounds = getRectBounds(label.center, label.width, label.height)
       const path = trace.tracePath
-      // Skip first and last segments — trace endpoints (pins) may legitimately
-      // sit inside or adjacent to labels of neighbouring nets.
-      const innerStart = 1
-      const innerEnd = path.length - 2
-      for (let i = innerStart; i < innerEnd; i++) {
+      for (let i = 0; i < path.length - 1; i++) {
         if (segmentIntersectsRect(path[i]!, path[i + 1]!, bounds)) {
           overlaps.push({ trace, label })
           break
@@ -183,7 +179,7 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
       return
     }
 
-    const overlaps = detectInnerTraceLabelOverlaps(
+    const overlaps = detectTraceLabelOverlaps(
       this.outputTraces,
       this.outputNetLabelPlacements,
     )

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts

@@ -30,6 +30,7 @@ export const generateCandidatesAlongTrace = (params: {
     getTraceVertexDistances(traceLocation.trace),
   )
   const netLabelWidth = getNetLabelWidth(inputProblem, label)
+  const netLabelHeight = getNetLabelHeight(inputProblem, label)
   const candidates: LabelCandidate[] = []
   const seenCandidateKeys = new Set<string>()
 
@@ -55,6 +56,7 @@ export const generateCandidatesAlongTrace = (params: {
           point,
           orientation,
           netLabelWidth,
+          netLabelHeight,
           traceLocation,
           pathDistance,
           label,
@@ -109,6 +111,7 @@ const createCandidate = (params: {
   point: Point
   orientation: FacingDirection
   netLabelWidth: number
+  netLabelHeight?: number
   traceLocation: TraceLocation
   pathDistance: number
   label: NetLabelPlacement
@@ -117,6 +120,7 @@ const createCandidate = (params: {
     point,
     orientation,
     netLabelWidth,
+    netLabelHeight,
     traceLocation,
     pathDistance,
     label,
@@ -124,6 +128,7 @@ const createCandidate = (params: {
   const { width, height } = getDimsForOrientation({
     orientation,
     netLabelWidth,
+    netLabelHeight,
   })
 
   return {
@@ -360,6 +365,20 @@ const getNetLabelWidth = (
   return label.width
 }
 
+const getNetLabelHeight = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+): number | undefined => {
+  const ncHeightByNetId = inputProblem.netConnections.find(
+    (connection) => connection.netId === label.netId,
+  )?.netLabelHeight
+  if (ncHeightByNetId !== undefined) return ncHeightByNetId
+
+  return inputProblem.netConnections.find((nc) =>
+    nc.pinIds.some((pid) => label.pinIds.includes(pid)),
+  )?.netLabelHeight
+}
+
 const roundDistance = (distance: number) => Number(distance.toFixed(6))
 
 const dedupeOrientations = (orientations: FacingDirection[]) => [

package/lib/types/InputProblem.ts

@@ -31,6 +31,7 @@ export interface InputNetConnection {
   netId: string
   pinIds: Array<PinId>
   netLabelWidth?: number
+  netLabelHeight?: number
 }
 
 export interface InputProblem {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/assets/example41.json

@@ -65,7 +65,8 @@
     {
       "netId": "SWD",
       "pinIds": ["U3.25", "R5.2"],
-      "netLabelWidth": 0.48
+      "netLabelWidth": 0.48,
+      "netLabelHeight": 0.48
     },
     {
       "netId": "CLK",

package/tests/examples/__snapshots__/example34.snap.svg

@@ -2,56 +2,60 @@
   <rect width="100%" height="100%" fill="white" />
   <g>
     <circle data-type="point" data-label="U1.1
-x+" data-x="1.1" data-y="0.30000000000000004" cx="487.83715012722644" cy="248.75318066157763" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0.30000000000000004" cx="479.84291324526953" cy="250.0249910746162" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.2
-x+" data-x="1.1" data-y="0.09999999999999998" cx="487.83715012722644" cy="289.46564885496184" r="3" fill="hsl(320, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0.09999999999999998" cx="479.84291324526953" cy="290.0107104605498" r="3" fill="hsl(320, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.3
-x+" data-x="1.1" data-y="-0.10000000000000003" cx="487.83715012722644" cy="330.17811704834605" r="3" fill="hsl(321, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="-0.10000000000000003" cx="479.84291324526953" cy="329.9964298464834" r="3" fill="hsl(321, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.4
-x+" data-x="1.1" data-y="-0.30000000000000004" cx="487.83715012722644" cy="370.89058524173026" r="3" fill="hsl(322, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="-0.30000000000000004" cx="479.84291324526953" cy="369.982149232417" r="3" fill="hsl(322, 100%, 50%, 0.8)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.1" data-y="0.30000000000000004" cx="487.83715012722644" cy="248.75318066157763" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: x+" data-x="1.1" data-y="0.30000000000000004" cx="479.84291324526953" cy="250.0249910746162" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.1" data-y="0.09999999999999998" cx="487.83715012722644" cy="289.46564885496184" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: x+" data-x="1.1" data-y="0.09999999999999998" cx="479.84291324526953" cy="290.0107104605498" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.5510000000000002" data-y="0.4009999999999999" cx="579.6437659033079" cy="228.1933842239186" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: y+" data-x="1.601" data-y="0.4009999999999999" cx="580.0071403070332" cy="229.83220278471975" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.201" data-y="-0.5010000000000001" cx="508.39694656488547" cy="411.80661577608146" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: y-" data-x="1.201" data-y="-0.5010000000000001" cx="500.035701535166" cy="410.1677972152803" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.10000000000000003 1.5510000000000002,-0.10000000000000003 1.5510000000000002,0.4009999999999999" data-type="line" data-label="" points="487.83715012722644,330.17811704834605 579.6437659033079,330.17811704834605 579.6437659033079,228.1933842239186" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,-0.10000000000000003 1.601,-0.10000000000000003 1.601,0.4009999999999999" data-type="line" data-label="" points="479.84291324526953,329.9964298464834 580.0071403070332,329.9964298464834 580.0071403070332,229.83220278471975" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.30000000000000004 1.201,-0.30000000000000004 1.201,-0.5010000000000001" data-type="line" data-label="" points="487.83715012722644,370.89058524173026 508.39694656488547,370.89058524173026 508.39694656488547,411.80661577608146" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,-0.30000000000000004 1.201,-0.30000000000000004 1.201,-0.5010000000000001" data-type="line" data-label="" points="479.84291324526953,369.982149232417 500.035701535166,369.982149232417 500.035701535166,410.1677972152803" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40" y="208.04071246819342" width="447.83715012722644" height="203.56234096692106" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.004912500000000001" />
+    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="39.99999999999997" y="210.03927168868262" width="439.84291324526953" height="199.92859692966795" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: SCL
-globalConnNetId: connectivity_net0" data-x="1.326" data-y="0.30000000000000004" x="488.0407124681933" y="228.39694656488552" width="91.60305343511459" height="40.71246819338421" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net0" data-x="1.326" data-y="0.30000000000000004" x="480.0428418421992" y="230.03213138164938" width="89.96786861835062" height="39.985719385933635" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: SDA
-globalConnNetId: connectivity_net1" data-x="1.326" data-y="0.09999999999999998" x="488.0407124681933" y="269.10941475826974" width="91.60305343511459" height="40.71246819338421" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net1" data-x="1.326" data-y="0.09999999999999998" x="480.0428418421992" y="270.017850767583" width="89.96786861835062" height="39.98571938593358" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: V3_3
-globalConnNetId: connectivity_net2" data-x="1.5510000000000002" data-y="0.6259999999999999" x="559.2875318066158" y="136.59033078880412" width="40.71246819338421" height="91.60305343511448" fill="#ef444466" stroke="#ef4444" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net2" data-x="1.601" data-y="0.6259999999999999" x="560.0142806140664" y="139.86433416636916" width="39.985719385933635" height="89.9678686183506" fill="#ef444466" stroke="#ef4444" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: GND
-globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001" x="488.0407124681933" y="411.80661577608146" width="40.71246819338421" height="91.60305343511448" fill="#00000066" stroke="#000000" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001" x="480.0428418421992" y="410.1677972152803" width="39.985719385933635" height="89.96786861835051" fill="#00000066" stroke="#000000" stroke-width="0.005001785714285715" />
   </g>
   <g id="crosshair" style="display: none">
     <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />
@@ -81,12 +85,12 @@ globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001"
 
       // Calculate real coordinates using inverse transformation
       const matrix = {
-        "a": 203.56234096692108,
+        "a": 199.92859692966798,
         "c": 0,
-        "e": 263.9185750636132,
+        "e": 259.92145662263476,
         "b": 0,
-        "d": -203.56234096692108,
-        "f": 309.82188295165395
+        "d": -199.92859692966798,
+        "f": 310.0035701535166
       };
       // Manually invert and apply the affine transform
       // Since we only use translate and scale, we can directly compute:

package/tests/examples/__snapshots__/example41.snap.svg

@@ -26,7 +26,7 @@ orientation: x-" data-x="-7.65" data-y="-0.22999999999999998" cx="325.9574468085
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: y+" data-x="-8.549999999999999" data-y="-0.4299999999999998" cx="218.72340425531945" cy="331.9148936170212" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y+" data-x="-8.65" data-y="-0.4299999999999998" cx="206.808510638298" cy="331.9148936170212" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
@@ -53,7 +53,7 @@ globalConnNetId: connectivity_net1" data-x="-8.011" data-y="-0.22999999999999998
   </g>
   <g>
     <rect data-type="rect" data-label="netId: SWD
-globalConnNetId: connectivity_net0" data-x="-8.549999999999999" data-y="-0.18989999999999985" x="206.80851063829823" y="274.7114893617021" width="23.829787234042442" height="57.19148936170211" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008392857142857145" />
+globalConnNetId: connectivity_net0" data-x="-8.65" data-y="-0.18989999999999985" x="178.2127659574469" y="274.7114893617021" width="57.191489361702224" height="57.19148936170211" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008392857142857145" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: CLK

package/tests/examples/example34.test.ts

@@ -2,11 +2,19 @@ import { test, expect } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import inputProblem from "../assets/example34.json"
 import "tests/fixtures/matcher"
+import { getTraceLabelCollisions } from "tests/fixtures/traceLabelCollisions"
 
 test("example34", () => {
   const solver = new SchematicTracePipelineSolver(inputProblem as any)
 
   solver.solve()
 
+  expect(
+    getTraceLabelCollisions(
+      solver.netLabelNetLabelCollisionSolver!.traces,
+      solver.netLabelNetLabelCollisionSolver!.outputNetLabelPlacements,
+    ),
+  ).toEqual([])
+
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/fixtures/traceLabelCollisions.ts

@@ -0,0 +1,42 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export const getTraceLabelCollisions = (
+  traces: SolvedTracePath[],
+  labels: NetLabelPlacement[],
+) => {
+  const collisions: Array<{
+    traceId: string
+    traceNetId: string
+    labelNetId: string
+    segmentIndex: number
+  }> = []
+
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue
+
+      const bounds = getRectBounds(label.center, label.width, label.height)
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        if (
+          segmentIntersectsRect(
+            trace.tracePath[i]!,
+            trace.tracePath[i + 1]!,
+            bounds,
+          )
+        ) {
+          collisions.push({
+            traceId: trace.mspPairId,
+            traceNetId: trace.globalConnNetId,
+            labelNetId: label.globalConnNetId,
+            segmentIndex: i,
+          })
+        }
+      }
+    }
+  }
+
+  return collisions
+}