@tscircuit/schematic-trace-solver 0.0.42 → 0.0.44

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -19,7 +19,7 @@ import { correctPinsInsideChips } from "./correctPinsInsideChip"
 import { expandChipsToFitPins } from "./expandChipsToFitPins"
 import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePairSolver"
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
-import { TraceCleanupSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
+import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -188,6 +188,25 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
+      const prevSolverOutput =
+        instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+      const traces = prevSolverOutput.traces
+
+      const labelMergingOutput =
+        instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
+
+      return [
+        {
+          inputProblem: instance.inputProblem,
+          allTraces: traces,
+          targetTraceIds: new Set(traces.map((t) => t.mspPairId)),
+          allLabelPlacements: labelMergingOutput.netLabelPlacements,
+          mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+          paddingBuffer: 0.1,
+        },
+      ]
+    }),
     definePipelineStep(
       "netLabelPlacementSolver",
       NetLabelPlacementSolver,

package/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -0,0 +1,133 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject, Line } from "graphics-debug"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
+import { balanceZShapes } from "./balanceZShapes"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+interface TraceCleanupSolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+  targetTraceIds: Set<string>
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}
+
+type PipelineStep = "minimizing_turns" | "balancing_l_shapes"
+
+/**
+ * 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 traceIdQueue: string[]
+  private tracesMap: Map<string, SolvedTracePath>
+  private pipelineStep: PipelineStep = "minimizing_turns"
+  private activeTraceId: string | null = null // New property
+
+  constructor(solverInput: TraceCleanupSolverInput) {
+    super()
+    this.input = solverInput
+    this.outputTraces = [...solverInput.allTraces]
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.traceIdQueue = Array.from(solverInput.targetTraceIds)
+  }
+
+  override _step() {
+    if (
+      this.pipelineStep === "minimizing_turns" &&
+      this.traceIdQueue.length === 0
+    ) {
+      this.pipelineStep = "balancing_l_shapes"
+      this.traceIdQueue = Array.from(this.input.targetTraceIds)
+    }
+
+    if (
+      this.pipelineStep === "balancing_l_shapes" &&
+      this.traceIdQueue.length === 0
+    ) {
+      this.solved = true
+      return
+    }
+
+    const targetMspConnectionPairId = this.traceIdQueue.shift()!
+    this.activeTraceId = targetMspConnectionPairId // Set active trace ID
+    const originalTrace = this.tracesMap.get(targetMspConnectionPairId)!
+
+    const { tracePath } = originalTrace
+
+    // Skip if the trace is a perfect rectangle
+    const is4PointRectangle = (path: typeof tracePath): boolean => {
+      if (path.length !== 4) return false
+      const [p0, p1, p2, p3] = path
+      // H-V-H "C" shape
+      const isHVHC =
+        p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x
+      // V-H-V "C" shape
+      const isVHVC =
+        p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y
+      return isHVHC || isVHVC
+    }
+
+    if (is4PointRectangle(tracePath)) {
+      return
+    }
+
+    const allTraces = Array.from(this.tracesMap.values())
+
+    let updatedTrace: SolvedTracePath
+
+    if (this.pipelineStep === "minimizing_turns") {
+      updatedTrace = minimizeTurnsWithFilteredLabels({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces,
+      })
+    } else {
+      updatedTrace = balanceZShapes({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces,
+      })
+    }
+
+    // Update the state in the central map
+    this.tracesMap.set(targetMspConnectionPairId, updatedTrace)
+
+    // Update the output for visualization
+    this.outputTraces = Array.from(this.tracesMap.values())
+  }
+
+  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: trace.mspPairId === this.activeTraceId ? "red" : "blue", // Highlight active trace
+      }
+      graphics.lines!.push(line)
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceCleanupSolver/balanceZShapes.ts

@@ -0,0 +1,200 @@
+import type { Point } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+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"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+export const balanceZShapes = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  targetMspConnectionPairId: string
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId,
+  )
+
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
+  }
+
+  const TOLERANCE = 1e-5
+
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId,
+  )
+
+  const TRACE_WIDTH = 0.01
+  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
+    trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1]!
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+      }
+    }),
+  )
+
+  const staticObstacles = getObstacleRects(inputProblem).map((obs) => ({
+    ...obs,
+    minX: obs.minX + TOLERANCE,
+    maxX: obs.maxX - TOLERANCE,
+    minY: obs.minY + TOLERANCE,
+    maxY: obs.maxY - TOLERANCE,
+  }))
+
+  const combinedObstacles = [...staticObstacles, ...traceObstacles]
+
+  const segmentIntersectsAnyRect = (
+    p1: Point,
+    p2: Point,
+    rects: any[],
+  ): boolean => {
+    for (const rect of rects) {
+      if (segmentIntersectsRect(p1, p2, rect)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId)
+    }
+    return label.globalConnNetId !== targetTrace.globalConnNetId
+  })
+
+  const labelBounds = filteredLabels.map((nl) => ({
+    minX: nl.center.x - nl.width / 2 + TOLERANCE,
+    maxX: nl.center.x + nl.width / 2 - TOLERANCE,
+    minY: nl.center.y - nl.height / 2 + TOLERANCE,
+    maxY: nl.center.y + nl.height / 2 - TOLERANCE,
+  }))
+
+  const newPath = [...targetTrace.tracePath]
+
+  if (newPath.length < 4) {
+    return { ...targetTrace }
+  }
+
+  if (newPath.length === 4) {
+    const [p0, p1, p2, p3] = newPath
+    let p1New: Point
+    let p2New: Point
+
+    const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
+
+    if (isHVHShape) {
+      const idealX = (p0.x + p3.x) / 2
+      p1New = { x: idealX, y: p1.y }
+      p2New = { x: idealX, y: p2.y }
+    } else {
+      const idealY = (p0.y + p3.y) / 2
+      p1New = { x: p1.x, y: idealY }
+      p2New = { x: p2.x, y: idealY }
+    }
+
+    const collides =
+      segmentIntersectsAnyRect(p0, p1New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p1New, p2New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p2New, p3, combinedObstacles) ||
+      segmentIntersectsAnyRect(p0, p1New, labelBounds) ||
+      segmentIntersectsAnyRect(p1New, p2New, labelBounds) ||
+      segmentIntersectsAnyRect(p2New, p3, labelBounds)
+
+    if (!collides) {
+      newPath[1] = p1New
+      newPath[2] = p2New
+    }
+
+    return { ...targetTrace, tracePath: simplifyPath(newPath) }
+  }
+
+  for (let i = 1; i < newPath.length - 4; i++) {
+    const p1 = newPath[i]!
+    const p2 = newPath[i + 1]!
+    const p3 = newPath[i + 2]!
+    const p4 = newPath[i + 3]!
+
+    const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y
+    const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x
+
+    const isCollinearHorizontal =
+      p1.y === p2.y && p2.y === p3.y && p3.y === p4.y
+    const isCollinearVertical = p1.x === p2.x && p2.x === p3.x && p3.x === p4.x
+    const isCollinear = isCollinearHorizontal || isCollinearVertical
+
+    let isSameDirection = false
+    if (isHVHZShape) {
+      isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x)
+    } else if (isVHVZShape) {
+      isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y)
+    }
+
+    const isValidZShape =
+      (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection
+
+    if (!isValidZShape) {
+      continue
+    }
+
+    let p2New: Point
+    let p3New: Point
+    const len1Original = isHVHZShape
+      ? Math.abs(p1.x - p2.x)
+      : Math.abs(p1.y - p2.y)
+    const len2Original = isHVHZShape
+      ? Math.abs(p3.x - p4.x)
+      : Math.abs(p3.y - p4.y)
+
+    if (Math.abs(len1Original - len2Original) < 0.001) {
+      continue
+    }
+
+    if (isHVHZShape) {
+      const idealX = (p1.x + p4.x) / 2
+      p2New = { x: idealX, y: p2.y }
+      p3New = { x: idealX, y: p3.y }
+    } else {
+      const idealY = (p1.y + p4.y) / 2
+      p2New = { x: p2.x, y: idealY }
+      p3New = { x: p3.x, y: idealY }
+    }
+
+    const collides =
+      segmentIntersectsAnyRect(p1, p2New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p2New, p3New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p3New, p4, combinedObstacles) ||
+      segmentIntersectsAnyRect(p1, p2New, labelBounds) ||
+      segmentIntersectsAnyRect(p2New, p3New, labelBounds) ||
+      segmentIntersectsAnyRect(p3New, p4, labelBounds)
+
+    if (!collides) {
+      newPath[i + 1] = p2New
+      newPath[i + 2] = p3New
+      i = 0
+    }
+  }
+
+  const finalSimplifiedPath = simplifyPath(newPath)
+  return {
+    ...targetTrace,
+    tracePath: finalSimplifiedPath,
+  }
+}

package/lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -0,0 +1,76 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { minimizeTurns } from "./turnMinimization"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+export const minimizeTurnsWithFilteredLabels = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  targetMspConnectionPairId: string
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId,
+  )
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
+  }
+
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId,
+  )
+
+  const TRACE_WIDTH = 0.01
+  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
+    trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1]!
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+      }
+    }),
+  )
+
+  const staticObstacles = getObstacleRects(inputProblem)
+  const combinedObstacles = [...staticObstacles, ...traceObstacles]
+
+  const originalPath = targetTrace.tracePath
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId)
+    }
+    return label.globalConnNetId !== targetTrace.globalConnNetId
+  })
+
+  const labelBounds = filteredLabels.map((nl) => ({
+    minX: nl.center.x - nl.width / 2 - paddingBuffer,
+    maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+    minY: nl.center.y - nl.height / 2 - paddingBuffer,
+    maxY: nl.center.y + nl.height / 2 + paddingBuffer,
+  }))
+
+  const newPath = minimizeTurns({
+    path: originalPath,
+    obstacles: combinedObstacles,
+    labelBounds,
+  })
+
+  return {
+    ...targetTrace,
+    tracePath: newPath,
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -5,7 +5,6 @@ import type { GraphicsObject } from "graphics-debug"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputProblem } from "../../types/InputProblem"
 import { MergedNetLabelObstacleSolver } from "./sub-solvers/LabelMergingSolver/LabelMergingSolver"
-import { TraceCleanupSolver } from "./sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { OverlapAvoidanceStepSolver } from "./sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver"
 
@@ -27,7 +26,6 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   // sub-solver instances
   labelMergingSolver?: MergedNetLabelObstacleSolver
   overlapAvoidanceSolver?: OverlapAvoidanceStepSolver
-  traceCleanupSolver?: TraceCleanupSolver
   pipelineStepIndex = 0
 
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
@@ -75,24 +73,6 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
         this.activeSubSolver = this.overlapAvoidanceSolver
         break
 
-      case 2:
-        this.traceCleanupSolver = new TraceCleanupSolver({
-          inputProblem: this.inputProblem,
-          allTraces: this.overlapAvoidanceSolver!.getOutput().allTraces,
-          targetTraceIds: new Set(
-            this.overlapAvoidanceSolver!.getOutput().modifiedTraces.map(
-              (t) => t.mspPairId,
-            ),
-          ),
-          allLabelPlacements:
-            this.labelMergingSolver!.getOutput().netLabelPlacements,
-          mergedLabelNetIdMap:
-            this.labelMergingSolver!.getOutput().mergedLabelNetIdMap,
-          paddingBuffer: 0.01,
-        })
-        this.activeSubSolver = this.traceCleanupSolver
-        break
-
       default:
         this.solved = true
         break
@@ -101,7 +81,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
 
   getOutput() {
     return {
-      traces: this.traceCleanupSolver?.getOutput().traces ?? this.traces,
+      traces: this.overlapAvoidanceSolver?.getOutput().allTraces ?? this.traces,
       netLabelPlacements:
         this.labelMergingSolver?.getOutput().netLabelPlacements ??
         this.netLabelPlacements,

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts

@@ -5,8 +5,8 @@ import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacemen
 import type { InputProblem } from "lib/types/InputProblem"
 import { findTraceViolationZone } from "./violation"
 import { generateSnipAndReconnectCandidates } from "./trySnipAndReconnect"
-import { simplifyPath } from "./sub-solvers/TraceCleanupSolver/simplifyPath"
 import { generateFourPointDetourCandidates } from "./tryFourPointDetour"
+import { simplifyPath } from "../TraceCleanupSolver/simplifyPath"
 
 export const generateRerouteCandidates = ({
   trace,

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

@@ -8,7 +8,7 @@ import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSol
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
-import { simplifyPath } from "../TraceCleanupSolver/simplifyPath"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
 
 interface SingleOverlapSolverInput {
   trace: SolvedTracePath

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -42,6 +42,8 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
 
+  cleanupPhase: "diagonals" | "done" | null = null
+
   constructor(params: {
     inputProblem: InputProblem
     inputTracePaths: Array<SolvedTracePath>
@@ -211,6 +213,62 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     return null
   }
 
+  private findNextDiagonalSegment() {
+    const EPS = 2e-3
+    for (const mspPairId in this.correctedTraceMap) {
+      const tracePath = this.correctedTraceMap[mspPairId]!.tracePath
+      for (let i = 0; i < tracePath.length - 1; i++) {
+        const p1 = tracePath[i]!
+        const p2 = tracePath[i + 1]!
+
+        const isHorizontal = Math.abs(p1.y - p2.y) < EPS
+        const isVertical = Math.abs(p1.x - p2.x) < EPS
+
+        if (!isHorizontal && !isVertical) {
+          return { mspPairId, tracePath, i, p1, p2 }
+        }
+      }
+    }
+    return null
+  }
+
+  private findAndFixNextDiagonalSegment(): boolean {
+    const diagonalInfo = this.findNextDiagonalSegment()
+
+    if (!diagonalInfo) {
+      return false // No diagonal segments found
+    }
+
+    const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo
+    const EPS = 2e-3
+
+    const p0 = i > 0 ? tracePath[i - 1] : null
+    const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null
+
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS : false
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS : false
+
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS : false
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS : false
+
+    const elbow1 = { x: p1.x, y: p2.y } // vertical from p1
+    const elbow2 = { x: p2.x, y: p1.y } // horizontal from p1
+
+    let score1 = 0
+    if (prevIsVertical) score1++
+    if (nextIsHorizontal) score1++
+
+    let score2 = 0
+    if (prevIsHorizontal) score2++
+    if (nextIsVertical) score2++
+
+    const elbowPoint = score1 < score2 ? elbow1 : elbow2
+
+    // Replace [p1, p2] with [p1, elbowPoint, p2]
+    tracePath.splice(i + 1, 0, elbowPoint)
+    return true // Fixed one diagonal, return true to re-evaluate in next step
+  }
+
   override _step() {
     if (this.activeSubSolver?.solved) {
       for (const [mspPairId, newTrace] of Object.entries(
@@ -231,6 +289,19 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     const overlapIssue = this.findNextOverlapIssue()
 
     if (overlapIssue === null) {
+      if (this.cleanupPhase === null) {
+        this.cleanupPhase = "diagonals"
+      }
+
+      if (this.cleanupPhase === "diagonals") {
+        const fixedDiagonal = this.findAndFixNextDiagonalSegment()
+        if (!fixedDiagonal) {
+          this.cleanupPhase = "done"
+          this.solved = true
+        }
+        return
+      }
+      // If cleanupPhase is "done", then the solver is truly solved.
       this.solved = true
       return
     }
@@ -249,6 +320,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     }
 
     const graphics = visualizeInputProblem(this.inputProblem)
+    graphics.circles = graphics.circles || []
 
     // Draw current corrected traces
     for (const trace of Object.values(this.correctedTraceMap)) {
@@ -258,6 +330,17 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       })
     }
 
+    if (this.cleanupPhase === "diagonals") {
+      const diagonalInfo = this.findNextDiagonalSegment()
+      if (diagonalInfo) {
+        graphics.lines!.push({
+          points: [diagonalInfo.p1, diagonalInfo.p2],
+          strokeColor: "red",
+          strokeWidth: 0.05,
+        })
+      }
+    }
+
     return graphics
   }
 }

package/package.json

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

package/site/examples/example26.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example26.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />