@tscircuit/schematic-trace-solver 0.0.57 → 0.0.61

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS9 = 1e-9;
+  const EPS10 = 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) < -EPS9) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS10) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS9) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS10) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS9 || Math.abs(p1.y - p2.y) < EPS9) {
+  if (Math.abs(p1.x - p2.x) < EPS10 || Math.abs(p1.y - p2.y) < EPS10) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -850,8 +850,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS9 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS9 && Math.abs(p.y - q.y) < EPS9;
+      const EPS10 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS10 && Math.abs(p.y - q.y) < EPS10;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1050,13 +1050,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS9 = 1e-6
+  EPS: EPS10 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical4 = Math.abs(start.x - end.x) < EPS9;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS9;
+  const isVertical4 = Math.abs(start.x - end.x) < EPS10;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS10;
   if (!isVertical4 && !isHorizontal3) return;
   const segDir = isVertical4 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
@@ -1123,13 +1123,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS9 = 1e-6;
+    const EPS10 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS9;
+    const eq = (a, b) => Math.abs(a - b) < EPS10;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1155,13 +1155,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS9
+              EPS: EPS10
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical4 = Math.abs(start.x - end.x) < EPS9;
-            const isHorizontal3 = Math.abs(start.y - end.y) < EPS9;
+            const isVertical4 = Math.abs(start.x - end.x) < EPS10;
+            const isHorizontal3 = Math.abs(start.y - end.y) < EPS10;
             if (!isVertical4 && !isHorizontal3) continue;
             if (isVertical4) {
               start.x += offset;
@@ -1258,7 +1258,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS9 = 2e-3;
+    const EPS10 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1276,7 +1276,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS9;
+          return overlap > EPS10;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1284,8 +1284,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) < EPS9;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS9;
+            const aVert = Math.abs(a1.x - a2.x) < EPS10;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS10;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1293,11 +1293,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) < EPS9;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS9;
+                const bVert = Math.abs(b1.x - b2.x) < EPS10;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS10;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS9) {
+                  if (Math.abs(a1.x - b1.x) < EPS10) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1318,7 +1318,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS9) {
+                  if (Math.abs(a1.y - b1.y) < EPS10) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1356,14 +1356,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS9 = 2e-3;
+    const EPS10 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS9;
-        const isVertical4 = Math.abs(p1.x - p2.x) < EPS9;
+        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS10;
+        const isVertical4 = Math.abs(p1.x - p2.x) < EPS10;
         if (!isHorizontal3 && !isVertical4) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -1377,13 +1377,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS9 = 2e-3;
+    const EPS10 = 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) < EPS9 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS9 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS9 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS9 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS10 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS10 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS10 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS10 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -1547,24 +1547,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS9 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS9;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS9;
+function segmentIntersectsRect2(p1, p2, rect, EPS10 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS10;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS10;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS9 || x > rect.maxX + EPS9) return false;
+    if (x < rect.minX - EPS10 || x > rect.maxX + EPS10) 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 > EPS9;
+    return overlap > EPS10;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS9 || y > rect.maxY + EPS9) return false;
+    if (y < rect.minY - EPS10 || y > rect.maxY + EPS10) 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 > EPS9;
+    return overlap > EPS10;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1942,14 +1942,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS9 = 1e-6;
+    const EPS10 = 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) < EPS9;
-        const isV = Math.abs(a.x - b.x) < EPS9;
+        const isH = Math.abs(a.y - b.y) < EPS10;
+        const isV = Math.abs(a.x - b.x) < EPS10;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -2227,6 +2227,29 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     }
     return groups;
   }
+  getNetLabelWidthForGroup(group) {
+    if (group.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (nc) => nc.netId === group.netId
+      )?.netLabelWidth;
+      if (ncWidth !== void 0) return ncWidth;
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === group.netId
+      )?.netLabelWidth;
+      if (dcWidthByNetId !== void 0) return dcWidthByNetId;
+    }
+    const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? [];
+    if (group.portOnlyPinId) {
+      pinIds.push(group.portOnlyPinId);
+    }
+    const dcWidthByPinId = this.inputProblem.directConnections.find(
+      (dc) => dc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelWidth;
+    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
+    return this.inputProblem.netConnections.find(
+      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelWidth;
+  }
   _step() {
     if (this.activeSubSolver?.solved) {
       this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement);
@@ -2241,9 +2264,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       const isAlreadyFull = currOrients.length === 4 && fullOrients.every((o) => currOrients.includes(o));
       if (!this.triedAnyOrientationFallbackForCurrentGroup && !isAlreadyFull && this.currentGroup) {
         this.triedAnyOrientationFallbackForCurrentGroup = true;
-        const netLabelWidth2 = this.currentGroup.netId ? this.inputProblem.netConnections.find(
-          (nc) => nc.netId === this.currentGroup.netId
-        )?.netLabelWidth : void 0;
+        const netLabelWidth2 = this.getNetLabelWidthForGroup(this.currentGroup);
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
@@ -2269,9 +2290,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     const netId = nextOverlappingSameNetTraceGroup.netId ?? nextOverlappingSameNetTraceGroup.globalConnNetId;
     this.currentGroup = nextOverlappingSameNetTraceGroup;
     this.triedAnyOrientationFallbackForCurrentGroup = false;
-    const netLabelWidth = this.currentGroup.netId ? this.inputProblem.netConnections.find(
-      (nc) => nc.netId === this.currentGroup.netId
-    )?.netLabelWidth : void 0;
+    const netLabelWidth = this.getNetLabelWidthForGroup(this.currentGroup);
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
@@ -4621,11 +4640,14 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
+var EPS5 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS5;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS5;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
-  const isHVHC = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x;
-  const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
+  const isHVHC = sameY(p0, p1) && sameX(p1, p2) && sameY(p2, p3) && sameX(p0, p3);
+  const isVHVC = sameX(p0, p1) && sameY(p1, p2) && sameX(p2, p3) && sameY(p0, p3);
   return isHVHC || isVHVC;
 };
 
@@ -4754,7 +4776,7 @@ var TraceCleanupSolver = class extends BaseSolver {
 };
 
 // lib/solvers/Example28Solver/types.ts
-var EPS5 = 1e-9;
+var EPS6 = 1e-9;
 
 // lib/solvers/Example28Solver/geometry.ts
 var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
@@ -4766,10 +4788,10 @@ var getPathLength = (path) => {
   return length;
 };
 var getDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS5 || Math.abs(start.y - end.y) < EPS5;
-var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS5 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS6 || Math.abs(start.y - end.y) < EPS6;
+var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS6 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS5) {
+  if (Math.abs(start.x - end.x) < EPS6) {
     return {
       x: start.x,
       y: Math.min(
@@ -4778,7 +4800,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS5) {
+  if (Math.abs(start.y - end.y) < EPS6) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -4821,9 +4843,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS5 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS5;
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS6 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS6;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS5 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS5;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS6 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS6;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -4851,18 +4873,18 @@ var projectPointToPath = (point, path) => {
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS5;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS5;
-  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS5 && value <= Math.max(p1, p2) + EPS5;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS6;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS6;
+  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS6 && value <= Math.max(p1, p2) + EPS6;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS5) return false;
+    if (Math.abs(a1.x - b1.x) > EPS6) 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 > EPS5;
+    return overlap > EPS6;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS5) return false;
+    if (Math.abs(a1.y - b1.y) > EPS6) 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 > EPS5;
+    return overlap > EPS6;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
@@ -4894,13 +4916,13 @@ var isPathCollidingWithChipInterior = (path, chipObstacles) => {
   return false;
 };
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical4 = Math.abs(start.x - end.x) < EPS5;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS5;
+  const isVertical4 = Math.abs(start.x - end.x) < EPS6;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS6;
   if (isVertical4) {
-    return Math.abs(start.x - rect.minX) < EPS5 || Math.abs(start.x - rect.maxX) < EPS5;
+    return Math.abs(start.x - rect.minX) < EPS6 || Math.abs(start.x - rect.maxX) < EPS6;
   }
   if (isHorizontal3) {
-    return Math.abs(start.y - rect.minY) < EPS5 || Math.abs(start.y - rect.maxY) < EPS5;
+    return Math.abs(start.y - rect.minY) < EPS6 || Math.abs(start.y - rect.maxY) < EPS6;
   }
   return false;
 };
@@ -5008,9 +5030,37 @@ var generateRerouteCandidateResults = ({
   outputNetLabelPlacements,
   chipObstacles
 }) => {
-  const rawCandidates = generateCandidatePaths(trace, label, inputProblem);
   const seen = /* @__PURE__ */ new Set();
   const candidateResults = [];
+  const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
+    trace,
+    label
+  );
+  if (horizontalSegmentPushCandidate) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: horizontalSegmentPushCandidate,
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles,
+        usesHorizontalSegmentPush: true
+      })
+    );
+  }
+  const rawCandidates = [
+    ...generateLabelHugCandidates(trace, label),
+    ...generateRerouteCandidates({
+      trace,
+      label,
+      problem: inputProblem,
+      paddingBuffer: LABEL_SIDE_CLEARANCE,
+      detourCount: 0
+    }),
+    ...generateEndpointDetourCandidates(trace, label)
+  ];
   for (const rawCandidate of rawCandidates) {
     candidateResults.push(
       createCandidateResult({
@@ -5026,17 +5076,6 @@ var generateRerouteCandidateResults = ({
   }
   return candidateResults;
 };
-var generateCandidatePaths = (trace, label, inputProblem) => [
-  ...generateLabelHugCandidates(trace, label),
-  ...generateRerouteCandidates({
-    trace,
-    label,
-    problem: inputProblem,
-    paddingBuffer: LABEL_SIDE_CLEARANCE,
-    detourCount: 0
-  }),
-  ...generateEndpointDetourCandidates(trace, label)
-];
 var createCandidateResult = ({
   trace,
   obstacleLabel,
@@ -5044,13 +5083,15 @@ var createCandidateResult = ({
   seen,
   outputTraces,
   outputNetLabelPlacements,
-  chipObstacles
+  chipObstacles,
+  usesHorizontalSegmentPush
 }) => {
   const key = getPathKey(path);
   if (seen.has(key)) {
     return {
       path,
       status: "duplicate",
+      usesHorizontalSegmentPush,
       selected: false
     };
   }
@@ -5059,6 +5100,7 @@ var createCandidateResult = ({
     return {
       path,
       status: "chip-collision",
+      usesHorizontalSegmentPush,
       selected: false
     };
   }
@@ -5072,6 +5114,7 @@ var createCandidateResult = ({
       outputNetLabelPlacements
     }),
     status: "valid",
+    usesHorizontalSegmentPush,
     selected: false
   };
 };
@@ -5148,6 +5191,12 @@ var selectBestReroutePath = ({
   outputNetLabelPlacements,
   candidateResults
 }) => {
+  for (const candidate of candidateResults) {
+    if (!candidate.usesHorizontalSegmentPush) continue;
+    if (candidate.status !== "valid") continue;
+    if (!candidate.score) continue;
+    return candidate.path;
+  }
   let bestPath = null;
   let bestScore = scoreTracePath({
     trace,
@@ -5164,6 +5213,71 @@ var selectBestReroutePath = ({
   }
   return bestPath;
 };
+var generateHorizontalSegmentPushCandidate = (trace, label) => {
+  const labelDirection = dir(label.orientation);
+  if (labelDirection.x === 0) return null;
+  const path = trace.tracePath;
+  const bounds = getRectBounds(label.center, label.width, label.height);
+  const collidingVerticalSegmentIndex = path.findIndex((start, index) => {
+    const end = path[index + 1];
+    if (!end) return false;
+    if (Math.abs(start.x - end.x) >= 1e-9) return false;
+    return segmentIntersectsRect2(start, end, bounds);
+  });
+  if (collidingVerticalSegmentIndex <= 0 || collidingVerticalSegmentIndex >= path.length - 2) {
+    return null;
+  }
+  const previousAnchor = path[collidingVerticalSegmentIndex - 1];
+  const verticalStart = path[collidingVerticalSegmentIndex];
+  const verticalEnd = path[collidingVerticalSegmentIndex + 1];
+  const nextAnchor = path[collidingVerticalSegmentIndex + 2];
+  if (Math.abs(previousAnchor.y - verticalStart.y) >= 1e-9 || Math.abs(verticalEnd.y - nextAnchor.y) >= 1e-9) {
+    return null;
+  }
+  let segmentPushX = bounds.minX - LABEL_SIDE_CLEARANCE;
+  if (labelDirection.x > 0) {
+    segmentPushX = bounds.maxX + LABEL_SIDE_CLEARANCE;
+  }
+  const segmentPushStartY = getClearedHorizontalY({
+    start: previousAnchor,
+    end: { x: segmentPushX, y: verticalStart.y },
+    labelBounds: bounds
+  });
+  const segmentPushEndY = getClearedHorizontalY({
+    start: { x: segmentPushX, y: verticalEnd.y },
+    end: nextAnchor,
+    labelBounds: bounds
+  });
+  const segmentPushPath = [
+    ...path.slice(0, collidingVerticalSegmentIndex - 1),
+    previousAnchor
+  ];
+  if (Math.abs(previousAnchor.y - segmentPushStartY) >= 1e-9) {
+    segmentPushPath.push({ x: previousAnchor.x, y: segmentPushStartY });
+  }
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushStartY });
+  segmentPushPath.push({ x: segmentPushX, y: segmentPushEndY });
+  if (Math.abs(nextAnchor.y - segmentPushEndY) >= 1e-9) {
+    segmentPushPath.push({ x: nextAnchor.x, y: segmentPushEndY });
+  }
+  segmentPushPath.push(
+    nextAnchor,
+    ...path.slice(collidingVerticalSegmentIndex + 3)
+  );
+  return simplifyPath(segmentPushPath);
+};
+var getClearedHorizontalY = ({
+  start,
+  end,
+  labelBounds
+}) => {
+  if (!segmentIntersectsRect2(start, end, labelBounds)) return start.y;
+  const labelCenterY = (labelBounds.minY + labelBounds.maxY) / 2;
+  if (start.y >= labelCenterY) {
+    return labelBounds.maxY + LABEL_HUG_CLEARANCE;
+  }
+  return labelBounds.minY - LABEL_HUG_CLEARANCE;
+};
 var markSelectedCandidate = (candidateResults, bestPath) => {
   if (!bestPath) return;
   for (const candidate of candidateResults) {
@@ -5432,16 +5546,16 @@ var Example28Solver = class extends BaseSolver {
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS6 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS6;
+var EPS7 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS7;
 var CANDIDATE_SELECTED_COLOR2 = "blue";
 var CANDIDATE_REJECTED_COLOR2 = "red";
 
 // lib/solvers/AvailableNetOrientationSolver/geometry.ts
 var isYOrientation = (orientation) => orientation === "y+" || orientation === "y-";
 var isXOrientation = (orientation) => orientation === "x+" || orientation === "x-";
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS6 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS6;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > 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 rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS7;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -5463,8 +5577,8 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
   if (interiorBounds.minX >= interiorBounds.maxX || interiorBounds.minY >= interiorBounds.maxY) {
     return false;
   }
-  if (sameX(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS6 || p1.x >= interiorBounds.maxX - EPS6) {
+  if (sameX2(p1, p2)) {
+    if (p1.x <= interiorBounds.minX + EPS7 || p1.x >= interiorBounds.maxX - EPS7) {
       return false;
     }
     return rangesOverlap(
@@ -5474,8 +5588,8 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
       interiorBounds.maxY
     );
   }
-  if (sameY(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS6 || p1.y >= interiorBounds.maxY - EPS6) {
+  if (sameY2(p1, p2)) {
+    if (p1.y <= interiorBounds.minY + EPS7 || p1.y >= interiorBounds.maxY - EPS7) {
       return false;
     }
     return rangesOverlap(
@@ -5514,11 +5628,11 @@ var tracePathCrossesAnyTrace = (tracePath, traceMap) => {
   return false;
 };
 var segmentsStrictlyCross = (a1, a2, b1, b2) => {
-  if (sameX(a1, a2) && sameY(b1, b2)) {
-    return a1.x > Math.min(b1.x, b2.x) + EPS6 && a1.x < Math.max(b1.x, b2.x) - EPS6 && b1.y > Math.min(a1.y, a2.y) + EPS6 && b1.y < Math.max(a1.y, a2.y) - EPS6;
+  if (sameX2(a1, a2) && sameY2(b1, b2)) {
+    return a1.x > Math.min(b1.x, b2.x) + EPS7 && a1.x < Math.max(b1.x, b2.x) - EPS7 && b1.y > Math.min(a1.y, a2.y) + EPS7 && b1.y < Math.max(a1.y, a2.y) - EPS7;
   }
-  if (sameY(a1, a2) && sameX(b1, b2)) {
-    return b1.x > Math.min(a1.x, a2.x) + EPS6 && b1.x < Math.max(a1.x, a2.x) - EPS6 && a1.y > Math.min(b1.y, b2.y) + EPS6 && a1.y < Math.max(b1.y, b2.y) - EPS6;
+  if (sameY2(a1, a2) && sameX2(b1, b2)) {
+    return b1.x > Math.min(a1.x, a2.x) + EPS7 && b1.x < Math.max(a1.x, a2.x) - EPS7 && a1.y > Math.min(b1.y, b2.y) + EPS7 && a1.y < Math.max(b1.y, b2.y) - EPS7;
   }
   return false;
 };
@@ -5541,7 +5655,7 @@ var simplifyOrthogonalPath = (path) => {
     const prev = simplified[simplified.length - 1];
     const point = deduped[i];
     const next = deduped[i + 1];
-    if (sameX(prev, point) && sameX(point, next) || sameY(prev, point) && sameY(point, next)) {
+    if (sameX2(prev, point) && sameX2(point, next) || sameY2(prev, point) && sameY2(point, next)) {
       continue;
     }
     simplified.push(point);
@@ -5549,9 +5663,9 @@ var simplifyOrthogonalPath = (path) => {
   simplified.push(deduped[deduped.length - 1]);
   return simplified;
 };
-var pointsEqual = (a, b) => sameX(a, b) && sameY(a, b);
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS6;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS6;
+var pointsEqual = (a, b) => sameX2(a, b) && sameY2(a, b);
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS7;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS7;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -5759,11 +5873,28 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.addConnectorTrace(label, candidate, labelIndex);
   }
   addConnectorTrace(label, candidate, labelIndex) {
-    const tracePath = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation
-    );
+    let tracePath;
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation);
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP
+      };
+      tracePath = simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation
+        )
+      ]);
+    } else {
+      tracePath = getConnectorTracePath(
+        label.anchorPoint,
+        candidate.anchorPoint,
+        candidate.orientation
+      );
+    }
     if (tracePath.length < 2) return;
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
     const connectorTrace = {
@@ -5796,7 +5927,18 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       labelIndex,
       orientations
     );
-    return rotatedCandidate ?? this.findValidShiftedCandidate(label, orientations[0], labelIndex);
+    if (rotatedCandidate) return rotatedCandidate;
+    const shiftedCandidate = this.findValidShiftedCandidate(
+      label,
+      orientations[0],
+      labelIndex
+    );
+    if (shiftedCandidate) return shiftedCandidate;
+    return this.findValidLateralShiftedCandidate(
+      label,
+      orientations[0],
+      labelIndex
+    );
   }
   findValidRotatedCandidate(label, labelIndex, orientations) {
     for (const orientation of orientations) {
@@ -5832,7 +5974,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 + EPS6; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS7; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -5850,6 +5992,50 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
+  /**
+   * When all candidates fail for the current (unshifted) position, try
+   * shifting the label anchor laterally — x for y-orientations, y for
+   * x-orientations — and re-attempting the required orientation.
+   *
+   * Offsets are tried in alternating sign order:
+   *   -1·step, +1·step, -2·step, +2·step, …
+   * so the nearest escape routes are tested first.
+   */
+  findValidLateralShiftedCandidate(label, orientation, labelIndex) {
+    const direction = dir(orientation);
+    const initialBaseAnchor = this.getSearchStartAnchor(label, orientation);
+    const lateralDir = {
+      x: isYOrientation(orientation) ? 1 : 0,
+      y: isXOrientation(orientation) ? 1 : 0
+    };
+    const maxSteps = Math.ceil(this.maxSearchDistance / LABEL_SEARCH_STEP);
+    for (let step = 1; step <= maxSteps; step++) {
+      for (const sign of [-1, 1]) {
+        const lateralOffset = sign * step * LABEL_SEARCH_STEP;
+        const baseAnchor = {
+          x: initialBaseAnchor.x + lateralDir.x * lateralOffset,
+          y: initialBaseAnchor.y + lateralDir.y * lateralOffset
+        };
+        const maxSearchDistance = this.getLateralColumnMaxDistance(
+          label,
+          orientation,
+          baseAnchor
+        );
+        const candidate = this.findValidCandidateInShiftColumn({
+          label,
+          labelIndex,
+          orientation,
+          direction,
+          baseAnchor,
+          maxSearchDistance,
+          outwardDistance: lateralOffset,
+          phase: "lateral-shift"
+        });
+        if (candidate) return candidate;
+      }
+    }
+    return null;
+  }
   findValidCandidateInShiftColumn(params) {
     const {
       label,
@@ -5858,9 +6044,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       direction,
       baseAnchor,
       maxSearchDistance,
-      outwardDistance
+      outwardDistance,
+      phase = "shift"
     } = params;
-    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS6; distance3 += LABEL_SEARCH_STEP) {
+    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS7; distance3 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance3,
         y: baseAnchor.y + direction.y * distance3
@@ -5870,7 +6057,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         candidate,
         label,
         labelIndex,
-        "shift",
+        phase,
         distance3,
         outwardDistance
       );
@@ -5951,6 +6138,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const labelLength = orientation === "y+" || orientation === "y-" ? height : width;
     return Math.min(this.maxSearchDistance, labelLength * 2);
   }
+  getLateralColumnMaxDistance(label, orientation, baseAnchor) {
+    const chipId = label.pinIds.map((pid) => this.pinMap[pid]?.chipId).find(Boolean);
+    const chip = chipId ? this.chipObstacleSpatialIndex.chips.find((c) => c.chipId === chipId) : null;
+    if (chip) {
+      if (orientation === "y-")
+        return Math.max(0, baseAnchor.y - chip.bounds.minY);
+      if (orientation === "y+")
+        return Math.max(0, chip.bounds.maxY - baseAnchor.y);
+      if (orientation === "x-")
+        return Math.max(0, baseAnchor.x - chip.bounds.minX);
+      if (orientation === "x+")
+        return Math.max(0, chip.bounds.maxX - baseAnchor.x);
+    }
+    return this.getSearchDistanceLimit(label, orientation);
+  }
   createCandidate(label, anchorPoint, orientation) {
     const { width, height } = getDimsForOrientation({
       orientation,
@@ -5965,9 +6167,22 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     };
   }
   getNetLabelWidth(label) {
-    if (!label.netId) return void 0;
+    if (label.netId) {
+      const ncWidth = this.inputProblem.netConnections.find(
+        (connection) => connection.netId === label.netId
+      )?.netLabelWidth;
+      if (ncWidth !== void 0) return ncWidth;
+      const dcWidthByNetId = this.inputProblem.directConnections.find(
+        (dc) => dc.netId === label.netId
+      )?.netLabelWidth;
+      if (dcWidthByNetId !== void 0) return dcWidthByNetId;
+    }
+    const dcWidthByPinId = this.inputProblem.directConnections.find(
+      (dc) => dc.pinIds.some((pid) => label.pinIds.includes(pid))
+    )?.netLabelWidth;
+    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
     return this.inputProblem.netConnections.find(
-      (connection) => connection.netId === label.netId
+      (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
     )?.netLabelWidth;
   }
   getCandidateStatus(candidate, label, labelIndex) {
@@ -5984,6 +6199,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision";
     }
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
+        return "chip-collision";
+      }
+    }
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
@@ -6023,8 +6243,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 + EPS6 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS6;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS6 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS6;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS7 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS7;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS7 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS7;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -6072,7 +6292,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 - EPS6 || point.x > bounds.maxX + EPS6 || point.y < bounds.minY - EPS6 || point.y > bounds.maxY + EPS6) {
+      if (point.x < bounds.minX - EPS7 || point.x > bounds.maxX + EPS7 || point.y < bounds.minY - EPS7 || point.y > bounds.maxY + EPS7) {
         continue;
       }
       for (const [side, distance3] of getSideDistances(point, bounds)) {
@@ -6089,8 +6309,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 - EPS6 ? bounds.minX - point.x : point.x > bounds.maxX + EPS6 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS6 ? bounds.minY - point.y : point.y > bounds.maxY + EPS6 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS7 ? bounds.minX - point.x : point.x > bounds.maxX + EPS7 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS7 ? bounds.minY - point.y : point.y > bounds.maxY + EPS7 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -6129,9 +6349,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
 };
 
 // lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts
-var EPS7 = 1e-6;
+var EPS8 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS7 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS7;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
 var getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -6155,11 +6375,11 @@ var getUniquePinCount = (pinIds) => new Set(pinIds).size;
 var isTraceCorner = (a, b, c) => getSegmentOrientation2(a, b) !== getSegmentOrientation2(b, c);
 var isPointOnSegment = (point, start, end) => {
   if (getSegmentOrientation2(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS7 && point.x >= Math.min(start.x, end.x) - EPS7 && point.x <= Math.max(start.x, end.x) + EPS7;
+    return Math.abs(point.y - start.y) <= EPS8 && point.x >= Math.min(start.x, end.x) - EPS8 && point.x <= Math.max(start.x, end.x) + EPS8;
   }
-  return Math.abs(point.x - start.x) <= EPS7 && point.y >= Math.min(start.y, end.y) - EPS7 && point.y <= Math.max(start.y, end.y) + EPS7;
+  return Math.abs(point.x - start.x) <= EPS8 && point.y >= Math.min(start.y, end.y) - EPS8 && point.y <= Math.max(start.y, end.y) + EPS8;
 };
-var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
+var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS8 ? "horizontal" : "vertical";
 
 // lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR3 = "blue";
@@ -6437,11 +6657,11 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS8 = 1e-6;
+var EPS9 = 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) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS8;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS9;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -6487,7 +6707,7 @@ var getPointAtTraceDistance = (trace, distance3) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance3 <= nextDistance + EPS8) {
+    if (distance3 <= nextDistance + EPS9) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance3 - pathDistance)
@@ -6526,7 +6746,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical3(start, end)) {
-    if (start.x <= interior.minX + EPS8 || start.x >= interior.maxX - EPS8) {
+    if (start.x <= interior.minX + EPS9 || start.x >= interior.maxX - EPS9) {
       return false;
     }
     return rangesOverlap2(
@@ -6537,7 +6757,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal2(start, end)) {
-    if (start.y <= interior.minY + EPS8 || start.y >= interior.maxY - EPS8) {
+    if (start.y <= interior.minY + EPS9 || start.y >= interior.maxY - EPS9) {
       return false;
     }
     return rangesOverlap2(
@@ -6551,10 +6771,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal2(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS8 && point.x >= Math.min(start.x, end.x) - EPS8 && point.x <= Math.max(start.x, end.x) + EPS8;
+    return Math.abs(point.y - start.y) <= EPS9 && point.x >= Math.min(start.x, end.x) - EPS9 && point.x <= Math.max(start.x, end.x) + EPS9;
   }
   if (isVertical3(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS8 && point.y >= Math.min(start.y, end.y) - EPS8 && point.y <= Math.max(start.y, end.y) + EPS8;
+    return Math.abs(point.x - start.x) <= EPS9 && point.y >= Math.min(start.y, end.y) - EPS9 && point.y <= Math.max(start.y, end.y) + EPS9;
   }
   return false;
 };
@@ -6562,9 +6782,9 @@ var getSegmentDirection = (start, end) => ({
   x: isVertical3(start, end) ? 0 : Math.sign(end.x - start.x),
   y: isHorizontal2(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS8;
-var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS8;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS8;
+var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS9;
+var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS9;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS9;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -6619,7 +6839,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance3 of vertexDistances) {
     distances.add(roundDistance(distance3));
   }
-  return [...distances].filter((distance3) => distance3 >= -EPS8 && distance3 <= traceLength + EPS8).sort((a, b) => a - b);
+  return [...distances].filter((distance3) => distance3 >= -EPS9 && distance3 <= traceLength + EPS9).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -6726,13 +6946,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS8) {
+  if (value > max + EPS9) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS8) {
+  if (value < min - EPS9) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -6743,7 +6963,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS8, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS9, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -6789,11 +7009,22 @@ var getChipBounds = (inputProblem) => {
   };
 };
 var getNetLabelWidth = (inputProblem, label) => {
-  const configuredWidth = inputProblem.netConnections.find(
+  const ncWidthByNetId = inputProblem.netConnections.find(
     (connection) => connection.netId === label.netId
   )?.netLabelWidth;
-  if (configuredWidth !== void 0) return configuredWidth;
-  return label.orientation === "y+" || label.orientation === "y-" ? label.height : label.width;
+  if (ncWidthByNetId !== void 0) return ncWidthByNetId;
+  const dcWidth = inputProblem.directConnections.find(
+    (dc) => dc.pinIds.some((pid) => label.pinIds.includes(pid))
+  )?.netLabelWidth;
+  if (dcWidth !== void 0) return dcWidth;
+  const ncWidthByPinId = inputProblem.netConnections.find(
+    (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
+  )?.netLabelWidth;
+  if (ncWidthByPinId !== void 0) return ncWidthByPinId;
+  if (label.orientation === "y+" || label.orientation === "y-") {
+    return label.height;
+  }
+  return label.width;
 };
 var roundDistance = (distance3) => Number(distance3.toFixed(6));
 var dedupeOrientations = (orientations) => [
@@ -6818,7 +7049,7 @@ var normalizeFacingDirection = (value) => {
 var dedupeStrings = (values) => [
   ...new Set(values.filter((value) => value !== void 0))
 ];
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS8 && Math.abs(point.y - label.anchorPoint.y) <= EPS8 && orientation === label.orientation;
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS9 && Math.abs(point.y - label.anchorPoint.y) <= EPS9 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";