@tscircuit/schematic-trace-solver 0.0.174 → 0.0.175

package/dist/index.d.ts

@@ -1286,6 +1286,7 @@ interface InlineNetLabelSolverInput {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
+    completedReroutes?: CompletedTraceReroute[];
 }
 interface InlineNetLabelOutput {
     inputProblem: InputProblem;
@@ -1311,6 +1312,7 @@ declare class InlineNetLabelSolver extends BaseSolver {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     inputNetLabelPlacements: NetLabelPlacement[];
+    completedReroutes: CompletedTraceReroute[];
     inlineNetLabelPlacements: InlineNetLabelPlacement[];
     /** Eligible connections still waiting to be processed. */
     queuedConnections: QueuedInlineConnection[];

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS15 = 1e-9;
+  const EPS16 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS15) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS16) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS15) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS16) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS15 || Math.abs(p1.y - p2.y) < EPS15) {
+  if (Math.abs(p1.x - p2.x) < EPS16 || Math.abs(p1.y - p2.y) < EPS16) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1575,8 +1575,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS15 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS15 && Math.abs(p.y - q.y) < EPS15;
+      const EPS16 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS16 && Math.abs(p.y - q.y) < EPS16;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1887,13 +1887,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS15 = 1e-6
+  EPS: EPS16 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical6 = Math.abs(start.x - end.x) < EPS15;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS15;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS16;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS16;
   if (!isVertical6 && !isHorizontal5) return;
   const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2327,7 +2327,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS15 = 2e-3;
+    const EPS16 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -2354,7 +2354,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS15) {
+          if (rangeOverlap > EPS16) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2373,7 +2373,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS15) return;
+          if (rangeOverlap < -EPS16) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2396,8 +2396,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS15;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS15;
+            const aVert = Math.abs(a1.x - a2.x) < EPS16;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS16;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2408,11 +2408,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS15;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS15;
+                const bVert = Math.abs(b1.x - b2.x) < EPS16;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS16;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS15) {
+                  if (Math.abs(a1.x - b1.x) < EPS16) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2422,7 +2422,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS15) {
+                  if (Math.abs(a1.y - b1.y) < EPS16) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2478,14 +2478,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS15 = 2e-3;
+    const EPS16 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS15;
-        const isVertical6 = Math.abs(p1.x - p2.x) < EPS15;
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS16;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS16;
         if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2499,13 +2499,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS15 = 2e-3;
+    const EPS16 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS15 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS15 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS15 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS15 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS16 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS16 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS16 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS16 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2667,24 +2667,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS15 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS15;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS15;
+function segmentIntersectsRect2(p1, p2, rect, EPS16 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS16;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS16;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS15 || x > rect.maxX + EPS15) return false;
+    if (x < rect.minX - EPS16 || x > rect.maxX + EPS16) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS15;
+    return overlap > EPS16;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS15 || y > rect.maxY + EPS15) return false;
+    if (y < rect.minY - EPS16 || y > rect.maxY + EPS16) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS15;
+    return overlap > EPS16;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3083,14 +3083,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS15 = 1e-6;
+    const EPS16 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS15;
-        const isV = Math.abs(a.x - b.x) < EPS15;
+        const isH = Math.abs(a.y - b.y) < EPS16;
+        const isV = Math.abs(a.x - b.x) < EPS16;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4171,7 +4171,11 @@ 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) => {
+var doesPathCoincideWithTraces = (path, traces) => doesPathCoincideWithPaths(
+  path,
+  traces.map((trace) => trace.tracePath)
+);
+var doesPathCoincideWithPaths = (path, otherPaths) => {
   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++) {
     const pathSegStart = path[i];
@@ -4181,10 +4185,10 @@ var doesPathCoincideWithTraces = (path, traces) => {
     if (!isVertical6 && !isHorizontal5) continue;
     const crossAxis = isVertical6 ? "x" : "y";
     const alongAxis = isVertical6 ? "y" : "x";
-    for (const trace of traces) {
-      for (let j = 0; j < trace.tracePath.length - 1; j++) {
-        const traceSegStart = trace.tracePath[j];
-        const traceSegEnd = trace.tracePath[j + 1];
+    for (const otherPath of otherPaths) {
+      for (let j = 0; j < otherPath.length - 1; j++) {
+        const traceSegStart = otherPath[j];
+        const traceSegEnd = otherPath[j + 1];
         const isParallel = Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) < COINCIDENT_EPS;
         if (!isParallel) continue;
         const isCoincident = Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) < COINCIDENT_EPS;
@@ -14445,6 +14449,131 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
   };
 };
 
+// lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
+import { getSegmentIntersection as getSegmentIntersection5 } from "@tscircuit/math-utils/line-intersections";
+
+// lib/utils/pathIntersectsRenderedLabel.ts
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect
+} from "@tscircuit/math-utils";
+var pathIntersectsRenderedLabel = (path, label) => {
+  let width = label.width;
+  let height = label.height;
+  if ("axis" in label && label.axis === "y") {
+    width = label.height;
+    height = label.width;
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height
+  });
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (doesSegmentIntersectRect(path[pathIndex], path[pathIndex + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
+var EPS14 = 1e-6;
+var getPathLength5 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
+  const previousPoint = path[pointIndex];
+  return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
+}, 0);
+var pathsEqual = (first, second) => first.length === second.length && first.every(
+  (point, index) => Math.abs(point.x - second[index].x) <= EPS14 && Math.abs(point.y - second[index].y) <= EPS14
+);
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength5(candidate) <= getPathLength5(current) + EPS14;
+var getIntersectionKeys = (path, otherPath) => {
+  const intersections = /* @__PURE__ */ new Set();
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    for (let otherPathIndex = 0; otherPathIndex < otherPath.length - 1; otherPathIndex++) {
+      const point = getSegmentIntersection5(
+        path[pathIndex],
+        path[pathIndex + 1],
+        otherPath[otherPathIndex],
+        otherPath[otherPathIndex + 1]
+      );
+      if (point) {
+        intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
+      }
+    }
+  }
+  return intersections;
+};
+var introducesNewCrossings = (candidatePath, currentPath, otherPaths) => otherPaths.some((otherPath) => {
+  const currentIntersections = getIntersectionKeys(currentPath, otherPath);
+  const candidateIntersections = getIntersectionKeys(candidatePath, otherPath);
+  return [...candidateIntersections].some(
+    (intersection) => !currentIntersections.has(intersection)
+  );
+});
+var restoreReroutesAroundSupersededLabels = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements,
+  completedReroutes
+}) => {
+  const outputTraces = [...traces];
+  const supersededLabelGlobalConnNetIds = new Set(
+    inlineNetLabelPlacements.map((placement) => placement.globalConnNetId)
+  );
+  const obstacles = getObstacleRects(inputProblem);
+  let restoredTraceCount = 0;
+  for (const reroute of [...completedReroutes].reverse()) {
+    if (!supersededLabelGlobalConnNetIds.has(reroute.label.globalConnNetId)) {
+      continue;
+    }
+    const traceIndex = outputTraces.findIndex(
+      (trace) => trace.mspPairId === reroute.initialTrace.mspPairId
+    );
+    if (traceIndex < 0) continue;
+    const currentTrace = outputTraces[traceIndex];
+    const currentPath = simplifyPath(currentTrace.tracePath);
+    const recordedReroutePath = simplifyPath(reroute.reroutedTracePath);
+    if (!pathsEqual(currentPath, recordedReroutePath)) continue;
+    const candidatePath = simplifyPath(reroute.initialTrace.tracePath);
+    if (!isStrictlySimpler(candidatePath, currentPath)) continue;
+    const candidateTrace = { ...currentTrace, tracePath: candidatePath };
+    const otherNetTraces = outputTraces.filter(
+      (trace) => trace.mspPairId !== currentTrace.mspPairId && trace.globalConnNetId !== currentTrace.globalConnNetId
+    );
+    const otherNetInlineLabels = inlineNetLabelPlacements.filter(
+      (label) => label.globalConnNetId !== currentTrace.globalConnNetId
+    );
+    const otherNetInlineStubPaths = otherNetInlineLabels.flatMap(
+      (label) => label.stubTracePath ? [[...label.stubTracePath]] : []
+    );
+    if (isPathCollidingWithObstacles(candidatePath, obstacles) || detectTraceLabelOverlap({
+      traces: [candidateTrace],
+      netLabels: netLabelPlacements
+    }).length > 0 || otherNetInlineLabels.some(
+      (label) => pathIntersectsRenderedLabel(candidatePath, label)
+    ) || doesPathCoincideWithTraces(candidatePath, otherNetTraces) || doesPathCoincideWithPaths(candidatePath, otherNetInlineStubPaths) || introducesNewCrossings(
+      candidatePath,
+      currentPath,
+      otherNetTraces.map((trace) => trace.tracePath)
+    ) || introducesNewCrossings(
+      candidatePath,
+      currentPath,
+      otherNetInlineStubPaths
+    ) || !preservesLabelAnchors(
+      netLabelPlacements,
+      [currentTrace],
+      [candidateTrace]
+    )) {
+      continue;
+    }
+    outputTraces[traceIndex] = candidateTrace;
+    restoredTraceCount++;
+  }
+  return { traces: outputTraces, restoredTraceCount };
+};
+
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
@@ -14477,6 +14606,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
   inputProblem;
   traces;
   inputNetLabelPlacements;
+  completedReroutes;
   inlineNetLabelPlacements = [];
   /** Eligible connections still waiting to be processed. */
   queuedConnections;
@@ -14490,6 +14620,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     this.inputProblem = input.inputProblem;
     this.traces = input.traces;
     this.inputNetLabelPlacements = input.netLabelPlacements;
+    this.completedReroutes = input.completedReroutes ?? [];
     this.globalConnMap = getConnectivityMapsFromInputProblem(
       this.inputProblem
     ).netConnMap;
@@ -14524,7 +14655,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
       {
         inputProblem: this.inputProblem,
         traces: this.traces,
-        netLabelPlacements: this.inputNetLabelPlacements
+        netLabelPlacements: this.inputNetLabelPlacements,
+        completedReroutes: this.completedReroutes
       }
     ];
   }
@@ -15097,9 +15229,17 @@ var InlineNetLabelSolver = class extends BaseSolver {
       if (blockedGlobalConnNetIds.size === 0) {
         this.inlineNetLabelPlacements = activeInlinePlacements;
         this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount;
-        return {
+        const restored = restoreReroutesAroundSupersededLabels({
+          inputProblem: this.inputProblem,
           traces: pushed.traces,
           netLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements,
+          completedReroutes: this.completedReroutes
+        });
+        this.stats.restoredSupersededLabelRerouteCount = restored.restoredTraceCount;
+        return {
+          traces: restored.traces,
+          netLabelPlacements: pushed.netLabelPlacements,
           inlineNetLabelPlacements: activeInlinePlacements
         };
       }
@@ -15307,12 +15447,6 @@ var getCollisionLimitedTerminalStubEnd = ({
   return isHorizontal5 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
 };
 
-// lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
-import {
-  doesSegmentIntersectRect,
-  getBoundFromCenteredRect
-} from "@tscircuit/math-utils";
-
 // lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts
 import { doSegmentsIntersect as doSegmentsIntersect4 } from "@tscircuit/math-utils";
 var EPSILON = 1e-6;
@@ -15407,12 +15541,12 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 };
 
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
-var EPS14 = 1e-9;
-var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS14;
-var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS14;
+var EPS15 = 1e-9;
+var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS15;
+var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS15;
 var compactConsecutivePoints = (path) => path.filter((point, index) => {
   const previousPoint = path[index - 1];
-  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS14 || Math.abs(point.y - previousPoint.y) >= EPS14;
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS15 || Math.abs(point.y - previousPoint.y) >= EPS15;
 });
 var isValidOrthogonalPath = (path) => {
   if (path.length < 2 || !path.every((point, index) => {
@@ -15450,7 +15584,7 @@ var getEndpointAlignedSegmentCandidates = (tracePath) => {
     }
     const alignedCoordinates = segmentIsVertical ? [previousPoint.x, nextPoint.x] : [previousPoint.y, nextPoint.y];
     for (const alignedCoordinate of alignedCoordinates) {
-      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS14) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS15) {
         continue;
       }
       const candidate = tracePath.map((point) => ({ ...point }));
@@ -15513,25 +15647,6 @@ var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
 var MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05;
 var MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25;
 var getCanonicalPairKey = (firstPinId, secondPinId) => [firstPinId, secondPinId].sort().join("--");
-var pathIntersectsRenderedLabel = (path, label) => {
-  let width = label.width;
-  let height = label.height;
-  if ("axis" in label && label.axis === "y") {
-    width = label.height;
-    height = label.width;
-  }
-  const bounds = getBoundFromCenteredRect({
-    center: label.center,
-    width,
-    height
-  });
-  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
-    if (doesSegmentIntersectRect(path[pathIndex], path[pathIndex + 1], bounds)) {
-      return true;
-    }
-  }
-  return false;
-};
 var getPerpendicularOffset = (firstPoint, secondPoint) => {
   const xDistance = Math.abs(firstPoint.x - secondPoint.x);
   const yDistance = Math.abs(firstPoint.y - secondPoint.y);
@@ -16345,11 +16460,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       InlineNetLabelSolver,
       (instance) => {
         const junctionOutput = instance.sameNetJunctionAlignmentSolver.getOutput();
+        const completedReroutes = [
+          ...instance.traceLabelOverlapAvoidanceSolver.getOutput().completedReroutes,
+          ...instance.preAlignmentNetLabelTraceCollisionSolver.getOutput().completedReroutes,
+          ...instance.netLabelTraceCollisionSolver.getOutput().completedReroutes
+        ];
         return [
           {
             inputProblem: instance.inputProblem,
             traces: junctionOutput.traces,
-            netLabelPlacements: junctionOutput.netLabelPlacements
+            netLabelPlacements: junctionOutput.netLabelPlacements,
+            completedReroutes
           }
         ];
       }

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -8,6 +8,7 @@ import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesS
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
 import type {
   InputDirectConnection,
   InputNetConnection,
@@ -24,6 +25,7 @@ import {
 import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
 import { pushAnchoredNetLabelsAwayFromInlineLabels } from "./pushAnchoredNetLabelsAwayFromInlineLabels"
 import { pushInlineTerminalLabelsAwayFromAnchoredLabels } from "./pushInlineTerminalLabelsAwayFromAnchoredLabels"
+import { restoreReroutesAroundSupersededLabels } from "./restoreReroutesAroundSupersededLabels"
 
 export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
 
@@ -95,6 +97,7 @@ interface InlineNetLabelSolverInput {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
+  completedReroutes?: CompletedTraceReroute[]
 }
 
 export interface InlineNetLabelOutput {
@@ -169,6 +172,7 @@ export class InlineNetLabelSolver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   inputNetLabelPlacements: NetLabelPlacement[]
+  completedReroutes: CompletedTraceReroute[]
 
   inlineNetLabelPlacements: InlineNetLabelPlacement[] = []
 
@@ -190,6 +194,7 @@ export class InlineNetLabelSolver extends BaseSolver {
     this.inputProblem = input.inputProblem
     this.traces = input.traces
     this.inputNetLabelPlacements = input.netLabelPlacements
+    this.completedReroutes = input.completedReroutes ?? []
     this.globalConnMap = getConnectivityMapsFromInputProblem(
       this.inputProblem,
     ).netConnMap
@@ -235,6 +240,7 @@ export class InlineNetLabelSolver extends BaseSolver {
         inputProblem: this.inputProblem,
         traces: this.traces,
         netLabelPlacements: this.inputNetLabelPlacements,
+        completedReroutes: this.completedReroutes,
       },
     ]
   }
@@ -1066,10 +1072,19 @@ export class InlineNetLabelSolver extends BaseSolver {
       if (blockedGlobalConnNetIds.size === 0) {
         this.inlineNetLabelPlacements = activeInlinePlacements
         this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount
-        return {
+        const restored = restoreReroutesAroundSupersededLabels({
+          inputProblem: this.inputProblem,
           traces: pushed.traces,
           netLabelPlacements: pushed.netLabelPlacements,
           inlineNetLabelPlacements: activeInlinePlacements,
+          completedReroutes: this.completedReroutes,
+        })
+        this.stats.restoredSupersededLabelRerouteCount =
+          restored.restoredTraceCount
+        return {
+          traces: restored.traces,
+          netLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements,
         }
       }
       activeInlinePlacements = activeInlinePlacements.filter(