@tscircuit/schematic-trace-solver 0.0.137 → 0.0.141

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationObstacleIndex.ts

@@ -0,0 +1,182 @@
+import type { Bounds, Point } from "@tscircuit/math-utils"
+import Flatbush from "flatbush"
+import type { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { EPS } from "./constants"
+import { segmentCrossesBoundsInterior } from "./geometry"
+
+export type IndexedTraceSegment = {
+  trace: SolvedTracePath
+  start: Point
+  end: Point
+}
+
+export class AvailableNetOrientationObstacleIndex {
+  private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
+  private labelIndex: Flatbush | null = null
+  private traceSegmentIndex: Flatbush | null = null
+  private traceSegments: IndexedTraceSegment[] = []
+
+  constructor(params: {
+    chipObstacleSpatialIndex: ChipObstacleSpatialIndex
+    netLabelPlacements: NetLabelPlacement[]
+    traces: SolvedTracePath[]
+  }) {
+    this.chipObstacleSpatialIndex = params.chipObstacleSpatialIndex
+    this.rebuild(params)
+  }
+
+  rebuild(params: {
+    netLabelPlacements: NetLabelPlacement[]
+    traces: SolvedTracePath[]
+  }) {
+    this.labelIndex = this.buildLabelIndex(params.netLabelPlacements)
+    this.traceSegments = this.getTraceSegments(params.traces)
+    this.traceSegmentIndex = this.buildTraceSegmentIndex(this.traceSegments)
+  }
+
+  getLabelIndicesInBounds(bounds: Bounds) {
+    if (!this.labelIndex) return []
+    return this.labelIndex.search(
+      bounds.minX,
+      bounds.minY,
+      bounds.maxX,
+      bounds.maxY,
+    )
+  }
+
+  getTraceSegmentsInBounds(bounds: Bounds) {
+    if (!this.traceSegmentIndex) return []
+    const searchBounds = getPaddedBounds(bounds, EPS)
+    return this.traceSegmentIndex
+      .search(
+        searchBounds.minX,
+        searchBounds.minY,
+        searchBounds.maxX,
+        searchBounds.maxY,
+      )
+      .map((segmentIndex) => this.traceSegments[segmentIndex]!)
+  }
+
+  getLabelIndicesNearTracePath(tracePath: Point[]) {
+    const labelIndices = new Set<number>()
+    for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
+      const segmentBounds = getPaddedBounds(
+        getSegmentBounds(tracePath[pointIndex]!, tracePath[pointIndex + 1]!),
+        EPS,
+      )
+      for (const labelIndex of this.getLabelIndicesInBounds(segmentBounds)) {
+        labelIndices.add(labelIndex)
+      }
+    }
+    return [...labelIndices].sort((a, b) => a - b)
+  }
+
+  doesTracePathCrossChip(tracePath: Point[]) {
+    for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
+      const start = tracePath[pointIndex]!
+      const end = tracePath[pointIndex + 1]!
+      const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(
+        getPaddedBounds(getSegmentBounds(start, end), EPS),
+      )
+      for (const chip of nearbyChips) {
+        if (segmentCrossesBoundsInterior(start, end, chip.bounds)) return true
+      }
+    }
+    return false
+  }
+
+  doesTraceCrossBoundsInterior(bounds: Bounds) {
+    for (const segment of this.getTraceSegmentsInBounds(bounds)) {
+      if (segmentCrossesBoundsInterior(segment.start, segment.end, bounds)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  doesTraceIntersectBounds(params: {
+    bounds: Bounds
+    excludedGlobalConnNetId: string
+  }) {
+    for (const segment of this.getTraceSegmentsInBounds(params.bounds)) {
+      if (segment.trace.globalConnNetId === params.excludedGlobalConnNetId) {
+        continue
+      }
+      if (segmentIntersectsRect(segment.start, segment.end, params.bounds)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  private buildLabelIndex(netLabelPlacements: NetLabelPlacement[]) {
+    if (netLabelPlacements.length === 0) return null
+
+    const labelIndex = new Flatbush(netLabelPlacements.length)
+    for (const label of netLabelPlacements) {
+      labelIndex.add(
+        label.center.x - label.width / 2,
+        label.center.y - label.height / 2,
+        label.center.x + label.width / 2,
+        label.center.y + label.height / 2,
+      )
+    }
+    labelIndex.finish()
+    return labelIndex
+  }
+
+  private getTraceSegments(traces: SolvedTracePath[]) {
+    const traceSegments: IndexedTraceSegment[] = []
+    for (const trace of traces) {
+      for (
+        let pointIndex = 0;
+        pointIndex < trace.tracePath.length - 1;
+        pointIndex++
+      ) {
+        traceSegments.push({
+          trace,
+          start: trace.tracePath[pointIndex]!,
+          end: trace.tracePath[pointIndex + 1]!,
+        })
+      }
+    }
+    return traceSegments
+  }
+
+  private buildTraceSegmentIndex(traceSegments: IndexedTraceSegment[]) {
+    if (traceSegments.length === 0) return null
+
+    const traceSegmentIndex = new Flatbush(traceSegments.length)
+    for (const segment of traceSegments) {
+      traceSegmentIndex.add(
+        Math.min(segment.start.x, segment.end.x),
+        Math.min(segment.start.y, segment.end.y),
+        Math.max(segment.start.x, segment.end.x),
+        Math.max(segment.start.y, segment.end.y),
+      )
+    }
+    traceSegmentIndex.finish()
+    return traceSegmentIndex
+  }
+}
+
+function getSegmentBounds(start: Point, end: Point): Bounds {
+  return {
+    minX: Math.min(start.x, end.x),
+    minY: Math.min(start.y, end.y),
+    maxX: Math.max(start.x, end.x),
+    maxY: Math.max(start.y, end.y),
+  }
+}
+
+function getPaddedBounds(bounds: Bounds, padding: number): Bounds {
+  return {
+    minX: bounds.minX - padding,
+    minY: bounds.minY - padding,
+    maxX: bounds.maxX + padding,
+    maxY: bounds.maxY + padding,
+  }
+}

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -17,7 +17,12 @@ import type {
 } from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
-import { EPS, LABEL_SEARCH_STEP, WICK_CLEARANCE } from "./constants"
+import {
+  EPS,
+  LABEL_SEARCH_STEP,
+  MAX_RECORDED_CANDIDATES,
+  WICK_CLEARANCE,
+} from "./constants"
 import {
   getConnectorTracePath,
   getMaxSearchDistance,
@@ -27,8 +32,6 @@ import {
   rangesOverlap,
   rectsOverlap,
   simplifyOrthogonalPath,
-  traceCrossesBoundsInterior,
-  tracePathCrossesAnyBounds,
   tracePathIntersectsBounds,
 } from "./geometry"
 import { orderRoutedLabelsBeforeOverlappingPortLabels } from "./orderRoutedLabelsBeforeOverlappingPortLabels"
@@ -43,6 +46,7 @@ import type {
   EvaluatedCandidate,
 } from "./types"
 import { visualizeAvailableNetOrientationSolver } from "./visualize"
+import { AvailableNetOrientationObstacleIndex } from "./AvailableNetOrientationObstacleIndex"
 
 const LABEL_TRACE_CLEARANCE = 0.1
 
@@ -64,6 +68,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   private maxSearchDistance: number
   private pinMap: Record<string, InputPin & { chipId: string }>
+  private obstacleIndex: AvailableNetOrientationObstacleIndex
 
   constructor(params: AvailableNetOrientationSolverParams) {
     super()
@@ -79,6 +84,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       params.inputProblem._chipObstacleSpatialIndex ??
       new ChipObstacleSpatialIndex(params.inputProblem.chips)
     this.maxSearchDistance = getMaxSearchDistance(params.inputProblem)
+    this.obstacleIndex = new AvailableNetOrientationObstacleIndex({
+      chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
+      netLabelPlacements: this.outputNetLabelPlacements,
+      traces: this.traces,
+    })
     this.crowdedPortOnlyLabelIndices = this.getCrowdedPortOnlyLabelIndices()
     this.queuedLabelIndices = this.getProcessableLabelIndices()
     this.setCurrentLabel(this.queuedLabelIndices[0] ?? null)
@@ -309,6 +319,10 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       ...toNetLabelPlacementPatch(candidate),
     }
     this.addConnectorTrace(label, candidate, labelIndex)
+    this.obstacleIndex.rebuild({
+      netLabelPlacements: this.outputNetLabelPlacements,
+      traces: this.traces,
+    })
   }
 
   private addConnectorTrace(
@@ -553,7 +567,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         anchorY - label.anchorPoint.y,
         anchorX - label.anchorPoint.x,
       )
-      this.currentCandidateResults.push(result)
+      this.recordCandidateResult(result)
       if (result.status !== "valid") continue
 
       result.selected = true
@@ -605,7 +619,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         labelIndex,
         "rotate",
       )
-      this.currentCandidateResults.push(result)
+      this.recordCandidateResult(result)
       if (result.status === "valid") {
         result.selected = true
         return result
@@ -637,7 +651,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         labelIndex,
         "trace-anchor",
       )
-      this.currentCandidateResults.push(result)
+      this.recordCandidateResult(result)
 
       if (result.status === "valid") {
         result.selected = true
@@ -682,7 +696,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         labelIndex,
         "outward-trace-anchor",
       )
-      this.currentCandidateResults.push(preservedColumnResult)
+      this.recordCandidateResult(preservedColumnResult)
       if (preservedColumnResult.status === "valid") {
         preservedColumnResult.selected = true
         return preservedColumnResult
@@ -716,7 +730,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
           "outward-trace-anchor",
           distance,
         )
-        this.currentCandidateResults.push(result)
+        this.recordCandidateResult(result)
 
         if (result.status === "valid") {
           result.selected = true
@@ -891,7 +905,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         distance,
         outwardDistance,
       )
-      this.currentCandidateResults.push(result)
+      this.recordCandidateResult(result)
 
       if (result.status === "valid") {
         result.selected = true
@@ -926,6 +940,19 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     }
   }
 
+  private recordCandidateResult(candidate: EvaluatedCandidate) {
+    this.stats.candidateEvaluations = (this.stats.candidateEvaluations ?? 0) + 1
+    if (this.currentCandidateResults.length < MAX_RECORDED_CANDIDATES) {
+      this.currentCandidateResults.push(candidate)
+    } else if (candidate.status === "valid") {
+      this.currentCandidateResults[MAX_RECORDED_CANDIDATES - 1] = candidate
+    }
+    this.stats.maxRecordedCandidates = Math.max(
+      this.stats.maxRecordedCandidates ?? 0,
+      this.currentCandidateResults.length,
+    )
+  }
+
   private getCandidateConnectorTrace(
     label: NetLabelPlacement,
     candidate: Pick<
@@ -1269,13 +1296,13 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       labelIndex,
     )
 
-    for (const chip of this.chipObstacleSpatialIndex.chips) {
-      if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
-        return "chip-collision"
-      }
+    if (this.obstacleIndex.doesTracePathCrossChip(connectorTrace)) {
+      return "chip-collision"
     }
 
-    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+    for (const i of this.obstacleIndex.getLabelIndicesNearTracePath(
+      connectorTrace,
+    )) {
       if (i === labelIndex) continue
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue
       const otherLabel = this.outputNetLabelPlacements[i]!
@@ -1345,7 +1372,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
       return "text-collision"
     }
-    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+    if (this.obstacleIndex.doesTraceCrossBoundsInterior(bounds)) {
       return "trace-collision"
     }
     if (this.isTraceTooCloseToLabel(bounds, label)) {
@@ -1361,14 +1388,10 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (!this.shouldCheckTraceClearanceForLabel(label)) return false
 
     const clearanceBounds = this.getLabelTraceClearanceBounds(bounds)
-    for (const trace of Object.values(this.traceMap)) {
-      if (trace.globalConnNetId === label.globalConnNetId) continue
-      if (tracePathIntersectsBounds(trace.tracePath, clearanceBounds)) {
-        return true
-      }
-    }
-
-    return false
+    return this.obstacleIndex.doesTraceIntersectBounds({
+      bounds: clearanceBounds,
+      excludedGlobalConnNetId: label.globalConnNetId,
+    })
   }
 
   private getLabelTraceClearanceBounds(bounds: Bounds): Bounds {
@@ -1496,7 +1519,17 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   }
 
   private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
-    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+    const searchBounds = {
+      minX: bounds.minX - LABEL_SEARCH_STEP,
+      minY: bounds.minY - LABEL_SEARCH_STEP,
+      maxX: bounds.maxX + LABEL_SEARCH_STEP,
+      maxY: bounds.maxY + LABEL_SEARCH_STEP,
+    }
+    const nearbyLabelIndices = this.obstacleIndex
+      .getLabelIndicesInBounds(searchBounds)
+      .sort((a, b) => a - b)
+
+    for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue
       const label = this.outputNetLabelPlacements[i]!
@@ -1515,7 +1548,16 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   }
 
   private sharesChipBoundary(bounds: Bounds) {
-    for (const chip of this.chipObstacleSpatialIndex.chips) {
+    const boundarySearchBounds = {
+      minX: bounds.minX - WICK_CLEARANCE - EPS,
+      minY: bounds.minY - WICK_CLEARANCE - EPS,
+      maxX: bounds.maxX + WICK_CLEARANCE + EPS,
+      maxY: bounds.maxY + WICK_CLEARANCE + EPS,
+    }
+    const nearbyChips =
+      this.chipObstacleSpatialIndex.getChipsInBounds(boundarySearchBounds)
+
+    for (const chip of nearbyChips) {
       const chipBounds = chip.bounds
       const adjacentToVerticalSide =
         Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS ||

package/lib/solvers/AvailableNetOrientationSolver/constants.ts

@@ -1,4 +1,6 @@
 export const LABEL_SEARCH_STEP = 0.05
+// Keep failed searches from retaining an unbounded visualization history.
+export const MAX_RECORDED_CANDIDATES = 2_000
 export const WICK_CLEARANCE = 0.001
 export const EPS = 1e-9
 export const TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS

package/lib/solvers/Example28Solver/labelMovement.ts

@@ -1,6 +1,7 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import { getMovedAnchorPointForReroute } from "./getMovedAnchorPointForReroute"
 import { isLabelAttachedToTrace } from "./isLabelAttachedToTrace"
 
@@ -39,3 +40,73 @@ export const moveAttachedLabelsToReroutedTrace = ({
       },
     }
   })
+
+export const moveNetLabelConnectorsToReroutedTraces = ({
+  originalTraces,
+  reroutedTraces,
+  netLabelPlacements,
+}: {
+  originalTraces: SolvedTracePath[]
+  reroutedTraces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  const traces = [...reroutedTraces]
+  const reroutedTraceMap = new Map(
+    reroutedTraces.map((trace) => [trace.mspPairId, trace]),
+  )
+
+  const labels = netLabelPlacements.map((label) => {
+    const originalHostTrace = originalTraces.find((trace) => {
+      if (!label.mspConnectionPairIds.includes(trace.mspPairId)) return false
+      const reroutedTrace = reroutedTraceMap.get(trace.mspPairId)
+      if (!reroutedTrace) return false
+      return reroutedTrace.tracePath !== trace.tracePath
+    })
+    if (!originalHostTrace) return label
+
+    const reroutedHostTrace = reroutedTraceMap.get(originalHostTrace.mspPairId)!
+    const connectorIndex = originalTraces.findIndex((trace) => {
+      if (trace.mspPairId === originalHostTrace.mspPairId) return false
+      if (trace.globalConnNetId !== label.globalConnNetId) return false
+      if (!tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+        return false
+      }
+      return label.pinIds.every((pinId) => trace.pinIds.includes(pinId))
+    })
+    if (connectorIndex < 0) return label
+
+    const connector = originalTraces[connectorIndex]!
+    const originalJunction = connector.tracePath.find((point) =>
+      tracePathContainsPoint(originalHostTrace.tracePath, point),
+    )
+    if (!originalJunction) return label
+
+    const reroutedJunction = getMovedAnchorPointForReroute(
+      originalJunction,
+      originalHostTrace.tracePath,
+      reroutedHostTrace.tracePath,
+    )
+    if (!reroutedJunction) return label
+
+    const delta = {
+      x: reroutedJunction.x - originalJunction.x,
+      y: reroutedJunction.y - originalJunction.y,
+    }
+    const movedConnector = {
+      ...connector,
+      tracePath: connector.tracePath.map((point) => ({
+        x: point.x + delta.x,
+        y: point.y + delta.y,
+      })),
+    }
+    traces[connectorIndex] = movedConnector
+    return moveAttachedLabelsToReroutedTrace({
+      trace: connector,
+      originalTracePath: connector.tracePath,
+      reroutedTracePath: movedConnector.tracePath,
+      netLabelPlacements: [label],
+    })[0]!
+  })
+
+  return { traces, netLabelPlacements: labels }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -22,7 +22,10 @@ import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePa
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
-import { moveAttachedLabelsToReroutedTrace } from "../Example28Solver/labelMovement"
+import {
+  moveAttachedLabelsToReroutedTrace,
+  moveNetLabelConnectorsToReroutedTraces,
+} from "../Example28Solver/labelMovement"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 import { RailNetLabelCornerPlacementSolver } from "../RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
@@ -426,12 +429,17 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         const previousOutput =
           instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
         const alignmentOutput = instance.traceCleanupSolver2!.getOutput()
+        const connectorMovement = moveNetLabelConnectorsToReroutedTraces({
+          originalTraces: previousOutput.traces,
+          reroutedTraces: alignmentOutput.traces,
+          netLabelPlacements: previousOutput.netLabelPlacements,
+        })
         const previousTraceMap = new Map(
           previousOutput.traces.map((trace) => [trace.mspPairId, trace]),
         )
-        let netLabelPlacements = previousOutput.netLabelPlacements
+        let netLabelPlacements = connectorMovement.netLabelPlacements
 
-        for (const trace of alignmentOutput.traces) {
+        for (const trace of connectorMovement.traces) {
           const previousTrace = previousTraceMap.get(trace.mspPairId)
           if (!previousTrace || previousTrace.tracePath === trace.tracePath) {
             continue
@@ -455,7 +463,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: alignmentOutput.traces,
+            traces: connectorMovement.traces,
             netLabelPlacements,
           },
         ]

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -11,6 +11,9 @@ import {
 import type { MspConnectionPairId } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 
 type ConnNetId = string
+type TraceState = Record<MspConnectionPairId, SolvedTracePath>
+
+const TRACE_STATE_POSITION_EPSILON = 1e-6
 
 /**
  * This solver finds traces that overlap or meet collinearly and aren't
@@ -44,6 +47,9 @@ export class TraceOverlapShiftSolver extends BaseSolver {
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>> = {}
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
+  // Keep only the current and previous layouts to detect a two-state cycle
+  // without accumulating routing history for the whole solve.
+  recentTraceStates: TraceState[] = []
 
   cleanupPhase: "diagonals" | "done" | null = null
 
@@ -64,6 +70,8 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       this.correctedTraceMap[mspPairId] = tracePath
     }
 
+    this.rememberTraceState(this.correctedTraceMap)
+
     this.traceNetIslands = this.computeTraceNetIslands()
   }
 
@@ -361,11 +369,19 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
   override _step() {
     if (this.activeSubSolver?.solved) {
-      for (const [mspPairId, newTrace] of Object.entries(
-        this.activeSubSolver.correctedTraceMap,
-      )) {
-        this.correctedTraceMap[mspPairId] = newTrace
+      const nextTraceState = {
+        ...this.correctedTraceMap,
+        ...this.activeSubSolver.correctedTraceMap,
       }
+      // Returning to the older retained layout means corrections are bouncing
+      // A -> B -> A. Keep B and finish this pass instead of retrying forever.
+      if (this.returnsToPreviousTraceState(nextTraceState)) {
+        this.activeSubSolver = null
+        this.solved = true
+        return
+      }
+      this.correctedTraceMap = nextTraceState
+      this.rememberTraceState(nextTraceState)
       this.activeSubSolver = null
       this.traceNetIslands = this.computeTraceNetIslands()
     }
@@ -407,6 +423,46 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     })
   }
 
+  private rememberTraceState(traceState: TraceState) {
+    this.recentTraceStates.push({ ...traceState })
+    if (this.recentTraceStates.length > 2) {
+      this.recentTraceStates.shift()
+    }
+  }
+
+  private returnsToPreviousTraceState(candidateTraceState: TraceState) {
+    if (this.recentTraceStates.length < 2) return false
+
+    const previousTraceState = this.recentTraceStates[0]!
+    const traceIds = Object.keys(candidateTraceState)
+    if (traceIds.length !== Object.keys(previousTraceState).length) return false
+
+    // Corrections create new objects, so compare the trace geometry itself.
+    for (const traceId of traceIds) {
+      const candidatePath = candidateTraceState[traceId]
+      const previousPath = previousTraceState[traceId]
+      if (!candidatePath || !previousPath) return false
+      if (candidatePath.tracePath.length !== previousPath.tracePath.length) {
+        return false
+      }
+
+      for (let i = 0; i < candidatePath.tracePath.length; i++) {
+        const candidatePoint = candidatePath.tracePath[i]!
+        const previousPoint = previousPath.tracePath[i]!
+        if (
+          Math.abs(candidatePoint.x - previousPoint.x) >
+            TRACE_STATE_POSITION_EPSILON ||
+          Math.abs(candidatePoint.y - previousPoint.y) >
+            TRACE_STATE_POSITION_EPSILON
+        ) {
+          return false
+        }
+      }
+    }
+
+    return true
+  }
+
   override visualize() {
     if (this.activeSubSolver) {
       return this.activeSubSolver.visualize()

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tscircuit/schematic-trace-solver.git"
+  },
   "main": "dist/index.js",
-  "version": "0.0.137",
+  "version": "0.0.141",
   "type": "module",
   "scripts": {
     "start": "cosmos",