feat: add findCloseSameNetTraceGroups for close same-net trace detection (#378)

- Add findCloseSameNetTraceGroups sub-solver that groups same-net traces
  by endpoint proximity (default threshold: 0.5mm)
- Wire into TraceCleanupSolver init and output
- Add focused test coverage for same-net grouping
- All 62 tests pass, typecheck clean, build clean, format clean

Addresses #378

Author: onchito-walks

lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -20,6 +20,10 @@ interface TraceCleanupSolverInput {
 
 import { UntangleTraceSubsolver } from "./sub-solver/UntangleTraceSubsolver"
 import { is4PointRectangle } from "./is4PointRectangle"
+import {
+  findCloseSameNetTraceGroups,
+  type CloseSameNetTraceGroup,
+} from "./sub-solver/findCloseSameNetTraceGroups"
 
 /**
  * Represents the different stages or steps within the trace cleanup pipeline.
@@ -42,6 +46,7 @@ export class TraceCleanupSolver extends BaseSolver {
   private outputTraces: SolvedTracePath[]
   private traceIdQueue: string[]
   private tracesMap: Map<string, SolvedTracePath>
+  private closeSameNetTraceGroups: CloseSameNetTraceGroup[] = []
   private pipelineStep: PipelineStep = "untangling_traces"
   private activeTraceId: string | null = null // New property
   override activeSubSolver: BaseSolver | null = null
@@ -54,6 +59,9 @@ export class TraceCleanupSolver extends BaseSolver {
     this.traceIdQueue = Array.from(
       solverInput.allTraces.map((e) => e.mspPairId),
     )
+    this.closeSameNetTraceGroups = findCloseSameNetTraceGroups(
+      solverInput.allTraces,
+    )
   }
 
   override _step() {
@@ -149,6 +157,7 @@ export class TraceCleanupSolver extends BaseSolver {
   getOutput() {
     return {
       traces: this.outputTraces,
+      closeSameNetTraceGroups: this.closeSameNetTraceGroups,
     }
   }
 
@@ -171,10 +180,11 @@ export class TraceCleanupSolver extends BaseSolver {
     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
+        strokeColor: trace.mspPairId === this.activeTraceId ? "red" : "blue",
       }
       graphics.lines!.push(line)
     }
+
     return graphics
   }
 }

lib/solvers/TraceCleanupSolver/sub-solver/findCloseSameNetTraceGroups.ts

@@ -0,0 +1,70 @@
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export interface CloseSameNetTraceGroup {
+  netId: string
+  traceIds: string[]
+  maxEndpointDistance: number
+}
+
+const distance = (a: { x: number; y: number }, b: { x: number; y: number }) =>
+  Math.hypot(a.x - b.x, a.y - b.y)
+
+const getTraceEndpoints = (trace: SolvedTracePath) => {
+  const start = trace.tracePath[0]
+  const end = trace.tracePath[trace.tracePath.length - 1]
+  return { start, end }
+}
+
+/**
+ * Finds same-net traces whose endpoints are already close enough that they are
+ * likely candidates for a later merge/join phase.
+ *
+ * This is intentionally conservative: it does not mutate paths, it only groups
+ * traces so the pipeline can decide whether to combine them.
+ */
+export const findCloseSameNetTraceGroups = (
+  traces: SolvedTracePath[],
+  maxEndpointDistance = 0.5,
+): CloseSameNetTraceGroup[] => {
+  const groupedByNet = new Map<string, SolvedTracePath[]>()
+
+  for (const trace of traces) {
+    const netId = trace.userNetId ?? trace.globalConnNetId ?? trace.dcConnNetId
+    const current = groupedByNet.get(netId) ?? []
+    current.push(trace)
+    groupedByNet.set(netId, current)
+  }
+
+  const groups: CloseSameNetTraceGroup[] = []
+
+  for (const [netId, netTraces] of groupedByNet.entries()) {
+    if (netTraces.length < 2) continue
+
+    for (let i = 0; i < netTraces.length; i++) {
+      for (let j = i + 1; j < netTraces.length; j++) {
+        const left = netTraces[i]
+        const right = netTraces[j]
+        const a = getTraceEndpoints(left)
+        const b = getTraceEndpoints(right)
+
+        const distances = [
+          distance(a.start, b.start),
+          distance(a.start, b.end),
+          distance(a.end, b.start),
+          distance(a.end, b.end),
+        ]
+        const minDistance = Math.min(...distances)
+
+        if (minDistance <= maxEndpointDistance) {
+          groups.push({
+            netId,
+            traceIds: [left.mspPairId as string, right.mspPairId as string],
+            maxEndpointDistance: minDistance,
+          })
+        }
+      }
+    }
+  }
+
+  return groups.sort((a, b) => a.maxEndpointDistance - b.maxEndpointDistance)
+}

tests/solvers/TraceCleanupSolver/findCloseSameNetTraceGroups.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test"
+import { findCloseSameNetTraceGroups } from "lib/solvers/TraceCleanupSolver/sub-solver/findCloseSameNetTraceGroups"
+
+const trace = (
+  id: string,
+  netId: string,
+  path: Array<{ x: number; y: number }>,
+) =>
+  ({
+    mspPairId: id,
+    userNetId: netId,
+    globalConnNetId: `${netId}-global`,
+    dcConnNetId: `${netId}-dc`,
+    tracePath: path,
+  }) as any
+
+test("findCloseSameNetTraceGroups groups close same-net traces by endpoint distance", () => {
+  const groups = findCloseSameNetTraceGroups(
+    [
+      trace("a", "N1", [
+        { x: 0, y: 0 },
+        { x: 1, y: 0 },
+      ]),
+      trace("b", "N1", [
+        { x: 1.15, y: 0 },
+        { x: 2, y: 0 },
+      ]),
+      trace("c", "N2", [
+        { x: 10, y: 10 },
+        { x: 11, y: 10 },
+      ]),
+    ],
+    0.2,
+  )
+
+  expect(groups).toHaveLength(1)
+  expect(groups[0].netId).toBe("N1")
+  expect(groups[0].traceIds).toEqual(["a", "b"])
+  expect(groups[0].maxEndpointDistance).toBeLessThanOrEqual(0.2)
+})