@tscircuit/schematic-trace-solver 0.0.125 → 0.0.126

package/dist/index.js

@@ -4000,6 +4000,16 @@ var doesPathOverlapTraceStrokes = (path, traces) => {
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
+var PATH_LENGTH_EPSILON = 1e-9;
+var getPathLength = (points) => {
+  let length = 0;
+  for (let pointIndex = 0; pointIndex < points.length - 1; pointIndex++) {
+    const point = points[pointIndex];
+    const nextPoint = points[pointIndex + 1];
+    length += Math.abs(nextPoint.x - point.x) + Math.abs(nextPoint.y - point.y);
+  }
+  return length;
+};
 var SingleOverlapSolver = class extends BaseSolver {
   queuedCandidatePaths;
   solvedTracePath = null;
@@ -4008,32 +4018,47 @@ var SingleOverlapSolver = class extends BaseSolver {
   obstacles;
   label;
   tracesToAvoidOverlapping;
+  netLabelPlacements;
+  detourCount;
   _tried = 0;
   constructor(solverInput) {
     super();
     this.initialTrace = solverInput.trace;
     this.problem = solverInput.problem;
     this.label = solverInput.label;
+    this.detourCount = solverInput.detourCount;
     this.tracesToAvoidOverlapping = (solverInput.tracesToAvoidOverlapping ?? []).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId);
+    this.netLabelPlacements = solverInput.netLabelPlacements ?? [
+      solverInput.label
+    ];
+    this.obstacles = getObstacleRects(this.problem);
     const effectivePadding = solverInput.paddingBuffer + solverInput.detourCount * solverInput.paddingBuffer;
     const candidates = generateRerouteCandidates({
       ...solverInput,
       paddingBuffer: effectivePadding
       // Use the calculated, larger padding
     });
-    const getPathLength3 = (pts) => {
-      let len = 0;
-      for (let i = 0; i < pts.length - 1; i++) {
-        const dx = pts[i + 1].x - pts[i].x;
-        const dy = pts[i + 1].y - pts[i].y;
-        len += Math.sqrt(dx * dx + dy * dy);
-      }
-      return len;
-    };
-    this.queuedCandidatePaths = candidates.sort(
-      (a, b) => getPathLength3(a) - getPathLength3(b)
-    );
-    this.obstacles = getObstacleRects(this.problem);
+    const getLabelOverlapCount = (path) => detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: path }],
+      netLabels: this.netLabelPlacements
+    }).length;
+    const candidateByPath = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const simplifiedCandidate = simplifyPath(candidate);
+      candidateByPath.set(
+        simplifiedCandidate.map((point) => `${point.x},${point.y}`).join(";"),
+        simplifiedCandidate
+      );
+    }
+    this.queuedCandidatePaths = [...candidateByPath.values()].sort((a, b) => {
+      const pathLengthDifference = getPathLength(a) - getPathLength(b);
+      if (Math.abs(pathLengthDifference) >= PATH_LENGTH_EPSILON) {
+        return pathLengthDifference;
+      }
+      const overlapCountDifference = getLabelOverlapCount(a) - getLabelOverlapCount(b);
+      if (overlapCountDifference !== 0) return overlapCountDifference;
+      return a.length - b.length;
+    });
   }
   _step() {
     if (this.queuedCandidatePaths.length === 0 || this._tried >= MAX_TRIES) {
@@ -4047,7 +4072,16 @@ var SingleOverlapSolver = class extends BaseSolver {
       traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
       netLabels: [this.label]
     }).length > 0;
-    if (!stillOverlapsLabel && !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
+    const initialPath = simplifyPath(this.initialTrace.tracePath);
+    const initialLabelOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: initialPath }],
+      netLabels: this.netLabelPlacements
+    });
+    const candidateLabelOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
+      netLabels: this.netLabelPlacements
+    });
+    if (!stillOverlapsLabel && candidateLabelOverlaps.length <= initialLabelOverlaps.length && !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) && !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)) {
       this.solvedTracePath = simplifiedPath;
       this.solved = true;
     }
@@ -4070,7 +4104,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       height: this.label.height,
       fill: "rgba(255, 0, 0, 0.2)"
     });
-    if (this.queuedCandidatePaths.length > 0) {
+    if (!this.solvedTracePath && this.queuedCandidatePaths.length > 0) {
       graphics.lines.push({
         points: this.queuedCandidatePaths[0],
         strokeColor: "orange"
@@ -4154,6 +4188,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   allTraces;
   tracesToAvoidOverlapping;
   modifiedTraces = [];
+  completedReroutes = [];
   PADDING_BUFFER = 0.1;
   detourCounts = /* @__PURE__ */ new Map();
   activeSubSolver = null;
@@ -4179,6 +4214,17 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
       if (this.activeSubSolver.solved) {
         const solvedPath = this.activeSubSolver.solvedTracePath;
         if (solvedPath) {
+          this.completedReroutes.push({
+            initialTrace: {
+              ...this.activeSubSolver.initialTrace,
+              tracePath: this.activeSubSolver.initialTrace.tracePath.map(
+                (point) => ({ ...point })
+              )
+            },
+            reroutedTracePath: solvedPath.map((point) => ({ ...point })),
+            label: this.activeSubSolver.label,
+            detourCount: this.activeSubSolver.detourCount
+          });
           const traceIndex = this.allTraces.findIndex(
             (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
           );
@@ -4251,7 +4297,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount2,
-            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+            netLabelPlacements: this.initialNetLabelPlacements
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -4287,7 +4334,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount2,
-            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+            netLabelPlacements: this.initialNetLabelPlacements
           });
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
@@ -4303,7 +4351,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
         detourCount,
-        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping
+        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+        netLabelPlacements: this.initialNetLabelPlacements
       });
     }
   }
@@ -4440,6 +4489,9 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     const solvedTraces = this.subSolvers.flatMap((s) => s.getOutput().allTraces);
     return {
       traces: [...this.cleanTraces, ...solvedTraces],
+      completedReroutes: this.subSolvers.flatMap(
+        (solver) => solver.completedReroutes
+      ),
       netLabelPlacements: this.labelMergingSolver?.getOutput().netLabelPlacements ?? this.netLabelPlacements
     };
   }
@@ -5527,7 +5579,7 @@ var segmentRunsAlongRectBoundary = (start, end, rect) => {
 
 // lib/solvers/Example28Solver/geometry.ts
 var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
-var getPathLength = (path) => {
+var getPathLength2 = (path) => {
   let length = 0;
   for (let i = 0; i < path.length - 1; i++) {
     length += Math.abs(path[i + 1].x - path[i].x) + Math.abs(path[i + 1].y - path[i].y);
@@ -5681,7 +5733,7 @@ var getTraceGeometryMetrics = (traces, allTraces) => ({
   ),
   visibleLength: getVisibleTraceLength(traces),
   pathLength: traces.reduce(
-    (sum, trace) => sum + getPathLength(trace.tracePath),
+    (sum, trace) => sum + getPathLength2(trace.tracePath),
     0
   ),
   otherNetCrossings: countOtherNetCrossings(traces, allTraces)
@@ -6496,7 +6548,7 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         candidate.traceId
       ).isColliding && (crossing.isInitialBundleCrossing || !candidate.collision.isColliding)
     ).sort(
-      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength(first.path) - getPathLength(second.path)
+      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength2(first.path) - getPathLength2(second.path)
     );
     const bestCandidate = validCandidates[0];
     if (!bestCandidate) return false;
@@ -7405,7 +7457,7 @@ var scoreTracePath = ({
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
     chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
-    pathLength: getPathLength(tracePath)
+    pathLength: getPathLength2(tracePath)
   };
 };
 var countTraceIntersections = (trace, outputTraces) => {
@@ -10297,6 +10349,7 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
   netLabelPlacements;
   outputTraces;
   outputNetLabelPlacements;
+  completedReroutes = [];
   activeSubSolver = null;
   recentlyFailed = /* @__PURE__ */ new Set();
   detourCounts = /* @__PURE__ */ new Map();
@@ -10322,6 +10375,17 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
       if (this.activeSubSolver.solved) {
         const solvedPath = this.activeSubSolver.solvedTracePath;
         if (solvedPath) {
+          this.completedReroutes.push({
+            initialTrace: {
+              ...this.activeSubSolver.initialTrace,
+              tracePath: this.activeSubSolver.initialTrace.tracePath.map(
+                (point) => ({ ...point })
+              )
+            },
+            reroutedTracePath: solvedPath.map((point) => ({ ...point })),
+            label: this.activeSubSolver.label,
+            detourCount: this.activeSubSolver.detourCount
+          });
           const idx = this.outputTraces.findIndex(
             (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
           );
@@ -10384,7 +10448,8 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
       problem: this.inputProblem,
       paddingBuffer: PADDING_BUFFER,
       detourCount,
-      tracesToAvoidOverlapping: this.outputTraces
+      tracesToAvoidOverlapping: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements
     });
   }
   /**
@@ -10416,6 +10481,7 @@ var NetLabelTraceCollisionSolver = class extends BaseSolver {
   getOutput() {
     return {
       traces: this.outputTraces,
+      completedReroutes: this.completedReroutes,
       netLabelPlacements: this.outputNetLabelPlacements
     };
   }
@@ -10828,7 +10894,7 @@ var removeConsecutiveDuplicatePoints = (path) => {
   }
   return filteredPath;
 };
-var getPathLength2 = (path) => {
+var getPathLength3 = (path) => {
   let pathLength = 0;
   for (let pointIndex = 0; pointIndex < path.length - 1; pointIndex++) {
     const startPoint = path[pointIndex];
@@ -10912,7 +10978,7 @@ var getPerimeterCandidates = ({
     );
   }
   return candidates.sort(
-    (firstPath, secondPath) => getPathLength2(firstPath) - getPathLength2(secondPath)
+    (firstPath, secondPath) => getPathLength3(firstPath) - getPathLength3(secondPath)
   );
 };
 var getSegmentMidpoint = (startPoint, endPoint) => {
@@ -11017,7 +11083,7 @@ var getJunctionCandidates = ({
     }
   }
   return candidates.sort(
-    (firstPath, secondPath) => getPathLength2(firstPath) - getPathLength2(secondPath)
+    (firstPath, secondPath) => getPathLength3(firstPath) - getPathLength3(secondPath)
   );
 };
 var pathCollidesWithObstacles = ({
@@ -11525,6 +11591,278 @@ orientation: ${label.orientation}`
   }
 };
 
+// lib/solvers/TraceElbowTransitionSimplificationSolver/generateElbowTransitionSimplificationCandidates.ts
+var isSimpleFiveSegmentElbow = (path) => {
+  const simplifiedPath = simplifyPath(path);
+  if (simplifiedPath.length !== 6) return false;
+  const segmentIsHorizontal = simplifiedPath.slice(0, -1).map((point, index) => isHorizontal(point, simplifiedPath[index + 1]));
+  return segmentIsHorizontal.every(
+    (isHorizontalSegment, index) => index === 0 || isHorizontalSegment !== segmentIsHorizontal[index - 1]
+  );
+};
+var generateSegmentShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount
+}) => {
+  if (trace.globalConnNetId === label.globalConnNetId) return [];
+  const path = simplifyPath(trace.tracePath);
+  if (!isSimpleFiveSegmentElbow(path)) return [];
+  const labelBounds = getRectBounds(label.center, label.width, label.height);
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding
+  };
+  const candidates = [];
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const segmentStart = path[segmentIndex];
+    const segmentEnd = path[segmentIndex + 1];
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue;
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd);
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd);
+    if (!isHorizontalSegment && !isVerticalSegment) continue;
+    const axis = isHorizontalSegment ? "y" : "x";
+    const coordinates = isHorizontalSegment ? [paddedLabelBounds.minY, paddedLabelBounds.maxY] : [paddedLabelBounds.minX, paddedLabelBounds.maxX];
+    for (const coordinate of coordinates) {
+      const shiftedPath = shiftSegmentOrth(path, segmentIndex, axis, coordinate);
+      if (shiftedPath) candidates.push(shiftedPath);
+    }
+  }
+  return candidates;
+};
+var generateTransitionShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount
+}) => {
+  const path = simplifyPath(trace.tracePath);
+  if (!isSimpleFiveSegmentElbow(path)) return [];
+  const labelBounds = getRectBounds(label.center, label.width, label.height);
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding
+  };
+  const start = path[0];
+  const end = path[path.length - 1];
+  const middleSegmentIndex = 2;
+  const candidates = [];
+  for (let segmentIndex = 0; segmentIndex < path.length - 1; segmentIndex++) {
+    const segmentStart = path[segmentIndex];
+    const segmentEnd = path[segmentIndex + 1];
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue;
+    if (Math.abs(segmentIndex - middleSegmentIndex) !== 1) continue;
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd);
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd);
+    if (!isHorizontalSegment && !isVerticalSegment) continue;
+    const axis = isHorizontalSegment ? "x" : "y";
+    const min = isHorizontalSegment ? paddedLabelBounds.minX : paddedLabelBounds.minY;
+    const max = isHorizontalSegment ? paddedLabelBounds.maxX : paddedLabelBounds.maxY;
+    const startCoordinate = isHorizontalSegment ? start.x : start.y;
+    const endCoordinate = isHorizontalSegment ? end.x : end.y;
+    const corridorCoordinates = [];
+    if (startCoordinate < min) {
+      corridorCoordinates.push((startCoordinate + min) / 2);
+    } else if (startCoordinate > max) {
+      corridorCoordinates.push((startCoordinate + max) / 2);
+    }
+    if (endCoordinate < min) {
+      corridorCoordinates.push((endCoordinate + min) / 2);
+    } else if (endCoordinate > max) {
+      corridorCoordinates.push((endCoordinate + max) / 2);
+    }
+    for (const coordinate of new Set(corridorCoordinates)) {
+      const shiftedPath = shiftSegmentOrth(
+        path,
+        middleSegmentIndex,
+        axis,
+        coordinate
+      );
+      if (shiftedPath) candidates.push(shiftedPath);
+    }
+  }
+  return candidates;
+};
+var generateElbowTransitionSimplificationCandidates = ({
+  trace,
+  label,
+  netLabelPlacements,
+  paddingBuffer,
+  detourCount
+}) => {
+  const transitionCandidates = generateTransitionShiftCandidates({
+    trace,
+    label,
+    paddingBuffer,
+    detourCount
+  });
+  return transitionCandidates.flatMap((tracePath) => {
+    const shiftedTrace = { ...trace, tracePath };
+    const shiftedOverlaps = detectTraceLabelOverlap({
+      traces: [shiftedTrace],
+      netLabels: netLabelPlacements
+    });
+    return shiftedOverlaps.flatMap(
+      ({ label: shiftedLabel }) => generateSegmentShiftCandidates({
+        trace: shiftedTrace,
+        label: shiftedLabel,
+        paddingBuffer,
+        detourCount
+      })
+    );
+  });
+};
+
+// lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver.ts
+var PATH_LENGTH_EPSILON2 = 1e-9;
+var getPathLength4 = (points) => points.slice(1).reduce((length, point, pointIndex) => {
+  const previousPoint = points[pointIndex];
+  return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
+}, 0);
+var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
+  input;
+  outputTraces;
+  traceIdQueue;
+  obstacles;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.outputTraces = [...input.traces];
+    const reroutedTraceIds = new Set(
+      input.completedReroutes.map(
+        (completedReroute) => completedReroute.initialTrace.mspPairId
+      )
+    );
+    this.traceIdQueue = input.traces.map((trace) => trace.mspPairId).filter((traceId) => reroutedTraceIds.has(traceId));
+    this.obstacles = getObstacleRects(input.inputProblem);
+  }
+  _step() {
+    const traceId = this.traceIdQueue.shift();
+    if (!traceId) {
+      this.solved = true;
+      return;
+    }
+    const traceIndex = this.outputTraces.findIndex(
+      (trace2) => trace2.mspPairId === traceId
+    );
+    const trace = this.outputTraces[traceIndex];
+    const tracePath = simplifyPath(trace.tracePath);
+    const initialOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...trace, tracePath }],
+      netLabels: this.input.netLabelPlacements
+    });
+    const otherNetTraces = this.outputTraces.filter(
+      (otherTrace) => otherTrace.mspPairId !== trace.mspPairId && otherTrace.globalConnNetId !== trace.globalConnNetId
+    );
+    const candidateByPath = /* @__PURE__ */ new Map();
+    const completedReroutes = this.input.completedReroutes.filter(
+      (completedReroute) => completedReroute.initialTrace.mspPairId === trace.mspPairId
+    );
+    for (const completedReroute of completedReroutes) {
+      const initialReroutePath = simplifyPath(
+        completedReroute.initialTrace.tracePath
+      );
+      const reroutedPath = simplifyPath(completedReroute.reroutedTracePath);
+      const initialRerouteOverlapCount = detectTraceLabelOverlap({
+        traces: [
+          { ...completedReroute.initialTrace, tracePath: initialReroutePath }
+        ],
+        netLabels: this.input.netLabelPlacements
+      }).length;
+      const candidates = generateElbowTransitionSimplificationCandidates({
+        trace: completedReroute.initialTrace,
+        label: completedReroute.label,
+        netLabelPlacements: this.input.netLabelPlacements,
+        paddingBuffer: this.input.paddingBuffer,
+        detourCount: completedReroute.detourCount
+      });
+      for (const candidate of candidates) {
+        const simplifiedCandidate = simplifyPath(candidate);
+        const candidateTrace = {
+          ...completedReroute.initialTrace,
+          tracePath: simplifiedCandidate
+        };
+        const candidateOverlapCount = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements
+        }).length;
+        const isSimplerEquivalentReroute = candidateOverlapCount < initialRerouteOverlapCount && Math.abs(
+          getPathLength4(simplifiedCandidate) - getPathLength4(reroutedPath)
+        ) < PATH_LENGTH_EPSILON2 && simplifiedCandidate.length < reroutedPath.length && preservesLabelAnchors(
+          this.input.netLabelPlacements,
+          [completedReroute.initialTrace],
+          [candidateTrace]
+        );
+        if (isSimplerEquivalentReroute) {
+          candidateByPath.set(
+            simplifiedCandidate.map((point) => `${point.x},${point.y}`).join(";"),
+            simplifiedCandidate
+          );
+        }
+      }
+    }
+    const initialOverlapIds = new Set(
+      initialOverlaps.map(
+        ({ label }) => `${label.globalConnNetId}:${label.netId}`
+      )
+    );
+    const initialPathLength = getPathLength4(tracePath);
+    const validCandidates = [...candidateByPath.values()].filter(
+      (candidatePath) => {
+        const candidateTrace = { ...trace, tracePath: candidatePath };
+        const candidateOverlaps = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements
+        });
+        const candidateOnlyKeepsExistingOverlaps = candidateOverlaps.every(
+          ({ label }) => initialOverlapIds.has(`${label.globalConnNetId}:${label.netId}`)
+        );
+        const reducesCollisions = candidateOverlaps.length < initialOverlaps.length;
+        const simplifiesGeometry = candidateOverlaps.length === initialOverlaps.length && getPathLength4(candidatePath) <= initialPathLength + PATH_LENGTH_EPSILON2 && candidatePath.length < tracePath.length;
+        return candidateOnlyKeepsExistingOverlaps && (reducesCollisions || simplifiesGeometry) && preservesLabelAnchors(
+          this.input.netLabelPlacements,
+          [trace],
+          [candidateTrace]
+        ) && !isPathCollidingWithObstacles(candidatePath, this.obstacles) && !doesPathCoincideWithTraces(candidatePath, otherNetTraces);
+      }
+    );
+    const getOverlapCount = (candidatePath) => detectTraceLabelOverlap({
+      traces: [{ ...trace, tracePath: candidatePath }],
+      netLabels: this.input.netLabelPlacements
+    }).length;
+    validCandidates.sort((a, b) => {
+      const overlapDifference = getOverlapCount(a) - getOverlapCount(b);
+      if (overlapDifference !== 0) return overlapDifference;
+      return getPathLength4(a) - getPathLength4(b) || a.length - b.length;
+    });
+    const bestCandidate = validCandidates[0];
+    if (!bestCandidate) return;
+    this.outputTraces[traceIndex] = { ...trace, tracePath: bestCandidate };
+    this.stats.simplifiedTraceCount = (this.stats.simplifiedTraceCount ?? 0) + 1;
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.input.inputProblem);
+    graphics.lines ??= [];
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({ points: trace.tracePath, strokeColor: "purple" });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -11555,6 +11893,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   netLabelTraceCollisionSolver;
   traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
+  traceElbowTransitionSimplificationSolver;
+  preAlignmentTraceElbowTransitionSimplificationSolver;
+  finalTraceElbowTransitionSimplificationSolver;
   sameNetJunctionAlignmentSolver;
   startTimeOfPhase;
   endTimeOfPhase;
@@ -11676,8 +12017,24 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         ];
       }
     ),
+    definePipelineStep(
+      "traceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const overlapAvoidanceOutput = instance.traceLabelOverlapAvoidanceSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: overlapAvoidanceOutput.traces,
+            completedReroutes: overlapAvoidanceOutput.completedReroutes,
+            netLabelPlacements: instance.traceLabelOverlapAvoidanceSolver.netLabelPlacements,
+            paddingBuffer: 0.1
+          }
+        ];
+      }
+    ),
     definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
-      const prevSolverOutput = instance.traceLabelOverlapAvoidanceSolver.getOutput();
+      const prevSolverOutput = instance.traceElbowTransitionSimplificationSolver.getOutput();
       const traces = prevSolverOutput.traces;
       const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
       return [
@@ -11779,11 +12136,27 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       ]
     ),
+    definePipelineStep(
+      "preAlignmentTraceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const collisionOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: collisionOutput.traces,
+            completedReroutes: collisionOutput.completedReroutes,
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            paddingBuffer: 0.1
+          }
+        ];
+      }
+    ),
     definePipelineStep(
       "traceCleanupSolver2",
       TraceCleanupSolver,
       (instance) => {
-        const collisionOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        const collisionOutput = instance.preAlignmentTraceElbowTransitionSimplificationSolver.getOutput();
         const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
         return [
           {
@@ -11836,16 +12209,35 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         ];
       }
     ),
+    definePipelineStep(
+      "finalTraceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const collisionOutput = instance.netLabelTraceCollisionSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: collisionOutput.traces,
+            completedReroutes: collisionOutput.completedReroutes,
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            paddingBuffer: 0.1
+          }
+        ];
+      }
+    ),
     definePipelineStep(
       "netLabelNetLabelCollisionSolver",
       NetLabelNetLabelCollisionSolver,
-      (instance) => [
-        {
-          inputProblem: instance.inputProblem,
-          traces: instance.netLabelTraceCollisionSolver.getOutput().traces,
-          netLabelPlacements: instance.netLabelTraceCollisionSolver.getOutput().netLabelPlacements
-        }
-      ]
+      (instance) => {
+        const simplificationOutput = instance.finalTraceElbowTransitionSimplificationSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: simplificationOutput.traces,
+            netLabelPlacements: simplificationOutput.netLabelPlacements
+          }
+        ];
+      }
     ),
     definePipelineStep(
       "sameNetJunctionAlignmentSolver",