tscircuit · lau90eth · Nov 29, 2025 · Nov 29, 2025 · Nov 30, 2025 · Nov 30, 2025
diff --git a/README.md b/README.md
@@ -38,10 +38,10 @@ If there is crowding at the pin, we look for an available spot along the trace c
 ## Usage
 
 ```tsx
-import { SchematicTracePipelineSolver } from "@tscircuit/schematic-trace-solver"
+import { SchematicTracePipelineSolver } from "@tscircuit/schematic-trace-solver";
 
-type ChipId = string
-type PinId = string
+type ChipId = string;
+type PinId = string;
 
 const solver = new SchematicTracePipelineSolver({
   chips: {
@@ -77,9 +77,9 @@ const solver = new SchematicTracePipelineSolver({
     VCC: ["y+", "y-"],
     GND: ["y+", "y-"],
   },
-})
+});
 
-solver.solve()
+solver.solve();
 ```
 
 ## Development

diff --git a/index.html b/index.html
@@ -1,13 +1,13 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Schematic Trace Solver</title>
     <script>
-      const script = document.createElement("script")
-      script.src = "https://cdn.tailwindcss.com"
-      document.head.appendChild(script)
+      const script = document.createElement("script");
+      script.src = "https://cdn.tailwindcss.com";
+      document.head.appendChild(script);
     </script>
   </head>
   <body>

diff --git a/lib/solvers/GuidelinesSolver/GuidelinesSolver.ts b/lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
@@ -31,9 +31,7 @@ export class GuidelinesSolver extends BaseSolver {
   usedXGuidelines: Set<number>
   usedYGuidelines: Set<number>
 
-  constructor(params: {
-    inputProblem: InputProblem
-  }) {
+  constructor(params: { inputProblem: InputProblem }) {
     super()
     this.inputProblem = params.inputProblem
     const inputProblemBounds = getInputProblemBounds(this.inputProblem)

diff --git a/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts b/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
@@ -225,7 +225,10 @@ export class LongDistancePairSolver extends BaseSolver {
     allTracesMerged: SolvedTracePath[]
   } {
     if (!this.solved) {
-      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces }
+      return {
+        newTraces: [],
+        allTracesMerged: this.params.alreadySolvedTraces,
+      }
     }
     return {
       newTraces: this.solvedLongDistanceTraces,

diff --git a/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts b/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
@@ -7,6 +7,9 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 
+import { UntangleTraceSubsolver } from "./sub-solver/UntangleTraceSubsolver"
+import { is4PointRectangle } from "./is4PointRectangle"
+
 /**
  * Defines the input structure for the TraceCleanupSolver.
  */
@@ -18,32 +21,27 @@ interface TraceCleanupSolverInput {
   paddingBuffer: number
 }
 
-import { UntangleTraceSubsolver } from "./sub-solver/UntangleTraceSubsolver"
-import { is4PointRectangle } from "./is4PointRectangle"
-
-/**
- * Represents the different stages or steps within the trace cleanup pipeline.
- */
 type PipelineStep =
+  | "untangling_traces"
   | "minimizing_turns"
   | "balancing_l_shapes"
-  | "untangling_traces"
 
 /**
- * The TraceCleanupSolver is responsible for improving the aesthetics and readability of schematic traces.
- * It operates in a multi-step pipeline:
- * 1. **Untangling Traces**: It first attempts to untangle any overlapping or highly convoluted traces using a sub-solver.
- * 2. **Minimizing Turns**: After untangling, it iterates through each trace to minimize the number of turns, simplifying their paths.
- * 3. **Balancing L-Shapes**: Finally, it balances L-shaped trace segments to create more visually appealing and consistent layouts.
- * The solver processes traces one by one, applying these cleanup steps sequentially to refine the overall trace layout.
+ * The TraceCleanupSolver improves trace readability through:
+ * 1. Untangling complex overlaps
+ * 2. Minimizing turns
+ * 3. Balancing L-shaped segments
  */
 export class TraceCleanupSolver extends BaseSolver {
   private input: TraceCleanupSolverInput
   private outputTraces: SolvedTracePath[]
   private traceIdQueue: string[]
   private tracesMap: Map<string, SolvedTracePath>
   private pipelineStep: PipelineStep = "untangling_traces"
-  private activeTraceId: string | null = null // New property
+
+  /** 👉 NEW: Keep track of which trace is being processed */
+  private activeTraceId: string | null = null
+
   override activeSubSolver: BaseSolver | null = null
 
   constructor(solverInput: TraceCleanupSolverInput) {
@@ -117,64 +115,64 @@ export class TraceCleanupSolver extends BaseSolver {
 
   private _processTrace(step: "minimizing_turns" | "balancing_l_shapes") {
     const targetMspConnectionPairId = this.traceIdQueue.shift()!
+
+    /** 👉 NEW: highlight this trace visually */
     this.activeTraceId = targetMspConnectionPairId
-    const originalTrace = this.tracesMap.get(targetMspConnectionPairId)!
 
-    if (is4PointRectangle(originalTrace.tracePath)) {
-      return
-    }
+    const originalTrace = this.tracesMap.get(targetMspConnectionPairId)!
+    if (is4PointRectangle(originalTrace.tracePath)) return
 
     const allTraces = Array.from(this.tracesMap.values())
 
-    let updatedTrace: SolvedTracePath
-
-    if (step === "minimizing_turns") {
-      updatedTrace = minimizeTurnsWithFilteredLabels({
-        ...this.input,
-        targetMspConnectionPairId,
-        traces: allTraces,
-      })
-    } else {
-      updatedTrace = balanceZShapes({
-        ...this.input,
-        targetMspConnectionPairId,
-        traces: allTraces,
-      })
-    }
+    const updatedTrace =
+      step === "minimizing_turns"
+        ? minimizeTurnsWithFilteredLabels({
+            ...this.input,
+            targetMspConnectionPairId,
+            traces: allTraces,
+          })
+        : balanceZShapes({
+            ...this.input,
+            targetMspConnectionPairId,
+            traces: allTraces,
+          })
 
     this.tracesMap.set(targetMspConnectionPairId, updatedTrace)
     this.outputTraces = Array.from(this.tracesMap.values())
   }
 
   getOutput() {
-    return {
-      traces: this.outputTraces,
-    }
+    return { traces: this.outputTraces }
   }
 
   override visualize(): GraphicsObject {
-    if (this.activeSubSolver) {
-      return this.activeSubSolver.visualize()
-    }
+    if (this.activeSubSolver) return this.activeSubSolver.visualize()
 
     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 = []
+    graphics.lines ||= []
+    graphics.points ||= []
+    graphics.rects ||= []
+    graphics.circles ||= []
+    graphics.texts ||= []
 
     for (const trace of this.outputTraces) {
+      const isActive = trace.mspPairId === this.activeTraceId
+
       const line: Line = {
         points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
-        strokeColor: trace.mspPairId === this.activeTraceId ? "red" : "blue", // Highlight active trace
+
+        /** 👉 NEW: highlight active trace */
+        strokeColor: isActive ? "red" : "blue",
+        strokeWidth: isActive ? 2 : 1,
       }
+
       graphics.lines!.push(line)
     }
+
     return graphics
   }
 }