@tscircuit/schematic-trace-solver 0.0.41 → 0.0.42

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver.ts

@@ -0,0 +1,205 @@
+import type { SolvedTracePath } from "../../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../../../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { GraphicsObject, Line } from "graphics-debug"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+
+interface LabelMergingSolverInput {
+  netLabelPlacements: NetLabelPlacement[]
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+}
+
+interface LabelMergingSolverOutput {
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+}
+
+/**
+ * Merges multiple net labels into a single, larger label if they are on the
+ * same side of the same chip, reducing schematic clutter.
+ */
+export class MergedNetLabelObstacleSolver extends BaseSolver {
+  private input: LabelMergingSolverInput
+  private output!: LabelMergingSolverOutput
+  private inputProblem: InputProblem
+  private traces: SolvedTracePath[]
+
+  constructor(solverInput: LabelMergingSolverInput) {
+    // console.log(JSON.stringify(solverInput));
+
+    super()
+    this.input = solverInput
+    this.inputProblem = solverInput.inputProblem
+    this.traces = solverInput.traces
+
+    // Initialize output to a default state to allow visualization before the first step
+    this.output = {
+      netLabelPlacements: solverInput.netLabelPlacements,
+      mergedLabelNetIdMap: {},
+    }
+  }
+
+  override _step() {
+    const originalLabels = this.input.netLabelPlacements
+    const mergedLabelNetIdMap: Record<string, Set<string>> = {}
+
+    if (!originalLabels || originalLabels.length === 0) {
+      this.output = {
+        netLabelPlacements: [],
+        mergedLabelNetIdMap: {},
+      }
+      this.solved = true
+      return
+    }
+
+    const labelGroups: Record<string, NetLabelPlacement[]> = {}
+
+    for (const p of originalLabels) {
+      if (p.pinIds.length === 0) continue
+      const chipId = p.pinIds[0].split(".")[0]
+      if (!chipId) continue
+      const key = `${chipId}-${p.orientation}`
+      if (!(key in labelGroups)) {
+        labelGroups[key] = []
+      }
+      labelGroups[key]!.push(p)
+    }
+
+    const finalPlacements: NetLabelPlacement[] = []
+    for (const [key, group] of Object.entries(labelGroups)) {
+      if (group.length <= 1) {
+        finalPlacements.push(...group)
+        continue
+      }
+
+      let minX = Infinity
+      let minY = Infinity
+      let maxX = -Infinity
+      let maxY = -Infinity
+      for (const p of group) {
+        const bounds = getRectBounds(p.center, p.width, p.height)
+        minX = Math.min(minX, bounds.minX)
+        minY = Math.min(minY, bounds.minY)
+        maxX = Math.max(maxX, bounds.maxX)
+        maxY = Math.max(maxY, bounds.maxY)
+      }
+
+      const newWidth = maxX - minX
+      const newHeight = maxY - minY
+      const template = group[0]!
+      const syntheticId = `merged-group-${key}`
+      const originalNetIds = new Set(group.map((p) => p.globalConnNetId))
+      mergedLabelNetIdMap[syntheticId] = originalNetIds
+
+      finalPlacements.push({
+        ...template,
+        globalConnNetId: syntheticId,
+        width: newWidth,
+        height: newHeight,
+        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
+        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
+        mspConnectionPairIds: [
+          ...new Set(group.flatMap((p) => p.mspConnectionPairIds)),
+        ],
+      })
+    }
+
+    this.output = {
+      netLabelPlacements: finalPlacements,
+      mergedLabelNetIdMap,
+    }
+    this.solved = true
+  }
+
+  getOutput(): LabelMergingSolverOutput {
+    return this.output
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.points) graphics.points = []
+    if (!graphics.texts) graphics.texts = []
+
+    const originalLabelsById = new Map<string, NetLabelPlacement>()
+    for (const label of this.input.netLabelPlacements) {
+      originalLabelsById.set(label.globalConnNetId, label)
+    }
+
+    for (const trace of this.traces) {
+      const line: Line = {
+        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
+        strokeColor: "blue",
+      }
+      graphics.lines!.push(line)
+    }
+
+    for (const finalLabel of this.output.netLabelPlacements) {
+      const isMerged = finalLabel.globalConnNetId.startsWith("merged-group-")
+      const color = getColorFromString(finalLabel.globalConnNetId)
+
+      if (isMerged) {
+        // Draw the new merged label
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          fill: color.replace(/, 1\)/, ", 0.2)"), // semi-transparent
+          stroke: color,
+          label: finalLabel.globalConnNetId,
+        })
+
+        const originalNetIds =
+          this.output.mergedLabelNetIdMap[finalLabel.globalConnNetId]
+        if (originalNetIds) {
+          for (const originalNetId of originalNetIds) {
+            const originalLabel = originalLabelsById.get(originalNetId)
+            if (originalLabel) {
+              // Draw the original label as a dashed box
+              const bounds = getRectBounds(
+                originalLabel.center,
+                originalLabel.width,
+                originalLabel.height,
+              )
+              const p1 = { x: bounds.minX, y: bounds.minY }
+              const p2 = { x: bounds.maxX, y: bounds.minY }
+              const p3 = { x: bounds.maxX, y: bounds.maxY }
+              const p4 = { x: bounds.minX, y: bounds.maxY }
+              graphics.lines.push({
+                points: [p1, p2, p3, p4, p1],
+                strokeColor: color,
+                strokeDash: "4 4",
+              })
+              // Draw line from original to new center
+              graphics.lines.push({
+                points: [originalLabel.center, finalLabel.center],
+                strokeColor: color,
+                strokeDash: "2 2",
+              })
+            }
+          }
+        }
+      } else {
+        // Draw un-merged labels
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          stroke: color,
+          label: finalLabel.globalConnNetId,
+        })
+      }
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -0,0 +1,144 @@
+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 { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
+
+type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
+
+// Define a type for the input of the internal overlap solver to avoid conflicts
+interface OverlapCollectionSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+}
+
+/**
+ * This is an internal solver that manages the step-by-step process of avoiding
+ * multiple overlaps. It follows the pattern of SchematicTraceLinesSolver.
+ */
+export class OverlapAvoidanceStepSolver extends BaseSolver {
+  inputProblem: InputProblem
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+
+  allTraces: SolvedTracePath[]
+  modifiedTraces: SolvedTracePath[] = []
+
+  private detourCountByLabel: Record<string, number> = {}
+  private readonly PADDING_BUFFER = 0.1
+
+  public override activeSubSolver: SingleOverlapSolver | null = null
+  private overlapQueue: Overlap[] = []
+  private recentlyFailed: Set<string> = new Set()
+
+  constructor(solverInput: OverlapCollectionSolverInput) {
+    super()
+    this.inputProblem = solverInput.inputProblem
+    this.netLabelPlacements = solverInput.netLabelPlacements
+    this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
+    this.allTraces = [...solverInput.traces]
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath
+        if (solvedPath) {
+          const traceIndex = this.allTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
+          )
+          if (traceIndex !== -1) {
+            this.allTraces[traceIndex].tracePath = solvedPath
+            this.modifiedTraces.push(this.allTraces[traceIndex])
+          }
+        }
+        this.activeSubSolver = null
+        this.recentlyFailed.clear()
+      } else if (this.activeSubSolver.failed) {
+        const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`
+        this.recentlyFailed.add(overlapId)
+        this.activeSubSolver = null
+      }
+      return
+    }
+
+    const overlaps = detectTraceLabelOverlap(
+      this.allTraces,
+      this.netLabelPlacements,
+    ).filter((o) => {
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
+      if (originalNetIds) {
+        return !originalNetIds.has(o.trace.globalConnNetId)
+      }
+      return o.trace.globalConnNetId !== o.label.globalConnNetId
+    })
+
+    if (overlaps.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const nonFailedOverlaps = overlaps.filter((o) => {
+      const overlapId = `${o.trace.mspPairId}-${o.label.globalConnNetId}`
+      return !this.recentlyFailed.has(overlapId)
+    })
+
+    if (nonFailedOverlaps.length === 0) {
+      this.solved = true // No more progress can be made
+      return
+    }
+
+    this.overlapQueue = nonFailedOverlaps
+
+    const nextOverlap = this.overlapQueue.shift()
+
+    if (nextOverlap) {
+      const traceToFix = this.allTraces.find(
+        (t) => t.mspPairId === nextOverlap.trace.mspPairId,
+      )
+      if (traceToFix) {
+        const labelId = nextOverlap.label.globalConnNetId
+        const detourCount = this.detourCountByLabel[labelId] || 0
+        this.detourCountByLabel[labelId] = detourCount + 1
+
+        this.activeSubSolver = new SingleOverlapSolver({
+          trace: traceToFix,
+          label: nextOverlap.label,
+          problem: this.inputProblem,
+          paddingBuffer: this.PADDING_BUFFER,
+          detourCount,
+        })
+      }
+    }
+  }
+
+  getOutput() {
+    return {
+      allTraces: this.allTraces,
+      modifiedTraces: this.modifiedTraces,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize()
+    }
+    // When idle, show all the traces
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    for (const trace of this.allTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -0,0 +1,117 @@
+import type { Point } from "@tscircuit/math-utils"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject } from "graphics-debug"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
+import { simplifyPath } from "../TraceCleanupSolver/simplifyPath"
+
+interface SingleOverlapSolverInput {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  problem: InputProblem
+  paddingBuffer: number
+  detourCount: number
+}
+
+/**
+ * This solver attempts to find a valid rerouting for a single trace that is
+ * overlapping with a net label. It tries various candidate paths until it
+ * finds one that does not introduce new collisions.
+ */
+export class SingleOverlapSolver extends BaseSolver {
+  queuedCandidatePaths: Point[][]
+  solvedTracePath: Point[] | null = null
+  initialTrace: SolvedTracePath
+  problem: InputProblem
+  obstacles: ReturnType<typeof getObstacleRects>
+  label: NetLabelPlacement
+
+  constructor(solverInput: SingleOverlapSolverInput) {
+    super()
+    this.initialTrace = solverInput.trace
+    this.problem = solverInput.problem
+    this.label = solverInput.label
+
+    const candidates = generateRerouteCandidates({
+      ...solverInput,
+    })
+
+    const getPathLength = (pts: Point[]) => {
+      let len = 0
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x
+        const dy = pts[i + 1].y - pts[i].y
+        len += Math.sqrt(dx * dx + dy * dy)
+      }
+      return len
+    }
+
+    this.queuedCandidatePaths = candidates.sort(
+      (a, b) => getPathLength(a) - getPathLength(b),
+    )
+    this.obstacles = getObstacleRects(this.problem)
+  }
+
+  override _step() {
+    if (this.queuedCandidatePaths.length === 0) {
+      this.failed = true
+      return
+    }
+
+    const nextCandidatePath = this.queuedCandidatePaths.shift()!
+    const simplifiedPath = simplifyPath(nextCandidatePath)
+
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+      this.solvedTracePath = simplifiedPath
+      this.solved = true
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.problem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+
+    // Draw initial trace
+    graphics.lines.push({
+      points: this.initialTrace.tracePath,
+      strokeColor: "red",
+      strokeDash: "4 4",
+    })
+
+    // Draw label
+    graphics.rects.push({
+      center: this.label.center,
+      width: this.label.width,
+      height: this.label.height,
+      fill: "rgba(255, 0, 0, 0.2)",
+    })
+
+    // Draw next candidate
+    if (this.queuedCandidatePaths.length > 0) {
+      graphics.lines.push({
+        points: this.queuedCandidatePaths[0],
+        strokeColor: "orange",
+      })
+    }
+
+    // Draw solved path
+    if (this.solvedTracePath) {
+      graphics.lines.push({
+        points: this.solvedTracePath,
+        strokeColor: "green",
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -0,0 +1,132 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
+import { balanceLShapes } from "./balanceLShapes"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+
+interface TraceCleanupSolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+  targetTraceIds: Set<string>
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}
+
+/**
+ * Cleans up traces by minimizing turns and balancing L-shapes to improve
+ * the overall aesthetics and readability of the schematic.
+ */
+export class TraceCleanupSolver extends BaseSolver {
+  private input: TraceCleanupSolverInput
+  private outputTraces: SolvedTracePath[]
+  private pipelineStepIndex = 0
+  private tracesToProcess: SolvedTracePath[]
+  private minimizedTraces: SolvedTracePath[] | null = null
+  private balancedTraces: SolvedTracePath[] | null = null
+
+  constructor(solverInput: TraceCleanupSolverInput) {
+    super()
+    this.input = solverInput
+    this.outputTraces = [...solverInput.allTraces]
+    this.tracesToProcess = this.outputTraces.filter((t) =>
+      this.input.targetTraceIds.has(t.mspPairId),
+    )
+  }
+
+  override _step() {
+    const {
+      targetTraceIds,
+      inputProblem,
+      allLabelPlacements,
+      mergedLabelNetIdMap,
+      paddingBuffer,
+    } = this.input
+
+    if (targetTraceIds.size === 0) {
+      this.solved = true
+      return
+    }
+
+    switch (this.pipelineStepIndex) {
+      case 0: {
+        // Step 0: Minimize turns
+        const minimizedTracesResult = minimizeTurnsWithFilteredLabels({
+          traces: this.tracesToProcess,
+          inputProblem,
+          allLabelPlacements,
+          mergedLabelNetIdMap,
+          paddingBuffer,
+        })
+
+        this.minimizedTraces = minimizedTracesResult ?? this.tracesToProcess
+
+        const tracesMap = new Map(
+          this.input.allTraces.map((t) => [t.mspPairId, t]),
+        )
+        for (const trace of this.minimizedTraces) {
+          tracesMap.set(trace.mspPairId, trace)
+        }
+        this.outputTraces = Array.from(tracesMap.values())
+        this.pipelineStepIndex++
+        break
+      }
+      case 1: {
+        // Step 1: Balance L-shapes
+        const balancedTracesResult = balanceLShapes({
+          traces: this.minimizedTraces!,
+          inputProblem,
+          allLabelPlacements,
+        })
+
+        this.balancedTraces = balancedTracesResult ?? this.minimizedTraces
+
+        const tracesMap = new Map(
+          this.input.allTraces.map((t) => [t.mspPairId, t]),
+        )
+        for (const trace of this.balancedTraces!) {
+          tracesMap.set(trace.mspPairId, trace)
+        }
+        this.outputTraces = Array.from(tracesMap.values())
+        this.pipelineStepIndex++
+        break
+      }
+      case 2: {
+        // Step 2: Done
+        this.solved = true
+        break
+      }
+    }
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.input.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.points) graphics.points = []
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.circles) graphics.circles = []
+    if (!graphics.texts) graphics.texts = []
+
+    for (const trace of this.outputTraces) {
+      const line: Line = {
+        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
+        strokeColor: "blue",
+      }
+      graphics.lines!.push(line)
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{balanceLShapes.ts → sub-solvers/TraceCleanupSolver/balanceLShapes.ts}

@@ -1,18 +1,18 @@
 import type { Point } from "graphics-debug"
 import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { simplifyPath } from "./simplifyPath"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 
 export const balanceLShapes = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements,
 }: {
   traces: SolvedTracePath[]
-  problem: InputProblem
+  inputProblem: InputProblem
   allLabelPlacements: NetLabelPlacement[]
 }): SolvedTracePath[] | null => {
   const TOLERANCE = 1e-5
@@ -46,7 +46,7 @@ export const balanceLShapes = ({
     }
   }
 
-  const obstacles = getObstacleRects(problem).map((obs) => ({
+  const obstacles = getObstacleRects(inputProblem).map((obs) => ({
     ...obs,
     minX: obs.minX + TOLERANCE,
     maxX: obs.maxX - TOLERANCE,
@@ -81,7 +81,7 @@ export const balanceLShapes = ({
   }
 
   const newTraces = traces.map((trace) => {
-    let newPath = [...trace.tracePath]
+    const newPath = [...trace.tracePath]
 
     if (newPath.length < 4) {
       return { ...trace }
@@ -94,7 +94,8 @@ export const balanceLShapes = ({
 
     if (newPath.length === 4) {
       const [p0, p1, p2, p3] = newPath
-      let p1New: Point, p2New: Point
+      let p1New: Point
+      let p2New: Point
 
       const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
 
@@ -154,7 +155,8 @@ export const balanceLShapes = ({
         continue
       }
 
-      let p2New: Point, p3New: Point
+      let p2New: Point
+      let p3New: Point
       const len1Original = isHVHZShape
         ? Math.abs(p1.x - p2.x)
         : Math.abs(p1.y - p2.y)

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{hasCollisions.ts → sub-solvers/TraceCleanupSolver/hasCollisions.ts}

@@ -1,5 +1,5 @@
 import type { Point } from "graphics-debug"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisions = (
   pathSegments: Point[],

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{hasCollisionsWithLabels.ts → sub-solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts}

@@ -1,5 +1,5 @@
 import type { Point } from "@tscircuit/math-utils"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisionsWithLabels = (
   pathSegments: Point[],