@tscircuit/schematic-trace-solver 0.0.64 → 0.0.65

package/dist/index.d.ts

@@ -204,13 +204,17 @@ interface OverlappingTraceSegmentLocator {
 declare class TraceOverlapIssueSolver extends BaseSolver {
     overlappingTraceSegments: OverlappingTraceSegmentLocator[];
     traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
+    obstacleRects: ReturnType<typeof getObstacleRects>;
     SHIFT_DISTANCE: number;
     correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath>;
     constructor(params: {
+        inputProblem: InputProblem;
         overlappingTraceSegments: OverlappingTraceSegmentLocator[];
         traceNetIslands: Record<ConnNetId$1, Array<SolvedTracePath>>;
     });
     _step(): void;
+    private getObstacleAwareOffset;
+    private getBlockingCollisions;
     visualize(): GraphicsObject;
 }
 

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS10 = 1e-9;
+  const EPS11 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS10) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS11) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS10) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS11) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS10 || Math.abs(p1.y - p2.y) < EPS10) {
+  if (Math.abs(p1.x - p2.x) < EPS11 || Math.abs(p1.y - p2.y) < EPS11) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -850,8 +850,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS10 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS10 && Math.abs(p.y - q.y) < EPS10;
+      const EPS11 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS11 && Math.abs(p.y - q.y) < EPS11;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1050,13 +1050,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS10 = 1e-6
+  EPS: EPS11 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical4 = Math.abs(start.x - end.x) < EPS10;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS10;
+  const isVertical4 = Math.abs(start.x - end.x) < EPS11;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS11;
   if (!isVertical4 && !isHorizontal3) return;
   const segDir = isVertical4 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
@@ -1103,15 +1103,18 @@ var applyJogToTerminalSegment = ({
 };
 
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
+var EPS4 = 1e-6;
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
   traceNetIslands;
+  obstacleRects;
   SHIFT_DISTANCE = 0.1;
   correctedTraceMap = {};
   constructor(params) {
     super();
     this.overlappingTraceSegments = params.overlappingTraceSegments;
     this.traceNetIslands = params.traceNetIslands;
+    this.obstacleRects = getObstacleRects(params.inputProblem);
     for (const { connNetId, pathsWithOverlap } of this.overlappingTraceSegments) {
       for (const {
         solvedTracePathIndex,
@@ -1123,13 +1126,15 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS10 = 1e-6;
-    const offsets = this.overlappingTraceSegments.map((_, idx) => {
+    const offsets = this.overlappingTraceSegments.map((group, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
-      return signed * this.SHIFT_DISTANCE;
+      return this.getObstacleAwareOffset({
+        group,
+        offset: signed * this.SHIFT_DISTANCE
+      });
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS10;
+    const eq = (a, b) => Math.abs(a - b) < EPS4;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1144,7 +1149,6 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         const original = this.traceNetIslands[group.connNetId][pathIdx];
         const current = this.correctedTraceMap[original.mspPairId] ?? original;
         const pts = current.tracePath.map((p) => ({ ...p }));
-        const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b);
         const segIdxsRev = Array.from(segIdxSet).sort((a, b) => a - b).reverse();
         const JOG_SIZE = this.SHIFT_DISTANCE;
         for (const si of segIdxsRev) {
@@ -1155,13 +1159,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS10
+              EPS: EPS4
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical4 = Math.abs(start.x - end.x) < EPS10;
-            const isHorizontal3 = Math.abs(start.y - end.y) < EPS10;
+            const isVertical4 = Math.abs(start.x - end.x) < EPS4;
+            const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
             if (!isVertical4 && !isHorizontal3) continue;
             if (isVertical4) {
               start.x += offset;
@@ -1186,6 +1190,53 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     });
     this.solved = true;
   }
+  getObstacleAwareOffset({
+    group,
+    offset
+  }) {
+    const blockingCollisions = this.getBlockingCollisions({ group, offset });
+    if (blockingCollisions.length === 0) return offset;
+    return blockingCollisions.flatMap(({ start, isVertical: isVertical4, obstacle }) => [
+      (isVertical4 ? obstacle.minX - start.x : obstacle.minY - start.y) - this.SHIFT_DISTANCE,
+      (isVertical4 ? obstacle.maxX - start.x : obstacle.maxY - start.y) + this.SHIFT_DISTANCE
+    ]).filter(
+      (candidateOffset) => this.getBlockingCollisions({ group, offset: candidateOffset }).length === 0
+    ).sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0] ?? offset;
+  }
+  getBlockingCollisions({
+    group,
+    offset
+  }) {
+    const blockingCollisions = [];
+    for (const {
+      solvedTracePathIndex,
+      traceSegmentIndex
+    } of group.pathsWithOverlap) {
+      const trace = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+      const start = trace.tracePath[traceSegmentIndex];
+      const end = trace.tracePath[traceSegmentIndex + 1];
+      if (!start || !end) continue;
+      const isVertical4 = Math.abs(start.x - end.x) < EPS4;
+      const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
+      if (!isVertical4 && !isHorizontal3) continue;
+      const shiftedSegment = isVertical4 ? [
+        { ...start, x: start.x + offset },
+        { ...end, x: end.x + offset }
+      ] : [
+        { ...start, y: start.y + offset },
+        { ...end, y: end.y + offset }
+      ];
+      const collision = findFirstCollision(shiftedSegment, this.obstacleRects);
+      if (collision) {
+        blockingCollisions.push({
+          start,
+          isVertical: isVertical4,
+          obstacle: collision.rect
+        });
+      }
+    }
+    return blockingCollisions;
+  }
   visualize() {
     const graphics = {
       lines: [],
@@ -1258,7 +1309,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS10 = 2e-3;
+    const EPS11 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1276,7 +1327,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS10;
+          return overlap > EPS11;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1284,8 +1335,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS10;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS10;
+            const aVert = Math.abs(a1.x - a2.x) < EPS11;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS11;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1293,11 +1344,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS10;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS10;
+                const bVert = Math.abs(b1.x - b2.x) < EPS11;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS11;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS10) {
+                  if (Math.abs(a1.x - b1.x) < EPS11) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1318,7 +1369,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS10) {
+                  if (Math.abs(a1.y - b1.y) < EPS11) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1356,14 +1407,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS10 = 2e-3;
+    const EPS11 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS10;
-        const isVertical4 = Math.abs(p1.x - p2.x) < EPS10;
+        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS11;
+        const isVertical4 = Math.abs(p1.x - p2.x) < EPS11;
         if (!isHorizontal3 && !isVertical4) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -1377,13 +1428,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS10 = 2e-3;
+    const EPS11 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS10 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS10 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS10 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS10 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS11 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS11 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS11 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS11 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -1428,6 +1479,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     }
     const { overlappingTraceSegments } = overlapIssue;
     this.activeSubSolver = new TraceOverlapIssueSolver({
+      inputProblem: this.inputProblem,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands
     });
@@ -1548,24 +1600,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS10 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS10;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS10;
+function segmentIntersectsRect2(p1, p2, rect, EPS11 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS11;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS11;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS10 || x > rect.maxX + EPS10) return false;
+    if (x < rect.minX - EPS11 || x > rect.maxX + EPS11) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS10;
+    return overlap > EPS11;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS10 || y > rect.maxY + EPS10) return false;
+    if (y < rect.minY - EPS11 || y > rect.maxY + EPS11) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS10;
+    return overlap > EPS11;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1949,14 +2001,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS10 = 1e-6;
+    const EPS11 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS10;
-        const isV = Math.abs(a.x - b.x) < EPS10;
+        const isH = Math.abs(a.y - b.y) < EPS11;
+        const isV = Math.abs(a.x - b.x) < EPS11;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4172,8 +4224,8 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS4 = 1e-6;
-var isVertical2 = (a, b, eps = EPS4) => Math.abs(a.x - b.x) < eps;
+var EPS5 = 1e-6;
+var isVertical2 = (a, b, eps = EPS5) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -4186,7 +4238,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+  if (Math.abs(p2.x - x) < EPS5 && Math.abs(p2.y - (y + height)) < EPS5) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical2(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -4198,7 +4250,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS5 && Math.abs(p2.y - (y + height)) < EPS5) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical2(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -4210,7 +4262,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+  } else if (Math.abs(p2.x - x) < EPS5 && Math.abs(p2.y - y) < EPS5) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical2(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -4222,7 +4274,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS5 && Math.abs(p2.y - y) < EPS5) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical2(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -4667,9 +4719,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS5 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS5;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS5;
+var EPS6 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS6;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS6;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -4803,7 +4855,7 @@ var TraceCleanupSolver = class extends BaseSolver {
 };
 
 // lib/solvers/Example28Solver/types.ts
-var EPS6 = 1e-9;
+var EPS7 = 1e-9;
 
 // lib/solvers/Example28Solver/geometry.ts
 var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
@@ -4815,10 +4867,10 @@ var getPathLength = (path) => {
   return length;
 };
 var getDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS6 || Math.abs(start.y - end.y) < EPS6;
-var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS6 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS7 || Math.abs(start.y - end.y) < EPS7;
+var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS7 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS6) {
+  if (Math.abs(start.x - end.x) < EPS7) {
     return {
       x: start.x,
       y: Math.min(
@@ -4827,7 +4879,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS6) {
+  if (Math.abs(start.y - end.y) < EPS7) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -4870,9 +4922,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS6 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS6;
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS7 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS7;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS6 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS6;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS7 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS7;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -4900,18 +4952,18 @@ var projectPointToPath = (point, path) => {
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS6;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS6;
-  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS6 && value <= Math.max(p1, p2) + EPS6;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS7;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS7;
+  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS7 && value <= Math.max(p1, p2) + EPS7;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS6) return false;
+    if (Math.abs(a1.x - b1.x) > EPS7) return false;
     const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
-    return overlap > EPS6;
+    return overlap > EPS7;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS6) return false;
+    if (Math.abs(a1.y - b1.y) > EPS7) return false;
     const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
-    return overlap > EPS6;
+    return overlap > EPS7;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
@@ -4943,13 +4995,13 @@ var isPathCollidingWithChipInterior = (path, chipObstacles) => {
   return false;
 };
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical4 = Math.abs(start.x - end.x) < EPS6;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS6;
+  const isVertical4 = Math.abs(start.x - end.x) < EPS7;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS7;
   if (isVertical4) {
-    return Math.abs(start.x - rect.minX) < EPS6 || Math.abs(start.x - rect.maxX) < EPS6;
+    return Math.abs(start.x - rect.minX) < EPS7 || Math.abs(start.x - rect.maxX) < EPS7;
   }
   if (isHorizontal3) {
-    return Math.abs(start.y - rect.minY) < EPS6 || Math.abs(start.y - rect.maxY) < EPS6;
+    return Math.abs(start.y - rect.minY) < EPS7 || Math.abs(start.y - rect.maxY) < EPS7;
   }
   return false;
 };
@@ -5573,16 +5625,16 @@ var Example28Solver = class extends BaseSolver {
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS7 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS7;
+var EPS8 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS8;
 var CANDIDATE_SELECTED_COLOR2 = "blue";
 var CANDIDATE_REJECTED_COLOR2 = "red";
 
 // lib/solvers/AvailableNetOrientationSolver/geometry.ts
 var isYOrientation = (orientation) => orientation === "y+" || orientation === "y-";
 var isXOrientation = (orientation) => orientation === "x+" || orientation === "x-";
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS7 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS7;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS7;
+var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS8;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -5605,7 +5657,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS7 || p1.x >= interiorBounds.maxX - EPS7) {
+    if (p1.x <= interiorBounds.minX + EPS8 || p1.x >= interiorBounds.maxX - EPS8) {
       return false;
     }
     return rangesOverlap(
@@ -5616,7 +5668,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS7 || p1.y >= interiorBounds.maxY - EPS7) {
+    if (p1.y <= interiorBounds.minY + EPS8 || p1.y >= interiorBounds.maxY - EPS8) {
       return false;
     }
     return rangesOverlap(
@@ -5664,10 +5716,10 @@ var tracePathCrossesAnyTrace = (tracePath, traceMap) => {
 };
 var segmentsStrictlyCross = (a1, a2, b1, b2) => {
   if (sameX2(a1, a2) && sameY2(b1, b2)) {
-    return a1.x > Math.min(b1.x, b2.x) + EPS7 && a1.x < Math.max(b1.x, b2.x) - EPS7 && b1.y > Math.min(a1.y, a2.y) + EPS7 && b1.y < Math.max(a1.y, a2.y) - EPS7;
+    return a1.x > Math.min(b1.x, b2.x) + EPS8 && a1.x < Math.max(b1.x, b2.x) - EPS8 && b1.y > Math.min(a1.y, a2.y) + EPS8 && b1.y < Math.max(a1.y, a2.y) - EPS8;
   }
   if (sameY2(a1, a2) && sameX2(b1, b2)) {
-    return b1.x > Math.min(a1.x, a2.x) + EPS7 && b1.x < Math.max(a1.x, a2.x) - EPS7 && a1.y > Math.min(b1.y, b2.y) + EPS7 && a1.y < Math.max(b1.y, b2.y) - EPS7;
+    return b1.x > Math.min(a1.x, a2.x) + EPS8 && b1.x < Math.max(a1.x, a2.x) - EPS8 && a1.y > Math.min(b1.y, b2.y) + EPS8 && a1.y < Math.max(b1.y, b2.y) - EPS8;
   }
   return false;
 };
@@ -5699,8 +5751,8 @@ var simplifyOrthogonalPath = (path) => {
   return simplified;
 };
 var pointsEqual = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS7;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS7;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS8;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS8;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -5988,7 +6040,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const maxSearchDistance = this.getSearchDistanceLimit(label, orientation);
     const maxOutwardDistance = outwardDirection.x === 0 && outwardDirection.y === 0 ? 0 : this.maxSearchDistance;
-    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS7; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS8; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -6061,7 +6113,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       outwardDistance,
       phase = "shift"
     } = params;
-    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS7; distance3 += LABEL_SEARCH_STEP) {
+    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS8; distance3 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance3,
         y: baseAnchor.y + direction.y * distance3
@@ -6299,8 +6351,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   sharesChipBoundary(bounds) {
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS7 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS7;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS7 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS7;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS8;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS8;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -6348,7 +6400,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      if (point.x < bounds.minX - EPS7 || point.x > bounds.maxX + EPS7 || point.y < bounds.minY - EPS7 || point.y > bounds.maxY + EPS7) {
+      if (point.x < bounds.minX - EPS8 || point.x > bounds.maxX + EPS8 || point.y < bounds.minY - EPS8 || point.y > bounds.maxY + EPS8) {
         continue;
       }
       for (const [side, distance3] of getSideDistances(point, bounds)) {
@@ -6365,8 +6417,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistanceSq = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      const dx = point.x < bounds.minX - EPS7 ? bounds.minX - point.x : point.x > bounds.maxX + EPS7 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS7 ? bounds.minY - point.y : point.y > bounds.maxY + EPS7 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS8 ? bounds.minX - point.x : point.x > bounds.maxX + EPS8 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS8 ? bounds.minY - point.y : point.y > bounds.maxY + EPS8 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -6405,9 +6457,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
 };
 
 // lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts
-var EPS8 = 1e-6;
+var EPS9 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
 var getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -6431,11 +6483,11 @@ var getUniquePinCount = (pinIds) => new Set(pinIds).size;
 var isTraceCorner = (a, b, c) => getSegmentOrientation2(a, b) !== getSegmentOrientation2(b, c);
 var isPointOnSegment = (point, start, end) => {
   if (getSegmentOrientation2(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS8 && point.x >= Math.min(start.x, end.x) - EPS8 && point.x <= Math.max(start.x, end.x) + EPS8;
+    return Math.abs(point.y - start.y) <= EPS9 && point.x >= Math.min(start.x, end.x) - EPS9 && point.x <= Math.max(start.x, end.x) + EPS9;
   }
-  return Math.abs(point.x - start.x) <= EPS8 && point.y >= Math.min(start.y, end.y) - EPS8 && point.y <= Math.max(start.y, end.y) + EPS8;
+  return Math.abs(point.x - start.x) <= EPS9 && point.y >= Math.min(start.y, end.y) - EPS9 && point.y <= Math.max(start.y, end.y) + EPS9;
 };
-var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS8 ? "horizontal" : "vertical";
+var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS9 ? "horizontal" : "vertical";
 
 // lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR3 = "blue";
@@ -6713,11 +6765,11 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS9 = 1e-6;
+var EPS10 = 1e-6;
 var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
 var getLabelBounds = (label) => getRectBounds(label.center, label.width, label.height);
-var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS9;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS10 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS10;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS10 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS10;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -6763,7 +6815,7 @@ var getPointAtTraceDistance = (trace, distance3) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance3 <= nextDistance + EPS9) {
+    if (distance3 <= nextDistance + EPS10) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance3 - pathDistance)
@@ -6802,7 +6854,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical3(start, end)) {
-    if (start.x <= interior.minX + EPS9 || start.x >= interior.maxX - EPS9) {
+    if (start.x <= interior.minX + EPS10 || start.x >= interior.maxX - EPS10) {
       return false;
     }
     return rangesOverlap2(
@@ -6813,7 +6865,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal2(start, end)) {
-    if (start.y <= interior.minY + EPS9 || start.y >= interior.maxY - EPS9) {
+    if (start.y <= interior.minY + EPS10 || start.y >= interior.maxY - EPS10) {
       return false;
     }
     return rangesOverlap2(
@@ -6827,10 +6879,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal2(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS9 && point.x >= Math.min(start.x, end.x) - EPS9 && point.x <= Math.max(start.x, end.x) + EPS9;
+    return Math.abs(point.y - start.y) <= EPS10 && point.x >= Math.min(start.x, end.x) - EPS10 && point.x <= Math.max(start.x, end.x) + EPS10;
   }
   if (isVertical3(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS9 && point.y >= Math.min(start.y, end.y) - EPS9 && point.y <= Math.max(start.y, end.y) + EPS9;
+    return Math.abs(point.x - start.x) <= EPS10 && point.y >= Math.min(start.y, end.y) - EPS10 && point.y <= Math.max(start.y, end.y) + EPS10;
   }
   return false;
 };
@@ -6838,9 +6890,9 @@ var getSegmentDirection = (start, end) => ({
   x: isVertical3(start, end) ? 0 : Math.sign(end.x - start.x),
   y: isHorizontal2(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS9;
-var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS9;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS9;
+var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS10;
+var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS10;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS10;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -6897,7 +6949,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance3 of vertexDistances) {
     distances.add(roundDistance(distance3));
   }
-  return [...distances].filter((distance3) => distance3 >= -EPS9 && distance3 <= traceLength + EPS9).sort((a, b) => a - b);
+  return [...distances].filter((distance3) => distance3 >= -EPS10 && distance3 <= traceLength + EPS10).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -7006,13 +7058,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS9) {
+  if (value > max + EPS10) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS9) {
+  if (value < min - EPS10) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -7023,7 +7075,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS9, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS10, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -7118,7 +7170,7 @@ var normalizeFacingDirection = (value) => {
 var dedupeStrings = (values) => [
   ...new Set(values.filter((value) => value !== void 0))
 ];
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS9 && Math.abs(point.y - label.anchorPoint.y) <= EPS9 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";

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

@@ -1,11 +1,16 @@
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { findFirstCollision } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
 import { applyJogToTerminalSegment } from "./applyJogToTrace"
 
 type ConnNetId = string
 
+const EPS = 1e-6
+
 export interface OverlappingTraceSegmentLocator {
   connNetId: string
   pathsWithOverlap: Array<{
@@ -17,18 +22,21 @@ export interface OverlappingTraceSegmentLocator {
 export class TraceOverlapIssueSolver extends BaseSolver {
   overlappingTraceSegments: OverlappingTraceSegmentLocator[]
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
+  obstacleRects: ReturnType<typeof getObstacleRects>
 
   SHIFT_DISTANCE = 0.1
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
 
   constructor(params: {
+    inputProblem: InputProblem
     overlappingTraceSegments: OverlappingTraceSegmentLocator[]
     traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
   }) {
     super()
     this.overlappingTraceSegments = params.overlappingTraceSegments
     this.traceNetIslands = params.traceNetIslands
+    this.obstacleRects = getObstacleRects(params.inputProblem)
 
     // Only add the relevant traces to the correctedTraceMap
     for (const { connNetId, pathsWithOverlap } of this
@@ -49,13 +57,14 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     // Shift only the overlapping segments, and move the shared endpoints
     // (the last point of the previous segment and the first point of the next
     // segment) so the polyline remains orthogonal without self-overlap.
-    const EPS = 1e-6
-
     // Compute offsets for each island involved: alternate directions
-    const offsets = this.overlappingTraceSegments.map((_, idx) => {
+    const offsets = this.overlappingTraceSegments.map((group, idx) => {
       const n = Math.floor(idx / 2) + 1
       const signed = idx % 2 === 0 ? -n : n
-      return signed * this.SHIFT_DISTANCE
+      return this.getObstacleAwareOffset({
+        group,
+        offset: signed * this.SHIFT_DISTANCE,
+      })
     })
 
     const eq = (a: number, b: number) => Math.abs(a - b) < EPS
@@ -82,8 +91,6 @@ export class TraceOverlapIssueSolver extends BaseSolver {
         const current = this.correctedTraceMap[original.mspPairId] ?? original
         const pts = current.tracePath.map((p) => ({ ...p }))
 
-        const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b)
-
         const segIdxsRev = Array.from(segIdxSet)
           .sort((a, b) => a - b)
           .reverse()
@@ -142,6 +149,82 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     this.solved = true
   }
 
+  private getObstacleAwareOffset({
+    group,
+    offset,
+  }: {
+    group: OverlappingTraceSegmentLocator
+    offset: number
+  }) {
+    const blockingCollisions = this.getBlockingCollisions({ group, offset })
+    if (blockingCollisions.length === 0) return offset
+
+    return (
+      blockingCollisions
+        .flatMap(({ start, isVertical, obstacle }) => [
+          (isVertical ? obstacle.minX - start.x : obstacle.minY - start.y) -
+            this.SHIFT_DISTANCE,
+          (isVertical ? obstacle.maxX - start.x : obstacle.maxY - start.y) +
+            this.SHIFT_DISTANCE,
+        ])
+        .filter(
+          (candidateOffset) =>
+            this.getBlockingCollisions({ group, offset: candidateOffset })
+              .length === 0,
+        )
+        .sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0] ??
+      offset
+    )
+  }
+
+  private getBlockingCollisions({
+    group,
+    offset,
+  }: {
+    group: OverlappingTraceSegmentLocator
+    offset: number
+  }) {
+    const blockingCollisions: Array<{
+      start: SolvedTracePath["tracePath"][number]
+      isVertical: boolean
+      obstacle: ReturnType<typeof getObstacleRects>[number]
+    }> = []
+
+    for (const {
+      solvedTracePathIndex,
+      traceSegmentIndex,
+    } of group.pathsWithOverlap) {
+      const trace = this.traceNetIslands[group.connNetId][solvedTracePathIndex]!
+      const start = trace.tracePath[traceSegmentIndex]
+      const end = trace.tracePath[traceSegmentIndex + 1]
+      if (!start || !end) continue
+
+      const isVertical = Math.abs(start.x - end.x) < EPS
+      const isHorizontal = Math.abs(start.y - end.y) < EPS
+      if (!isVertical && !isHorizontal) continue
+
+      const shiftedSegment = isVertical
+        ? [
+            { ...start, x: start.x + offset },
+            { ...end, x: end.x + offset },
+          ]
+        : [
+            { ...start, y: start.y + offset },
+            { ...end, y: end.y + offset },
+          ]
+      const collision = findFirstCollision(shiftedSegment, this.obstacleRects)
+      if (collision) {
+        blockingCollisions.push({
+          start,
+          isVertical,
+          obstacle: collision.rect,
+        })
+      }
+    }
+
+    return blockingCollisions
+  }
+
   override visualize(): GraphicsObject {
     // Visualize overlapped segments and proposed corrections
     const graphics: GraphicsObject = {

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -309,6 +309,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     const { overlappingTraceSegments } = overlapIssue
 
     this.activeSubSolver = new TraceOverlapIssueSolver({
+      inputProblem: this.inputProblem,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands,
     })

package/package.json

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

package/tests/repros/__snapshots__/trace-overlap-box-resistor.snap.svg

@@ -18,7 +18,7 @@ y-" data-x="2.25" data-y="-2.6500000000000004" cx="500.642827694859" cy="536.849
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: y-" data-x="2.125" data-y="-2.8500000000000005" cx="489.034204145937" cy="555.4228855721392" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y-" data-x="1.9902723250000003" data-y="-2.8500000000000005" cx="476.52218126036485" cy="555.4228855721392" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
@@ -34,7 +34,7 @@ orientation: y+" data-x="1.9249999999999998" data-y="-0.32499999999999996" cx="4
     <polyline data-points="1.7999999999999998,-0.32499999999999996 1.9249999999999998,-0.32499999999999996 1.9249999999999998,-1.1 2.25,-1.1 2.25,-0.9" data-type="line" data-label="" points="458.8517829187396,320.9286898839137 470.46040646766164,320.9286898839137 470.46040646766164,392.9021558872305 500.642827694859,392.9021558872305 500.642827694859,374.3283582089552" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.7999999999999998,-0.975 2.125,-0.975 2.125,-2.8500000000000005 2.25,-2.8500000000000005 2.25,-2.6500000000000004" data-type="line" data-label="" points="458.8517829187396,381.2935323383084 489.034204145937,381.2935323383084 489.034204145937,555.4228855721392 500.642827694859,555.4228855721392 500.642827694859,536.849087893864" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.7999999999999998,-0.975 1.9902723250000003,-0.975 1.9902723250000003,-2.8500000000000005 2.25,-2.8500000000000005 2.25,-2.6500000000000004" data-type="line" data-label="" points="458.8517829187396,381.2935323383084 476.52218126036485,381.2935323383084 476.52218126036485,555.4228855721392 500.642827694859,555.4228855721392 500.642827694859,536.849087893864" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="124.52342470978448" y="40" width="334.32835820895514" height="501.49253731343276" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.010767857142857145" />
@@ -47,7 +47,7 @@ orientation: y+" data-x="1.9249999999999998" data-y="-0.32499999999999996" cx="4
   </g>
   <g>
     <rect data-type="rect" data-label="netId: GND
-globalConnNetId: connectivity_net1" data-x="2.125" data-y="-3.0900000000000007" x="479.7473053067993" y="555.4228855721392" width="18.573797678275298" height="44.577114427860806" fill="#00000066" stroke="#000000" stroke-width="0.010767857142857145" />
+globalConnNetId: connectivity_net1" data-x="1.9902723250000003" data-y="-3.0900000000000007" x="467.2352824212272" y="555.4228855721392" width="18.573797678275298" height="44.577114427860806" fill="#00000066" stroke="#000000" stroke-width="0.010767857142857145" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: U1.FB to R1.pin2