@tscircuit/schematic-trace-solver 0.0.132 → 0.0.134

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS13 = 1e-9;
+  const EPS14 = 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) < -EPS13) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS14) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS13) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS14) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS13 || Math.abs(p1.y - p2.y) < EPS13) {
+  if (Math.abs(p1.x - p2.x) < EPS14 || Math.abs(p1.y - p2.y) < EPS14) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1424,8 +1424,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS13 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS13 && Math.abs(p.y - q.y) < EPS13;
+      const EPS14 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS14 && Math.abs(p.y - q.y) < EPS14;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1709,13 +1709,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS13 = 1e-6
+  EPS: EPS14 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical5 = Math.abs(start.x - end.x) < EPS13;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS13;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS14;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS14;
   if (!isVertical5 && !isHorizontal4) return;
   const segDir = isVertical5 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2144,7 +2144,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS13 = 2e-3;
+    const EPS14 = 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++) {
@@ -2171,7 +2171,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS13) {
+          if (rangeOverlap > EPS14) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2190,7 +2190,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS13) return;
+          if (rangeOverlap < -EPS14) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2213,8 +2213,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) < EPS13;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS13;
+            const aVert = Math.abs(a1.x - a2.x) < EPS14;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS14;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2225,11 +2225,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) < EPS13;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS13;
+                const bVert = Math.abs(b1.x - b2.x) < EPS14;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS14;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS13) {
+                  if (Math.abs(a1.x - b1.x) < EPS14) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2239,7 +2239,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS13) {
+                  if (Math.abs(a1.y - b1.y) < EPS14) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2295,14 +2295,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS13 = 2e-3;
+    const EPS14 = 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 isHorizontal4 = Math.abs(p1.y - p2.y) < EPS13;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS13;
+        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS14;
+        const isVertical5 = Math.abs(p1.x - p2.x) < EPS14;
         if (!isHorizontal4 && !isVertical5) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2316,13 +2316,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS13 = 2e-3;
+    const EPS14 = 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) < EPS13 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS13 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS13 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS13 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS14 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS14 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS14 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS14 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2450,24 +2450,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS13 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS13;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS13;
+function segmentIntersectsRect2(p1, p2, rect, EPS14 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS14;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS14;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS13 || x > rect.maxX + EPS13) return false;
+    if (x < rect.minX - EPS14 || x > rect.maxX + EPS14) 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 > EPS13;
+    return overlap > EPS14;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS13 || y > rect.maxY + EPS13) return false;
+    if (y < rect.minY - EPS14 || y > rect.maxY + EPS14) 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 > EPS13;
+    return overlap > EPS14;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -2864,14 +2864,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS13 = 1e-6;
+    const EPS14 = 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) < EPS13;
-        const isV = Math.abs(a.x - b.x) < EPS13;
+        const isH = Math.abs(a.y - b.y) < EPS14;
+        const isV = Math.abs(a.x - b.x) < EPS14;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4619,6 +4619,81 @@ var distance3 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 var manhattanDistance = (p1, p2) => Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+var EPS6 = 1e-9;
+var between = (value, first, second) => value >= Math.min(first, second) - EPS6 && value <= Math.max(first, second) + EPS6;
+var getAxisAlignedIntersection = (firstStart, firstEnd, secondStart, secondEnd) => {
+  const firstIsHorizontal = Math.abs(firstStart.y - firstEnd.y) <= EPS6;
+  const firstIsVertical = Math.abs(firstStart.x - firstEnd.x) <= EPS6;
+  const secondIsHorizontal = Math.abs(secondStart.y - secondEnd.y) <= EPS6;
+  const secondIsVertical = Math.abs(secondStart.x - secondEnd.x) <= EPS6;
+  if (firstIsHorizontal && secondIsVertical) {
+    const point = { x: secondStart.x, y: firstStart.y };
+    return between(point.x, firstStart.x, firstEnd.x) && between(point.y, secondStart.y, secondEnd.y) ? point : null;
+  }
+  if (firstIsVertical && secondIsHorizontal) {
+    const point = { x: firstStart.x, y: secondStart.y };
+    return between(point.y, firstStart.y, firstEnd.y) && between(point.x, secondStart.x, secondEnd.x) ? point : null;
+  }
+  if (firstIsHorizontal && secondIsHorizontal && Math.abs(firstStart.y - secondStart.y) <= EPS6) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.x, firstEnd.x),
+      Math.min(secondStart.x, secondEnd.x)
+    );
+    const overlapMax = Math.min(
+      Math.max(firstStart.x, firstEnd.x),
+      Math.max(secondStart.x, secondEnd.x)
+    );
+    if (overlapMin > overlapMax + EPS6) return null;
+    return {
+      x: Math.max(overlapMin, Math.min(firstStart.x, overlapMax)),
+      y: firstStart.y
+    };
+  }
+  if (firstIsVertical && secondIsVertical && Math.abs(firstStart.x - secondStart.x) <= EPS6) {
+    const overlapMin = Math.max(
+      Math.min(firstStart.y, firstEnd.y),
+      Math.min(secondStart.y, secondEnd.y)
+    );
+    const overlapMax = Math.min(
+      Math.max(firstStart.y, firstEnd.y),
+      Math.max(secondStart.y, secondEnd.y)
+    );
+    if (overlapMin > overlapMax + EPS6) return null;
+    return {
+      x: firstStart.x,
+      y: Math.max(overlapMin, Math.min(firstStart.y, overlapMax))
+    };
+  }
+  return null;
+};
+var clipPathAtFirstIntersection = (tracePath, existingTraces) => {
+  for (let pathIndex = 0; pathIndex < tracePath.length - 1; pathIndex++) {
+    const pathStart = tracePath[pathIndex];
+    const pathEnd = tracePath[pathIndex + 1];
+    const intersections = existingTraces.flatMap(
+      (trace) => trace.tracePath.slice(0, -1).flatMap((traceStart, traceIndex) => {
+        const intersection2 = getAxisAlignedIntersection(
+          pathStart,
+          pathEnd,
+          traceStart,
+          trace.tracePath[traceIndex + 1]
+        );
+        return intersection2 ? [intersection2] : [];
+      })
+    );
+    intersections.sort(
+      (first, second) => distance3(pathStart, first) - distance3(pathStart, second)
+    );
+    const intersection = intersections[0];
+    if (!intersection) continue;
+    const clippedPath = tracePath.slice(0, pathIndex + 1);
+    if (distance3(clippedPath.at(-1), intersection) > EPS6) {
+      clippedPath.push(intersection);
+    }
+    return clippedPath;
+  }
+  return null;
+};
 var LongDistancePairSolver = class extends BaseSolver {
   constructor(params) {
     super();
@@ -4733,20 +4808,36 @@ var LongDistancePairSolver = class extends BaseSolver {
     } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath;
       if (newTracePath && this.currentCandidatePair) {
+        const [p1, p2] = this.currentCandidatePair;
+        const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
+        const sameNetTraces = this.allSolvedTraces.filter(
+          (trace) => trace.globalConnNetId === globalConnNetId
+        );
+        const inputNetConnection = this.inputProblem.netConnections.find(
+          (connection) => connection.pinIds.length === 3 && connection.pinIds.includes(p1.pinId) && connection.pinIds.includes(p2.pinId)
+        );
+        const sourceChip = this.chipMap[p1.chipId];
+        const targetRailTrace = sameNetTraces.find(
+          (trace) => trace.pinIds.includes(p2.pinId) && trace.pins.every((pin) => pin.chipId === p2.chipId)
+        );
+        const canJoinThreePinNet = inputNetConnection !== void 0 && sourceChip?.pins.length === 2 && targetRailTrace !== void 0;
+        const junctionTracePath = canJoinThreePinNet ? clipPathAtFirstIntersection(newTracePath, sameNetTraces) : null;
+        const acceptedTracePath = junctionTracePath ?? newTracePath;
+        const tracesToCheck = junctionTracePath ? this.allSolvedTraces.filter(
+          (trace) => trace.globalConnNetId !== globalConnNetId
+        ) : this.allSolvedTraces;
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
-          newTracePath,
-          this.allSolvedTraces
+          acceptedTracePath,
+          tracesToCheck
         );
         if (isTraceClear) {
-          const [p1, p2] = this.currentCandidatePair;
-          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
           const mspPairId = `${p1.pinId}-${p2.pinId}`;
           const newSolvedTrace = {
             mspPairId,
             dcConnNetId: globalConnNetId,
             globalConnNetId,
             pins: [p1, p2],
-            tracePath: newTracePath,
+            tracePath: acceptedTracePath,
             mspConnectionPairIds: [mspPairId],
             pinIds: [p1.pinId, p2.pinId]
           };
@@ -5525,9 +5616,9 @@ var moveRailSegments = (trace, segments, coordinate) => {
 };
 
 // lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
-var EPS6 = 1e-6;
+var EPS7 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS6 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS6;
+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 getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -5551,11 +5642,11 @@ var getUniquePinCount = (pinIds) => new Set(pinIds).size;
 var isTraceCorner = (a, b, c) => getSegmentOrientation(a, b) !== getSegmentOrientation(b, c);
 var isPointOnSegment = (point, start, end) => {
   if (getSegmentOrientation(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS6 && point.x >= Math.min(start.x, end.x) - EPS6 && point.x <= Math.max(start.x, end.x) + EPS6;
+    return Math.abs(point.y - start.y) <= EPS7 && point.x >= Math.min(start.x, end.x) - EPS7 && point.x <= Math.max(start.x, end.x) + EPS7;
   }
-  return Math.abs(point.x - start.x) <= EPS6 && point.y >= Math.min(start.y, end.y) - EPS6 && point.y <= Math.max(start.y, end.y) + EPS6;
+  return Math.abs(point.x - start.x) <= EPS7 && point.y >= Math.min(start.y, end.y) - EPS7 && point.y <= Math.max(start.y, end.y) + EPS7;
 };
-var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS6 ? "horizontal" : "vertical";
+var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts
 var getAnchoredTraceIds = (label, traces) => new Set(
@@ -5571,17 +5662,17 @@ var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
 });
 
 // lib/solvers/Example28Solver/types.ts
-var EPS7 = 1e-9;
+var EPS8 = 1e-9;
 
 // lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS7;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS8;
   if (isVertical5) {
-    return Math.abs(start.x - rect.minX) < EPS7 || Math.abs(start.x - rect.maxX) < EPS7;
+    return Math.abs(start.x - rect.minX) < EPS8 || Math.abs(start.x - rect.maxX) < EPS8;
   }
   if (isHorizontal4) {
-    return Math.abs(start.y - rect.minY) < EPS7 || Math.abs(start.y - rect.maxY) < EPS7;
+    return Math.abs(start.y - rect.minY) < EPS8 || Math.abs(start.y - rect.maxY) < EPS8;
   }
   return false;
 };
@@ -5596,10 +5687,10 @@ var getPathLength2 = (path) => {
   return length;
 };
 var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS7 || Math.abs(start.y - end.y) < EPS7;
-var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS7 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS8 || Math.abs(start.y - end.y) < EPS8;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS8 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS7) {
+  if (Math.abs(start.x - end.x) < EPS8) {
     return {
       x: start.x,
       y: Math.min(
@@ -5608,7 +5699,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS7) {
+  if (Math.abs(start.y - end.y) < EPS8) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -5651,9 +5742,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    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.x >= Math.min(segment.start.x, segment.end.x) - EPS8 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS8;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS7 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS7;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS8 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS8;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -5681,24 +5772,24 @@ var projectPointToPath = (point, path) => {
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  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;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS8;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS8;
+  const between2 = (value, p1, p2) => value >= Math.min(p1, p2) - EPS8 && value <= Math.max(p1, p2) + EPS8;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS7) return false;
+    if (Math.abs(a1.x - b1.x) > EPS8) 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 > EPS7;
+    return overlap > EPS8;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS7) return false;
+    if (Math.abs(a1.y - b1.y) > EPS8) 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 > EPS7;
+    return overlap > EPS8;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
   const horizontalA = aVertical ? b1 : a1;
   const horizontalB = aVertical ? b2 : a2;
-  return between(verticalA.x, horizontalA.x, horizontalB.x) && between(horizontalA.y, verticalA.y, verticalB.y);
+  return between2(verticalA.x, horizontalA.x, horizontalB.x) && between2(horizontalA.y, verticalA.y, verticalB.y);
 };
 var countPathIntersections = (pathA, pathB) => {
   let count = 0;
@@ -6068,7 +6159,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
-var EPS8 = 1e-6;
+var EPS9 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections = [];
   for (const obstacle of obstacles) {
@@ -6087,17 +6178,17 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections;
 };
-var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS8 && Math.abs(first.y - second.y) < EPS8;
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS9 && Math.abs(first.y - second.y) < EPS9;
 var findPerpendicularPathCrossings = (path, otherPath) => {
   const crossings = [];
   for (let pathSegmentIndex = 1; pathSegmentIndex < path.length - 2; pathSegmentIndex++) {
     const start = path[pathSegmentIndex];
     const end = path[pathSegmentIndex + 1];
-    const isVertical5 = Math.abs(start.x - end.x) < EPS8;
+    const isVertical5 = Math.abs(start.x - end.x) < EPS9;
     for (let otherPathSegmentIndex = 1; otherPathSegmentIndex < otherPath.length - 2; otherPathSegmentIndex++) {
       const otherStart = otherPath[otherPathSegmentIndex];
       const otherEnd = otherPath[otherPathSegmentIndex + 1];
-      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS8;
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS9;
       if (isVertical5 === otherIsVertical) continue;
       const intersection = getSegmentIntersection(
         start,
@@ -6117,8 +6208,8 @@ var findPerpendicularPathCrossings = (path, otherPath) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS9 = 1e-6;
-var isVertical3 = (a, b, eps = EPS9) => Math.abs(a.x - b.x) < eps;
+var EPS10 = 1e-6;
+var isVertical3 = (a, b, eps = EPS10) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -6131,7 +6222,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
+  if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6143,7 +6234,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - (y + height)) < EPS10) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -6155,7 +6246,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - y) < EPS9) {
+  } else if (Math.abs(p2.x - x) < EPS10 && Math.abs(p2.y - y) < EPS10) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6167,7 +6258,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - y) < EPS9) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS10 && Math.abs(p2.y - y) < EPS10) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -6195,7 +6286,7 @@ var generatePerpendicularTraceDetours = ({
   const buildDetours = (path, index) => {
     const start = path[index];
     const end = path[index + 1];
-    const movingAxis = Math.abs(start.x - end.x) < EPS9 ? "y" : "x";
+    const movingAxis = Math.abs(start.x - end.x) < EPS10 ? "y" : "x";
     const detourAxis = movingAxis === "x" ? "y" : "x";
     const gate = obstacleStart[movingAxis] + Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance;
     const obstacleRange = [obstacleStart[detourAxis], obstacleEnd[detourAxis]];
@@ -6793,9 +6884,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS10 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS10;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS10;
+var EPS11 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS11;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS11;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -7070,7 +7161,7 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
     const end = path[i + 1];
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS8) {
         return true;
       }
     }
@@ -7085,13 +7176,13 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS7) total += overlap;
+      if (overlap > EPS8) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
   if (isVertical5) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
@@ -7855,16 +7946,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS11 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS11;
+var EPS12 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS12;
 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 rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS11 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS11;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS11;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS12;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS12;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -7887,7 +7978,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS11 || p1.x >= interiorBounds.maxX - EPS11) {
+    if (p1.x <= interiorBounds.minX + EPS12 || p1.x >= interiorBounds.maxX - EPS12) {
       return false;
     }
     return rangesOverlap(
@@ -7898,7 +7989,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS11 || p1.y >= interiorBounds.maxY - EPS11) {
+    if (p1.y <= interiorBounds.minY + EPS12 || p1.y >= interiorBounds.maxY - EPS12) {
       return false;
     }
     return rangesOverlap(
@@ -7954,8 +8045,8 @@ var simplifyOrthogonalPath = (path) => {
   return simplified;
 };
 var pointsEqual2 = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS11;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS11;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS12;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS12;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -7964,6 +8055,42 @@ var getMaxSearchDistance = (inputProblem) => {
   return maxChipWidth * 3;
 };
 
+// lib/solvers/AvailableNetOrientationSolver/orderRoutedLabelsBeforeOverlappingPortLabels.ts
+var isPortOnlyLabel = (label) => label.mspConnectionPairIds.length === 0;
+var orderRoutedLabelsBeforeOverlappingPortLabels = ({
+  labelIndices,
+  netLabelPlacements
+}) => {
+  const orderedLabelIndices = [...labelIndices];
+  for (const routedLabelIndex of labelIndices) {
+    const routedLabel = netLabelPlacements[routedLabelIndex];
+    if (isPortOnlyLabel(routedLabel)) continue;
+    const routedBounds = getRectBounds(
+      routedLabel.center,
+      routedLabel.width,
+      routedLabel.height
+    );
+    const blockingPosition = orderedLabelIndices.findIndex((labelIndex) => {
+      const portOnlyLabel = netLabelPlacements[labelIndex];
+      if (!isPortOnlyLabel(portOnlyLabel)) return false;
+      if (portOnlyLabel.globalConnNetId === routedLabel.globalConnNetId) {
+        return false;
+      }
+      const portOnlyBounds = getRectBounds(
+        portOnlyLabel.center,
+        portOnlyLabel.width,
+        portOnlyLabel.height
+      );
+      return rectsOverlap2(routedBounds, portOnlyBounds);
+    });
+    const routedPosition = orderedLabelIndices.indexOf(routedLabelIndex);
+    if (blockingPosition === -1 || blockingPosition > routedPosition) continue;
+    orderedLabelIndices.splice(routedPosition, 1);
+    orderedLabelIndices.splice(blockingPosition, 0, routedLabelIndex);
+  }
+  return orderedLabelIndices;
+};
+
 // lib/solvers/AvailableNetOrientationSolver/visualize.ts
 var visualizeAvailableNetOrientationSolver = (params) => {
   const graphics = visualizeInputProblem(params.inputProblem);
@@ -8114,12 +8241,16 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       }
     }
     this.sortCrowdedTopBankByPin(indices);
-    const blockedStandaloneLabelIndex = indices.find((index) => {
+    const orderedIndices = orderRoutedLabelsBeforeOverlappingPortLabels({
+      labelIndices: indices,
+      netLabelPlacements: this.outputNetLabelPlacements
+    });
+    const blockedStandaloneLabelIndex = orderedIndices.find((index) => {
       const label = this.outputNetLabelPlacements[index];
       const orientations = this.getAvailableOrientations(label);
       return this.isPortOnlyLabel(label) && this.isStandaloneSinglePinNetLabel(label) && orientations.length === 1 && isYOrientation(orientations[0]) && this.labelIntersectsDifferentNetTrace(label);
     });
-    if (blockedStandaloneLabelIndex === void 0) return indices;
+    if (blockedStandaloneLabelIndex === void 0) return orderedIndices;
     this.blockedStandaloneLabelIndex = blockedStandaloneLabelIndex;
     this.blockedStandaloneLabelTargetAnchorX = null;
     const blockedLabel = this.outputNetLabelPlacements[blockedStandaloneLabelIndex];
@@ -8127,8 +8258,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const chipSide = this.getChipSideForPoint(blockedLabel.anchorPoint);
     const affectedSlots = [];
     const labelsToOrder = [];
-    for (let slot = 0; slot < indices.length; slot++) {
-      const index = indices[slot];
+    for (let slot = 0; slot < orderedIndices.length; slot++) {
+      const index = orderedIndices[slot];
       const label = this.outputNetLabelPlacements[index];
       const orientations = this.getAvailableOrientations(label);
       if (this.getChipSideForPoint(label.anchorPoint) === chipSide && orientations.length === 1 && orientations[0] === requiredOrientation) {
@@ -8158,9 +8289,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ).x;
     }
     for (let i = 0; i < affectedSlots.length; i++) {
-      indices[affectedSlots[i]] = labelsToOrder[i];
+      orderedIndices[affectedSlots[i]] = labelsToOrder[i];
     }
-    return indices;
+    return orderedIndices;
   }
   sortCrowdedTopBankByPin(indices) {
     const slotsByChip = /* @__PURE__ */ new Map();
@@ -8371,7 +8502,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       index,
       pin: this.pinMap[otherLabel.pinIds[0]]
     })).filter(
-      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS11
+      ({ index, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS12
     ).sort((a, b) => a.pin.x - b.pin.x)[0]?.pin;
     if (orientation === "y-" && nextPinToRight) return null;
     const anchorX = orientation === "y-" ? Math.max(
@@ -8404,7 +8535,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const centeredAnchorY = hasUpFacingStack ? (lowestUpFacingLabelY + highestUpFacingLabelY) / 2 : stackedAnchorY;
     const anchorYs = orientation === "y-" ? [centeredAnchorY, stackedAnchorY] : [stackedAnchorY];
     for (const anchorY of anchorYs) {
-      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS11) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS12) {
         continue;
       }
       const candidate = this.createCandidate(
@@ -8433,11 +8564,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (trace.globalConnNetId !== label.globalConnNetId) return false;
       const path = trace.tracePath;
       return path.some((point, pointIndex) => {
-        if (Math.abs(point.x - label.anchorPoint.x) > EPS11 || Math.abs(point.y - label.anchorPoint.y) > EPS11) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS12 || Math.abs(point.y - label.anchorPoint.y) > EPS12) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS11 && (neighbor.y - point.y) * direction.y > EPS11
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS12 && (neighbor.y - point.y) * direction.y > EPS12
         );
       });
     });
@@ -8527,7 +8658,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation
       );
       if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
-      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
           x: connectorSource.x + outwardDirection.x * distance5,
           y: connectorSource.y + outwardDirection.y * distance5
@@ -8582,7 +8713,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 + EPS11; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS12; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -8656,7 +8787,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
+    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance5,
         y: baseAnchor.y + direction.y * distance5
@@ -8962,9 +9093,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS11 || anchorPoint.x > chipBounds.maxX + EPS11;
+        return anchorPoint.x < chipBounds.minX - EPS12 || anchorPoint.x > chipBounds.maxX + EPS12;
       }
-      return anchorPoint.y < chipBounds.minY - EPS11 || anchorPoint.y > chipBounds.maxY + EPS11;
+      return anchorPoint.y < chipBounds.minY - EPS12 || anchorPoint.y > chipBounds.maxY + EPS12;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -9065,8 +9196,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (!chip) return null;
     const sides = new Set(
       pins.map((pin) => {
-        if (Math.abs(pin.x - chip.bounds.minX) <= EPS11) return "left";
-        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS11) return "right";
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS12) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS12) return "right";
         return null;
       })
     );
@@ -9099,8 +9230,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 + EPS11 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS11;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS11 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS11;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS12;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS12;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -9162,7 +9293,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 - EPS11 || point.x > bounds.maxX + EPS11 || point.y < bounds.minY - EPS11 || point.y > bounds.maxY + EPS11) {
+      if (point.x < bounds.minX - EPS12 || point.x > bounds.maxX + EPS12 || point.y < bounds.minY - EPS12 || point.y > bounds.maxY + EPS12) {
         continue;
       }
       for (const [side, distance5] of getSideDistances(point, bounds)) {
@@ -9179,8 +9310,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 - EPS11 ? bounds.minX - point.x : point.x > bounds.maxX + EPS11 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS11 ? bounds.minY - point.y : point.y > bounds.maxY + EPS11 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS12 ? bounds.minX - point.x : point.x > bounds.maxX + EPS12 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS12 ? bounds.minY - point.y : point.y > bounds.maxY + EPS12 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -9496,7 +9627,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       for (const anchorPoint of getTraceCorners(path)) {
         const cornerIndex = path.indexOf(anchorPoint);
         const anchorAlignedToPin = pins.some(
-          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS6
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS7
         );
         const pinAligned = anchorAlignedToPin || allowRailAlignedFallback && this.isPinAlignedCorner(path, cornerIndex);
         if (!pinAligned) continue;
@@ -9536,12 +9667,12 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     return traceCrossesBoundsInterior(bounds, otherNetTraceMap);
   }
   pointsEqual(a, b) {
-    return Math.abs(a.x - b.x) <= EPS6 && Math.abs(a.y - b.y) <= EPS6;
+    return Math.abs(a.x - b.x) <= EPS7 && Math.abs(a.y - b.y) <= EPS7;
   }
   getVerticalSegmentPointIndices(path, cornerIndex) {
     const corner = path[cornerIndex];
-    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS6;
-    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS6;
+    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS7;
+    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS7;
     if (previousIsVertical === nextIsVertical) return null;
     const indices = previousIsVertical ? [cornerIndex - 1, cornerIndex] : [cornerIndex, cornerIndex + 1];
     return indices;
@@ -9591,7 +9722,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
         const end = otherTrace.tracePath[i + 1];
         if (!segmentCrossesBoundsInterior(start, end, labelBounds)) continue;
         const halfLabelWidth = label.width / 2;
-        if (Math.abs(start.x - end.x) <= EPS6) {
+        if (Math.abs(start.x - end.x) <= EPS7) {
           shiftedCoordinates.add(
             start.x - halfLabelWidth - LABEL_TRACE_CLEARANCE3
           );
@@ -9609,7 +9740,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       }
     }
     return [...shiftedCoordinates].flatMap((x) => {
-      if (Math.abs(x - corner.x) <= EPS6) return [];
+      if (Math.abs(x - corner.x) <= EPS7) return [];
       const reroutedTracePath = simplifyPath(
         path.map(
           (point, pointIndex) => verticalPointIndices.includes(pointIndex) ? { ...point, x } : point
@@ -9740,11 +9871,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS12 = 1e-6;
+var EPS13 = 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) > EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS12;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS12;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS13 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS13;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS13 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS13;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -9790,7 +9921,7 @@ var getPointAtTraceDistance = (trace, distance5) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance5 <= nextDistance + EPS12) {
+    if (distance5 <= nextDistance + EPS13) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance5 - pathDistance)
@@ -9829,7 +9960,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS12 || start.x >= interior.maxX - EPS12) {
+    if (start.x <= interior.minX + EPS13 || start.x >= interior.maxX - EPS13) {
       return false;
     }
     return rangesOverlap2(
@@ -9840,7 +9971,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS12 || start.y >= interior.maxY - EPS12) {
+    if (start.y <= interior.minY + EPS13 || start.y >= interior.maxY - EPS13) {
       return false;
     }
     return rangesOverlap2(
@@ -9854,10 +9985,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS12 && point.x >= Math.min(start.x, end.x) - EPS12 && point.x <= Math.max(start.x, end.x) + EPS12;
+    return Math.abs(point.y - start.y) <= EPS13 && point.x >= Math.min(start.x, end.x) - EPS13 && point.x <= Math.max(start.x, end.x) + EPS13;
   }
   if (isVertical4(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS12 && point.y >= Math.min(start.y, end.y) - EPS12 && point.y <= Math.max(start.y, end.y) + EPS12;
+    return Math.abs(point.x - start.x) <= EPS13 && point.y >= Math.min(start.y, end.y) - EPS13 && point.y <= Math.max(start.y, end.y) + EPS13;
   }
   return false;
 };
@@ -9865,9 +9996,9 @@ var getSegmentDirection = (start, end) => ({
   x: isVertical4(start, end) ? 0 : Math.sign(end.x - start.x),
   y: isHorizontal3(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS12;
-var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS12;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS12;
+var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS13;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS13;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS13;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -9924,7 +10055,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance5 of vertexDistances) {
     distances.add(roundDistance(distance5));
   }
-  return [...distances].filter((distance5) => distance5 >= -EPS12 && distance5 <= traceLength + EPS12).sort((a, b) => a - b);
+  return [...distances].filter((distance5) => distance5 >= -EPS13 && distance5 <= traceLength + EPS13).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -10013,13 +10144,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS12) {
+  if (value > max + EPS13) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS12) {
+  if (value < min - EPS13) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -10030,7 +10161,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS12, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS13, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -10103,7 +10234,7 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance5) => Number(distance5.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS12 && Math.abs(point.y - label.anchorPoint.y) <= EPS12 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS13 && Math.abs(point.y - label.anchorPoint.y) <= EPS13 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";