@tscircuit/schematic-trace-solver 0.0.64 → 0.0.66

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,15 +1050,41 @@ 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 (pts.length === 2) {
+    if (isVertical4) {
+      const jogYNearStart = start.y + segDir * JOG_SIZE;
+      const jogYNearEnd = end.y - segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        0,
+        { x: start.x, y: jogYNearStart },
+        { x: start.x + offset, y: jogYNearStart },
+        { x: end.x + offset, y: jogYNearEnd },
+        { x: end.x, y: jogYNearEnd }
+      );
+    } else {
+      const jogXNearStart = start.x + segDir * JOG_SIZE;
+      const jogXNearEnd = end.x - segDir * JOG_SIZE;
+      pts.splice(
+        1,
+        0,
+        { x: jogXNearStart, y: start.y },
+        { x: jogXNearStart, y: start.y + offset },
+        { x: jogXNearEnd, y: end.y + offset },
+        { x: jogXNearEnd, y: end.y }
+      );
+    }
+    return;
+  }
   if (si === 0) {
     if (isVertical4) {
       const jogY = start.y + segDir * JOG_SIZE;
@@ -1103,15 +1129,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,16 +1152,30 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS10 = 1e-6;
-    const offsets = this.overlappingTraceSegments.map((_, idx) => {
+    const containsStraightPinToPinTrace = (group) => group.pathsWithOverlap.some(({ solvedTracePathIndex }) => {
+      const path = this.traceNetIslands[group.connNetId][solvedTracePathIndex];
+      return path.tracePath.length === 2;
+    });
+    const groupShouldStayInPlace = this.overlappingTraceSegments.map(
+      containsStraightPinToPinTrace
+    );
+    const someGroupCanShift = groupShouldStayInPlace.some(
+      (shouldStay) => !shouldStay
+    );
+    const offsets = this.overlappingTraceSegments.map((group, idx) => {
+      if (someGroupCanShift && groupShouldStayInPlace[idx]) return 0;
       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];
+      if (offset === 0) return;
       const byPath = /* @__PURE__ */ new Map();
       for (const loc of group.pathsWithOverlap) {
         if (!byPath.has(loc.solvedTracePathIndex)) {
@@ -1144,7 +1187,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 +1197,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 +1228,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 +1347,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 +1365,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 +1373,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 +1382,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 +1407,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 +1445,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 +1466,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 +1517,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     }
     const { overlappingTraceSegments } = overlapIssue;
     this.activeSubSolver = new TraceOverlapIssueSolver({
+      inputProblem: this.inputProblem,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands
     });
@@ -1548,24 +1638,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 +2039,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(
@@ -2094,6 +2184,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroups;
   queuedOverlappingSameNetTraceGroups;
   netLabelPlacements = [];
+  failedGroups = [];
   currentGroup = null;
   triedAnyOrientationFallbackForCurrentGroup = false;
   constructor(params) {
@@ -2299,8 +2390,12 @@ var NetLabelPlacementSolver = class extends BaseSolver {
         });
         return;
       }
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
+      if (this.currentGroup) {
+        this.failedGroups.push(this.currentGroup);
+      }
+      this.activeSubSolver = null;
+      this.currentGroup = null;
+      this.triedAnyOrientationFallbackForCurrentGroup = false;
       return;
     }
     if (this.activeSubSolver) {
@@ -2961,6 +3056,38 @@ var generateRerouteCandidates = ({
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
+var COINCIDENT_EPS = 2e-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++) {
+    const pathSegStart = path[i];
+    const pathSegEnd = path[i + 1];
+    const isVertical4 = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS;
+    const isHorizontal3 = Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS;
+    if (!isVertical4 && !isHorizontal3) continue;
+    const crossAxis = isVertical4 ? "x" : "y";
+    const alongAxis = isVertical4 ? "y" : "x";
+    for (const trace of traces) {
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const traceSegStart = trace.tracePath[j];
+        const traceSegEnd = trace.tracePath[j + 1];
+        const isParallel = Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) < COINCIDENT_EPS;
+        if (!isParallel) continue;
+        const isCoincident = Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) < COINCIDENT_EPS;
+        if (!isCoincident) continue;
+        if (rangesOverlap1D(
+          pathSegStart[alongAxis],
+          pathSegEnd[alongAxis],
+          traceSegStart[alongAxis],
+          traceSegEnd[alongAxis]
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
 var SingleOverlapSolver = class extends BaseSolver {
   queuedCandidatePaths;
   solvedTracePath = null;
@@ -2968,12 +3095,14 @@ var SingleOverlapSolver = class extends BaseSolver {
   problem;
   obstacles;
   label;
+  tracesToAvoidOverlapping;
   _tried = 0;
   constructor(solverInput) {
     super();
     this.initialTrace = solverInput.trace;
     this.problem = solverInput.problem;
     this.label = solverInput.label;
+    this.tracesToAvoidOverlapping = (solverInput.tracesToAvoidOverlapping ?? []).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId);
     const effectivePadding = solverInput.paddingBuffer + solverInput.detourCount * solverInput.paddingBuffer;
     const candidates = generateRerouteCandidates({
       ...solverInput,
@@ -3002,7 +3131,7 @@ var SingleOverlapSolver = class extends BaseSolver {
     this._tried++;
     const nextCandidatePath = this.queuedCandidatePaths.shift();
     const simplifiedPath = simplifyPath(nextCandidatePath);
-    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
       this.solvedTracePath = simplifiedPath;
       this.solved = true;
     }
@@ -3107,6 +3236,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   mergedNetLabelPlacements;
   mergedLabelNetIdMap;
   allTraces;
+  tracesToAvoidOverlapping;
   modifiedTraces = [];
   PADDING_BUFFER = 0.1;
   detourCounts = /* @__PURE__ */ new Map();
@@ -3122,6 +3252,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements;
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
     this.allTraces = [...solverInput.traces];
+    this.tracesToAvoidOverlapping = solverInput.tracesToAvoidOverlapping ?? [];
     this.detourCounts = solverInput.detourCounts;
   }
   _step() {
@@ -3203,7 +3334,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount: detourCount2
+            detourCount: detourCount2,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -3238,7 +3370,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount: detourCount2
+            detourCount: detourCount2,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -3253,7 +3386,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         label: labelToAvoid,
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
-        detourCount
+        detourCount,
+        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
       });
     }
   }
@@ -3321,10 +3455,12 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   phase = "searching_for_overlaps";
   detourCounts = /* @__PURE__ */ new Map();
   labelMergingSolver;
+  allInputTraces;
   constructor(solverInput) {
     super();
     this.inputProblem = solverInput.inputProblem;
     this.unprocessedTraces = [...solverInput.traces];
+    this.allInputTraces = solverInput.traces;
     this.netLabelPlacements = solverInput.netLabelPlacements;
     this.cleanTraces = [];
     this.subSolvers = [];
@@ -3360,7 +3496,10 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
           initialNetLabelPlacements: this.netLabelPlacements,
           mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
-          detourCounts: this.detourCounts
+          detourCounts: this.detourCounts,
+          tracesToAvoidOverlapping: this.allInputTraces.filter(
+            (t) => t.mspPairId !== currentTargetTrace.mspPairId
+          )
         });
         this.subSolvers.push(subSolver);
       }
@@ -4172,8 +4311,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 +4325,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 +4337,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 +4349,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 +4361,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 +4806,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 +4942,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 +4954,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 +4966,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 +5009,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 +5039,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 +5082,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 +5712,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 +5744,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 +5755,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 +5803,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 +5838,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 +6127,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 +6200,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 +6438,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 +6487,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 +6504,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 +6544,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 +6570,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 +6852,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 +6902,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 +6941,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 +6952,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 +6966,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 +6977,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 +7036,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 +7145,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 +7162,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 +7257,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";