@tscircuit/schematic-trace-solver 0.0.37 → 0.0.39

package/dist/index.js

@@ -588,6 +588,16 @@ var findFirstCollision = (pts, rects, opts = {}) => {
   }
   return null;
 };
+var isPathCollidingWithObstacles = (path, obstacles) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    for (const obstacle of obstacles) {
+      if (segmentIntersectsRect(path[i], path[i + 1], obstacle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts
 var EPS2 = 1e-9;
@@ -658,23 +668,33 @@ var candidateMidsFromSet = (axis, colliding, rectsById, collisionRectIds, aabb,
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
 var EPS3 = 1e-9;
 var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
-  if (segIndex < 0 || segIndex >= pts.length - 1) return null;
+  if (segIndex < 0 || segIndex >= pts.length - 1) {
+    return null;
+  }
   const a = pts[segIndex];
   const b = pts[segIndex + 1];
   const vert = isVertical(a, b, eps);
   const horz = isHorizontal(a, b, eps);
-  if (!vert && !horz) return null;
-  if (vert && axis !== "x") return null;
-  if (horz && axis !== "y") return null;
+  if (!vert && !horz) {
+    return null;
+  }
+  if (vert && axis !== "x") {
+    return null;
+  }
+  if (horz && axis !== "y") {
+    return null;
+  }
   const out = pts.map((p) => ({ ...p }));
   if (axis === "x") {
-    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps)
+    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps) {
       return null;
+    }
     out[segIndex] = { ...out[segIndex], x: newCoord };
     out[segIndex + 1] = { ...out[segIndex + 1], x: newCoord };
   } else {
-    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps)
+    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps) {
       return null;
+    }
     out[segIndex] = { ...out[segIndex], y: newCoord };
     out[segIndex + 1] = { ...out[segIndex + 1], y: newCoord };
   }
@@ -682,22 +702,31 @@ var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
     const p = out[segIndex - 1];
     const q = out[segIndex];
     const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y);
-    if (manhattan < eps) return null;
+    if (manhattan < eps) {
+      return null;
+    }
   }
   if (segIndex + 2 <= out.length - 1) {
     const p = out[segIndex + 1];
     const q = out[segIndex + 2];
     const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y);
-    if (manhattan < eps) return null;
+    if (manhattan < eps) {
+      return null;
+    }
   }
   for (let i = 0; i < out.length - 1; i++) {
     const u = out[i];
     const v = out[i + 1];
-    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) return null;
+    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) {
+      return null;
+    }
   }
   return out;
 };
-var pathKey = (pts, decimals = 6) => pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
+var pathKey = (pts, decimals = 6) => {
+  const key = pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
+  return key;
+};
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
@@ -2170,6 +2199,854 @@ var NetLabelPlacementSolver = class extends BaseSolver {
 // lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
 import { getBounds as getBounds3 } from "graphics-debug";
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts
+var detectTraceLabelOverlap = (traces, netLabels) => {
+  const overlaps = [];
+  for (const trace of traces) {
+    for (const label of netLabels) {
+      const labelBounds = getRectBounds(label.center, label.width, label.height);
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        const p1 = trace.tracePath[i];
+        const p2 = trace.tracePath[i + 1];
+        if (segmentIntersectsRect2(p1, p2, labelBounds)) {
+          if (trace.globalConnNetId === label.globalConnNetId) {
+            break;
+          }
+          overlaps.push({ trace, label });
+          break;
+        }
+      }
+    }
+  }
+  return overlaps;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts
+var findTraceViolationZone = (path, labelBounds) => {
+  const isPointInside = (p) => p.x > labelBounds.minX && p.x < labelBounds.maxX && p.y > labelBounds.minY && p.y < labelBounds.maxY;
+  let firstInsideIndex = -1;
+  let lastInsideIndex = -1;
+  for (let i = 0; i < path.length; i++) {
+    if (isPointInside(path[i])) {
+      if (firstInsideIndex === -1) {
+        firstInsideIndex = i;
+      }
+      lastInsideIndex = i;
+    }
+  }
+  return { firstInsideIndex, lastInsideIndex };
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/simplifyPath.ts
+var simplifyPath = (path) => {
+  if (path.length < 3) return path;
+  const newPath = [path[0]];
+  for (let i = 1; i < path.length - 1; i++) {
+    const p1 = newPath[newPath.length - 1];
+    const p2 = path[i];
+    const p3 = path[i + 1];
+    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
+      continue;
+    }
+    newPath.push(p2);
+  }
+  newPath.push(path[path.length - 1]);
+  if (newPath.length < 3) return newPath;
+  const finalPath = [newPath[0]];
+  for (let i = 1; i < newPath.length - 1; i++) {
+    const p1 = finalPath[finalPath.length - 1];
+    const p2 = newPath[i];
+    const p3 = newPath[i + 1];
+    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
+      continue;
+    }
+    finalPath.push(p2);
+  }
+  finalPath.push(newPath[newPath.length - 1]);
+  return finalPath;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
+var trySnipAndReconnect = ({
+  initialTrace,
+  firstInsideIndex,
+  lastInsideIndex,
+  labelBounds,
+  obstacles
+}) => {
+  if (firstInsideIndex <= 0 || lastInsideIndex >= initialTrace.tracePath.length - 1) {
+    return null;
+  }
+  const entryPoint = initialTrace.tracePath[firstInsideIndex - 1];
+  const exitPoint = initialTrace.tracePath[lastInsideIndex + 1];
+  const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex);
+  const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1);
+  const candidateDetours = [];
+  if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
+    candidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }]);
+    candidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }]);
+  } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
+    const newPath = [...pathToEntry, ...pathFromExit];
+    const simplified = simplifyPath(newPath);
+    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
+      return { ...initialTrace, tracePath: simplified };
+    }
+  }
+  for (let i = 0; i < candidateDetours.length; i++) {
+    const detour = candidateDetours[i];
+    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit];
+    const simplified = simplifyPath(newFullPath);
+    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
+      return { ...initialTrace, tracePath: simplified };
+    }
+  }
+  candidateDetours.length = 0;
+  const buffer = 0.1;
+  const leftX = labelBounds.minX - buffer;
+  const rightX = labelBounds.maxX + buffer;
+  const topY = labelBounds.maxY + buffer;
+  const bottomY = labelBounds.minY - buffer;
+  if ((entryPoint.x <= labelBounds.minX || exitPoint.x <= labelBounds.minX) && entryPoint.x < labelBounds.maxX && exitPoint.x < labelBounds.maxX) {
+    candidateDetours.push([
+      { x: leftX, y: entryPoint.y },
+      { x: leftX, y: exitPoint.y }
+    ]);
+  }
+  if ((entryPoint.x >= labelBounds.maxX || exitPoint.x >= labelBounds.maxX) && entryPoint.x > labelBounds.minX && exitPoint.x > labelBounds.minX) {
+    candidateDetours.push([
+      { x: rightX, y: entryPoint.y },
+      { x: rightX, y: exitPoint.y }
+    ]);
+  }
+  if ((entryPoint.y >= labelBounds.maxY || exitPoint.y >= labelBounds.maxY) && entryPoint.y > labelBounds.minY && exitPoint.y > labelBounds.minY) {
+    candidateDetours.push([
+      { x: entryPoint.x, y: topY },
+      { x: exitPoint.x, y: topY }
+    ]);
+  }
+  if ((entryPoint.y <= labelBounds.minY || exitPoint.y <= labelBounds.minY) && entryPoint.y < labelBounds.maxY && exitPoint.y < labelBounds.maxY) {
+    candidateDetours.push([
+      { x: entryPoint.x, y: bottomY },
+      { x: exitPoint.x, y: bottomY }
+    ]);
+  }
+  for (let i = 0; i < candidateDetours.length; i++) {
+    const detour = candidateDetours[i];
+    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit];
+    const simplified = simplifyPath(newFullPath);
+    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
+      return { ...initialTrace, tracePath: simplified };
+    }
+  }
+  return null;
+};
+var tryFourPointDetour = ({
+  initialTrace,
+  label,
+  labelBounds,
+  obstacles,
+  paddingBuffer,
+  detourCount
+}) => {
+  let collidingSegIndex = -1;
+  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+    if (segmentIntersectsRect(
+      initialTrace.tracePath[i],
+      initialTrace.tracePath[i + 1],
+      labelBounds
+    )) {
+      collidingSegIndex = i;
+      break;
+    }
+  }
+  if (collidingSegIndex === -1) return initialTrace;
+  const pA = initialTrace.tracePath[collidingSegIndex];
+  const pB = initialTrace.tracePath[collidingSegIndex + 1];
+  if (!pA || !pB) return null;
+  const candidateDetours = [];
+  const paddedLabelBounds = getRectBounds(
+    label.center,
+    label.width,
+    label.height
+  );
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  if (isVertical(pA, pB)) {
+    const xCandidates = [
+      paddedLabelBounds.maxX + effectivePadding,
+      paddedLabelBounds.minX - effectivePadding
+    ];
+    for (const newX of xCandidates) {
+      candidateDetours.push(
+        pB.y > pA.y ? [
+          { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
+          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding }
+        ] : [
+          { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+          { x: pB.x, y: paddedLabelBounds.minY - effectivePadding }
+        ]
+      );
+    }
+  } else {
+    const yCandidates = [
+      paddedLabelBounds.maxY + effectivePadding,
+      paddedLabelBounds.minY - effectivePadding
+    ];
+    for (const newY of yCandidates) {
+      candidateDetours.push(
+        pB.x > pA.x ? [
+          { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
+          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y }
+        ] : [
+          { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+          { x: paddedLabelBounds.minX - effectivePadding, y: pB.y }
+        ]
+      );
+    }
+  }
+  for (const detourPoints of candidateDetours) {
+    const finalPath = [
+      ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+      ...detourPoints,
+      ...initialTrace.tracePath.slice(collidingSegIndex + 1)
+    ];
+    const simplifiedFinalPath = simplifyPath(finalPath);
+    if (!isPathCollidingWithObstacles(simplifiedFinalPath, obstacles)) {
+      return { ...initialTrace, tracePath: simplifiedFinalPath };
+    }
+  }
+  return null;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts
+var rerouteCollidingTrace = ({
+  trace,
+  label,
+  problem,
+  paddingBuffer,
+  detourCount
+}) => {
+  const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) };
+  if (trace.globalConnNetId === label.globalConnNetId) {
+    return initialTrace;
+  }
+  const obstacles = getObstacleRects(problem);
+  const labelPadding = paddingBuffer;
+  const labelBoundsRaw = getRectBounds(label.center, label.width, label.height);
+  const labelBounds = {
+    minX: labelBoundsRaw.minX - labelPadding,
+    minY: labelBoundsRaw.minY - labelPadding,
+    maxX: labelBoundsRaw.maxX + labelPadding,
+    maxY: labelBoundsRaw.maxY + labelPadding,
+    chipId: `netlabel-${label.netId}`
+  };
+  const fourPointResult = tryFourPointDetour({
+    initialTrace,
+    label,
+    labelBounds,
+    obstacles,
+    paddingBuffer,
+    detourCount
+  });
+  if (fourPointResult) {
+    initialTrace.tracePath = fourPointResult.tracePath;
+  }
+  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
+    initialTrace.tracePath,
+    labelBounds
+  );
+  const snipReconnectResult = trySnipAndReconnect({
+    initialTrace,
+    firstInsideIndex,
+    lastInsideIndex,
+    labelBounds,
+    obstacles
+  });
+  if (snipReconnectResult) {
+    return snipReconnectResult;
+  }
+  if (fourPointResult) {
+    return fourPointResult;
+  }
+  return initialTrace;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisions.ts
+var hasCollisions = (pathSegments, obstacles) => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i];
+    const p2 = pathSegments[i + 1];
+    for (const obstacle of obstacles) {
+      if (segmentIntersectsRect(p1, p2, obstacle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/countTurns.ts
+var countTurns = (points) => {
+  let turns = 0;
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const prevVertical = prev.x === curr.x;
+    const nextVertical = curr.x === next.x;
+    if (prevVertical !== nextVertical) {
+      turns++;
+    }
+  }
+  return turns;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryConnectPoints.ts
+var tryConnectPoints = (start, end) => {
+  const candidates = [];
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end]);
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end]);
+    candidates.push([start, { x: start.x, y: end.y }, end]);
+  }
+  return candidates;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisionsWithLabels.ts
+var hasCollisionsWithLabels = (pathSegments, labels) => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i];
+    const p2 = pathSegments[i + 1];
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts
+var minimizeTurns = ({
+  path,
+  obstacles,
+  labelBounds
+}) => {
+  if (path.length <= 2) {
+    return path;
+  }
+  const recognizeStairStepPattern = (pathToCheck, startIdx) => {
+    if (startIdx >= pathToCheck.length - 3) return -1;
+    let endIdx = startIdx;
+    let isStairStep = true;
+    for (let i = startIdx; i < pathToCheck.length - 2 && i < startIdx + 10; i++) {
+      if (i + 2 >= pathToCheck.length) break;
+      const p1 = pathToCheck[i];
+      const p2 = pathToCheck[i + 1];
+      const p3 = pathToCheck[i + 2];
+      const seg1Vertical = p1.x === p2.x;
+      const seg2Vertical = p2.x === p3.x;
+      if (seg1Vertical === seg2Vertical) {
+        break;
+      }
+      const seg1Direction = seg1Vertical ? Math.sign(p2.y - p1.y) : Math.sign(p2.x - p1.x);
+      if (i > startIdx) {
+        const prevP = pathToCheck[i - 1];
+        const prevSegVertical = prevP.x === p1.x;
+        const prevDirection = prevSegVertical ? Math.sign(p1.y - prevP.y) : Math.sign(p1.x - prevP.x);
+        if (seg1Vertical && prevSegVertical && seg1Direction !== prevDirection || !seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection) {
+          isStairStep = false;
+          break;
+        }
+      }
+      endIdx = i + 2;
+    }
+    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
+  };
+  let optimizedPath = [...path];
+  let currentTurns = countTurns(optimizedPath);
+  let improved = true;
+  while (improved) {
+    improved = false;
+    for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
+      const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx);
+      if (stairEndIdx > 0) {
+        const startPoint = optimizedPath[startIdx];
+        const endPoint = optimizedPath[stairEndIdx];
+        const connectionOptions = tryConnectPoints(startPoint, endPoint);
+        for (const connection of connectionOptions) {
+          const testPath = [
+            ...optimizedPath.slice(0, startIdx + 1),
+            ...connection.slice(1, -1),
+            ...optimizedPath.slice(stairEndIdx)
+          ];
+          const collidesWithObstacles = hasCollisions(connection, obstacles);
+          const collidesWithLabels = hasCollisionsWithLabels(
+            connection,
+            labelBounds
+          );
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            const newTurns = countTurns(testPath);
+            const turnsRemoved = stairEndIdx - startIdx - 1;
+            optimizedPath = testPath;
+            currentTurns = newTurns;
+            improved = true;
+            break;
+          }
+        }
+        if (improved) break;
+      }
+    }
+    if (!improved) {
+      for (let startIdx = 0; startIdx < optimizedPath.length - 2; startIdx++) {
+        const maxRemove = Math.min(
+          optimizedPath.length - startIdx - 2,
+          optimizedPath.length - 2
+        );
+        for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
+          const endIdx = startIdx + removeCount + 1;
+          if (endIdx >= optimizedPath.length) continue;
+          const startPoint = optimizedPath[startIdx];
+          const endPoint = optimizedPath[endIdx];
+          const connectionOptions = tryConnectPoints(startPoint, endPoint);
+          for (const connection of connectionOptions) {
+            const testPath = [
+              ...optimizedPath.slice(0, startIdx + 1),
+              ...connection.slice(1, -1),
+              ...optimizedPath.slice(endIdx)
+            ];
+            const connectionSegments = connection;
+            const collidesWithObstacles = hasCollisions(
+              connectionSegments,
+              obstacles
+            );
+            const collidesWithLabels = hasCollisionsWithLabels(
+              connectionSegments,
+              labelBounds
+            );
+            if (!collidesWithObstacles && !collidesWithLabels) {
+              const newTurns = countTurns(testPath);
+              if (newTurns < currentTurns || newTurns === currentTurns && testPath.length < optimizedPath.length) {
+                optimizedPath = testPath;
+                currentTurns = newTurns;
+                improved = true;
+                break;
+              }
+            }
+          }
+          if (improved) break;
+        }
+        if (improved) break;
+      }
+    }
+    if (!improved) {
+      for (let i = 0; i < optimizedPath.length - 2; i++) {
+        const p1 = optimizedPath[i];
+        const p2 = optimizedPath[i + 1];
+        const p3 = optimizedPath[i + 2];
+        const allVertical = p1.x === p2.x && p2.x === p3.x;
+        const allHorizontal = p1.y === p2.y && p2.y === p3.y;
+        if (allVertical || allHorizontal) {
+          const testPath = [
+            ...optimizedPath.slice(0, i + 1),
+            ...optimizedPath.slice(i + 2)
+          ];
+          const collidesWithObstacles = hasCollisions([p1, p3], obstacles);
+          const collidesWithLabels = hasCollisionsWithLabels(
+            [p1, p3],
+            labelBounds
+          );
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            optimizedPath = testPath;
+            improved = true;
+            break;
+          }
+        }
+      }
+    }
+  }
+  const finalSimplifiedPath = simplifyPath(optimizedPath);
+  return finalSimplifiedPath;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts
+var minimizeTurnsWithFilteredLabels = ({
+  traces,
+  problem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer
+}) => {
+  let changesMade = false;
+  const obstacles = getObstacleRects(problem);
+  const newTraces = traces.map((trace) => {
+    const originalPath = trace.tracePath;
+    const filteredLabels = allLabelPlacements.filter((label) => {
+      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
+      if (originalNetIds) {
+        return !originalNetIds.has(trace.globalConnNetId);
+      }
+      return label.globalConnNetId !== trace.globalConnNetId;
+    });
+    const labelBounds = filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 - paddingBuffer,
+      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+      minY: nl.center.y - nl.height / 2 - paddingBuffer,
+      maxY: nl.center.y + nl.height / 2 + paddingBuffer
+    }));
+    const newPath = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds
+    });
+    if (newPath.length !== originalPath.length || newPath.some(
+      (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y
+    )) {
+      changesMade = true;
+    }
+    return {
+      ...trace,
+      tracePath: newPath
+    };
+  });
+  if (changesMade) {
+    return newTraces;
+  } else {
+    return null;
+  }
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/balanceLShapes.ts
+var balanceLShapes = ({
+  traces,
+  problem,
+  allLabelPlacements
+}) => {
+  const TOLERANCE = 1e-5;
+  let changesMade = false;
+  for (const trace of traces) {
+    if (trace.tracePath.length === 4) {
+      const [p0, p1, p2, p3] = trace.tracePath;
+      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y;
+      const isVHVShape = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x;
+      const isCollinearHorizontal = p0.y === p1.y && p1.y === p2.y && p2.y === p3.y;
+      const isCollinearVertical = p0.x === p1.x && p1.x === p2.x && p2.x === p3.x;
+      const isCollinear = isCollinearHorizontal || isCollinearVertical;
+      let isSameDirection = false;
+      if (isHVHShape) {
+        isSameDirection = Math.sign(p1.x - p0.x) === Math.sign(p3.x - p2.x);
+      } else if (isVHVShape) {
+        isSameDirection = Math.sign(p1.y - p0.y) === Math.sign(p3.y - p2.y);
+      }
+      const isValidZShape = (isHVHShape || isVHVShape) && !isCollinear && isSameDirection;
+      if (!isValidZShape) {
+        return null;
+      }
+    }
+  }
+  const obstacles = getObstacleRects(problem).map((obs) => ({
+    ...obs,
+    minX: obs.minX + TOLERANCE,
+    maxX: obs.maxX - TOLERANCE,
+    minY: obs.minY + TOLERANCE,
+    maxY: obs.maxY - TOLERANCE
+  }));
+  const segmentIntersectsAnyRect = (p1, p2, rects) => {
+    for (const rect of rects) {
+      if (segmentIntersectsRect(p1, p2, rect)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const getLabelBounds = (labels, traceNetId) => {
+    const filteredLabels = labels.filter(
+      (label) => label.globalConnNetId !== traceNetId
+    );
+    return filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 + TOLERANCE,
+      maxX: nl.center.x + nl.width / 2 - TOLERANCE,
+      minY: nl.center.y - nl.height / 2 + TOLERANCE,
+      maxY: nl.center.y + nl.height / 2 - TOLERANCE
+    }));
+  };
+  const newTraces = traces.map((trace) => {
+    let newPath = [...trace.tracePath];
+    if (newPath.length < 4) {
+      return { ...trace };
+    }
+    const labelBounds = getLabelBounds(
+      allLabelPlacements,
+      trace.globalConnNetId
+    );
+    if (newPath.length === 4) {
+      const [p0, p1, p2, p3] = newPath;
+      let p1New, p2New;
+      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y;
+      if (isHVHShape) {
+        const idealX = (p0.x + p3.x) / 2;
+        p1New = { x: idealX, y: p1.y };
+        p2New = { x: idealX, y: p2.y };
+      } else {
+        const idealY = (p0.y + p3.y) / 2;
+        p1New = { x: p1.x, y: idealY };
+        p2New = { x: p2.x, y: idealY };
+      }
+      const collides = segmentIntersectsAnyRect(p0, p1New, obstacles) || segmentIntersectsAnyRect(p1New, p2New, obstacles) || segmentIntersectsAnyRect(p2New, p3, obstacles) || segmentIntersectsAnyRect(p0, p1New, labelBounds) || segmentIntersectsAnyRect(p1New, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3, labelBounds);
+      if (!collides) {
+        newPath[1] = p1New;
+        newPath[2] = p2New;
+        changesMade = true;
+      }
+      return { ...trace, tracePath: simplifyPath(newPath) };
+    }
+    for (let i = 1; i < newPath.length - 4; i++) {
+      const p1 = newPath[i];
+      const p2 = newPath[i + 1];
+      const p3 = newPath[i + 2];
+      const p4 = newPath[i + 3];
+      const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y;
+      const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x;
+      const isCollinearHorizontal = p1.y === p2.y && p2.y === p3.y && p3.y === p4.y;
+      const isCollinearVertical = p1.x === p2.x && p2.x === p3.x && p3.x === p4.x;
+      const isCollinear = isCollinearHorizontal || isCollinearVertical;
+      let isSameDirection = false;
+      if (isHVHZShape) {
+        isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x);
+      } else if (isVHVZShape) {
+        isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y);
+      }
+      const isValidZShape = (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection;
+      if (!isValidZShape) {
+        continue;
+      }
+      let p2New, p3New;
+      const len1Original = isHVHZShape ? Math.abs(p1.x - p2.x) : Math.abs(p1.y - p2.y);
+      const len2Original = isHVHZShape ? Math.abs(p3.x - p4.x) : Math.abs(p3.y - p4.y);
+      if (Math.abs(len1Original - len2Original) < 1e-3) {
+        continue;
+      }
+      if (isHVHZShape) {
+        const idealX = (p1.x + p4.x) / 2;
+        p2New = { x: idealX, y: p2.y };
+        p3New = { x: idealX, y: p3.y };
+      } else {
+        const idealY = (p1.y + p4.y) / 2;
+        p2New = { x: p2.x, y: idealY };
+        p3New = { x: p3.x, y: idealY };
+      }
+      const collides = segmentIntersectsAnyRect(p1, p2New, obstacles) || segmentIntersectsAnyRect(p2New, p3New, obstacles) || segmentIntersectsAnyRect(p3New, p4, obstacles) || segmentIntersectsAnyRect(p1, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3New, labelBounds) || segmentIntersectsAnyRect(p3New, p4, labelBounds);
+      if (!collides) {
+        newPath[i + 1] = p2New;
+        newPath[i + 2] = p3New;
+        changesMade = true;
+        i = 0;
+      }
+    }
+    const finalSimplifiedPath = simplifyPath(newPath);
+    return {
+      ...trace,
+      tracePath: finalSimplifiedPath
+    };
+  });
+  if (changesMade) {
+    return newTraces;
+  } else {
+    return null;
+  }
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts
+var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
+  problem;
+  traces;
+  netTempLabelPlacements;
+  netLabelPlacements;
+  updatedTraces;
+  mergedLabelNetIdMap;
+  detourCountByLabel;
+  PADDING_BUFFER = 0.1;
+  constructor(solverInput) {
+    super();
+    this.problem = solverInput.inputProblem;
+    this.traces = solverInput.traces;
+    this.updatedTraces = [...solverInput.traces];
+    this.mergedLabelNetIdMap = {};
+    this.detourCountByLabel = {};
+    const originalLabels = solverInput.netLabelPlacements;
+    this.netLabelPlacements = originalLabels;
+    if (!originalLabels || originalLabels.length === 0) {
+      this.netTempLabelPlacements = [];
+      return;
+    }
+    const labelGroups = {};
+    for (const p of originalLabels) {
+      if (p.pinIds.length === 0) continue;
+      const chipId = p.pinIds[0].split(".")[0];
+      if (!chipId) continue;
+      const key = `${chipId}-${p.orientation}`;
+      if (!(key in labelGroups)) {
+        labelGroups[key] = [];
+      }
+      labelGroups[key].push(p);
+    }
+    const finalPlacements = [];
+    for (const [key, group] of Object.entries(labelGroups)) {
+      if (group.length <= 1) {
+        finalPlacements.push(...group);
+        continue;
+      }
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const p of group) {
+        const bounds = getRectBounds(p.center, p.width, p.height);
+        minX = Math.min(minX, bounds.minX);
+        minY = Math.min(minY, bounds.minY);
+        maxX = Math.max(maxX, bounds.maxX);
+        maxY = Math.max(maxY, bounds.maxY);
+      }
+      const newWidth = maxX - minX;
+      const newHeight = maxY - minY;
+      const template = group[0];
+      const syntheticId = `merged-group-${key}`;
+      const originalNetIds = new Set(group.map((p) => p.globalConnNetId));
+      this.mergedLabelNetIdMap[syntheticId] = originalNetIds;
+      finalPlacements.push({
+        ...template,
+        globalConnNetId: syntheticId,
+        width: newWidth,
+        height: newHeight,
+        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
+        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
+        mspConnectionPairIds: [
+          ...new Set(group.flatMap((p) => p.mspConnectionPairIds))
+        ]
+      });
+    }
+    this.netTempLabelPlacements = finalPlacements;
+  }
+  _step() {
+    if (!this.traces || this.traces.length === 0 || !this.netTempLabelPlacements || this.netTempLabelPlacements.length === 0) {
+      this.solved = true;
+      return;
+    }
+    this.detourCountByLabel = {};
+    const overlaps = detectTraceLabelOverlap(
+      this.traces,
+      this.netTempLabelPlacements
+    );
+    if (overlaps.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const unfriendlyOverlaps = overlaps.filter((o) => {
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId];
+      if (originalNetIds) {
+        return !originalNetIds.has(o.trace.globalConnNetId);
+      }
+      return o.trace.globalConnNetId !== o.label.globalConnNetId;
+    });
+    if (unfriendlyOverlaps.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const updatedTracesMap = {};
+    for (const trace of this.traces) {
+      updatedTracesMap[trace.mspPairId] = trace;
+    }
+    const processedTraceIds = /* @__PURE__ */ new Set();
+    for (const overlap of unfriendlyOverlaps) {
+      if (processedTraceIds.has(overlap.trace.mspPairId)) {
+        continue;
+      }
+      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId];
+      const labelId = overlap.label.globalConnNetId;
+      const detourCount = this.detourCountByLabel[labelId] || 0;
+      const newTrace = rerouteCollidingTrace({
+        trace: currentTraceState,
+        label: overlap.label,
+        problem: this.problem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount
+      });
+      if (newTrace.tracePath !== currentTraceState.tracePath) {
+        this.detourCountByLabel[labelId] = detourCount + 1;
+      }
+      updatedTracesMap[currentTraceState.mspPairId] = newTrace;
+      processedTraceIds.add(currentTraceState.mspPairId);
+    }
+    this.updatedTraces = Object.values(updatedTracesMap);
+    const minimizedTraces = minimizeTurnsWithFilteredLabels({
+      traces: this.updatedTraces,
+      problem: this.problem,
+      allLabelPlacements: this.netTempLabelPlacements,
+      // Use temp labels which include merged ones
+      mergedLabelNetIdMap: this.mergedLabelNetIdMap,
+      paddingBuffer: this.PADDING_BUFFER
+    });
+    if (minimizedTraces) {
+      this.updatedTraces = minimizedTraces;
+    }
+    const balancedTraces = balanceLShapes({
+      traces: this.updatedTraces,
+      problem: this.problem,
+      allLabelPlacements: this.netLabelPlacements
+    });
+    if (balancedTraces) {
+      this.updatedTraces = balancedTraces;
+    }
+    const finalLabelPlacementSolver = new NetLabelPlacementSolver({
+      inputProblem: this.problem,
+      inputTraceMap: Object.fromEntries(
+        this.updatedTraces.map((trace) => [trace.mspPairId, trace])
+      )
+    });
+    finalLabelPlacementSolver.solve();
+    this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements;
+    this.solved = true;
+  }
+  getOutput() {
+    return {
+      traces: this.updatedTraces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.problem);
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.circles) graphics.circles = [];
+    if (!graphics.texts) graphics.texts = [];
+    if (!graphics.rects) graphics.rects = [];
+    for (const trace of this.updatedTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const p of this.netLabelPlacements) {
+      graphics.rects.push({
+        center: p.center,
+        width: p.width,
+        height: p.height,
+        fill: getColorFromString(p.globalConnNetId, 0.35)
+      });
+      graphics.points.push({
+        x: p.anchorPoint.x,
+        y: p.anchorPoint.y,
+        color: getColorFromString(p.globalConnNetId, 0.9)
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
 var correctPinsInsideChips = (problem) => {
   for (const chip of problem.chips) {
@@ -2236,6 +3113,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   schematicTraceLinesSolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
+  traceLabelOverlapAvoidanceSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -2314,6 +3192,35 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         onSolved: (_solver) => {
         }
       }
+    ),
+    definePipelineStep(
+      "traceLabelOverlapAvoidanceSolver",
+      TraceLabelOverlapAvoidanceSolver,
+      (instance) => {
+        const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
+          instance.schematicTraceLinesSolver.solvedTracePaths.map((p) => [
+            p.mspPairId,
+            p
+          ])
+        );
+        const traces = Object.values(traceMap);
+        const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces,
+            netLabelPlacements
+          }
+        ];
+      },
+      {
+        onSolved: (instance) => {
+          if (instance.traceLabelOverlapAvoidanceSolver && instance.netLabelPlacementSolver) {
+            const { netLabelPlacements } = instance.traceLabelOverlapAvoidanceSolver.getOutput();
+            instance.netLabelPlacementSolver.netLabelPlacements = netLabelPlacements;
+          }
+        }
+      }
     )
   ];
   constructor(inputProblem) {