@tscircuit/schematic-trace-solver 0.0.63 → 0.0.65

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(
@@ -5636,6 +5688,14 @@ var tracePathCrossesAnyBounds = (tracePath, bounds) => {
   }
   return false;
 };
+var tracePathIntersectsBounds = (tracePath, bounds) => {
+  for (let i = 0; i < tracePath.length - 1; i++) {
+    if (segmentIntersectsRect2(tracePath[i], tracePath[i + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
 var tracePathCrossesAnyTrace = (tracePath, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -5656,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;
 };
@@ -5691,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),
@@ -5900,28 +5960,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.addConnectorTrace(label, candidate, labelIndex);
   }
   addConnectorTrace(label, candidate, labelIndex) {
-    let tracePath;
-    if (candidate.phase === "lateral-shift") {
-      const orientDir = dir(candidate.orientation);
-      const kickedSource = {
-        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
-        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
-      };
-      tracePath = simplifyOrthogonalPath([
-        label.anchorPoint,
-        ...getConnectorTracePath(
-          kickedSource,
-          candidate.anchorPoint,
-          candidate.orientation
-        )
-      ]);
-    } else {
-      tracePath = getConnectorTracePath(
-        label.anchorPoint,
-        candidate.anchorPoint,
-        candidate.orientation
-      );
-    }
+    const tracePath = this.getCandidateConnectorTrace(label, candidate);
     if (tracePath.length < 2) return;
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
     const connectorTrace = {
@@ -6001,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
@@ -6074,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
@@ -6104,9 +6143,36 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       distance: distance3,
       outwardDistance,
       selected: false,
-      status: this.getCandidateStatus(candidate, label, labelIndex)
+      status: this.getCandidateStatus({
+        candidate,
+        label,
+        labelIndex,
+        phase
+      })
     };
   }
+  getCandidateConnectorTrace(label, candidate) {
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation);
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
+      };
+      return simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation
+        )
+      ]);
+    }
+    return getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation
+    );
+  }
   getSearchStartAnchor(label, orientation) {
     const anchorPoint = this.getWickOffsetAnchor(label.anchorPoint, orientation);
     const { width, height } = getDimsForOrientation({
@@ -6226,17 +6292,18 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
     )?.netLabelHeight;
   }
-  getCandidateStatus(candidate, label, labelIndex) {
+  getCandidateStatus(params) {
+    const { candidate, label, labelIndex, phase } = params;
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
       labelIndex
     );
     if (boundsStatus !== "valid") return boundsStatus;
-    const connectorTrace = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation
-    );
+    const connectorTrace = this.getCandidateConnectorTrace(label, {
+      anchorPoint: candidate.anchorPoint,
+      orientation: candidate.orientation,
+      phase
+    });
     if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision";
     }
@@ -6248,7 +6315,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
-      if (tracePathCrossesAnyBounds(
+      if (tracePathIntersectsBounds(
         connectorTrace,
         getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height)
       )) {
@@ -6284,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,
@@ -6333,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)) {
@@ -6350,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;
@@ -6390,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++) {
@@ -6416,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";
@@ -6698,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;
@@ -6748,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)
@@ -6787,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(
@@ -6798,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(
@@ -6812,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;
 };
@@ -6823,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
@@ -6882,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;
@@ -6991,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
@@ -7008,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) {
@@ -7103,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";
@@ -7491,16 +7558,14 @@ function buildMergedObstacleLabel(seedLabel, allLabels) {
     height: h
   };
 }
-function detectInnerTraceLabelOverlaps(traces, labels) {
+function detectTraceLabelOverlaps(traces, labels) {
   const overlaps = [];
   for (const trace of traces) {
     for (const label of labels) {
       if (trace.globalConnNetId === label.globalConnNetId) continue;
       const bounds = getRectBounds(label.center, label.width, label.height);
       const path = trace.tracePath;
-      const innerStart = 1;
-      const innerEnd = path.length - 2;
-      for (let i = innerStart; i < innerEnd; i++) {
+      for (let i = 0; i < path.length - 1; i++) {
         if (segmentIntersectsRect2(path[i], path[i + 1], bounds)) {
           overlaps.push({ trace, label });
           break;
@@ -7566,7 +7631,7 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
       }
       return;
     }
-    const overlaps = detectInnerTraceLabelOverlaps(
+    const overlaps = detectTraceLabelOverlaps(
       this.outputTraces,
       this.outputNetLabelPlacements
     );