@tscircuit/schematic-trace-solver 0.0.120 → 0.0.122

package/dist/index.d.ts

@@ -828,11 +828,11 @@ type TraceCornerCandidate = {
     traceId: string;
     distance: number;
     /**
-     * True when the corner lines up with one of the trace's pins along the
-     * label's stub axis (same x for a vertical rail label), so the label reads as
-     * a clean stub off that pin rather than floating over a mid-trace bend.
+     * True when the corner is on a vertical rail that connects directly to one
+     * of the trace's endpoint pins, rather than on an arbitrary middle bend.
      */
     pinAligned: boolean;
+    reroutedTracePath?: Point[];
 };
 type CornerCandidateStatus = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "netlabel-collision";
 type EvaluatedCornerCandidate = TraceCornerCandidate & {
@@ -859,6 +859,7 @@ declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     getConstructorParams(): ConstructorParameters<typeof RailNetLabelCornerPlacementSolver>[0];
     _step(): void;
     getOutput(): {
+        traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];
     };
     private getProcessableLabelIndices;
@@ -873,6 +874,12 @@ declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     private intersectsAnyChip;
     private intersectsAnyOtherNetLabel;
     private getCornerCandidatesForLabel;
+    private isConfiguredRailLabel;
+    private pointsEqual;
+    private getVerticalSegmentPointIndices;
+    private isPinAlignedCorner;
+    private getClearanceShiftedCornerCandidates;
+    private isReroutedTraceClear;
     private getTraceLinesForLabel;
     private isTraceForLabel;
     visualize(): GraphicsObject;

package/dist/index.js

@@ -3922,7 +3922,12 @@ var generateRerouteCandidates = ({
 };
 
 // lib/utils/doesPathCoincideWithTraces.ts
+import { boundsIntersection } from "@tscircuit/math-utils";
 var COINCIDENT_EPS = 2e-3;
+var GEOMETRY_EPS = 1e-6;
+var SCHEMATIC_TRACE_STROKE_WIDTH = 0.02;
+var SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH + GEOMETRY_EPS;
+var SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH * 3;
 var doesPathCoincideWithTraces = (path, traces) => {
   const rangesOverlap1D = (a1, a2, b1, b2) => Math.min(Math.max(a1, a2), Math.max(b1, b2)) - Math.max(Math.min(a1, a2), Math.min(b1, b2)) > COINCIDENT_EPS;
   for (let i = 0; i < path.length - 1; i++) {
@@ -3954,6 +3959,44 @@ var doesPathCoincideWithTraces = (path, traces) => {
   }
   return false;
 };
+var doesPathOverlapTraceStrokes = (path, traces) => {
+  const traceStrokeRadius = SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE / 2;
+  const getStrokeBounds = (start, end, isVertical5) => isVertical5 ? {
+    minX: start.x - traceStrokeRadius,
+    maxX: start.x + traceStrokeRadius,
+    minY: Math.min(start.y, end.y),
+    maxY: Math.max(start.y, end.y)
+  } : {
+    minX: Math.min(start.x, end.x),
+    maxX: Math.max(start.x, end.x),
+    minY: start.y - traceStrokeRadius,
+    maxY: start.y + traceStrokeRadius
+  };
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    const pathStart = path[pathIndex];
+    const pathEnd = path[pathIndex + 1];
+    const isVertical5 = Math.abs(pathStart.x - pathEnd.x) < COINCIDENT_EPS;
+    const isHorizontal4 = Math.abs(pathStart.y - pathEnd.y) < COINCIDENT_EPS;
+    if (!isVertical5 && !isHorizontal4) continue;
+    const pathBounds = getStrokeBounds(pathStart, pathEnd, isVertical5);
+    for (const trace of traces) {
+      for (let traceIndex = 0; traceIndex < trace.tracePath.length - 1; traceIndex++) {
+        const traceStart = trace.tracePath[traceIndex];
+        const traceEnd = trace.tracePath[traceIndex + 1];
+        const isParallel = isVertical5 ? Math.abs(traceStart.x - traceEnd.x) < COINCIDENT_EPS : Math.abs(traceStart.y - traceEnd.y) < COINCIDENT_EPS;
+        if (!isParallel) continue;
+        const overlap = boundsIntersection(
+          pathBounds,
+          getStrokeBounds(traceStart, traceEnd, isVertical5)
+        );
+        if (!overlap) continue;
+        const overlapLength = isVertical5 ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
+        if (overlapLength > COINCIDENT_EPS) return true;
+      }
+    }
+  }
+  return false;
+};
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
@@ -5307,6 +5350,53 @@ var balanceZShapes = ({
   };
 };
 
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailAlignmentFallbackCoordinates.ts
+import { boundsIntersection as boundsIntersection2 } from "@tscircuit/math-utils";
+var getAlongBounds = (orientation, minAlong, maxAlong) => orientation === "vertical" ? { minX: 0, maxX: 0, minY: minAlong, maxY: maxAlong } : { minX: minAlong, maxX: maxAlong, minY: 0, maxY: 0 };
+var hasPositiveAlongOverlap = (orientation, first, second) => {
+  const overlap = boundsIntersection2(first, second);
+  if (!overlap) return false;
+  const overlapLength = orientation === "vertical" ? overlap.maxY - overlap.minY : overlap.maxX - overlap.minX;
+  return overlapLength > RAIL_ALIGNMENT_EPSILON;
+};
+var getRailAlignmentFallbackCoordinates = ({
+  group,
+  originalCoordinates,
+  otherNetTraces
+}) => {
+  const orientation = group[0].orientation;
+  const groupAlongBounds = group.map(
+    (segment) => getAlongBounds(orientation, segment.minAlong, segment.maxAlong)
+  );
+  const fallbackClearance = SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE;
+  const coordinates = [];
+  for (const trace of otherNetTraces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index];
+      const end = trace.tracePath[index + 1];
+      if (getRailOrientation(start, end) !== orientation) continue;
+      const minAlong = orientation === "vertical" ? Math.min(start.y, end.y) : Math.min(start.x, end.x);
+      const maxAlong = orientation === "vertical" ? Math.max(start.y, end.y) : Math.max(start.x, end.x);
+      const traceAlongBounds = getAlongBounds(orientation, minAlong, maxAlong);
+      if (!groupAlongBounds.some(
+        (bounds) => hasPositiveAlongOverlap(orientation, bounds, traceAlongBounds)
+      )) {
+        continue;
+      }
+      const coordinate = orientation === "vertical" ? start.x : start.y;
+      const touchesOriginalCandidate = originalCoordinates.some(
+        (originalCoordinate) => Math.abs(originalCoordinate - coordinate) <= SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE
+      );
+      if (!touchesOriginalCandidate) continue;
+      coordinates.push(
+        coordinate - fallbackClearance,
+        coordinate + fallbackClearance
+      );
+    }
+  }
+  return getDistinctCoordinates(coordinates);
+};
+
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
 var moveRailSegments = (trace, segments, coordinate) => {
   const pointsToMove = /* @__PURE__ */ new Set();
@@ -5578,7 +5668,7 @@ var evaluateRailGroup = ({
     (trace) => groupTraceIds.has(trace.mspPairId)
   );
   const baseline = getTraceGeometryMetrics(originalGroupTraces, traces);
-  const coordinates = getDistinctCoordinates(
+  const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate)
   );
   const otherNetTraces = traces.filter(
@@ -5587,58 +5677,72 @@ var evaluateRailGroup = ({
   const immutableSameNetTraces = traces.filter(
     (trace) => trace.globalConnNetId === group[0].globalConnNetId && !eligibleTraceIds.has(trace.mspPairId)
   );
-  let best = null;
-  for (const coordinate of coordinates) {
-    const candidateMap = /* @__PURE__ */ new Map();
-    for (const trace of originalGroupTraces) {
-      const candidateTrace = moveRailSegments(
-        trace,
-        group.filter((segment) => segment.traceId === trace.mspPairId),
-        coordinate
+  const evaluateCoordinates = (coordinates) => {
+    let best = null;
+    for (const coordinate of coordinates) {
+      const candidateMap = /* @__PURE__ */ new Map();
+      for (const trace of originalGroupTraces) {
+        const candidateTrace = moveRailSegments(
+          trace,
+          group.filter((segment) => segment.traceId === trace.mspPairId),
+          coordinate
+        );
+        candidateMap.set(trace.mspPairId, candidateTrace);
+      }
+      const candidateTraces = [...candidateMap.values()];
+      const allCandidateTraces = traces.map(
+        (trace) => candidateMap.get(trace.mspPairId) ?? trace
       );
-      candidateMap.set(trace.mspPairId, candidateTrace);
-    }
-    const candidateTraces = [...candidateMap.values()];
-    const allCandidateTraces = traces.map(
-      (trace) => candidateMap.get(trace.mspPairId) ?? trace
-    );
-    const candidatesAreClear = candidateTraces.every(
-      (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
-        traces: [candidate2],
-        netLabels: netLabelPlacements
-      }).length === 0 && !doesPathCoincideWithTraces(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
-        candidate2.tracePath,
-        immutableSameNetTraces.filter(
-          (trace) => trace.mspPairId !== candidate2.mspPairId
+      const candidatesAreClear = candidateTraces.every(
+        (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
+          traces: [candidate2],
+          netLabels: netLabelPlacements
+        }).length === 0 && !doesPathOverlapTraceStrokes(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
+          candidate2.tracePath,
+          immutableSameNetTraces.filter(
+            (trace) => trace.mspPairId !== candidate2.mspPairId
+          )
         )
-      )
-    );
-    if (!candidatesAreClear) continue;
-    if (!preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)) {
-      continue;
-    }
-    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces);
-    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
-    if (!isReadabilityImprovement(metrics, baseline)) continue;
-    const score = {
-      ...metrics,
-      displacement: group.reduce(
-        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
-        0
-      ),
-      coordinate
-    };
-    const changedTraceIds = candidateTraces.filter((candidate2) => {
-      const original = traces.find(
-        (trace) => trace.mspPairId === candidate2.mspPairId
       );
-      return tracePathChanged(original, candidate2);
-    }).map((trace) => trace.mspPairId);
-    if (changedTraceIds.length === 0) continue;
-    const candidate = { traces: allCandidateTraces, changedTraceIds, score };
-    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
-  }
-  return best;
+      if (!candidatesAreClear) continue;
+      if (!preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)) {
+        continue;
+      }
+      const metrics = getTraceGeometryMetrics(
+        candidateTraces,
+        allCandidateTraces
+      );
+      if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
+      if (!isReadabilityImprovement(metrics, baseline)) continue;
+      const score = {
+        ...metrics,
+        displacement: group.reduce(
+          (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+          0
+        ),
+        coordinate
+      };
+      const changedTraceIds = candidateTraces.filter((candidate2) => {
+        const original = traces.find(
+          (trace) => trace.mspPairId === candidate2.mspPairId
+        );
+        return tracePathChanged(original, candidate2);
+      }).map((trace) => trace.mspPairId);
+      if (changedTraceIds.length === 0) continue;
+      const candidate = { traces: allCandidateTraces, changedTraceIds, score };
+      if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
+    }
+    return best;
+  };
+  const originalCandidate = evaluateCoordinates(originalCoordinates);
+  if (originalCandidate) return originalCandidate;
+  return evaluateCoordinates(
+    getRailAlignmentFallbackCoordinates({
+      group,
+      originalCoordinates,
+      otherNetTraces
+    })
+  );
 };
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts
@@ -8948,6 +9052,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
   getOutput() {
     return {
+      traces: this.traces,
       netLabelPlacements: this.outputNetLabelPlacements
     };
   }
@@ -9000,15 +9105,25 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
       center,
       width: label.width,
       height: label.height,
-      status: this.getCandidateStatus(bounds, labelIndex),
+      status: this.getCandidateStatus(bounds, labelIndex, candidate),
       selected: false
     };
   }
-  getCandidateStatus(bounds, labelIndex) {
+  getCandidateStatus(bounds, labelIndex, candidate) {
     if (this.intersectsAnyChip(bounds)) return "chip-collision";
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
       return "text-collision";
-    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+    const candidateTraceMap = candidate.reroutedTracePath ? {
+      ...this.traceMap,
+      [candidate.traceId]: {
+        ...this.traceMap[candidate.traceId],
+        tracePath: candidate.reroutedTracePath
+      }
+    } : this.traceMap;
+    if (traceCrossesBoundsInterior(bounds, candidateTraceMap)) {
+      return "trace-collision";
+    }
+    if (candidate.reroutedTracePath && !this.isReroutedTraceClear(candidate, labelIndex)) {
       return "trace-collision";
     }
     if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
@@ -9017,6 +9132,23 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     return "valid";
   }
   applyCandidate(labelIndex, label, candidate) {
+    if (candidate.reroutedTracePath) {
+      const originalTrace = this.traceMap[candidate.traceId];
+      const reroutedTrace = {
+        ...originalTrace,
+        tracePath: candidate.reroutedTracePath
+      };
+      this.traces = this.traces.map(
+        (trace) => trace.mspPairId === candidate.traceId ? reroutedTrace : trace
+      );
+      this.traceMap[candidate.traceId] = reroutedTrace;
+      this.outputNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+        trace: originalTrace,
+        originalTracePath: originalTrace.tracePath,
+        reroutedTracePath: candidate.reroutedTracePath,
+        netLabelPlacements: this.outputNetLabelPlacements
+      });
+    }
     this.outputNetLabelPlacements[labelIndex] = {
       ...label,
       anchorPoint: candidate.anchorPoint,
@@ -9042,30 +9174,152 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
     });
   }
   getCornerCandidatesForLabel(label) {
-    const isVertical5 = label.orientation === "y+" || label.orientation === "y-";
-    const candidates = [];
-    const seenCornerKeys = /* @__PURE__ */ new Set();
-    for (const trace of this.getTraceLinesForLabel(label)) {
+    const anchorAlignedCandidates = [];
+    const railAlignedCandidates = [];
+    const labelTraces = this.getTraceLinesForLabel(label);
+    const allowRailAlignedFallback = this.isConfiguredRailLabel(label) && !labelTraces.some(
+      (trace) => getTraceCorners(trace.tracePath).some(
+        (corner) => this.pointsEqual(corner, label.anchorPoint)
+      )
+    );
+    for (const trace of labelTraces) {
       const path = trace.tracePath;
       const pins = [path[0], path[path.length - 1]];
       for (const anchorPoint of getTraceCorners(path)) {
-        const key = `${anchorPoint.x}:${anchorPoint.y}`;
-        if (seenCornerKeys.has(key)) continue;
-        seenCornerKeys.add(key);
-        const pinAligned = pins.some((pin) => {
-          if (isVertical5) return Math.abs(pin.x - anchorPoint.x) < EPS6;
-          return Math.abs(pin.y - anchorPoint.y) < EPS6;
-        });
+        const cornerIndex = path.indexOf(anchorPoint);
+        const anchorAlignedToPin = pins.some(
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS6
+        );
+        const pinAligned = anchorAlignedToPin || allowRailAlignedFallback && this.isPinAlignedCorner(path, cornerIndex);
         if (!pinAligned) continue;
-        candidates.push({
+        const candidates = anchorAlignedToPin ? anchorAlignedCandidates : railAlignedCandidates;
+        candidates.push(
+          {
+            anchorPoint,
+            traceId: trace.mspPairId,
+            distance: getDistance(anchorPoint, label.anchorPoint),
+            pinAligned
+          },
+          ...this.getClearanceShiftedCornerCandidates({
+            label,
+            trace,
+            cornerIndex,
+            pinAligned
+          })
+        );
+      }
+    }
+    return [
+      ...anchorAlignedCandidates.sort((a, b) => a.distance - b.distance),
+      ...railAlignedCandidates.sort((a, b) => a.distance - b.distance)
+    ];
+  }
+  isConfiguredRailLabel(label) {
+    if (!label.netId) return false;
+    return this.inputProblem.availableNetLabelOrientations[label.netId]?.some(
+      (orientation) => orientation === "y+" || orientation === "y-"
+    );
+  }
+  pointsEqual(a, b) {
+    return Math.abs(a.x - b.x) <= EPS6 && Math.abs(a.y - b.y) <= EPS6;
+  }
+  getVerticalSegmentPointIndices(path, cornerIndex) {
+    const corner = path[cornerIndex];
+    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS6;
+    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS6;
+    if (previousIsVertical === nextIsVertical) return null;
+    const indices = previousIsVertical ? [cornerIndex - 1, cornerIndex] : [cornerIndex, cornerIndex + 1];
+    return indices;
+  }
+  isPinAlignedCorner(path, cornerIndex) {
+    const verticalPointIndices = this.getVerticalSegmentPointIndices(
+      path,
+      cornerIndex
+    );
+    if (!verticalPointIndices) return false;
+    const [startIndex, endIndex] = verticalPointIndices;
+    return startIndex <= 1 || endIndex >= path.length - 2;
+  }
+  getClearanceShiftedCornerCandidates({
+    label,
+    trace,
+    cornerIndex,
+    pinAligned
+  }) {
+    if (label.orientation !== "y+" && label.orientation !== "y-") return [];
+    const path = trace.tracePath;
+    const corner = path[cornerIndex];
+    const verticalPointIndices = this.getVerticalSegmentPointIndices(
+      path,
+      cornerIndex
+    );
+    if (!verticalPointIndices || verticalPointIndices.includes(0) || verticalPointIndices.includes(path.length - 1)) {
+      return [];
+    }
+    const center = getCenterFromAnchor(
+      corner,
+      label.orientation,
+      label.width,
+      label.height
+    );
+    const labelBounds = getRectBounds(center, label.width, label.height);
+    const collidingChipBounds = this.inputProblem.chips.map((chip) => getRectBounds(chip.center, chip.width, chip.height)).filter((chipBounds) => rectsOverlap(labelBounds, chipBounds));
+    const shiftedCoordinates = /* @__PURE__ */ new Set();
+    for (const chipBounds of collidingChipBounds) {
+      shiftedCoordinates.add(chipBounds.minX - label.width / 2);
+      shiftedCoordinates.add(chipBounds.maxX + label.width / 2);
+    }
+    return [...shiftedCoordinates].flatMap((x) => {
+      if (Math.abs(x - corner.x) <= EPS6) return [];
+      const reroutedTracePath = simplifyPath(
+        path.map(
+          (point, pointIndex) => verticalPointIndices.includes(pointIndex) ? { ...point, x } : point
+        )
+      );
+      const anchorPoint = { x, y: corner.y };
+      const remainsCorner = getTraceCorners(reroutedTracePath).some(
+        (point) => this.pointsEqual(point, anchorPoint)
+      );
+      if (!remainsCorner) return [];
+      return [
+        {
           anchorPoint,
           traceId: trace.mspPairId,
           distance: getDistance(anchorPoint, label.anchorPoint),
-          pinAligned
-        });
-      }
+          pinAligned,
+          reroutedTracePath
+        }
+      ];
+    });
+  }
+  isReroutedTraceClear(candidate, labelIndex) {
+    const reroutedTracePath = candidate.reroutedTracePath;
+    if (isPathCollidingWithObstacles(
+      reroutedTracePath,
+      getObstacleRects(this.inputProblem)
+    )) {
+      return false;
+    }
+    const candidateTrace = this.traceMap[candidate.traceId];
+    const otherNetTraces = this.traces.filter(
+      (trace) => trace.mspPairId !== candidate.traceId && trace.globalConnNetId !== candidateTrace.globalConnNetId
+    );
+    if (doesPathOverlapTraceStrokes(reroutedTracePath, otherNetTraces)) {
+      return false;
     }
-    return candidates.sort((a, b) => a.distance - b.distance);
+    const reroutedTraceMap = {
+      [candidate.traceId]: {
+        ...candidateTrace,
+        tracePath: reroutedTracePath
+      }
+    };
+    return this.outputNetLabelPlacements.every((label, index) => {
+      if (index === labelIndex) return true;
+      return !traceCrossesBoundsInterior(
+        getRectBounds(label.center, label.width, label.height),
+        reroutedTraceMap
+      );
+    });
   }
   getTraceLinesForLabel(label) {
     return this.traces.filter(
@@ -11380,9 +11634,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: Object.values(
-            instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
-          ),
+          traces: instance.railNetLabelCornerPlacementSolver.getOutput().traces,
           netLabelPlacements: instance.railNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
@@ -11393,9 +11645,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: Object.values(
-            instance.postLabelTraceOverlapShiftSolver.correctedTraceMap
-          ),
+          traces: instance.railNetLabelCornerPlacementSolver.getOutput().traces,
           netLabelPlacements: instance.traceAnchoredNetLabelOverlapSolver.outputNetLabelPlacements
         }
       ]
@@ -11425,12 +11675,34 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       "netLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => {
-        const previousCollisionOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        const previousOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
+        const alignmentOutput = instance.traceCleanupSolver2.getOutput();
+        const previousTraceMap = new Map(
+          previousOutput.traces.map((trace) => [trace.mspPairId, trace])
+        );
+        let netLabelPlacements = previousOutput.netLabelPlacements;
+        for (const trace of alignmentOutput.traces) {
+          const previousTrace = previousTraceMap.get(trace.mspPairId);
+          if (!previousTrace || previousTrace.tracePath === trace.tracePath) {
+            continue;
+          }
+          const currentLabels = netLabelPlacements;
+          const movedLabels = moveAttachedLabelsToReroutedTrace({
+            trace: previousTrace,
+            originalTracePath: previousTrace.tracePath,
+            reroutedTracePath: trace.tracePath,
+            netLabelPlacements: currentLabels
+          });
+          netLabelPlacements = movedLabels.map((movedLabel, labelIndex) => {
+            const label = currentLabels[labelIndex];
+            return label.orientation === "y+" || label.orientation === "y-" ? movedLabel : label;
+          });
+        }
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: instance.traceCleanupSolver2.getOutput().traces,
-            netLabelPlacements: previousCollisionOutput.netLabelPlacements
+            traces: alignmentOutput.traces,
+            netLabelPlacements
           }
         ];
       }