@tscircuit/schematic-trace-solver 0.0.169 → 0.0.171

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS14 = 1e-9;
+  const EPS15 = 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) < -EPS14) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS15) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS14) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS15) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS14 || Math.abs(p1.y - p2.y) < EPS14) {
+  if (Math.abs(p1.x - p2.x) < EPS15 || Math.abs(p1.y - p2.y) < EPS15) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1575,8 +1575,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS14 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS14 && Math.abs(p.y - q.y) < EPS14;
+      const EPS15 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS15 && Math.abs(p.y - q.y) < EPS15;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1887,17 +1887,17 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS14 = 1e-6
+  EPS: EPS15 = 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) < 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;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS15;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS15;
+  if (!isVertical6 && !isHorizontal5) return;
+  const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
-    if (isVertical5) {
+    if (isVertical6) {
       const jogYNearStart = start.y + segDir * JOG_SIZE;
       const jogYNearEnd = end.y - segDir * JOG_SIZE;
       pts.splice(
@@ -1923,7 +1923,7 @@ var applyJogToTerminalSegment = ({
     return;
   }
   if (si === 0) {
-    if (isVertical5) {
+    if (isVertical6) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1943,7 +1943,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical5) {
+    if (isVertical6) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -2175,11 +2175,11 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   }) {
     const blockingCollisions = this.getBlockingCollisions({ group, offset });
     if (blockingCollisions.length === 0) return offset;
-    const crossesThroughObstacle = (candidateOffset) => blockingCollisions.some(({ start, isVertical: isVertical5, obstacle }) => {
+    const crossesThroughObstacle = (candidateOffset) => blockingCollisions.some(({ start, isVertical: isVertical6, obstacle }) => {
       let orig;
       let min;
       let max;
-      if (isVertical5) {
+      if (isVertical6) {
         orig = start.x;
         min = obstacle.minX;
         max = obstacle.maxX;
@@ -2191,8 +2191,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const next = orig + candidateOffset;
       return orig <= min + EPS5 && next >= max - EPS5 || orig >= max - EPS5 && next <= min + EPS5;
     });
-    const edges = blockingCollisions.map(({ start, isVertical: isVertical5, obstacle }) => {
-      if (isVertical5) {
+    const edges = blockingCollisions.map(({ start, isVertical: isVertical6, obstacle }) => {
+      if (isVertical6) {
         return {
           coord: start.x,
           lowEdge: obstacle.minX,
@@ -2226,10 +2226,10 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const start = trace.tracePath[traceSegmentIndex];
       const end = trace.tracePath[traceSegmentIndex + 1];
       if (!start || !end) continue;
-      const isVertical5 = Math.abs(start.x - end.x) < EPS5;
-      const isHorizontal4 = Math.abs(start.y - end.y) < EPS5;
-      if (!isVertical5 && !isHorizontal4) continue;
-      const shiftedSegment = isVertical5 ? [
+      const isVertical6 = Math.abs(start.x - end.x) < EPS5;
+      const isHorizontal5 = Math.abs(start.y - end.y) < EPS5;
+      if (!isVertical6 && !isHorizontal5) continue;
+      const shiftedSegment = isVertical6 ? [
         { ...start, x: start.x + offset },
         { ...end, x: end.x + offset }
       ] : [
@@ -2240,7 +2240,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       if (collision) {
         blockingCollisions.push({
           start,
-          isVertical: isVertical5,
+          isVertical: isVertical6,
           obstacle: collision.rect
         });
       }
@@ -2327,7 +2327,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS14 = 2e-3;
+    const EPS15 = 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++) {
@@ -2354,7 +2354,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS14) {
+          if (rangeOverlap > EPS15) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2373,7 +2373,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS14) return;
+          if (rangeOverlap < -EPS15) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2396,8 +2396,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) < EPS14;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS14;
+            const aVert = Math.abs(a1.x - a2.x) < EPS15;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS15;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2408,11 +2408,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) < EPS14;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS14;
+                const bVert = Math.abs(b1.x - b2.x) < EPS15;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS15;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS14) {
+                  if (Math.abs(a1.x - b1.x) < EPS15) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2422,7 +2422,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS14) {
+                  if (Math.abs(a1.y - b1.y) < EPS15) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2478,15 +2478,15 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS14 = 2e-3;
+    const EPS15 = 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) < EPS14;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS14;
-        if (!isHorizontal4 && !isVertical5) {
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS15;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS15;
+        if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
       }
@@ -2499,13 +2499,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS14 = 2e-3;
+    const EPS15 = 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) < 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 prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS15 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS15 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS15 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS15 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2667,24 +2667,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-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;
+function segmentIntersectsRect2(p1, p2, rect, EPS15 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS15;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS15;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS14 || x > rect.maxX + EPS14) return false;
+    if (x < rect.minX - EPS15 || x > rect.maxX + EPS15) 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 > EPS14;
+    return overlap > EPS15;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS14 || y > rect.maxY + EPS14) return false;
+    if (y < rect.minY - EPS15 || y > rect.maxY + EPS15) 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 > EPS14;
+    return overlap > EPS15;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3083,14 +3083,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS14 = 1e-6;
+    const EPS15 = 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) < EPS14;
-        const isV = Math.abs(a.x - b.x) < EPS14;
+        const isH = Math.abs(a.y - b.y) < EPS15;
+        const isV = Math.abs(a.x - b.x) < EPS15;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4176,11 +4176,11 @@ var doesPathCoincideWithTraces = (path, traces) => {
   for (let i = 0; i < path.length - 1; i++) {
     const pathSegStart = path[i];
     const pathSegEnd = path[i + 1];
-    const isVertical5 = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS;
-    const isHorizontal4 = Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS;
-    if (!isVertical5 && !isHorizontal4) continue;
-    const crossAxis = isVertical5 ? "x" : "y";
-    const alongAxis = isVertical5 ? "y" : "x";
+    const isVertical6 = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS;
+    const isHorizontal5 = Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS;
+    if (!isVertical6 && !isHorizontal5) continue;
+    const crossAxis = isVertical6 ? "x" : "y";
+    const alongAxis = isVertical6 ? "y" : "x";
     for (const trace of traces) {
       for (let j = 0; j < trace.tracePath.length - 1; j++) {
         const traceSegStart = trace.tracePath[j];
@@ -4204,7 +4204,7 @@ var doesPathCoincideWithTraces = (path, traces) => {
 };
 var doesPathOverlapTraceStrokes = (path, traces) => {
   const traceStrokeRadius = SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE / 2;
-  const getStrokeBounds = (start, end, isVertical5) => isVertical5 ? {
+  const getStrokeBounds = (start, end, isVertical6) => isVertical6 ? {
     minX: start.x - traceStrokeRadius,
     maxX: start.x + traceStrokeRadius,
     minY: Math.min(start.y, end.y),
@@ -4218,22 +4218,22 @@ var doesPathOverlapTraceStrokes = (path, traces) => {
   for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
     const pathStart = path[pathIndex];
     const pathEnd = path[pathIndex + 1];
-    const isVertical5 = Math.abs(pathStart.x - pathEnd.x) < COINCIDENT_EPS;
-    const isHorizontal4 = Math.abs(pathStart.y - pathEnd.y) < COINCIDENT_EPS;
-    if (!isVertical5 && !isHorizontal4) continue;
-    const pathBounds = getStrokeBounds(pathStart, pathEnd, isVertical5);
+    const isVertical6 = Math.abs(pathStart.x - pathEnd.x) < COINCIDENT_EPS;
+    const isHorizontal5 = Math.abs(pathStart.y - pathEnd.y) < COINCIDENT_EPS;
+    if (!isVertical6 && !isHorizontal5) continue;
+    const pathBounds = getStrokeBounds(pathStart, pathEnd, isVertical6);
     for (const trace of traces) {
       for (let traceIndex = 0; traceIndex < trace.tracePath.length - 1; traceIndex++) {
         const traceStart = trace.tracePath[traceIndex];
         const traceEnd = trace.tracePath[traceIndex + 1];
-        const isParallel = isVertical5 ? Math.abs(traceStart.x - traceEnd.x) < COINCIDENT_EPS : Math.abs(traceStart.y - traceEnd.y) < COINCIDENT_EPS;
+        const isParallel = isVertical6 ? Math.abs(traceStart.x - traceEnd.x) < COINCIDENT_EPS : Math.abs(traceStart.y - traceEnd.y) < COINCIDENT_EPS;
         if (!isParallel) continue;
         const overlap = boundsIntersection(
           pathBounds,
-          getStrokeBounds(traceStart, traceEnd, isVertical5)
+          getStrokeBounds(traceStart, traceEnd, isVertical6)
         );
         if (!overlap) continue;
-        const overlapLength = isVertical5 ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
+        const overlapLength = isVertical6 ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
         if (overlapLength > COINCIDENT_EPS) return true;
       }
     }
@@ -6015,12 +6015,12 @@ var EPS8 = 1e-9;
 
 // lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS8;
-  if (isVertical5) {
+  const isVertical6 = Math.abs(start.x - end.x) < EPS8;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS8;
+  if (isVertical6) {
     return Math.abs(start.x - rect.minX) < EPS8 || Math.abs(start.x - rect.maxX) < EPS8;
   }
-  if (isHorizontal4) {
+  if (isHorizontal5) {
     return Math.abs(start.y - rect.minY) < EPS8 || Math.abs(start.y - rect.maxY) < EPS8;
   }
   return false;
@@ -6614,12 +6614,12 @@ var findPerpendicularPathCrossings = (path, otherPath) => {
   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) < EPS9;
+    const isVertical6 = 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) < EPS9;
-      if (isVertical5 === otherIsVertical) continue;
+      if (isVertical6 === otherIsVertical) continue;
       const intersection = getSegmentIntersection(
         start,
         end,
@@ -7727,8 +7727,8 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS8;
-  if (isVertical5) {
+  const isVertical6 = Math.abs(start.x - end.x) < EPS8;
+  if (isVertical6) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
   return Math.min(Math.max(start.x, end.x), rect.maxX) - Math.max(Math.min(start.x, end.x), rect.minX);
@@ -10049,7 +10049,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         changed = true;
       }
     }
-    if (connectedPinIds.size <= 3) return null;
+    if (connectedPinIds.size < 3 || connectedPinIds.size === 3 && !this.hasPortOnlyLabelOnSameNet(label)) {
+      return null;
+    }
     const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]);
     const direction = dir(orientation);
     const pinX = pins[0].x;
@@ -11978,11 +11980,11 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         for (let si = 0; si < pts.length - 1; si++) {
           const segStart = pts[si];
           const segEnd = pts[si + 1];
-          const isHorizontal4 = Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS;
-          const isVertical5 = Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS;
-          if (!isHorizontal4 && !isVertical5) continue;
+          const isHorizontal5 = Math.abs(segStart.y - segEnd.y) < SEGMENT_PARALLEL_EPS;
+          const isVertical6 = Math.abs(segStart.x - segEnd.x) < SEGMENT_PARALLEL_EPS;
+          if (!isHorizontal5 && !isVertical6) continue;
           let perpendicularOrientations;
-          if (isHorizontal4) {
+          if (isHorizontal5) {
             perpendicularOrientations = ["y+", "y-"];
           } else {
             perpendicularOrientations = ["x+", "x-"];
@@ -13660,9 +13662,9 @@ var getStubLength = (path) => {
   return Math.abs(end.x - start.x) + Math.abs(end.y - start.y);
 };
 var getLabelBounds2 = (placement) => {
-  const isVertical5 = placement.axis === "y";
-  const width = isVertical5 ? placement.height : placement.width;
-  const height = isVertical5 ? placement.width : placement.height;
+  const isVertical6 = placement.axis === "y";
+  const width = isVertical6 ? placement.height : placement.width;
+  const height = isVertical6 ? placement.width : placement.height;
   return {
     minX: placement.center.x - width / 2,
     maxX: placement.center.x + width / 2,
@@ -13890,9 +13892,9 @@ var isPointOnPath2 = (point, path) => {
     const maxX = Math.max(start.x, end.x) + POINT_EPSILON;
     const minY = Math.min(start.y, end.y) - POINT_EPSILON;
     const maxY = Math.max(start.y, end.y) + POINT_EPSILON;
-    const isHorizontal4 = Math.abs(start.y - end.y) <= POINT_EPSILON;
-    const isVertical5 = Math.abs(start.x - end.x) <= POINT_EPSILON;
-    if ((isHorizontal4 && Math.abs(point.y - start.y) <= POINT_EPSILON || isVertical5 && Math.abs(point.x - start.x) <= POINT_EPSILON) && point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY) {
+    const isHorizontal5 = Math.abs(start.y - end.y) <= POINT_EPSILON;
+    const isVertical6 = Math.abs(start.x - end.x) <= POINT_EPSILON;
+    if ((isHorizontal5 && Math.abs(point.y - start.y) <= POINT_EPSILON || isVertical6 && Math.abs(point.x - start.x) <= POINT_EPSILON) && point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY) {
       return true;
     }
   }
@@ -15127,10 +15129,10 @@ orientation: ${label.orientation}`
         strokeColor: "purple"
       });
     }
-    const isHorizontal4 = inlineLabel.axis === "x";
+    const isHorizontal5 = inlineLabel.axis === "x";
     let renderedWidth = inlineLabel.width;
     let renderedHeight = inlineLabel.height;
-    if (!isHorizontal4) {
+    if (!isHorizontal5) {
       renderedWidth = inlineLabel.height;
       renderedHeight = inlineLabel.width;
     }
@@ -15230,9 +15232,9 @@ var getCollisionLimitedTerminalStubEnd = ({
   ownGlobalConnNetId,
   ignoredTraceIds
 }) => {
-  const isHorizontal4 = Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y);
-  const alongAxis = isHorizontal4 ? "x" : "y";
-  const acrossAxis = isHorizontal4 ? "y" : "x";
+  const isHorizontal5 = Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y);
+  const alongAxis = isHorizontal5 ? "x" : "y";
+  const acrossAxis = isHorizontal5 ? "y" : "x";
   const direction = Math.sign(intendedEnd[alongAxis] - start[alongAxis]) || 1;
   const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis]);
   let availableLength = intendedLength;
@@ -15270,7 +15272,7 @@ var getCollisionLimitedTerminalStubEnd = ({
     }
   }
   if (availableLength + GEOMETRY_EPSILON < minimumLength) return null;
-  return isHorizontal4 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
+  return isHorizontal5 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
 };
 
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
@@ -15279,23 +15281,6 @@ import {
   getBoundFromCenteredRect
 } from "@tscircuit/math-utils";
 
-// lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps.ts
-var getTraceRecoveryConnectivityMaps = (inputProblem) => {
-  const chipMap = {};
-  const pinMap = /* @__PURE__ */ new Map();
-  for (const chip of inputProblem.chips) {
-    chipMap[chip.chipId] = chip;
-    for (const pin of chip.pins) {
-      pinMap.set(pin.pinId, {
-        ...pin,
-        chipId: chip.chipId,
-        _facingDirection: pin._facingDirection ?? getPinDirection(pin, chip)
-      });
-    }
-  }
-  return { chipMap, pinMap };
-};
-
 // lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts
 import { doSegmentsIntersect as doSegmentsIntersect4 } from "@tscircuit/math-utils";
 var EPSILON = 1e-6;
@@ -15372,6 +15357,124 @@ var doesTraceRecoveryPathConflict = (tracePath, collisionTraces) => {
   return false;
 };
 
+// lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps.ts
+var getTraceRecoveryConnectivityMaps = (inputProblem) => {
+  const chipMap = {};
+  const pinMap = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    chipMap[chip.chipId] = chip;
+    for (const pin of chip.pins) {
+      pinMap.set(pin.pinId, {
+        ...pin,
+        chipId: chip.chipId,
+        _facingDirection: pin._facingDirection ?? getPinDirection(pin, chip)
+      });
+    }
+  }
+  return { chipMap, pinMap };
+};
+
+// lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
+var EPS14 = 1e-9;
+var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS14;
+var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS14;
+var compactConsecutivePoints = (path) => path.filter((point, index) => {
+  const previousPoint = path[index - 1];
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS14 || Math.abs(point.y - previousPoint.y) >= EPS14;
+});
+var isValidOrthogonalPath = (path) => {
+  if (path.length < 2 || !path.every((point, index) => {
+    const nextPoint = path[index + 1];
+    if (!nextPoint) return true;
+    return isHorizontal4(point, nextPoint) || isVertical5(point, nextPoint);
+  })) {
+    return false;
+  }
+  for (let firstSegmentIndex = 0; firstSegmentIndex < path.length - 1; firstSegmentIndex++) {
+    for (let secondSegmentIndex = firstSegmentIndex + 2; secondSegmentIndex < path.length - 1; secondSegmentIndex++) {
+      if (segmentsIntersect(
+        path[firstSegmentIndex],
+        path[firstSegmentIndex + 1],
+        path[secondSegmentIndex],
+        path[secondSegmentIndex + 1]
+      )) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+var getEndpointAlignedSegmentCandidates = (tracePath) => {
+  const candidates = [];
+  for (let segmentIndex = 2; segmentIndex <= tracePath.length - 4; segmentIndex++) {
+    const previousPoint = tracePath[segmentIndex - 1];
+    const start = tracePath[segmentIndex];
+    const end = tracePath[segmentIndex + 1];
+    const nextPoint = tracePath[segmentIndex + 2];
+    const segmentIsVertical = isVertical5(start, end);
+    const segmentIsHorizontal = isHorizontal4(start, end);
+    if (!segmentIsVertical && !segmentIsHorizontal || segmentIsVertical && (!isHorizontal4(previousPoint, start) || !isHorizontal4(end, nextPoint)) || segmentIsHorizontal && (!isVertical5(previousPoint, start) || !isVertical5(end, nextPoint))) {
+      continue;
+    }
+    const alignedCoordinates = segmentIsVertical ? [previousPoint.x, nextPoint.x] : [previousPoint.y, nextPoint.y];
+    for (const alignedCoordinate of alignedCoordinates) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS14) {
+        continue;
+      }
+      const candidate = tracePath.map((point) => ({ ...point }));
+      if (segmentIsVertical) {
+        candidate[segmentIndex].x = alignedCoordinate;
+        candidate[segmentIndex + 1].x = alignedCoordinate;
+      } else {
+        candidate[segmentIndex].y = alignedCoordinate;
+        candidate[segmentIndex + 1].y = alignedCoordinate;
+      }
+      const compactedCandidate = compactConsecutivePoints(candidate);
+      if (isValidOrthogonalPath(compactedCandidate)) {
+        candidates.push(compactedCandidate);
+      }
+    }
+  }
+  return candidates;
+};
+var countOtherNetCrossings2 = ({
+  tracePath,
+  globalConnNetId,
+  otherTraces
+}) => otherTraces.reduce(
+  (crossingCount, otherTrace) => crossingCount + (otherTrace.globalConnNetId === globalConnNetId ? 0 : countPathIntersections(tracePath, otherTrace.tracePath)),
+  0
+);
+var reduceTraceCrossings = ({
+  tracePath,
+  globalConnNetId,
+  otherTraces,
+  isCandidateValid
+}) => {
+  let bestPath = tracePath;
+  let bestCrossingCount = countOtherNetCrossings2({
+    tracePath,
+    globalConnNetId,
+    otherTraces
+  });
+  let bestPathLength = getPathLength2(tracePath);
+  for (const candidate of getEndpointAlignedSegmentCandidates(tracePath)) {
+    if (!isCandidateValid(candidate)) continue;
+    const crossingCount = countOtherNetCrossings2({
+      tracePath: candidate,
+      globalConnNetId,
+      otherTraces
+    });
+    const pathLength = getPathLength2(candidate);
+    if (crossingCount < bestCrossingCount || crossingCount === bestCrossingCount && pathLength < bestPathLength) {
+      bestPath = candidate;
+      bestCrossingCount = crossingCount;
+      bestPathLength = pathLength;
+    }
+  }
+  return bestPath;
+};
+
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
 var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
 var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
@@ -15631,7 +15734,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
   }
   tryAcceptCurrentRoute() {
     const candidate = this.currentCandidate;
-    const tracePath = this.activeSubSolver?.solvedTracePath;
+    let tracePath = this.activeSubSolver?.solvedTracePath;
     if (!candidate || !tracePath) return;
     const retainedTraces = this.outputTraces.filter(
       (trace) => !this.isSupersededConnectorTrace(trace, candidate)
@@ -15645,6 +15748,12 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     if (doesTraceRecoveryPathConflict(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }
+    tracePath = reduceTraceCrossings({
+      tracePath,
+      globalConnNetId: candidate.firstLabel.globalConnNetId,
+      otherTraces: collisionTraces,
+      isCandidateValid: (candidatePath) => findFirstCollision(candidatePath, this.activeSubSolver.obstacles) === null && !doesTraceRecoveryPathConflict(candidatePath, collisionTraces) && !this.routeIntersectsRemainingLabels(candidatePath, candidate)
+    });
     const [firstPin, secondPin] = candidate.pins;
     const mspPairId = `${RECOVERED_TRACE_PREFIX}${candidate.key}`;
     const recoveredTrace = {

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -1695,7 +1695,12 @@ export class AvailableNetOrientationSolver extends BaseSolver {
         changed = true
       }
     }
-    if (connectedPinIds.size <= 3) return null
+    if (
+      connectedPinIds.size < 3 ||
+      (connectedPinIds.size === 3 && !this.hasPortOnlyLabelOnSameNet(label))
+    ) {
+      return null
+    }
 
     const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]!)
     const direction = dir(orientation)