@tscircuit/schematic-trace-solver 0.0.125 → 0.0.127

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,569 @@ 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/InlineNetLabelSolver/getAxisAlignedSegments.ts
+var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
+  const segments = [];
+  let runStart = null;
+  let runAxis = null;
+  let runSign = 0;
+  const closeRun = (runEnd) => {
+    if (runStart && runAxis) {
+      const length = runAxis === "x" ? Math.abs(runEnd.x - runStart.x) : Math.abs(runEnd.y - runStart.y);
+      if (length > epsilon) {
+        segments.push({ start: runStart, end: runEnd, axis: runAxis, length });
+      }
+    }
+    runStart = null;
+    runAxis = null;
+    runSign = 0;
+  };
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i];
+    const b = path[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    if (Math.abs(dx) <= epsilon && Math.abs(dy) <= epsilon) continue;
+    const axis = Math.abs(dy) <= epsilon ? "x" : Math.abs(dx) <= epsilon ? "y" : null;
+    if (!axis) {
+      closeRun(a);
+      continue;
+    }
+    const sign = Math.sign(axis === "x" ? dx : dy);
+    if (runStart && runAxis === axis && runSign === sign) continue;
+    closeRun(a);
+    runStart = a;
+    runAxis = axis;
+    runSign = sign;
+  }
+  if (path.length >= 2) {
+    closeRun(path[path.length - 1]);
+  }
+  return segments.sort((a, b) => b.length - a.length);
+};
+
+// lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
+var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
+var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
+var MIN_INLINE_NET_LABEL_SEGMENT_RATIO = 0.5;
+var getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
+var InlineNetLabelSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  inputNetLabelPlacements;
+  inlineNetLabelPlacements = [];
+  /** Direct connections that opted in, still waiting to be processed */
+  queuedDirectConnections;
+  tracesByPinPairKey;
+  constructor(input) {
+    super();
+    this.inputProblem = input.inputProblem;
+    this.traces = input.traces;
+    this.inputNetLabelPlacements = input.netLabelPlacements;
+    this.queuedDirectConnections = this.inputProblem.directConnections.filter(
+      (dc) => dc.allowInlineNetLabel && dc.netId
+    );
+    this.tracesByPinPairKey = /* @__PURE__ */ new Map();
+    for (const trace of this.traces) {
+      const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
+      const existing = this.tracesByPinPairKey.get(key);
+      if (existing) {
+        existing.push(trace);
+      } else {
+        this.tracesByPinPairKey.set(key, [trace]);
+      }
+    }
+  }
+  getConstructorParams() {
+    return [
+      {
+        inputProblem: this.inputProblem,
+        traces: this.traces,
+        netLabelPlacements: this.inputNetLabelPlacements
+      }
+    ];
+  }
+  _step() {
+    const directConnection = this.queuedDirectConnections.shift();
+    if (!directConnection) {
+      this.solved = true;
+      this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
+      return;
+    }
+    const placement = this.computeInlinePlacement(directConnection);
+    if (placement) {
+      this.inlineNetLabelPlacements.push(placement);
+    }
+  }
+  computeInlinePlacement(directConnection) {
+    const traces = this.tracesByPinPairKey.get(getPinPairKey2(directConnection.pinIds)) ?? [];
+    if (traces.length === 0) return null;
+    const trace = traces[0];
+    const segments = getAxisAlignedSegments(trace.tracePath);
+    if (segments.length === 0) return null;
+    const height = directConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
+    const width = directConnection.inlineNetLabelWidth ?? directConnection.netLabelWidth ?? estimateInlineNetLabelWidth(directConnection.netId, height);
+    const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
+    const usableSegments = segments.filter(
+      (segment) => segment.length >= width * MIN_INLINE_NET_LABEL_SEGMENT_RATIO
+    ).sort((a, b) => {
+      const aFits = a.length >= width;
+      const bFits = b.length >= width;
+      if (aFits !== bFits) return aFits ? -1 : 1;
+      return b.length - a.length;
+    });
+    for (const segment of usableSegments) {
+      const sides = segment.axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
+      for (const side of sides) {
+        for (const anchorPoint of getAnchorCandidates(segment, width)) {
+          const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset } : side === "x-" ? { x: anchorPoint.x - offset, y: anchorPoint.y } : { x: anchorPoint.x + offset, y: anchorPoint.y };
+          const halfAlong = width / 2;
+          const halfAcross = height / 2;
+          const bounds = segment.axis === "x" ? {
+            minX: center.x - halfAlong,
+            maxX: center.x + halfAlong,
+            minY: center.y - halfAcross,
+            maxY: center.y + halfAcross
+          } : {
+            minX: center.x - halfAcross,
+            maxX: center.x + halfAcross,
+            minY: center.y - halfAlong,
+            maxY: center.y + halfAlong
+          };
+          if (this.isObstructed(bounds, trace)) continue;
+          return {
+            globalConnNetId: trace.globalConnNetId,
+            netId: directConnection.netId,
+            mspPairId: trace.mspPairId,
+            pinIds: [...directConnection.pinIds],
+            axis: segment.axis,
+            anchorPoint,
+            center,
+            width,
+            height,
+            side
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * An inline label may not sit on top of a chip, a component's text, or a
+   * trace belonging to another net.
+   */
+  isObstructed(bounds, ownTrace) {
+    for (const chip of this.inputProblem.chips) {
+      const chipBounds = {
+        minX: chip.center.x - chip.width / 2,
+        maxX: chip.center.x + chip.width / 2,
+        minY: chip.center.y - chip.height / 2,
+        maxY: chip.center.y + chip.height / 2
+      };
+      if (boundsOverlap(bounds, chipBounds)) return true;
+    }
+    for (const textBox of this.inputProblem.textBoxes ?? []) {
+      if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+    }
+    for (const trace of this.traces) {
+      if (trace.mspPairId === ownTrace.mspPairId) continue;
+      if (trace.globalConnNetId === ownTrace.globalConnNetId) continue;
+      if (doesPathIntersectBounds(trace.tracePath, bounds)) return true;
+    }
+    return false;
+  }
+  /**
+   * Net label placements superseded by an inline label. A net gets one label or
+   * the other, never both.
+   */
+  getSupersededNetLabelKeys() {
+    const keys = /* @__PURE__ */ new Set();
+    for (const placement of this.inlineNetLabelPlacements) {
+      keys.add(placement.globalConnNetId);
+    }
+    return keys;
+  }
+  getOutput() {
+    const superseded = this.getSupersededNetLabelKeys();
+    return {
+      traces: this.traces,
+      netLabelPlacements: this.inputNetLabelPlacements.filter(
+        (placement) => !superseded.has(placement.globalConnNetId)
+      ),
+      inlineNetLabelPlacements: this.inlineNetLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem);
+    graphics.lines ??= [];
+    graphics.rects ??= [];
+    graphics.points ??= [];
+    graphics.texts ??= [];
+    for (const trace of this.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    const { netLabelPlacements } = this.getOutput();
+    for (const label of netLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+      });
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint
+orientation: ${label.orientation}`
+      });
+    }
+    for (const inlineLabel of this.inlineNetLabelPlacements) {
+      const isHorizontal4 = inlineLabel.axis === "x";
+      graphics.rects.push({
+        center: inlineLabel.center,
+        width: isHorizontal4 ? inlineLabel.width : inlineLabel.height,
+        height: isHorizontal4 ? inlineLabel.height : inlineLabel.width,
+        fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
+        strokeColor: "green",
+        label: [
+          `INLINE netId: ${inlineLabel.netId}`,
+          `axis: ${inlineLabel.axis}`,
+          `side: ${inlineLabel.side}`
+        ].join("\n")
+      });
+      graphics.texts.push({
+        x: inlineLabel.center.x,
+        y: inlineLabel.center.y,
+        text: inlineLabel.netId ?? "",
+        color: "green",
+        fontSize: inlineLabel.height,
+        anchorSide: "center"
+      });
+      graphics.points.push({
+        x: inlineLabel.anchorPoint.x,
+        y: inlineLabel.anchorPoint.y,
+        color: "green",
+        label: `inline anchor
+${inlineLabel.netId}`
+      });
+    }
+    return graphics;
+  }
+};
+var estimateInlineNetLabelWidth = (text, fontSize = DEFAULT_INLINE_NET_LABEL_HEIGHT) => {
+  const fontScale = fontSize / 0.18;
+  return text.length * 0.12 * fontScale + 0.12 * fontScale;
+};
+var getAnchorCandidates = (segment, labelWidth, step = 0.1) => {
+  const along = segment.axis === "x" ? "x" : "y";
+  const start = segment.start[along];
+  const end = segment.end[along];
+  const mid = (start + end) / 2;
+  const direction = Math.sign(end - start) || 1;
+  const pointAt = (value) => segment.axis === "x" ? { x: value, y: segment.start.y } : { x: segment.start.x, y: segment.start.y + (value - start) };
+  const slack = segment.length - labelWidth;
+  if (slack <= 0) return [pointAt(mid)];
+  const offsets = [0];
+  for (let offset = step; offset <= slack / 2 + 1e-9; offset += step) {
+    offsets.push(offset, -offset);
+  }
+  offsets.push(slack / 2, -slack / 2);
+  return offsets.map((offset) => pointAt(mid + offset * direction));
+};
+var doesPathIntersectBounds = (path, bounds) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i];
+    const b = path[i + 1];
+    const segmentBounds = {
+      minX: Math.min(a.x, b.x),
+      maxX: Math.max(a.x, b.x),
+      minY: Math.min(a.y, b.y),
+      maxY: Math.max(a.y, b.y)
+    };
+    if (boundsOverlap(segmentBounds, bounds)) return true;
+  }
+  return false;
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -11555,7 +12184,11 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   netLabelTraceCollisionSolver;
   traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
+  traceElbowTransitionSimplificationSolver;
+  preAlignmentTraceElbowTransitionSimplificationSolver;
+  finalTraceElbowTransitionSimplificationSolver;
   sameNetJunctionAlignmentSolver;
+  inlineNetLabelSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -11676,8 +12309,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 +12428,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 +12501,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",
@@ -11860,6 +12544,20 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           }
         ];
       }
+    ),
+    definePipelineStep(
+      "inlineNetLabelSolver",
+      InlineNetLabelSolver,
+      (instance) => {
+        const junctionOutput = instance.sameNetJunctionAlignmentSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: junctionOutput.traces,
+            netLabelPlacements: junctionOutput.netLabelPlacements
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem, opts) {
@@ -11973,6 +12671,11 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   }
 };
 export {
+  DEFAULT_INLINE_NET_LABEL_HEIGHT,
+  INLINE_NET_LABEL_TRACE_MARGIN,
+  InlineNetLabelSolver,
+  MIN_INLINE_NET_LABEL_SEGMENT_RATIO,
   SchematicTracePipelineSolver,
-  SchematicTraceSingleLineSolver2
+  SchematicTraceSingleLineSolver2,
+  estimateInlineNetLabelWidth
 };