@tscircuit/schematic-trace-solver 0.0.106 → 0.0.108

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -7,16 +7,18 @@ import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/Singl
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import type { FacingDirection } from "lib/utils/dir"
-import type { RectPadding } from "lib/utils/textBoxBounds"
+import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
 import { calculateDirectShortPath } from "./calculateDirectShortPath"
 import {
   findFirstCollision,
   isHorizontal,
   isVertical,
+  segmentIntersectsRect,
   segmentOverlapsRectBoundary,
 } from "./collisions"
 import { generateEndpointCollisionDetours } from "./generateEndpointCollisionDetours"
+import { generateInternalSegmentCollisionDetours } from "./generateInternalSegmentCollisionDetours"
 import {
   type Axis,
   aabbFromPoints,
@@ -24,7 +26,12 @@ import {
   midBetweenPointAndRect,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
-import { getObstacleRects, type ObstacleRect } from "./rect"
+import {
+  getObstacleRects,
+  isTextBoxObstacle,
+  type ObstacleRect,
+  type TextBoxObstacleRect,
+} from "./rect"
 
 type PathKey = string
 
@@ -58,8 +65,8 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
   chipMap: Record<string, InputChip>
 
   obstacles: ObstacleRect[]
-  textObstacles: Set<ObstacleRect>
-  endpointTextObstacles: Set<ObstacleRect>
+  textObstacles: Set<TextBoxObstacleRect>
+  endpointTextObstacles: Set<TextBoxObstacleRect>
   aabb: { minX: number; maxX: number; minY: number; maxY: number }
 
   baseElbow: Point[]
@@ -95,18 +102,17 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     this.obstacles = getObstacleRects(this.inputProblem, {
       textBoxPadding: this.getTextBoxPaddingForConnectionPair(),
     })
-    this.textObstacles = new Set(
-      this.obstacles.filter((r) => r.kind === "text_box"),
-    )
+    this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle))
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId))
     this.endpointTextObstacles = new Set(
       endpointChipIds.size > 1
-        ? this.obstacles.filter(
-            (r) =>
-              r.kind === "text_box" &&
-              r.textBox.chipId !== undefined &&
-              endpointChipIds.has(r.textBox.chipId),
-          )
+        ? this.obstacles
+            .filter(isTextBoxObstacle)
+            .filter(
+              (obstacle) =>
+                obstacle.textBox.chipId !== undefined &&
+                endpointChipIds.has(obstacle.textBox.chipId),
+            )
         : [],
     )
 
@@ -356,7 +362,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
           )
         ) {
           for (const textObstacle of this.endpointTextObstacles) {
-            excludedRects.add(textObstacle)
+            // Outside-pin-band routing may cross label padding around endpoint
+            // text, but the actual text bounds remain a hard obstacle.
+            const textBounds = getTextBoxBounds(textObstacle.textBox)
+            if (!segmentIntersectsRect(segmentStart, segmentEnd, textBounds)) {
+              excludedRects.add(textObstacle)
+            }
           }
         }
 
@@ -500,18 +511,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       pinBandPenalty: number
     }> = []
 
-    const addShiftedCandidate = (
-      candidateSegIndex: number,
-      candidateAxis: Axis,
-      coord: number,
-    ) => {
-      const newPath = shiftSegmentOrth(
-        path,
-        candidateSegIndex,
-        candidateAxis,
-        coord,
-      )
-      if (!newPath) return
+    const addPathCandidate = (newPath: Point[]) => {
       const key = pathKey(newPath)
       if (this.visited.has(key)) return
       this.visited.add(key)
@@ -525,11 +525,42 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       })
     }
 
+    const addShiftedCandidate = (
+      candidateSegIndex: number,
+      candidateAxis: Axis,
+      coord: number,
+    ) => {
+      const newPath = shiftSegmentOrth(
+        path,
+        candidateSegIndex,
+        candidateAxis,
+        coord,
+      )
+      if (newPath) addPathCandidate(newPath)
+    }
+
+    const lastSegIndex = path.length - 2
+    if (
+      this.connectionPair === undefined &&
+      rect.kind === "text_box" &&
+      this.endpointTextObstacles.has(rect) &&
+      !collisionRects.has(rect) &&
+      originalSegIndex > 0 &&
+      originalSegIndex < lastSegIndex
+    ) {
+      for (const detour of generateInternalSegmentCollisionDetours({
+        path,
+        collidingSegmentIndex: originalSegIndex,
+        obstacle: rect,
+      })) {
+        addPathCandidate(detour)
+      }
+    }
+
     for (const coord of candidates) {
       addShiftedCandidate(segIndex, axis, coord)
     }
 
-    const lastSegIndex = path.length - 2
     const adjacentSegmentIndexes =
       originalSegIndex === 1
         ? [2]

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts

@@ -1,6 +1,7 @@
 import type { Point } from "@tscircuit/math-utils"
 import { isHorizontal, isVertical } from "./collisions"
 import { type Axis, midBetweenPointAndRect } from "./mid"
+import { hasOnlyNonzeroOrthogonalSegments } from "./pathOps"
 import type { ObstacleRect } from "./rect"
 
 const getSegmentAxis = (start: Point, end: Point): Axis | null => {
@@ -9,16 +10,6 @@ const getSegmentAxis = (start: Point, end: Point): Axis | null => {
   return null
 }
 
-const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
-  path.every((point, index) => {
-    const nextPoint = path[index + 1]
-    if (!nextPoint) return true
-    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
-      return false
-    }
-    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
-  })
-
 export const generateEndpointCollisionDetours = ({
   path,
   collidingSegmentIndex,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateInternalSegmentCollisionDetours.ts

@@ -0,0 +1,94 @@
+import type { Point } from "@tscircuit/math-utils"
+import { isHorizontal, isVertical } from "./collisions"
+import { hasOnlyNonzeroOrthogonalSegments } from "./pathOps"
+import type { RectBounds } from "./rect"
+
+const EPS = 1e-9
+const DEFAULT_CLEARANCE = 0.2
+
+const isStrictlyBetween = (value: number, a: number, b: number) =>
+  value > Math.min(a, b) + EPS && value < Math.max(a, b) - EPS
+
+export const generateInternalSegmentCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle,
+  clearance = DEFAULT_CLEARANCE,
+}: {
+  path: Point[]
+  collidingSegmentIndex: number
+  obstacle: RectBounds
+  clearance?: number
+}): Point[][] => {
+  if (collidingSegmentIndex <= 0 || collidingSegmentIndex >= path.length - 2) {
+    return []
+  }
+
+  const start = path[collidingSegmentIndex]!
+  const end = path[collidingSegmentIndex + 1]!
+  const detourPoints: Point[][] = []
+
+  if (isHorizontal(start, end)) {
+    const movingRight = start.x < end.x
+    const entryX = movingRight
+      ? obstacle.minX - clearance
+      : obstacle.maxX + clearance
+    const exitX = movingRight
+      ? obstacle.maxX + clearance
+      : obstacle.minX - clearance
+
+    if (
+      !isStrictlyBetween(entryX, start.x, end.x) ||
+      !isStrictlyBetween(exitX, start.x, end.x)
+    ) {
+      return []
+    }
+
+    for (const detourY of [
+      obstacle.minY - clearance,
+      obstacle.maxY + clearance,
+    ]) {
+      detourPoints.push([
+        { x: entryX, y: start.y },
+        { x: entryX, y: detourY },
+        { x: exitX, y: detourY },
+        { x: exitX, y: end.y },
+      ])
+    }
+  } else if (isVertical(start, end)) {
+    const movingUp = start.y < end.y
+    const entryY = movingUp
+      ? obstacle.minY - clearance
+      : obstacle.maxY + clearance
+    const exitY = movingUp
+      ? obstacle.maxY + clearance
+      : obstacle.minY - clearance
+
+    if (
+      !isStrictlyBetween(entryY, start.y, end.y) ||
+      !isStrictlyBetween(exitY, start.y, end.y)
+    ) {
+      return []
+    }
+
+    for (const detourX of [
+      obstacle.minX - clearance,
+      obstacle.maxX + clearance,
+    ]) {
+      detourPoints.push([
+        { x: start.x, y: entryY },
+        { x: detourX, y: entryY },
+        { x: detourX, y: exitY },
+        { x: end.x, y: exitY },
+      ])
+    }
+  }
+
+  return detourPoints
+    .map((points) => [
+      ...path.slice(0, collidingSegmentIndex + 1),
+      ...points,
+      ...path.slice(collidingSegmentIndex + 1),
+    ])
+    .filter(hasOnlyNonzeroOrthogonalSegments)
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts

@@ -5,6 +5,16 @@ const EPS = 1e-9
 
 export type Axis = "x" | "y"
 
+export const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
+  path.every((point, index) => {
+    const nextPoint = path[index + 1]
+    if (!nextPoint) return true
+    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+      return false
+    }
+    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
+  })
+
 export const shiftSegmentOrth = (
   pts: Point[],
   segIndex: number,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts

@@ -1,5 +1,5 @@
-import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 
 export type RectBounds = {
@@ -21,6 +21,10 @@ export type TextBoxObstacleRect = RectBounds & {
 
 export type ObstacleRect = ChipObstacleRect | TextBoxObstacleRect
 
+export const isTextBoxObstacle = (
+  obstacle: ObstacleRect,
+): obstacle is TextBoxObstacleRect => obstacle.kind === "text_box"
+
 export const chipToRect = (chip: InputChip): ChipObstacleRect => {
   const b = getInputChipBounds(chip)
   return { kind: "chip", chipId: chip.chipId, ...b }

package/lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts

@@ -6,8 +6,14 @@ import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatia
 
 import { findAllLShapedTurns, type LShape } from "./findAllLShapedTurns"
 import { getTraceObstacles } from "./getTraceObstacles"
-import { findIntersectionsWithObstacles } from "./findIntersectionsWithObstacles"
-import { generateLShapeRerouteCandidates } from "./generateLShapeRerouteCandidates"
+import {
+  findIntersectionsWithObstacles,
+  findPerpendicularPathCrossings,
+} from "./findIntersectionsWithObstacles"
+import {
+  generateLShapeRerouteCandidates,
+  generatePerpendicularTraceDetours,
+} from "./generateLShapeRerouteCandidates"
 import { isPathColliding, type CollisionInfo } from "./isPathColliding"
 import {
   generateRectangleCandidates,
@@ -24,6 +30,19 @@ import { visualizeTightRectangle } from "../visualizeTightRectangle"
 import { visualizeCandidates } from "./visualizeCandidates"
 import { mergeGraphicsObjects } from "../mergeGraphicsObjects"
 import { visualizeCollision } from "./visualizeCollision"
+import {
+  getPathLength,
+  isPathCollidingWithChipInterior,
+} from "../../Example28Solver/geometry"
+import { getObstacleRects } from "../../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+
+interface TraceCrossing {
+  trace: SolvedTracePath
+  segmentIndex: number
+  otherTrace: SolvedTracePath
+  otherSegmentIndex: number
+  isInitialBundleCrossing: boolean
+}
 
 /**
  * Defines the input structure for the UntangleTraceSubsolver.
@@ -60,6 +79,9 @@ export class UntangleTraceSubsolver extends BaseSolver {
   private input: UntangleTraceSubsolverInput
   private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   private lShapesToProcess: LShape[] = []
+  private ignoredCrossings = new Set<string>()
+  private reroutedTraceIds = new Set<string>()
+  private processingCrossings = true
   private visualizationMode: VisualizationMode = "l_shapes"
 
   private currentLShape: LShape | null = null
@@ -95,13 +117,6 @@ export class UntangleTraceSubsolver extends BaseSolver {
       this.input.inputProblem._chipObstacleSpatialIndex =
         this.chipObstacleSpatialIndex
     }
-
-    for (const trace of this.input.allTraces) {
-      const lShapes = findAllLShapedTurns(trace.tracePath)
-      this.lShapesToProcess.push(
-        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId as string })),
-      )
-    }
   }
 
   override _step(): void {
@@ -110,6 +125,21 @@ export class UntangleTraceSubsolver extends BaseSolver {
       return
     }
 
+    if (this.processingCrossings) {
+      // The L-shape pass below only reacts when both arms intersect obstacles.
+      // Resolve strict crossings on merged-label bundles before entering it.
+      const crossing = this._findCrossing()
+      if (crossing) {
+        if (!this._resolveCrossing(crossing)) {
+          this.ignoredCrossings.add(this._crossingKey(crossing))
+        }
+        return
+      }
+      this.processingCrossings = false
+      this._initializeLShapes()
+      return
+    }
+
     if (this.lShapeJustProcessed) {
       this._resetAfterLShapProcessing()
       return
@@ -136,6 +166,145 @@ export class UntangleTraceSubsolver extends BaseSolver {
     }
   }
 
+  private _initializeLShapes() {
+    for (const trace of this.input.allTraces) {
+      this.lShapesToProcess.push(
+        ...findAllLShapedTurns(trace.tracePath).map((lShape) => ({
+          ...lShape,
+          traceId: trace.mspPairId,
+        })),
+      )
+    }
+  }
+
+  private _crossingKey(crossing: TraceCrossing) {
+    return `${crossing.trace.mspPairId}:${crossing.segmentIndex}:${crossing.otherTrace.mspPairId}:${crossing.otherSegmentIndex}`
+  }
+
+  private _isTraceBundle(first: SolvedTracePath, second: SolvedTracePath) {
+    const componentPair = (trace: SolvedTracePath) =>
+      trace.pins
+        .map((pin) => pin.chipId)
+        .sort()
+        .join(":")
+    if (componentPair(first) !== componentPair(second)) return false
+
+    return Object.values(this.input.mergedLabelNetIdMap).some(
+      (netIds) =>
+        netIds.has(first.globalConnNetId) && netIds.has(second.globalConnNetId),
+    )
+  }
+
+  private _findCrossing(): TraceCrossing | null {
+    const traces = this.input.allTraces
+    for (let firstIndex = 0; firstIndex < traces.length; firstIndex++) {
+      const trace = traces[firstIndex]!
+      for (
+        let secondIndex = firstIndex + 1;
+        secondIndex < traces.length;
+        secondIndex++
+      ) {
+        const otherTrace = traces[secondIndex]!
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue
+        const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace)
+        if (
+          !isInitialBundleCrossing &&
+          !this.reroutedTraceIds.has(trace.mspPairId) &&
+          !this.reroutedTraceIds.has(otherTrace.mspPairId)
+        ) {
+          continue
+        }
+
+        const crossings = findPerpendicularPathCrossings(
+          trace.tracePath,
+          otherTrace.tracePath,
+        )
+        for (const { pathSegmentIndex, otherPathSegmentIndex } of crossings) {
+          const crossing = {
+            trace,
+            segmentIndex: pathSegmentIndex,
+            otherTrace,
+            otherSegmentIndex: otherPathSegmentIndex,
+            isInitialBundleCrossing,
+          }
+          if (!this.ignoredCrossings.has(this._crossingKey(crossing))) {
+            return crossing
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  private _resolveCrossing(crossing: TraceCrossing) {
+    const chipBounds = this.chipObstacleSpatialIndex.chips.map(
+      (chip) => chip.bounds,
+    )
+    const candidates = [
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.trace,
+        segmentIndex: crossing.segmentIndex,
+        obstacleStart:
+          crossing.otherTrace.tracePath[crossing.otherSegmentIndex]!,
+        obstacleEnd:
+          crossing.otherTrace.tracePath[crossing.otherSegmentIndex + 1]!,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.otherTrace,
+        segmentIndex: crossing.otherSegmentIndex,
+        obstacleStart: crossing.trace.tracePath[crossing.segmentIndex]!,
+        obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1]!,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
+    ]
+    const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
+      (obstacle) => obstacle.kind === "chip",
+    )
+    // Prefer a globally clear route. If the initial bundle detour transfers
+    // the crossing, continue rip-up/reroute from that moved trace until clear.
+    const validCandidates = candidates
+      .map((candidate) => ({
+        ...candidate,
+        collision: isPathColliding(
+          candidate.path,
+          this.input.allTraces,
+          candidate.traceId,
+        ),
+      }))
+      .filter(
+        (candidate) =>
+          !isPathCollidingWithChipInterior(candidate.path, chipObstacles) &&
+          !isPathColliding(
+            candidate.path,
+            [crossing.trace, crossing.otherTrace],
+            candidate.traceId,
+          ).isColliding &&
+          (crossing.isInitialBundleCrossing ||
+            !candidate.collision.isColliding),
+      )
+      .sort(
+        (first, second) =>
+          Number(first.collision.isColliding) -
+            Number(second.collision.isColliding) ||
+          getPathLength(first.path) - getPathLength(second.path),
+      )
+    const bestCandidate = validCandidates[0]
+    if (!bestCandidate) return false
+
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === bestCandidate.traceId,
+    )
+    this.input.allTraces[traceIndex] = {
+      ...this.input.allTraces[traceIndex]!,
+      tracePath: bestCandidate.path,
+    }
+    this.reroutedTraceIds.add(bestCandidate.traceId)
+    return true
+  }
+
   private _resetAfterLShapProcessing() {
     this.lShapeProcessingStep = "idle"
     this.currentLShape = null

package/lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts

@@ -2,6 +2,13 @@ import type { Point } from "@tscircuit/math-utils"
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
 import type { TraceObstacle } from "./getTraceObstacles"
 
+const EPS = 1e-6
+
+export interface PerpendicularPathCrossing {
+  pathSegmentIndex: number
+  otherPathSegmentIndex: number
+}
+
 /**
  * Finds all intersection points between a given line segment (p1-p2) and a list of trace obstacles.
  * It iterates through each segment of every obstacle and checks for intersections with the input segment.
@@ -34,3 +41,55 @@ export const findIntersectionsWithObstacles = (
 
   return intersections
 }
+
+const isSamePoint = (first: Point, second: Point) =>
+  Math.abs(first.x - second.x) < EPS && Math.abs(first.y - second.y) < EPS
+
+export const findPerpendicularPathCrossings = (
+  path: Point[],
+  otherPath: Point[],
+): PerpendicularPathCrossing[] => {
+  const crossings: PerpendicularPathCrossing[] = []
+
+  // Terminal segments connect to pins and are allowed to meet other traces at
+  // their endpoints. Only internal, strict crossings need to be untangled.
+  for (
+    let pathSegmentIndex = 1;
+    pathSegmentIndex < path.length - 2;
+    pathSegmentIndex++
+  ) {
+    const start = path[pathSegmentIndex]!
+    const end = path[pathSegmentIndex + 1]!
+    const isVertical = Math.abs(start.x - end.x) < EPS
+
+    for (
+      let otherPathSegmentIndex = 1;
+      otherPathSegmentIndex < otherPath.length - 2;
+      otherPathSegmentIndex++
+    ) {
+      const otherStart = otherPath[otherPathSegmentIndex]!
+      const otherEnd = otherPath[otherPathSegmentIndex + 1]!
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS
+      if (isVertical === otherIsVertical) continue
+
+      const intersection = getSegmentIntersection(
+        start,
+        end,
+        otherStart,
+        otherEnd,
+      )
+      if (
+        !intersection ||
+        [start, end, otherStart, otherEnd].some((point) =>
+          isSamePoint(point, intersection),
+        )
+      ) {
+        continue
+      }
+
+      crossings.push({ pathSegmentIndex, otherPathSegmentIndex })
+    }
+  }
+
+  return crossings
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -1,6 +1,8 @@
-import type { Point } from "@tscircuit/math-utils"
+import type { Bounds, Point } from "@tscircuit/math-utils"
 import type { LShape } from "./findAllLShapedTurns"
 import type { Rectangle } from "./generateRectangleCandidates"
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { simplifyPath } from "../simplifyPath"
 
 const EPS = 1e-6
 
@@ -105,3 +107,64 @@ export const generateLShapeRerouteCandidates = ({
 
   return [[i1_padded, c2, i2_padded]]
 }
+
+export interface PerpendicularTraceDetourInput {
+  trace: SolvedTracePath
+  segmentIndex: number
+  obstacleStart: Point
+  obstacleEnd: Point
+  chipBounds: Bounds[]
+  clearance: number
+}
+
+export interface TraceDetourCandidate {
+  traceId: string
+  path: Point[]
+}
+
+export const generatePerpendicularTraceDetours = ({
+  trace,
+  segmentIndex,
+  obstacleStart,
+  obstacleEnd,
+  chipBounds,
+  clearance,
+}: PerpendicularTraceDetourInput): TraceDetourCandidate[] => {
+  const buildDetours = (path: Point[], index: number) => {
+    const start = path[index]!
+    const end = path[index + 1]!
+    const movingAxis: "x" | "y" = Math.abs(start.x - end.x) < EPS ? "y" : "x"
+    const detourAxis = movingAxis === "x" ? "y" : "x"
+    const gate =
+      obstacleStart[movingAxis] +
+      Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance
+    const obstacleRange = [obstacleStart[detourAxis], obstacleEnd[detourAxis]]
+    const lowBound = detourAxis === "x" ? "minX" : "minY"
+    const highBound = detourAxis === "x" ? "maxX" : "maxY"
+    const detourCoordinates = [
+      Math.min(...obstacleRange) - clearance,
+      Math.max(...obstacleRange) + clearance,
+      ...chipBounds.flatMap((bounds) => [
+        bounds[lowBound] - clearance,
+        bounds[highBound] + clearance,
+      ]),
+    ]
+
+    return [...new Set(detourCoordinates)].map((detour) =>
+      simplifyPath([
+        ...path.slice(0, index + 1),
+        { ...start, [movingAxis]: gate },
+        { ...start, [movingAxis]: gate, [detourAxis]: detour },
+        { ...end, [detourAxis]: detour },
+        ...path.slice(index + 2),
+      ]),
+    )
+  }
+
+  const reversedPath = [...trace.tracePath].reverse()
+  const reversedIndex = trace.tracePath.length - 2 - segmentIndex
+  return [
+    ...buildDetours(trace.tracePath, segmentIndex),
+    ...buildDetours(reversedPath, reversedIndex).map((path) => path.reverse()),
+  ].map((path) => ({ traceId: trace.mspPairId, path }))
+}

package/package.json

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