@tscircuit/schematic-trace-solver 0.0.120 → 0.0.121

package/dist/index.js

@@ -3922,7 +3922,12 @@ var generateRerouteCandidates = ({
 };
 
 // lib/utils/doesPathCoincideWithTraces.ts
+import { boundsIntersection } from "@tscircuit/math-utils";
 var COINCIDENT_EPS = 2e-3;
+var GEOMETRY_EPS = 1e-6;
+var SCHEMATIC_TRACE_STROKE_WIDTH = 0.02;
+var SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH + GEOMETRY_EPS;
+var SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH * 3;
 var doesPathCoincideWithTraces = (path, traces) => {
   const rangesOverlap1D = (a1, a2, b1, b2) => Math.min(Math.max(a1, a2), Math.max(b1, b2)) - Math.max(Math.min(a1, a2), Math.min(b1, b2)) > COINCIDENT_EPS;
   for (let i = 0; i < path.length - 1; i++) {
@@ -3954,6 +3959,44 @@ var doesPathCoincideWithTraces = (path, traces) => {
   }
   return false;
 };
+var doesPathOverlapTraceStrokes = (path, traces) => {
+  const traceStrokeRadius = SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE / 2;
+  const getStrokeBounds = (start, end, isVertical5) => isVertical5 ? {
+    minX: start.x - traceStrokeRadius,
+    maxX: start.x + traceStrokeRadius,
+    minY: Math.min(start.y, end.y),
+    maxY: Math.max(start.y, end.y)
+  } : {
+    minX: Math.min(start.x, end.x),
+    maxX: Math.max(start.x, end.x),
+    minY: start.y - traceStrokeRadius,
+    maxY: start.y + traceStrokeRadius
+  };
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    const pathStart = path[pathIndex];
+    const pathEnd = path[pathIndex + 1];
+    const isVertical5 = Math.abs(pathStart.x - pathEnd.x) < COINCIDENT_EPS;
+    const isHorizontal4 = Math.abs(pathStart.y - pathEnd.y) < COINCIDENT_EPS;
+    if (!isVertical5 && !isHorizontal4) continue;
+    const pathBounds = getStrokeBounds(pathStart, pathEnd, isVertical5);
+    for (const trace of traces) {
+      for (let traceIndex = 0; traceIndex < trace.tracePath.length - 1; traceIndex++) {
+        const traceStart = trace.tracePath[traceIndex];
+        const traceEnd = trace.tracePath[traceIndex + 1];
+        const isParallel = isVertical5 ? Math.abs(traceStart.x - traceEnd.x) < COINCIDENT_EPS : Math.abs(traceStart.y - traceEnd.y) < COINCIDENT_EPS;
+        if (!isParallel) continue;
+        const overlap = boundsIntersection(
+          pathBounds,
+          getStrokeBounds(traceStart, traceEnd, isVertical5)
+        );
+        if (!overlap) continue;
+        const overlapLength = isVertical5 ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
+        if (overlapLength > COINCIDENT_EPS) return true;
+      }
+    }
+  }
+  return false;
+};
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
@@ -5307,6 +5350,53 @@ var balanceZShapes = ({
   };
 };
 
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailAlignmentFallbackCoordinates.ts
+import { boundsIntersection as boundsIntersection2 } from "@tscircuit/math-utils";
+var getAlongBounds = (orientation, minAlong, maxAlong) => orientation === "vertical" ? { minX: 0, maxX: 0, minY: minAlong, maxY: maxAlong } : { minX: minAlong, maxX: maxAlong, minY: 0, maxY: 0 };
+var hasPositiveAlongOverlap = (orientation, first, second) => {
+  const overlap = boundsIntersection2(first, second);
+  if (!overlap) return false;
+  const overlapLength = orientation === "vertical" ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
+  return overlapLength > RAIL_ALIGNMENT_EPSILON;
+};
+var getRailAlignmentFallbackCoordinates = ({
+  group,
+  originalCoordinates,
+  otherNetTraces
+}) => {
+  const orientation = group[0].orientation;
+  const groupAlongBounds = group.map(
+    (segment) => getAlongBounds(orientation, segment.minAlong, segment.maxAlong)
+  );
+  const fallbackClearance = SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE;
+  const coordinates = [];
+  for (const trace of otherNetTraces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index];
+      const end = trace.tracePath[index + 1];
+      if (getRailOrientation(start, end) !== orientation) continue;
+      const minAlong = orientation === "vertical" ? Math.min(start.y, end.y) : Math.min(start.x, end.x);
+      const maxAlong = orientation === "vertical" ? Math.max(start.y, end.y) : Math.max(start.x, end.x);
+      const traceAlongBounds = getAlongBounds(orientation, minAlong, maxAlong);
+      if (!groupAlongBounds.some(
+        (bounds) => hasPositiveAlongOverlap(orientation, bounds, traceAlongBounds)
+      )) {
+        continue;
+      }
+      const coordinate = orientation === "vertical" ? start.x : start.y;
+      const touchesOriginalCandidate = originalCoordinates.some(
+        (originalCoordinate) => Math.abs(originalCoordinate - coordinate) <= SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE
+      );
+      if (!touchesOriginalCandidate) continue;
+      coordinates.push(
+        coordinate - fallbackClearance,
+        coordinate + fallbackClearance
+      );
+    }
+  }
+  return getDistinctCoordinates(coordinates);
+};
+
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
 var moveRailSegments = (trace, segments, coordinate) => {
   const pointsToMove = /* @__PURE__ */ new Set();
@@ -5578,7 +5668,7 @@ var evaluateRailGroup = ({
     (trace) => groupTraceIds.has(trace.mspPairId)
   );
   const baseline = getTraceGeometryMetrics(originalGroupTraces, traces);
-  const coordinates = getDistinctCoordinates(
+  const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate)
   );
   const otherNetTraces = traces.filter(
@@ -5587,58 +5677,72 @@ var evaluateRailGroup = ({
   const immutableSameNetTraces = traces.filter(
     (trace) => trace.globalConnNetId === group[0].globalConnNetId && !eligibleTraceIds.has(trace.mspPairId)
   );
-  let best = null;
-  for (const coordinate of coordinates) {
-    const candidateMap = /* @__PURE__ */ new Map();
-    for (const trace of originalGroupTraces) {
-      const candidateTrace = moveRailSegments(
-        trace,
-        group.filter((segment) => segment.traceId === trace.mspPairId),
-        coordinate
+  const evaluateCoordinates = (coordinates) => {
+    let best = null;
+    for (const coordinate of coordinates) {
+      const candidateMap = /* @__PURE__ */ new Map();
+      for (const trace of originalGroupTraces) {
+        const candidateTrace = moveRailSegments(
+          trace,
+          group.filter((segment) => segment.traceId === trace.mspPairId),
+          coordinate
+        );
+        candidateMap.set(trace.mspPairId, candidateTrace);
+      }
+      const candidateTraces = [...candidateMap.values()];
+      const allCandidateTraces = traces.map(
+        (trace) => candidateMap.get(trace.mspPairId) ?? trace
       );
-      candidateMap.set(trace.mspPairId, candidateTrace);
-    }
-    const candidateTraces = [...candidateMap.values()];
-    const allCandidateTraces = traces.map(
-      (trace) => candidateMap.get(trace.mspPairId) ?? trace
-    );
-    const candidatesAreClear = candidateTraces.every(
-      (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
-        traces: [candidate2],
-        netLabels: netLabelPlacements
-      }).length === 0 && !doesPathCoincideWithTraces(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
-        candidate2.tracePath,
-        immutableSameNetTraces.filter(
-          (trace) => trace.mspPairId !== candidate2.mspPairId
+      const candidatesAreClear = candidateTraces.every(
+        (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
+          traces: [candidate2],
+          netLabels: netLabelPlacements
+        }).length === 0 && !doesPathOverlapTraceStrokes(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
+          candidate2.tracePath,
+          immutableSameNetTraces.filter(
+            (trace) => trace.mspPairId !== candidate2.mspPairId
+          )
         )
-      )
-    );
-    if (!candidatesAreClear) continue;
-    if (!preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)) {
-      continue;
-    }
-    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces);
-    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
-    if (!isReadabilityImprovement(metrics, baseline)) continue;
-    const score = {
-      ...metrics,
-      displacement: group.reduce(
-        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
-        0
-      ),
-      coordinate
-    };
-    const changedTraceIds = candidateTraces.filter((candidate2) => {
-      const original = traces.find(
-        (trace) => trace.mspPairId === candidate2.mspPairId
       );
-      return tracePathChanged(original, candidate2);
-    }).map((trace) => trace.mspPairId);
-    if (changedTraceIds.length === 0) continue;
-    const candidate = { traces: allCandidateTraces, changedTraceIds, score };
-    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
-  }
-  return best;
+      if (!candidatesAreClear) continue;
+      if (!preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)) {
+        continue;
+      }
+      const metrics = getTraceGeometryMetrics(
+        candidateTraces,
+        allCandidateTraces
+      );
+      if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
+      if (!isReadabilityImprovement(metrics, baseline)) continue;
+      const score = {
+        ...metrics,
+        displacement: group.reduce(
+          (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+          0
+        ),
+        coordinate
+      };
+      const changedTraceIds = candidateTraces.filter((candidate2) => {
+        const original = traces.find(
+          (trace) => trace.mspPairId === candidate2.mspPairId
+        );
+        return tracePathChanged(original, candidate2);
+      }).map((trace) => trace.mspPairId);
+      if (changedTraceIds.length === 0) continue;
+      const candidate = { traces: allCandidateTraces, changedTraceIds, score };
+      if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
+    }
+    return best;
+  };
+  const originalCandidate = evaluateCoordinates(originalCoordinates);
+  if (originalCandidate) return originalCandidate;
+  return evaluateCoordinates(
+    getRailAlignmentFallbackCoordinates({
+      group,
+      originalCoordinates,
+      otherNetTraces
+    })
+  );
 };
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts

@@ -3,8 +3,12 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
-import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import {
+  doesPathCoincideWithTraces,
+  doesPathOverlapTraceStrokes,
+} from "lib/utils/doesPathCoincideWithTraces"
 import { getDistinctCoordinates, pointsEqual } from "./geometry"
+import { getRailAlignmentFallbackCoordinates } from "./getRailAlignmentFallbackCoordinates"
 import { moveRailSegments } from "./moveRailSegments"
 import { preservesLabelAnchors } from "./preservesLabelAnchors"
 import {
@@ -43,7 +47,7 @@ export const evaluateRailGroup = ({
     groupTraceIds.has(trace.mspPairId),
   )
   const baseline = getTraceGeometryMetrics(originalGroupTraces, traces)
-  const coordinates = getDistinctCoordinates(
+  const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate),
   )
   const otherNetTraces = traces.filter(
@@ -55,70 +59,86 @@ export const evaluateRailGroup = ({
       !eligibleTraceIds.has(trace.mspPairId),
   )
 
-  let best: AlignmentCandidate | null = null
-  for (const coordinate of coordinates) {
-    const candidateMap = new Map<string, SolvedTracePath>()
+  const evaluateCoordinates = (coordinates: number[]) => {
+    let best: AlignmentCandidate | null = null
+    for (const coordinate of coordinates) {
+      const candidateMap = new Map<string, SolvedTracePath>()
 
-    for (const trace of originalGroupTraces) {
-      const candidateTrace = moveRailSegments(
-        trace,
-        group.filter((segment) => segment.traceId === trace.mspPairId),
-        coordinate,
-      )
-      candidateMap.set(trace.mspPairId, candidateTrace)
-    }
+      for (const trace of originalGroupTraces) {
+        const candidateTrace = moveRailSegments(
+          trace,
+          group.filter((segment) => segment.traceId === trace.mspPairId),
+          coordinate,
+        )
+        candidateMap.set(trace.mspPairId, candidateTrace)
+      }
 
-    const candidateTraces = [...candidateMap.values()]
-    const allCandidateTraces = traces.map(
-      (trace) => candidateMap.get(trace.mspPairId) ?? trace,
-    )
-    const candidatesAreClear = candidateTraces.every(
-      (candidate) =>
-        !isPathCollidingWithObstacles(candidate.tracePath, obstacles) &&
-        detectTraceLabelOverlap({
-          traces: [candidate],
-          netLabels: netLabelPlacements,
-        }).length === 0 &&
-        !doesPathCoincideWithTraces(candidate.tracePath, otherNetTraces) &&
-        !doesPathCoincideWithTraces(
-          candidate.tracePath,
-          immutableSameNetTraces.filter(
-            (trace) => trace.mspPairId !== candidate.mspPairId,
+      const candidateTraces = [...candidateMap.values()]
+      const allCandidateTraces = traces.map(
+        (trace) => candidateMap.get(trace.mspPairId) ?? trace,
+      )
+      const candidatesAreClear = candidateTraces.every(
+        (candidate) =>
+          !isPathCollidingWithObstacles(candidate.tracePath, obstacles) &&
+          detectTraceLabelOverlap({
+            traces: [candidate],
+            netLabels: netLabelPlacements,
+          }).length === 0 &&
+          !doesPathOverlapTraceStrokes(candidate.tracePath, otherNetTraces) &&
+          !doesPathCoincideWithTraces(
+            candidate.tracePath,
+            immutableSameNetTraces.filter(
+              (trace) => trace.mspPairId !== candidate.mspPairId,
+            ),
           ),
-        ),
-    )
-    if (!candidatesAreClear) continue
-    if (
-      !preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)
-    ) {
-      continue
-    }
+      )
+      if (!candidatesAreClear) continue
+      if (
+        !preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)
+      ) {
+        continue
+      }
 
-    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces)
-    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue
-    if (!isReadabilityImprovement(metrics, baseline)) continue
+      const metrics = getTraceGeometryMetrics(
+        candidateTraces,
+        allCandidateTraces,
+      )
+      if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue
+      if (!isReadabilityImprovement(metrics, baseline)) continue
 
-    const score: AlignmentScore = {
-      ...metrics,
-      displacement: group.reduce(
-        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
-        0,
-      ),
-      coordinate,
+      const score: AlignmentScore = {
+        ...metrics,
+        displacement: group.reduce(
+          (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+          0,
+        ),
+        coordinate,
+      }
+      const changedTraceIds = candidateTraces
+        .filter((candidate) => {
+          const original = traces.find(
+            (trace) => trace.mspPairId === candidate.mspPairId,
+          )!
+          return tracePathChanged(original, candidate)
+        })
+        .map((trace) => trace.mspPairId)
+      if (changedTraceIds.length === 0) continue
+
+      const candidate = { traces: allCandidateTraces, changedTraceIds, score }
+      if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate
     }
-    const changedTraceIds = candidateTraces
-      .filter((candidate) => {
-        const original = traces.find(
-          (trace) => trace.mspPairId === candidate.mspPairId,
-        )!
-        return tracePathChanged(original, candidate)
-      })
-      .map((trace) => trace.mspPairId)
-    if (changedTraceIds.length === 0) continue
 
-    const candidate = { traces: allCandidateTraces, changedTraceIds, score }
-    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate
+    return best
   }
 
-  return best
+  const originalCandidate = evaluateCoordinates(originalCoordinates)
+  if (originalCandidate) return originalCandidate
+
+  return evaluateCoordinates(
+    getRailAlignmentFallbackCoordinates({
+      group,
+      originalCoordinates,
+      otherNetTraces,
+    }),
+  )
 }

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailAlignmentFallbackCoordinates.ts

@@ -0,0 +1,96 @@
+import { boundsIntersection, type Bounds } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE,
+  SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE,
+} from "lib/utils/doesPathCoincideWithTraces"
+import {
+  getDistinctCoordinates,
+  getRailOrientation,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./geometry"
+import type { RailOrientation, RailSegment } from "./types"
+
+const getAlongBounds = (
+  orientation: RailOrientation,
+  minAlong: number,
+  maxAlong: number,
+): Bounds =>
+  orientation === "vertical"
+    ? { minX: 0, maxX: 0, minY: minAlong, maxY: maxAlong }
+    : { minX: minAlong, maxX: maxAlong, minY: 0, maxY: 0 }
+
+const hasPositiveAlongOverlap = (
+  orientation: RailOrientation,
+  first: Bounds,
+  second: Bounds,
+) => {
+  const overlap = boundsIntersection(first, second)
+  if (!overlap) return false
+  const overlapLength =
+    orientation === "vertical"
+      ? overlap.maxY - overlap.minY
+      : overlap.maxX - overlap.minX
+  return overlapLength > RAIL_ALIGNMENT_EPSILON
+}
+
+/**
+ * Derives alternatives only for original alignment coordinates whose rendered
+ * stroke touches a parallel segment from another net.
+ */
+export const getRailAlignmentFallbackCoordinates = ({
+  group,
+  originalCoordinates,
+  otherNetTraces,
+}: {
+  group: RailSegment[]
+  originalCoordinates: number[]
+  otherNetTraces: SolvedTracePath[]
+}) => {
+  const orientation = group[0]!.orientation
+  const groupAlongBounds = group.map((segment) =>
+    getAlongBounds(orientation, segment.minAlong, segment.maxAlong),
+  )
+  const fallbackClearance = SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE
+  const coordinates: number[] = []
+
+  for (const trace of otherNetTraces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index]!
+      const end = trace.tracePath[index + 1]!
+      if (getRailOrientation(start, end) !== orientation) continue
+
+      const minAlong =
+        orientation === "vertical"
+          ? Math.min(start.y, end.y)
+          : Math.min(start.x, end.x)
+      const maxAlong =
+        orientation === "vertical"
+          ? Math.max(start.y, end.y)
+          : Math.max(start.x, end.x)
+      const traceAlongBounds = getAlongBounds(orientation, minAlong, maxAlong)
+      if (
+        !groupAlongBounds.some((bounds) =>
+          hasPositiveAlongOverlap(orientation, bounds, traceAlongBounds),
+        )
+      ) {
+        continue
+      }
+
+      const coordinate = orientation === "vertical" ? start.x : start.y
+      const touchesOriginalCandidate = originalCoordinates.some(
+        (originalCoordinate) =>
+          Math.abs(originalCoordinate - coordinate) <=
+          SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE,
+      )
+      if (!touchesOriginalCandidate) continue
+
+      coordinates.push(
+        coordinate - fallbackClearance,
+        coordinate + fallbackClearance,
+      )
+    }
+  }
+
+  return getDistinctCoordinates(coordinates)
+}

package/lib/utils/doesPathCoincideWithTraces.ts

@@ -1,7 +1,18 @@
-import type { Point } from "@tscircuit/math-utils"
+import { boundsIntersection, type Point } from "@tscircuit/math-utils"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 
 const COINCIDENT_EPS = 2e-3
+const GEOMETRY_EPS = 1e-6
+
+// Schematic traces are rendered 0.02 schematic units wide.
+export const SCHEMATIC_TRACE_STROKE_WIDTH = 0.02
+export const SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE =
+  SCHEMATIC_TRACE_STROKE_WIDTH + GEOMETRY_EPS
+// Rail-alignment fallbacks need a visible gap, not only non-overlapping trace
+// bodies. Three stroke widths of centerline separation leave two stroke widths
+// of whitespace between the rendered traces.
+export const SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE =
+  SCHEMATIC_TRACE_STROKE_WIDTH * 3
 
 /**
  * Returns true when an orthogonal path shares a positive-length segment with
@@ -59,3 +70,62 @@ export const doesPathCoincideWithTraces = (
 
   return false
 }
+
+/** Returns true when the rendered strokes of parallel trace runs overlap. */
+export const doesPathOverlapTraceStrokes = (
+  path: Point[],
+  traces: SolvedTracePath[],
+): boolean => {
+  const traceStrokeRadius = SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE / 2
+  const getStrokeBounds = (start: Point, end: Point, isVertical: boolean) =>
+    isVertical
+      ? {
+          minX: start.x - traceStrokeRadius,
+          maxX: start.x + traceStrokeRadius,
+          minY: Math.min(start.y, end.y),
+          maxY: Math.max(start.y, end.y),
+        }
+      : {
+          minX: Math.min(start.x, end.x),
+          maxX: Math.max(start.x, end.x),
+          minY: start.y - traceStrokeRadius,
+          maxY: start.y + traceStrokeRadius,
+        }
+
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    const pathStart = path[pathIndex]!
+    const pathEnd = path[pathIndex + 1]!
+    const isVertical = Math.abs(pathStart.x - pathEnd.x) < COINCIDENT_EPS
+    const isHorizontal = Math.abs(pathStart.y - pathEnd.y) < COINCIDENT_EPS
+    if (!isVertical && !isHorizontal) continue
+
+    const pathBounds = getStrokeBounds(pathStart, pathEnd, isVertical)
+    for (const trace of traces) {
+      for (
+        let traceIndex = 0;
+        traceIndex < trace.tracePath.length - 1;
+        traceIndex++
+      ) {
+        const traceStart = trace.tracePath[traceIndex]!
+        const traceEnd = trace.tracePath[traceIndex + 1]!
+        const isParallel = isVertical
+          ? Math.abs(traceStart.x - traceEnd.x) < COINCIDENT_EPS
+          : Math.abs(traceStart.y - traceEnd.y) < COINCIDENT_EPS
+        if (!isParallel) continue
+
+        const overlap = boundsIntersection(
+          pathBounds,
+          getStrokeBounds(traceStart, traceEnd, isVertical),
+        )
+        if (!overlap) continue
+
+        const overlapLength = isVertical
+          ? overlap.maxY - overlap.minY
+          : overlap.maxX - overlap.minX
+        if (overlapLength > COINCIDENT_EPS) return true
+      }
+    }
+  }
+
+  return false
+}

package/package.json

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