@tscircuit/schematic-trace-solver 0.0.105 → 0.0.107

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS11 = 1e-9;
+  const EPS12 = 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) < -EPS11) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS12) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS11) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS12) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS11 || Math.abs(p1.y - p2.y) < EPS11) {
+  if (Math.abs(p1.x - p2.x) < EPS12 || Math.abs(p1.y - p2.y) < EPS12) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1299,8 +1299,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS11 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS11 && Math.abs(p.y - q.y) < EPS11;
+      const EPS12 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS12 && Math.abs(p.y - q.y) < EPS12;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1573,13 +1573,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS11 = 1e-6
+  EPS: EPS12 = 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) < EPS11;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS11;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS12;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS12;
   if (!isVertical5 && !isHorizontal4) return;
   const segDir = isVertical5 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -1997,7 +1997,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS11 = 2e-3;
+    const EPS12 = 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++) {
@@ -2024,7 +2024,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS11) {
+          if (rangeOverlap > EPS12) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2043,7 +2043,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS11) return;
+          if (rangeOverlap < -EPS12) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2066,8 +2066,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) < EPS11;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS11;
+            const aVert = Math.abs(a1.x - a2.x) < EPS12;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS12;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2075,11 +2075,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) < EPS11;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS11;
+                const bVert = Math.abs(b1.x - b2.x) < EPS12;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS12;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS11) {
+                  if (Math.abs(a1.x - b1.x) < EPS12) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2089,7 +2089,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS11) {
+                  if (Math.abs(a1.y - b1.y) < EPS12) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2145,14 +2145,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS11 = 2e-3;
+    const EPS12 = 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) < EPS11;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS11;
+        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS12;
+        const isVertical5 = Math.abs(p1.x - p2.x) < EPS12;
         if (!isHorizontal4 && !isVertical5) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2166,13 +2166,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS11 = 2e-3;
+    const EPS12 = 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) < 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 prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS12 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS12 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS12 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS12 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2299,24 +2299,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-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;
+function segmentIntersectsRect2(p1, p2, rect, EPS12 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS12;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS12;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS11 || x > rect.maxX + EPS11) return false;
+    if (x < rect.minX - EPS12 || x > rect.maxX + EPS12) 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 > EPS11;
+    return overlap > EPS12;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS11 || y > rect.maxY + EPS11) return false;
+    if (y < rect.minY - EPS12 || y > rect.maxY + EPS12) 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 > EPS11;
+    return overlap > EPS12;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -2713,14 +2713,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS11 = 1e-6;
+    const EPS12 = 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) < EPS11;
-        const isV = Math.abs(a.x - b.x) < EPS11;
+        const isH = Math.abs(a.y - b.y) < EPS12;
+        const isV = Math.abs(a.x - b.x) < EPS12;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4774,6 +4774,95 @@ var minimizeTurns = ({
   return finalSimplifiedPath;
 };
 
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts
+var RAIL_ALIGNMENT_EPSILON = 2e-3;
+var nearlyEqual = (a, b) => Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON;
+var isHorizontal2 = (a, b) => nearlyEqual(a.y, b.y);
+var isVertical2 = (a, b) => nearlyEqual(a.x, b.x);
+var isPositiveLength = (a, b) => Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON || Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON;
+var getRailOrientation = (a, b) => {
+  if (!isPositiveLength(a, b)) return null;
+  if (isVertical2(a, b)) return "vertical";
+  if (isHorizontal2(a, b)) return "horizontal";
+  return null;
+};
+var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
+var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
+var getDistinctCoordinates = (coordinates) => {
+  const distinct = [];
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate);
+    }
+  }
+  return distinct;
+};
+var getMergedIntervalMetrics = (intervals) => {
+  const groups = [];
+  for (const interval of intervals) {
+    const group = groups.find(
+      (items) => nearlyEqual(items[0].coordinate, interval.coordinate)
+    );
+    if (group) group.push(interval);
+    else groups.push([interval]);
+  }
+  return groups.reduce(
+    (total, group) => {
+      const sorted = [...group].sort((a, b) => a.min - b.min);
+      let groupLength = 0;
+      let segmentCount = 1;
+      let currentMin = sorted[0].min;
+      let currentMax = sorted[0].max;
+      for (const interval of sorted.slice(1)) {
+        if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+          currentMax = Math.max(currentMax, interval.max);
+        } else {
+          groupLength += currentMax - currentMin;
+          segmentCount++;
+          currentMin = interval.min;
+          currentMax = interval.max;
+        }
+      }
+      return {
+        length: total.length + groupLength + currentMax - currentMin,
+        segmentCount: total.segmentCount + segmentCount
+      };
+    },
+    { length: 0, segmentCount: 0 }
+  );
+};
+var getVisibleTraceMetrics = (traces) => {
+  const horizontal = [];
+  const vertical = [];
+  for (const trace of traces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index];
+      const end = trace.tracePath[index + 1];
+      if (isHorizontal2(start, end)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x)
+        });
+      } else if (isVertical2(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y)
+        });
+      }
+    }
+  }
+  const horizontalMetrics = getMergedIntervalMetrics(horizontal);
+  const verticalMetrics = getMergedIntervalMetrics(vertical);
+  return {
+    length: horizontalMetrics.length + verticalMetrics.length,
+    segmentCount: horizontalMetrics.segmentCount + verticalMetrics.segmentCount
+  };
+};
+var getVisibleTraceLength = (traces) => getVisibleTraceMetrics(traces).length;
+var getVisibleTraceSegmentCount = (traces) => getVisibleTraceMetrics(traces).segmentCount;
+
 // lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
@@ -4789,11 +4878,16 @@ var minimizeTurnsWithFilteredLabels = ({
   if (!targetTrace) {
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`);
   }
-  const obstacleTraces = traces.filter(
-    (t) => t.mspPairId !== targetMspConnectionPairId && t.globalConnNetId !== targetTrace.globalConnNetId
+  const targetPinIds = new Set(targetTrace.pinIds);
+  const otherTraces = traces.filter(
+    (trace) => trace.mspPairId !== targetMspConnectionPairId
   );
+  const relaxedObstacleTraces = otherTraces.filter((trace) => {
+    const sharesEndpoint = trace.pinIds.some((pinId) => targetPinIds.has(pinId));
+    return trace.globalConnNetId !== targetTrace.globalConnNetId || !sharesEndpoint;
+  });
   const TRACE_WIDTH = 0.01;
-  const traceObstacles = obstacleTraces.flatMap(
+  const getTraceObstacles2 = (obstacleTraces) => obstacleTraces.flatMap(
     (trace, i) => trace.tracePath.slice(0, -1).map((p1, pi) => {
       const p2 = trace.tracePath[pi + 1];
       return {
@@ -4814,7 +4908,6 @@ var minimizeTurnsWithFilteredLabels = ({
     maxX: obs.maxX + PADDING,
     maxY: obs.maxY + PADDING
   }));
-  const combinedObstacles = [...staticObstacles, ...traceObstacles];
   const originalPath = targetTrace.tracePath;
   const filteredLabels = allLabelPlacements.filter((label) => {
     const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
@@ -4829,12 +4922,46 @@ var minimizeTurnsWithFilteredLabels = ({
     minY: nl.center.y - nl.height / 2 - paddingBuffer,
     maxY: nl.center.y + nl.height / 2 + paddingBuffer
   }));
-  const newPath = minimizeTurns({
+  const strictPath = minimizeTurns({
+    path: originalPath,
+    obstacles: [...staticObstacles, ...getTraceObstacles2(otherTraces)],
+    labelBounds,
+    originalPath
+  });
+  const relaxedPath = minimizeTurns({
     path: originalPath,
-    obstacles: combinedObstacles,
+    obstacles: [
+      ...staticObstacles,
+      ...getTraceObstacles2(relaxedObstacleTraces)
+    ],
     labelBounds,
     originalPath
   });
+  const sameNetTraces = otherTraces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const getSameNetReadability = (tracePath) => {
+    const tracesWithCandidate = [
+      ...sameNetTraces,
+      { ...targetTrace, tracePath }
+    ];
+    return {
+      segmentCount: getVisibleTraceSegmentCount(tracesWithCandidate),
+      visibleLength: getVisibleTraceLength(tracesWithCandidate)
+    };
+  };
+  const strictTurns = countTurns(strictPath);
+  const relaxedTurns = countTurns(relaxedPath);
+  let newPath = strictPath;
+  if (relaxedTurns < strictTurns) {
+    newPath = relaxedPath;
+  } else if (relaxedTurns === strictTurns) {
+    const strictReadability = getSameNetReadability(strictPath);
+    const relaxedReadability = getSameNetReadability(relaxedPath);
+    if (relaxedReadability.segmentCount < strictReadability.segmentCount || relaxedReadability.segmentCount === strictReadability.segmentCount && relaxedReadability.visibleLength < strictReadability.visibleLength - RAIL_ALIGNMENT_EPSILON) {
+      newPath = relaxedPath;
+    }
+  }
   return {
     ...targetTrace,
     tracePath: newPath
@@ -4978,80 +5105,6 @@ var balanceZShapes = ({
   };
 };
 
-// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts
-var RAIL_ALIGNMENT_EPSILON = 2e-3;
-var nearlyEqual = (a, b) => Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON;
-var isHorizontal2 = (a, b) => nearlyEqual(a.y, b.y);
-var isVertical2 = (a, b) => nearlyEqual(a.x, b.x);
-var isPositiveLength = (a, b) => Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON || Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON;
-var getRailOrientation = (a, b) => {
-  if (!isPositiveLength(a, b)) return null;
-  if (isVertical2(a, b)) return "vertical";
-  if (isHorizontal2(a, b)) return "horizontal";
-  return null;
-};
-var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
-var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
-var getDistinctCoordinates = (coordinates) => {
-  const distinct = [];
-  for (const coordinate of coordinates) {
-    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
-      distinct.push(coordinate);
-    }
-  }
-  return distinct;
-};
-var getMergedIntervalLength = (intervals) => {
-  const groups = [];
-  for (const interval of intervals) {
-    const group = groups.find(
-      (items) => nearlyEqual(items[0].coordinate, interval.coordinate)
-    );
-    if (group) group.push(interval);
-    else groups.push([interval]);
-  }
-  return groups.reduce((total, group) => {
-    const sorted = [...group].sort((a, b) => a.min - b.min);
-    let groupLength = 0;
-    let currentMin = sorted[0].min;
-    let currentMax = sorted[0].max;
-    for (const interval of sorted.slice(1)) {
-      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
-        currentMax = Math.max(currentMax, interval.max);
-      } else {
-        groupLength += currentMax - currentMin;
-        currentMin = interval.min;
-        currentMax = interval.max;
-      }
-    }
-    return total + groupLength + currentMax - currentMin;
-  }, 0);
-};
-var getVisibleTraceLength = (traces) => {
-  const horizontal = [];
-  const vertical = [];
-  for (const trace of traces) {
-    for (let index = 0; index < trace.tracePath.length - 1; index++) {
-      const start = trace.tracePath[index];
-      const end = trace.tracePath[index + 1];
-      if (isHorizontal2(start, end)) {
-        horizontal.push({
-          coordinate: start.y,
-          min: Math.min(start.x, end.x),
-          max: Math.max(start.x, end.x)
-        });
-      } else if (isVertical2(start, end)) {
-        vertical.push({
-          coordinate: start.x,
-          min: Math.min(start.y, end.y),
-          max: Math.max(start.y, end.y)
-        });
-      }
-    }
-  }
-  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical);
-};
-
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
 var moveRailSegments = (trace, segments, coordinate) => {
   const pointsToMove = /* @__PURE__ */ new Set();
@@ -5599,6 +5652,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
+var EPS7 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections = [];
   for (const obstacle of obstacles) {
@@ -5617,10 +5671,38 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections;
 };
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS7 && Math.abs(first.y - second.y) < EPS7;
+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) < EPS7;
+    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) < EPS7;
+      if (isVertical5 === otherIsVertical) continue;
+      const intersection = getSegmentIntersection(
+        start,
+        end,
+        otherStart,
+        otherEnd
+      );
+      if (!intersection || [start, end, otherStart, otherEnd].some(
+        (point) => isSamePoint(point, intersection)
+      )) {
+        continue;
+      }
+      crossings.push({ pathSegmentIndex, otherPathSegmentIndex });
+    }
+  }
+  return crossings;
+};
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS7 = 1e-6;
-var isVertical3 = (a, b, eps = EPS7) => Math.abs(a.x - b.x) < eps;
+var EPS8 = 1e-6;
+var isVertical3 = (a, b, eps = EPS8) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -5633,7 +5715,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
+  if (Math.abs(p2.x - x) < EPS8 && Math.abs(p2.y - (y + height)) < EPS8) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -5645,7 +5727,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS8 && Math.abs(p2.y - (y + height)) < EPS8) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -5657,7 +5739,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - y) < EPS7) {
+  } else if (Math.abs(p2.x - x) < EPS8 && Math.abs(p2.y - y) < EPS8) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -5669,7 +5751,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - y) < EPS7) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS8 && Math.abs(p2.y - y) < EPS8) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -5686,6 +5768,48 @@ var generateLShapeRerouteCandidates = ({
   }
   return [[i1_padded, c2, i2_padded]];
 };
+var generatePerpendicularTraceDetours = ({
+  trace,
+  segmentIndex,
+  obstacleStart,
+  obstacleEnd,
+  chipBounds,
+  clearance
+}) => {
+  const buildDetours = (path, index) => {
+    const start = path[index];
+    const end = path[index + 1];
+    const movingAxis = Math.abs(start.x - end.x) < EPS8 ? "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]];
+    const lowBound = detourAxis === "x" ? "minX" : "minY";
+    const highBound = detourAxis === "x" ? "maxX" : "maxY";
+    const detourCoordinates = [
+      Math.min(...obstacleRange) - clearance,
+      Math.max(...obstacleRange) + clearance,
+      ...chipBounds.flatMap((bounds) => [
+        bounds[lowBound] - clearance,
+        bounds[highBound] + clearance
+      ])
+    ];
+    return [...new Set(detourCoordinates)].map(
+      (detour) => simplifyPath([
+        ...path.slice(0, index + 1),
+        { ...start, [movingAxis]: gate },
+        { ...start, [movingAxis]: gate, [detourAxis]: detour },
+        { ...end, [detourAxis]: detour },
+        ...path.slice(index + 2)
+      ])
+    );
+  };
+  const reversedPath = [...trace.tracePath].reverse();
+  const reversedIndex = trace.tracePath.length - 2 - segmentIndex;
+  return [
+    ...buildDetours(trace.tracePath, segmentIndex),
+    ...buildDetours(reversedPath, reversedIndex).map((path) => path.reverse())
+  ].map((path) => ({ traceId: trace.mspPairId, path }));
+};
 
 // lib/solvers/TraceCleanupSolver/sub-solver/isPathColliding.ts
 import { getSegmentIntersection as getSegmentIntersection2 } from "@tscircuit/math-utils/line-intersections";
@@ -5860,6 +5984,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
   input;
   chipObstacleSpatialIndex;
   lShapesToProcess = [];
+  ignoredCrossings = /* @__PURE__ */ new Set();
+  reroutedTraceIds = /* @__PURE__ */ new Set();
+  processingCrossings = true;
   visualizationMode = "l_shapes";
   currentLShape = null;
   intersectionPoints = [];
@@ -5883,18 +6010,24 @@ var UntangleTraceSubsolver = class extends BaseSolver {
     if (!this.input.inputProblem._chipObstacleSpatialIndex) {
       this.input.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
     }
-    for (const trace of this.input.allTraces) {
-      const lShapes = findAllLShapedTurns(trace.tracePath);
-      this.lShapesToProcess.push(
-        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId }))
-      );
-    }
   }
   _step() {
     if (this.isInitialStep) {
       this.isInitialStep = false;
       return;
     }
+    if (this.processingCrossings) {
+      const crossing = this._findCrossing();
+      if (crossing) {
+        if (!this._resolveCrossing(crossing)) {
+          this.ignoredCrossings.add(this._crossingKey(crossing));
+        }
+        return;
+      }
+      this.processingCrossings = false;
+      this._initializeLShapes();
+      return;
+    }
     if (this.lShapeJustProcessed) {
       this._resetAfterLShapProcessing();
       return;
@@ -5918,6 +6051,110 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         break;
     }
   }
+  _initializeLShapes() {
+    for (const trace of this.input.allTraces) {
+      this.lShapesToProcess.push(
+        ...findAllLShapedTurns(trace.tracePath).map((lShape) => ({
+          ...lShape,
+          traceId: trace.mspPairId
+        }))
+      );
+    }
+  }
+  _crossingKey(crossing) {
+    return `${crossing.trace.mspPairId}:${crossing.segmentIndex}:${crossing.otherTrace.mspPairId}:${crossing.otherSegmentIndex}`;
+  }
+  _isTraceBundle(first, second) {
+    const componentPair = (trace) => trace.pins.map((pin) => pin.chipId).sort().join(":");
+    if (componentPair(first) !== componentPair(second)) return false;
+    return Object.values(this.input.mergedLabelNetIdMap).some(
+      (netIds) => netIds.has(first.globalConnNetId) && netIds.has(second.globalConnNetId)
+    );
+  }
+  _findCrossing() {
+    const traces = this.input.allTraces;
+    for (let firstIndex = 0; firstIndex < traces.length; firstIndex++) {
+      const trace = traces[firstIndex];
+      for (let secondIndex = firstIndex + 1; secondIndex < traces.length; secondIndex++) {
+        const otherTrace = traces[secondIndex];
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
+        const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace);
+        if (!isInitialBundleCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
+          continue;
+        }
+        const crossings = findPerpendicularPathCrossings(
+          trace.tracePath,
+          otherTrace.tracePath
+        );
+        for (const { pathSegmentIndex, otherPathSegmentIndex } of crossings) {
+          const crossing = {
+            trace,
+            segmentIndex: pathSegmentIndex,
+            otherTrace,
+            otherSegmentIndex: otherPathSegmentIndex,
+            isInitialBundleCrossing
+          };
+          if (!this.ignoredCrossings.has(this._crossingKey(crossing))) {
+            return crossing;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  _resolveCrossing(crossing) {
+    const chipBounds = this.chipObstacleSpatialIndex.chips.map(
+      (chip) => chip.bounds
+    );
+    const candidates = [
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.trace,
+        segmentIndex: crossing.segmentIndex,
+        obstacleStart: crossing.otherTrace.tracePath[crossing.otherSegmentIndex],
+        obstacleEnd: crossing.otherTrace.tracePath[crossing.otherSegmentIndex + 1],
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      }),
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.otherTrace,
+        segmentIndex: crossing.otherSegmentIndex,
+        obstacleStart: crossing.trace.tracePath[crossing.segmentIndex],
+        obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1],
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      })
+    ];
+    const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
+      (obstacle) => obstacle.kind === "chip"
+    );
+    const validCandidates = candidates.map((candidate) => ({
+      ...candidate,
+      collision: isPathColliding(
+        candidate.path,
+        this.input.allTraces,
+        candidate.traceId
+      )
+    })).filter(
+      (candidate) => !isPathCollidingWithChipInterior(candidate.path, chipObstacles) && !isPathColliding(
+        candidate.path,
+        [crossing.trace, crossing.otherTrace],
+        candidate.traceId
+      ).isColliding && (crossing.isInitialBundleCrossing || !candidate.collision.isColliding)
+    ).sort(
+      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength(first.path) - getPathLength(second.path)
+    );
+    const bestCandidate = validCandidates[0];
+    if (!bestCandidate) return false;
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === bestCandidate.traceId
+    );
+    this.input.allTraces[traceIndex] = {
+      ...this.input.allTraces[traceIndex],
+      tracePath: bestCandidate.path
+    };
+    this.reroutedTraceIds.add(bestCandidate.traceId);
+    return true;
+  }
   _resetAfterLShapProcessing() {
     this.lShapeProcessingStep = "idle";
     this.currentLShape = null;
@@ -6140,9 +6377,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS8 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS8;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS8;
+var EPS9 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS9;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS9;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -7202,16 +7439,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS9 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS9;
+var EPS10 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS10;
 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) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS9;
+var rectsOverlap2 = (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 rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS10;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -7234,7 +7471,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS9 || p1.x >= interiorBounds.maxX - EPS9) {
+    if (p1.x <= interiorBounds.minX + EPS10 || p1.x >= interiorBounds.maxX - EPS10) {
       return false;
     }
     return rangesOverlap(
@@ -7245,7 +7482,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS9 || p1.y >= interiorBounds.maxY - EPS9) {
+    if (p1.y <= interiorBounds.minY + EPS10 || p1.y >= interiorBounds.maxY - EPS10) {
       return false;
     }
     return rangesOverlap(
@@ -7301,8 +7538,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) <= EPS9;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS9;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS10;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS10;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -7557,11 +7794,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) > EPS9 || Math.abs(point.y - label.anchorPoint.y) > EPS9) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS10 || Math.abs(point.y - label.anchorPoint.y) > EPS10) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS9 && (neighbor.y - point.y) * direction.y > EPS9
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS10 && (neighbor.y - point.y) * direction.y > EPS10
         );
       });
     });
@@ -7640,7 +7877,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 + EPS9; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS10; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -7714,7 +7951,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS9; distance4 += LABEL_SEARCH_STEP) {
+    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS10; distance4 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance4,
         y: baseAnchor.y + direction.y * distance4
@@ -7951,9 +8188,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS9 || anchorPoint.x > chipBounds.maxX + EPS9;
+        return anchorPoint.x < chipBounds.minX - EPS10 || anchorPoint.x > chipBounds.maxX + EPS10;
       }
-      return anchorPoint.y < chipBounds.minY - EPS9 || anchorPoint.y > chipBounds.maxY + EPS9;
+      return anchorPoint.y < chipBounds.minY - EPS10 || anchorPoint.y > chipBounds.maxY + EPS10;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -8027,8 +8264,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 + EPS9 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS9;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS9 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS9;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS10 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS10;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS10 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS10;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -8076,7 +8313,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 - EPS9 || point.x > bounds.maxX + EPS9 || point.y < bounds.minY - EPS9 || point.y > bounds.maxY + EPS9) {
+      if (point.x < bounds.minX - EPS10 || point.x > bounds.maxX + EPS10 || point.y < bounds.minY - EPS10 || point.y > bounds.maxY + EPS10) {
         continue;
       }
       for (const [side, distance4] of getSideDistances(point, bounds)) {
@@ -8093,8 +8330,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 - EPS9 ? bounds.minX - point.x : point.x > bounds.maxX + EPS9 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS9 ? bounds.minY - point.y : point.y > bounds.maxY + EPS9 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS10 ? bounds.minX - point.x : point.x > bounds.maxX + EPS10 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS10 ? bounds.minY - point.y : point.y > bounds.maxY + EPS10 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -8472,11 +8709,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS10 = 1e-6;
+var EPS11 = 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) > 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 rectsOverlap3 = (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 rectsTouchOrOverlap = (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 traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -8522,7 +8759,7 @@ var getPointAtTraceDistance = (trace, distance4) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance4 <= nextDistance + EPS10) {
+    if (distance4 <= nextDistance + EPS11) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance4 - pathDistance)
@@ -8561,7 +8798,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS10 || start.x >= interior.maxX - EPS10) {
+    if (start.x <= interior.minX + EPS11 || start.x >= interior.maxX - EPS11) {
       return false;
     }
     return rangesOverlap2(
@@ -8572,7 +8809,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS10 || start.y >= interior.maxY - EPS10) {
+    if (start.y <= interior.minY + EPS11 || start.y >= interior.maxY - EPS11) {
       return false;
     }
     return rangesOverlap2(
@@ -8586,10 +8823,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    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;
+    return Math.abs(point.y - start.y) <= EPS11 && point.x >= Math.min(start.x, end.x) - EPS11 && point.x <= Math.max(start.x, end.x) + EPS11;
   }
   if (isVertical4(start, end)) {
-    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 Math.abs(point.x - start.x) <= EPS11 && point.y >= Math.min(start.y, end.y) - EPS11 && point.y <= Math.max(start.y, end.y) + EPS11;
   }
   return false;
 };
@@ -8597,9 +8834,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) <= EPS10;
-var isVertical4 = (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 isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS11;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS11;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS11;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -8656,7 +8893,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance4 of vertexDistances) {
     distances.add(roundDistance(distance4));
   }
-  return [...distances].filter((distance4) => distance4 >= -EPS10 && distance4 <= traceLength + EPS10).sort((a, b) => a - b);
+  return [...distances].filter((distance4) => distance4 >= -EPS11 && distance4 <= traceLength + EPS11).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -8745,13 +8982,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS10) {
+  if (value > max + EPS11) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS10) {
+  if (value < min - EPS11) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -8762,7 +8999,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS10, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS11, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -8835,7 +9072,7 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance4) => Number(distance4.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS11 && Math.abs(point.y - label.anchorPoint.y) <= EPS11 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";