@tscircuit/schematic-trace-solver 0.0.101 → 0.0.102

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -1,3 +1,4 @@
+import { doSegmentsIntersect } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
@@ -19,8 +20,11 @@ export interface OverlappingTraceSegmentLocator {
   }>
 }
 
+export type TraceInteractionKind = "overlap" | "point_contact"
+
 export class TraceOverlapIssueSolver extends BaseSolver {
   overlappingTraceSegments: OverlappingTraceSegmentLocator[]
+  interactionKind: TraceInteractionKind
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
   obstacleRects: ReturnType<typeof getObstacleRects>
 
@@ -31,10 +35,12 @@ export class TraceOverlapIssueSolver extends BaseSolver {
   constructor(params: {
     inputProblem: InputProblem
     overlappingTraceSegments: OverlappingTraceSegmentLocator[]
+    interactionKind: TraceInteractionKind
     traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
   }) {
     super()
     this.overlappingTraceSegments = params.overlappingTraceSegments
+    this.interactionKind = params.interactionKind
     this.traceNetIslands = params.traceNetIslands
     this.obstacleRects = getObstacleRects(params.inputProblem)
 
@@ -76,17 +82,87 @@ export class TraceOverlapIssueSolver extends BaseSolver {
       (shouldStay) => !shouldStay,
     )
 
-    // Compute offsets for each island involved: alternate directions
-    const offsets = this.overlappingTraceSegments.map((group, idx) => {
-      if (someGroupCanShift && groupShouldStayInPlace[idx]) return 0
-      const n = Math.floor(idx / 2) + 1
-      const signed = idx % 2 === 0 ? -n : n
-      return this.getObstacleAwareOffset({
-        group,
-        offset: signed * this.SHIFT_DISTANCE,
+    const getSeparationOffsets = (firstDirection: number) =>
+      this.overlappingTraceSegments.map((group, groupIndex) => {
+        if (someGroupCanShift && groupShouldStayInPlace[groupIndex]) return 0
+        const n = Math.floor(groupIndex / 2) + 1
+        const direction =
+          groupIndex % 2 === 0 ? firstDirection : -firstDirection
+        return this.getObstacleAwareOffset({
+          group,
+          offset: direction * n * this.SHIFT_DISTANCE,
+        })
       })
+
+    const establishedOffsets = getSeparationOffsets(-1)
+    const isCompoundOverlap =
+      this.interactionKind === "overlap" &&
+      this.overlappingTraceSegments.some(
+        (group) => group.pathsWithOverlap.length > 1,
+      )
+
+    // A compound overlap moves multiple rails as one correction. Preserve the
+    // established deterministic separation because a single candidate score
+    // cannot attribute downstream intersections to one participating rail.
+    if (isCompoundOverlap) {
+      this.correctedTraceMap = this.applyOffsets(establishedOffsets)
+      this.solved = true
+      return
+    }
+
+    const offsetCandidates: number[][] =
+      this.interactionKind === "overlap"
+        ? [establishedOffsets, getSeparationOffsets(1)]
+        : []
+
+    if (this.interactionKind === "point_contact") {
+      // A point contact needs only one island to move. Try later islands first
+      // so an established earlier trace remains stable when scores are equal.
+      const movableGroupIndexes = this.overlappingTraceSegments
+        .map((_, groupIndex) => groupIndex)
+        .filter(
+          (groupIndex) =>
+            !someGroupCanShift || !groupShouldStayInPlace[groupIndex],
+        )
+        .reverse()
+      for (const groupIndex of movableGroupIndexes) {
+        const group = this.overlappingTraceSegments[groupIndex]!
+        for (const direction of [-1, 1]) {
+          const offsets = this.overlappingTraceSegments.map(() => 0)
+          offsets[groupIndex] = this.getObstacleAwareOffset({
+            group,
+            offset: direction * this.SHIFT_DISTANCE,
+          })
+          offsetCandidates.push(offsets)
+        }
+      }
+    }
+
+    const candidates = offsetCandidates.map((offsets) => {
+      const correctedTraceMap = this.applyOffsets(offsets)
+      return {
+        correctedTraceMap,
+        intersectionCount:
+          this.countDifferentNetIntersections(correctedTraceMap),
+        totalDisplacement: offsets.reduce(
+          (total, offset) => total + Math.abs(offset),
+          0,
+        ),
+      }
     })
 
+    candidates.sort(
+      (a, b) =>
+        a.intersectionCount - b.intersectionCount ||
+        a.totalDisplacement - b.totalDisplacement,
+    )
+    this.correctedTraceMap = candidates[0]!.correctedTraceMap
+    this.solved = true
+  }
+
+  private applyOffsets(offsets: number[]) {
+    const correctedTraceMap = { ...this.correctedTraceMap }
+
     const eq = (a: number, b: number) => Math.abs(a - b) < EPS
     const samePoint = (
       p: { x: number; y: number } | undefined,
@@ -94,8 +170,8 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     ) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y)
 
     // For each net island group, shift only its overlapping segments and adjust adjacent joints
-    this.overlappingTraceSegments.forEach((group, gidx) => {
-      const offset = offsets[gidx]!
+    this.overlappingTraceSegments.forEach((group, groupIndex) => {
+      const offset = offsets[groupIndex]!
       if (offset === 0) return
 
       // Gather unique segment indices per path
@@ -109,12 +185,25 @@ export class TraceOverlapIssueSolver extends BaseSolver {
 
       for (const [pathIdx, segIdxSet] of byPath) {
         const original = this.traceNetIslands[group.connNetId][pathIdx]!
-        const current = this.correctedTraceMap[original.mspPairId] ?? original
+        const current = correctedTraceMap[original.mspPairId] ?? original
         const pts = current.tracePath.map((p) => ({ ...p }))
 
         const segIdxsRev = Array.from(segIdxSet)
           .sort((a, b) => a - b)
           .reverse()
+        const segmentAxes = new Map<number, "vertical" | "horizontal">()
+        for (const si of segIdxsRev) {
+          const start = pts[si]
+          const end = pts[si + 1]
+          if (!start || !end) continue
+          if (Math.abs(start.x - end.x) < EPS) {
+            segmentAxes.set(si, "vertical")
+          } else if (Math.abs(start.y - end.y) < EPS) {
+            segmentAxes.set(si, "horizontal")
+          }
+        }
+        const shiftedXPointIndexes = new Set<number>()
+        const shiftedYPointIndexes = new Set<number>()
 
         const JOG_SIZE = this.SHIFT_DISTANCE
 
@@ -134,17 +223,26 @@ export class TraceOverlapIssueSolver extends BaseSolver {
             // Internal segment - shift both points
             const start = pts[si]!
             const end = pts[si + 1]!
-            const isVertical = Math.abs(start.x - end.x) < EPS
-            const isHorizontal = Math.abs(start.y - end.y) < EPS
-            if (!isVertical && !isHorizontal) continue
-
-            if (isVertical) {
-              start.x += offset
-              end.x += offset
-            } else {
-              // Horizontal
-              start.y += offset
-              end.y += offset
+            const axis = segmentAxes.get(si)
+
+            if (axis === "vertical") {
+              if (!shiftedXPointIndexes.has(si)) {
+                start.x += offset
+                shiftedXPointIndexes.add(si)
+              }
+              if (!shiftedXPointIndexes.has(si + 1)) {
+                end.x += offset
+                shiftedXPointIndexes.add(si + 1)
+              }
+            } else if (axis === "horizontal") {
+              if (!shiftedYPointIndexes.has(si)) {
+                start.y += offset
+                shiftedYPointIndexes.add(si)
+              }
+              if (!shiftedYPointIndexes.has(si + 1)) {
+                end.y += offset
+                shiftedYPointIndexes.add(si + 1)
+              }
             }
           }
         }
@@ -160,14 +258,60 @@ export class TraceOverlapIssueSolver extends BaseSolver {
           }
         }
 
-        this.correctedTraceMap[original.mspPairId] = {
+        correctedTraceMap[original.mspPairId] = {
           ...current,
           tracePath: cleaned,
         }
       }
     })
 
-    this.solved = true
+    return correctedTraceMap
+  }
+
+  private countDifferentNetIntersections(
+    correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath>,
+  ) {
+    const traces = Object.values(this.traceNetIslands).flatMap((island) =>
+      island.map((trace) => correctedTraceMap[trace.mspPairId] ?? trace),
+    )
+    let intersectionCount = 0
+
+    for (let traceIndex = 0; traceIndex < traces.length; traceIndex++) {
+      const trace = traces[traceIndex]!
+      for (
+        let otherTraceIndex = traceIndex + 1;
+        otherTraceIndex < traces.length;
+        otherTraceIndex++
+      ) {
+        const otherTrace = traces[otherTraceIndex]!
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue
+
+        for (
+          let segmentIndex = 0;
+          segmentIndex < trace.tracePath.length - 1;
+          segmentIndex++
+        ) {
+          for (
+            let otherSegmentIndex = 0;
+            otherSegmentIndex < otherTrace.tracePath.length - 1;
+            otherSegmentIndex++
+          ) {
+            if (
+              doSegmentsIntersect(
+                trace.tracePath[segmentIndex]!,
+                trace.tracePath[segmentIndex + 1]!,
+                otherTrace.tracePath[otherSegmentIndex]!,
+                otherTrace.tracePath[otherSegmentIndex + 1]!,
+              )
+            ) {
+              intersectionCount++
+            }
+          }
+        }
+      }
+    }
+
+    return intersectionCount
   }
 
   private getObstacleAwareOffset({

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -6,20 +6,22 @@ import type { ConnectivityMap } from "connectivity-map"
 import {
   TraceOverlapIssueSolver,
   type OverlappingTraceSegmentLocator,
+  type TraceInteractionKind,
 } from "./TraceOverlapIssueSolver/TraceOverlapIssueSolver"
 import type { MspConnectionPairId } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 
 type ConnNetId = string
 
 /**
- * This solver finds traces that overlap (coincident and parallel) and aren't
- * connected via the globalConnMap, then shifts them to avoid the overlap in
- * such a way that minimizes the resulting intersections
+ * This solver finds traces that overlap or meet collinearly and aren't
+ * connected via the globalConnMap, then shifts them apart in the direction
+ * that minimizes the resulting intersections.
  *
  * All traces are orthogonal, so for traces to be considered overlapping, they
- * need to each have a segment where both are horizontal or both are vertical
- * AND the segments must be within 1e-6 of each other in X (if vertical) or
- * Y (if horizontal)
+ * need to each have a segment where both are horizontal or both are vertical,
+ * the segments must be on the same axis, and their ranges must overlap. A
+ * point contact is also handled when both segments are internal rails, where
+ * it can be separated without moving an anchored terminal segment.
  *
  * Each iteration, we find overlapping traces that aren't part of the same net.
  * This is the same as finding two "trace net islands" that have an overlap.
@@ -89,6 +91,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
   findNextOverlapIssue(): {
     overlappingTraceSegments: Array<OverlappingTraceSegmentLocator>
+    interactionKind: TraceInteractionKind
   } | null {
     // Detect the next set of overlapping segments between two different net islands.
     const EPS = 2e-3
@@ -111,23 +114,89 @@ export class TraceOverlapShiftSolver extends BaseSolver {
           solvedTracePathIndex: number
           traceSegmentIndex: number
         }> = []
+        const pointContacts: Array<{
+          pathAIndex: number
+          segmentAIndex: number
+          pathBIndex: number
+          segmentBIndex: number
+          combinedLength: number
+        }> = []
 
         // Track to avoid duplicates
         const seenA = new Set<string>()
         const seenB = new Set<string>()
 
-        const overlaps1D = (
+        const getRangeOverlap1D = (
           a1: number,
           a2: number,
           b1: number,
           b2: number,
-        ): boolean => {
+        ) => {
           const minA = Math.min(a1, a2)
           const maxA = Math.max(a1, a2)
           const minB = Math.min(b1, b2)
           const maxB = Math.max(b1, b2)
-          const overlap = Math.min(maxA, maxB) - Math.max(minA, minB)
-          return overlap > EPS
+          return Math.min(maxA, maxB) - Math.max(minA, minB)
+        }
+
+        const recordCollinearInteraction = ({
+          pathAIndex,
+          segmentAIndex,
+          pathBIndex,
+          segmentBIndex,
+          rangeOverlap,
+        }: {
+          pathAIndex: number
+          segmentAIndex: number
+          pathBIndex: number
+          segmentBIndex: number
+          rangeOverlap: number
+        }) => {
+          if (rangeOverlap > EPS) {
+            const keyA = `${pathAIndex}:${segmentAIndex}`
+            const keyB = `${pathBIndex}:${segmentBIndex}`
+            if (!seenA.has(keyA)) {
+              overlapsA.push({
+                solvedTracePathIndex: pathAIndex,
+                traceSegmentIndex: segmentAIndex,
+              })
+              seenA.add(keyA)
+            }
+            if (!seenB.has(keyB)) {
+              overlapsB.push({
+                solvedTracePathIndex: pathBIndex,
+                traceSegmentIndex: segmentBIndex,
+              })
+              seenB.add(keyB)
+            }
+            return
+          }
+          if (rangeOverlap < -EPS) return
+
+          const pathA = pathsA[pathAIndex]!.tracePath
+          const pathB = pathsB[pathBIndex]!.tracePath
+          const segmentAStart = pathA[segmentAIndex]!
+          const segmentAEnd = pathA[segmentAIndex + 1]!
+          const segmentBStart = pathB[segmentBIndex]!
+          const segmentBEnd = pathB[segmentBIndex + 1]!
+          const hasTerminalSegment =
+            segmentAIndex === 0 ||
+            segmentAIndex === pathA.length - 2 ||
+            segmentBIndex === 0 ||
+            segmentBIndex === pathB.length - 2
+          if (hasTerminalSegment) return
+
+          pointContacts.push({
+            pathAIndex,
+            segmentAIndex,
+            pathBIndex,
+            segmentBIndex,
+            combinedLength:
+              Math.abs(segmentAStart.x - segmentAEnd.x) +
+              Math.abs(segmentAStart.y - segmentAEnd.y) +
+              Math.abs(segmentBStart.x - segmentBEnd.x) +
+              Math.abs(segmentBStart.y - segmentBEnd.y),
+          })
         }
 
         for (let pa = 0; pa < pathsA.length; pa++) {
@@ -150,48 +219,26 @@ export class TraceOverlapShiftSolver extends BaseSolver {
                 const bHorz = Math.abs(b1.y - b2.y) < EPS
                 if (!bVert && !bHorz) continue
 
-                // Only consider colinear, parallel orientation overlaps
+                // Only consider collinear, parallel interactions.
                 if (aVert && bVert) {
                   if (Math.abs(a1.x - b1.x) < EPS) {
-                    if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
-                      const keyA = `${pa}:${sa}`
-                      const keyB = `${pb}:${sb}`
-                      if (!seenA.has(keyA)) {
-                        overlapsA.push({
-                          solvedTracePathIndex: pa,
-                          traceSegmentIndex: sa,
-                        })
-                        seenA.add(keyA)
-                      }
-                      if (!seenB.has(keyB)) {
-                        overlapsB.push({
-                          solvedTracePathIndex: pb,
-                          traceSegmentIndex: sb,
-                        })
-                        seenB.add(keyB)
-                      }
-                    }
+                    recordCollinearInteraction({
+                      pathAIndex: pa,
+                      segmentAIndex: sa,
+                      pathBIndex: pb,
+                      segmentBIndex: sb,
+                      rangeOverlap: getRangeOverlap1D(a1.y, a2.y, b1.y, b2.y),
+                    })
                   }
                 } else if (aHorz && bHorz) {
                   if (Math.abs(a1.y - b1.y) < EPS) {
-                    if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
-                      const keyA = `${pa}:${sa}`
-                      const keyB = `${pb}:${sb}`
-                      if (!seenA.has(keyA)) {
-                        overlapsA.push({
-                          solvedTracePathIndex: pa,
-                          traceSegmentIndex: sa,
-                        })
-                        seenA.add(keyA)
-                      }
-                      if (!seenB.has(keyB)) {
-                        overlapsB.push({
-                          solvedTracePathIndex: pb,
-                          traceSegmentIndex: sb,
-                        })
-                        seenB.add(keyB)
-                      }
-                    }
+                    recordCollinearInteraction({
+                      pathAIndex: pa,
+                      segmentAIndex: sa,
+                      pathBIndex: pb,
+                      segmentBIndex: sb,
+                      rangeOverlap: getRangeOverlap1D(a1.x, a2.x, b1.x, b2.x),
+                    })
                   }
                 }
               }
@@ -201,12 +248,44 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
         if (overlapsA.length > 0 && overlapsB.length > 0) {
           return {
+            interactionKind: "overlap",
             overlappingTraceSegments: [
               { connNetId: netA, pathsWithOverlap: overlapsA },
               { connNetId: netB, pathsWithOverlap: overlapsB },
             ],
           }
         }
+
+        // An elbow can touch on both axes. Separating the longest internal
+        // rail changes one coordinate and avoids moving both sides of it.
+        const bestPointContact = pointContacts.sort(
+          (a, b) => b.combinedLength - a.combinedLength,
+        )[0]
+        if (bestPointContact) {
+          return {
+            interactionKind: "point_contact",
+            overlappingTraceSegments: [
+              {
+                connNetId: netA,
+                pathsWithOverlap: [
+                  {
+                    solvedTracePathIndex: bestPointContact.pathAIndex,
+                    traceSegmentIndex: bestPointContact.segmentAIndex,
+                  },
+                ],
+              },
+              {
+                connNetId: netB,
+                pathsWithOverlap: [
+                  {
+                    solvedTracePathIndex: bestPointContact.pathBIndex,
+                    traceSegmentIndex: bestPointContact.segmentBIndex,
+                  },
+                ],
+              },
+            ],
+          }
+        }
       }
     }
 
@@ -306,10 +385,11 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       return
     }
 
-    const { overlappingTraceSegments } = overlapIssue
+    const { interactionKind, overlappingTraceSegments } = overlapIssue
 
     this.activeSubSolver = new TraceOverlapIssueSolver({
       inputProblem: this.inputProblem,
+      interactionKind,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands,
     })

package/package.json

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

package/site/bug-reports/bug-report-20260716T144856Z.page.tsx

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

package/site/bug-reports/bug-report-20260717T022934Z.page.tsx

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

package/site/bug-reports/bug-report-20260717T031704Z.page.tsx

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